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

1

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

2

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

3

* Version 1.3.29

4

*

5

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

6

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

7

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

8

* interface file instead.

9

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

10

11

#define SWIGPYTHON

12

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

13

14

#ifdef __cplusplus

15

template<class T> class SwigValueWrapper {

16

T *tt;

17

public:

18

SwigValueWrapper() : tt(0) { }

19

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

20

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

21

~SwigValueWrapper() { delete tt; }

22

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

23

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

24

T *operator&() { return tt; }

25

private:

26

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

27

};

28

#endif

29

30

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

31

* This section contains generic SWIG labels for method/variable

32

* declarations/attributes, and other compiler dependent labels.

33

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

34

35

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

36

#ifndef SWIGTEMPLATEDISAMBIGUATOR

37

# if defined(__SUNPRO_CC)

38

# if (__SUNPRO_CC <= 0x560)

39

# define SWIGTEMPLATEDISAMBIGUATOR template

40

# else

41

# define SWIGTEMPLATEDISAMBIGUATOR

42

# endif

43

# else

44

# define SWIGTEMPLATEDISAMBIGUATOR

45

# endif

46

#endif

47

48

/* inline attribute */

49

#ifndef SWIGINLINE

50

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

51

# define SWIGINLINE inline

52

# else

53

# define SWIGINLINE

54

# endif

55

#endif

56

57

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

58

#ifndef SWIGUNUSED

59

# if defined(__GNUC__)

60

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

61

# define SWIGUNUSED __attribute__ ((__unused__))

62

# else

63

# define SWIGUNUSED

64

# endif

65

# elif defined(__ICC)

66

# define SWIGUNUSED __attribute__ ((__unused__))

67

# else

68

# define SWIGUNUSED

69

# endif

70

#endif

71

72

#ifndef SWIGUNUSEDPARM

73

# ifdef __cplusplus

74

# define SWIGUNUSEDPARM(p)

75

# else

76

# define SWIGUNUSEDPARM(p) p SWIGUNUSED

77

# endif

78

#endif

79

80

/* internal SWIG method */

81

#ifndef SWIGINTERN

82

# define SWIGINTERN static SWIGUNUSED

83

#endif

84

85

/* internal inline SWIG method */

86

#ifndef SWIGINTERNINLINE

87

# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE

88

#endif

89

90

/* exporting methods */

91

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

92

# ifndef GCC_HASCLASSVISIBILITY

93

# define GCC_HASCLASSVISIBILITY

94

# endif

95

#endif

96

97

#ifndef SWIGEXPORT

98

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

99

# if defined(STATIC_LINKED)

100

# define SWIGEXPORT

101

# else

102

# define SWIGEXPORT __declspec(dllexport)

103

# endif

104

# else

105

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

106

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

107

# else

108

# define SWIGEXPORT

109

# endif

110

# endif

111

#endif

112

113

/* calling conventions for Windows */

114

#ifndef SWIGSTDCALL

115

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

116

# define SWIGSTDCALL __stdcall

117

# else

118

# define SWIGSTDCALL

119

# endif

120

#endif

121

122

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

123

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

124

# define _CRT_SECURE_NO_DEPRECATE

125

#endif

126

127

128

/* Python.h has to appear first */

129

#include <Python.h>

130

131

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

132

* swigrun.swg

133

*

134

* This file contains generic CAPI SWIG runtime support for pointer

135

* type checking.

136

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

137

138

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

139

or for whatever reason, the runtime changes incompatibly */

140

#define SWIG_RUNTIME_VERSION "2"

141

142

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */

143

#ifdef SWIG_TYPE_TABLE

144

# define SWIG_QUOTE_STRING(x) #x

145

# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)

146

# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)

147

#else

148

# define SWIG_TYPE_TABLE_NAME

149

#endif

150

151

/*

152

You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for

153

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

154

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

155

156

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

157

with your compiler or so.

158

*/

159

160

#ifndef SWIGRUNTIME

161

# define SWIGRUNTIME SWIGINTERN

162

#endif

163

164

#ifndef SWIGRUNTIMEINLINE

165

# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE

166

#endif

167

168

/* Generic buffer size */

169

#ifndef SWIG_BUFFER_SIZE

170

# define SWIG_BUFFER_SIZE 1024

171

#endif

172

173

/* Flags for pointer conversions */

174

#define SWIG_POINTER_DISOWN 0x1

175

176

/* Flags for new pointer objects */

177

#define SWIG_POINTER_OWN 0x1

178

179

180

/*

181

Flags/methods for returning states.

182

183

The swig conversion methods, as ConvertPtr, return and integer

184

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

185

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

186

187

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

188

states.

189

190

In old swig versions, you usually write code as:

191

192

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

193

// success code

194

} else {

195

//fail code

196

}

197

198

Now you can be more explicit as:

199

200

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

201

if (SWIG_IsOK(res)) {

202

// success code

203

} else {

204

// fail code

205

}

206

207

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

208

209

Type *ptr;

210

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

211

if (SWIG_IsOK(res)) {

212

// success code

213

if (SWIG_IsNewObj(res) {

214

...

215

delete *ptr;

216

} else {

217

...

218

}

219

} else {

220

// fail code

221

}

222

223

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

224

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

225

requires also to SWIG_ConvertPtr to return new result values, as

226

227

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

228

if (<obj is ok>) {

229

if (<need new object>) {

230

*ptr = <ptr to new allocated object>;

231

return SWIG_NEWOBJ;

232

} else {

233

*ptr = <ptr to old object>;

234

return SWIG_OLDOBJ;

235

}

236

} else {

237

return SWIG_BADOBJ;

238

}

239

}

240

241

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

242

more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the

243

swig errors code.

244

245

Finally, if the SWIG_CASTRANK_MODE is enabled, the result code

246

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

247

248

int food(double)

249

int fooi(int);

250

251

and you call

252

253

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

254

fooi(1) // cast rank '0'

255

256

just use the SWIG_AddCast()/SWIG_CheckState()

257

258

259

*/

260

#define SWIG_OK (0)

261

#define SWIG_ERROR (-1)

262

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

263

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

264

265

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

266

#define SWIG_CASTRANKLIMIT (1 << 8)

267

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

268

#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)

269

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

270

#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)

271

/* Simple returning values */

272

#define SWIG_BADOBJ (SWIG_ERROR)

273

#define SWIG_OLDOBJ (SWIG_OK)

274

#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)

275

#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)

276

/* Check, add and del mask methods */

277

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

278

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

279

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

280

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

281

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

282

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

283

284

285

/* Cast-Rank Mode */

286

#if defined(SWIG_CASTRANK_MODE)

287

# ifndef SWIG_TypeRank

288

# define SWIG_TypeRank unsigned long

289

# endif

290

# ifndef SWIG_MAXCASTRANK /* Default cast allowed */

291

# define SWIG_MAXCASTRANK (2)

292

# endif

293

# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)

294

# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)

295

SWIGINTERNINLINE int SWIG_AddCast(int r) {

296

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

297

}

298

SWIGINTERNINLINE int SWIG_CheckState(int r) {

299

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

300

}

301

#else /* no cast-rank mode */

302

# define SWIG_AddCast

303

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

304

#endif

305

306

307

308

309

#include <string.h>

310

311

#ifdef __cplusplus

312

extern "C" {

313

#endif

314

315

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

316

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

317

318

/* Structure to store inforomation on one type */

319

typedef struct swig_type_info {

320

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

321

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

322

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

323

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

324

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

325

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

326

} swig_type_info;

327

328

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

329

typedef struct swig_cast_info {

330

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

331

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

332

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

333

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

334

} swig_cast_info;

335

336

/* Structure used to store module information

337

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

338

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

339

typedef struct swig_module_info {

340

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

341

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

342

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

343

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

344

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

345

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

346

} swig_module_info;

347

348

/*

349

Compare two type names skipping the space characters, therefore

350

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

351

352

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

353

strncmp, but skipping ' '.

354

*/

355

SWIGRUNTIME int

356

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

357

const char *f2, const char *l2) {

358

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

359

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

360

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

361

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

362

}

363

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

364

}

365

366

/*

367

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

368

Return 0 if not equal, 1 if equal

369

*/

370

SWIGRUNTIME int

371

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

372

int equiv = 0;

373

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

374

const char* ne = nb;

375

while (!equiv && *ne) {

376

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

377

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

378

}

379

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

380

if (*ne) ++ne;

381

}

382

return equiv;

383

}

384

385

/*

386

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

387

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

388

*/

389

SWIGRUNTIME int

390

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

391

int equiv = 0;

392

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

393

const char* ne = nb;

394

while (!equiv && *ne) {

395

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

396

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

397

}

398

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

399

if (*ne) ++ne;

400

}

401

return equiv;

402

}

403

404

405

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

406

#define SWIG_TypeCheck_Template(comparison, ty) \

407

if (ty) { \

408

swig_cast_info *iter = ty->cast; \

409

while (iter) { \

410

if (comparison) { \

411

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

412

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

413

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

414

if (iter->next) \

415

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

416

iter->next = ty->cast; \

417

iter->prev = 0; \

418

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

419

ty->cast = iter; \

420

return iter; \

421

} \

422

iter = iter->next; \

423

} \

424

} \

425

return 0

426

427

/*

428

Check the typename

429

*/

430

SWIGRUNTIME swig_cast_info *

431

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

432

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

433

}

434

435

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

436

SWIGRUNTIME swig_cast_info *

437

SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {

438

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

439

}

440

441

/*

442

Cast a pointer up an inheritance hierarchy

443

*/

444

SWIGRUNTIMEINLINE void *

445

SWIG_TypeCast(swig_cast_info *ty, void *ptr) {

446

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

447

}

448

449

/*

450

Dynamic pointer casting. Down an inheritance hierarchy

451

*/

452

SWIGRUNTIME swig_type_info *

453

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

454

swig_type_info *lastty = ty;

455

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

456

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

457

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

458

if (ty) lastty = ty;

459

}

460

return lastty;

461

}

462

463

/*

464

Return the name associated with this type

465

*/

466

SWIGRUNTIMEINLINE const char *

467

SWIG_TypeName(const swig_type_info *ty) {

468

return ty->name;

469

}

470

471

/*

472

Return the pretty name associated with this type,

473

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

474

*/

475

SWIGRUNTIME const char *

476

SWIG_TypePrettyName(const swig_type_info *type) {

477

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

478

type, separated by vertical-bar characters. We choose

479

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

480

specific. */

481

if (!type) return NULL;

482

if (type->str != NULL) {

483

const char *last_name = type->str;

484

const char *s;

485

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

486

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

487

return last_name;

488

}

489

else

490

return type->name;

491

}

492

493

/*

494

Set the clientdata field for a type

495

*/

496

SWIGRUNTIME void

497

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

498

swig_cast_info *cast = ti->cast;

499

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

500

ti->clientdata = clientdata;

501

502

while (cast) {

503

if (!cast->converter) {

504

swig_type_info *tc = cast->type;

505

if (!tc->clientdata) {

506

SWIG_TypeClientData(tc, clientdata);

507

}

508

}

509

cast = cast->next;

510

}

511

}

512

SWIGRUNTIME void

513

SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {

514

SWIG_TypeClientData(ti, clientdata);

515

ti->owndata = 1;

516

}

517

518

/*

519

Search for a swig_type_info structure only by mangled name

520

Search is a O(log #types)

521

522

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

523

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

524

the circular list.

525

*/

526

SWIGRUNTIME swig_type_info *

527

SWIG_MangledTypeQueryModule(swig_module_info *start,

528

swig_module_info *end,

529

const char *name) {

530

swig_module_info *iter = start;

531

do {

532

if (iter->size) {

533

register size_t l = 0;

534

register size_t r = iter->size - 1;

535

do {

536

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

537

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

538

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

539

if (iname) {

540

register int compare = strcmp(name, iname);

541

if (compare == 0) {

542

return iter->types[i];

543

} else if (compare < 0) {

544

if (i) {

545

r = i - 1;

546

} else {

547

break;

548

}

549

} else if (compare > 0) {

550

l = i + 1;

551

}

552

} else {

553

break; /* should never happen */

554

}

555

} while (l <= r);

556

}

557

iter = iter->next;

558

} while (iter != end);

559

return 0;

560

}

561

562

/*

563

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

564

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

565

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

566

567

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

568

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

569

the circular list.

570

*/

571

SWIGRUNTIME swig_type_info *

572

SWIG_TypeQueryModule(swig_module_info *start,

573

swig_module_info *end,

574

const char *name) {

575

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

576

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

577

if (ret) {

578

return ret;

579

} else {

580

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

581

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

582

swig_module_info *iter = start;

583

do {

584

register size_t i = 0;

585

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

586

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

587

return iter->types[i];

588

}

589

iter = iter->next;

590

} while (iter != end);

591

}

592

593

/* neither found a match */

594

return 0;

595

}

596

597

/*

598

Pack binary data into a string

599

*/

600

SWIGRUNTIME char *

601

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

602

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

603

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

604

register const unsigned char *eu = u + sz;

605

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

606

register unsigned char uu = *u;

607

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

608

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

609

}

610

return c;

611

}

612

613

/*

614

Unpack binary data from a string

615

*/

616

SWIGRUNTIME const char *

617

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

618

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

619

register const unsigned char *eu = u + sz;

620

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

621

register char d = *(c++);

622

register unsigned char uu;

623

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

624

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

625

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

626

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

627

else

628

return (char *) 0;

629

d = *(c++);

630

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

631

uu |= (d - '0');

632

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

633

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

634

else

635

return (char *) 0;

636

*u = uu;

637

}

638

return c;

639

}

640

641

/*

642

Pack 'void *' into a string buffer.

643

*/

644

SWIGRUNTIME char *

645

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

646

char *r = buff;

647

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

648

*(r++) = '_';

649

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

650

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

651

strcpy(r,name);

652

return buff;

653

}

654

655

SWIGRUNTIME const char *

656

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

657

if (*c != '_') {

658

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

659

*ptr = (void *) 0;

660

return name;

661

} else {

662

return 0;

663

}

664

}

665

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

666

}

667

668

SWIGRUNTIME char *

669

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

670

char *r = buff;

671

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

672

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

673

*(r++) = '_';

674

r = SWIG_PackData(r,ptr,sz);

675

if (lname) {

676

strncpy(r,name,lname+1);

677

} else {

678

*r = 0;

679

}

680

return buff;

681

}

682

683

SWIGRUNTIME const char *

684

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

685

if (*c != '_') {

686

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

687

memset(ptr,0,sz);

688

return name;

689

} else {

690

return 0;

691

}

692

}

693

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

694

}

695

696

#ifdef __cplusplus

697

}

698

#endif

699

700

/* Errors in SWIG */

701

#define SWIG_UnknownError -1

702

#define SWIG_IOError -2

703

#define SWIG_RuntimeError -3

704

#define SWIG_IndexError -4

705

#define SWIG_TypeError -5

706

#define SWIG_DivisionByZero -6

707

#define SWIG_OverflowError -7

708

#define SWIG_SyntaxError -8

709

#define SWIG_ValueError -9

710

#define SWIG_SystemError -10

711

#define SWIG_AttributeError -11

712

#define SWIG_MemoryError -12

713

#define SWIG_NullReferenceError -13

714

715

716

717

/* Python.h has to appear first */

718

#include <Python.h>

719

720

/* Add PyOS_snprintf for old Pythons */

721

#if PY_VERSION_HEX < 0x02020000

722

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

723

# define PyOS_snprintf _snprintf

724

# else

725

# define PyOS_snprintf snprintf

726

# endif

727

#endif

728

729

/* A crude PyString_FromFormat implementation for old Pythons */

730

#if PY_VERSION_HEX < 0x02020000

731

732

#ifndef SWIG_PYBUFFER_SIZE

733

# define SWIG_PYBUFFER_SIZE 1024

734

#endif

735

736

static PyObject *

737

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

738

va_list ap;

739

char buf[SWIG_PYBUFFER_SIZE * 2];

740

int res;

741

va_start(ap, fmt);

742

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

743

va_end(ap);

744

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

745

}

746

#endif

747

748

/* Add PyObject_Del for old Pythons */

749

#if PY_VERSION_HEX < 0x01060000

750

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

751

#endif

752

#ifndef PyObject_DEL

753

# define PyObject_DEL PyObject_Del

754

#endif

755

756

/* A crude PyExc_StopIteration exception for old Pythons */

757

#if PY_VERSION_HEX < 0x02020000

758

# ifndef PyExc_StopIteration

759

# define PyExc_StopIteration PyExc_RuntimeError

760

# endif

761

# ifndef PyObject_GenericGetAttr

762

# define PyObject_GenericGetAttr 0

763

# endif

764

#endif

765

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

766

#if PY_VERSION_HEX < 0x02010000

767

# ifndef Py_NotImplemented

768

# define Py_NotImplemented PyExc_RuntimeError

769

# endif

770

#endif

771

772

773

/* A crude PyString_AsStringAndSize implementation for old Pythons */

774

#if PY_VERSION_HEX < 0x02010000

775

# ifndef PyString_AsStringAndSize

776

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

777

# endif

778

#endif

779

780

/* PySequence_Size for old Pythons */

781

#if PY_VERSION_HEX < 0x02000000

782

# ifndef PySequence_Size

783

# define PySequence_Size PySequence_Length

784

# endif

785

#endif

786

787

788

/* PyBool_FromLong for old Pythons */

789

#if PY_VERSION_HEX < 0x02030000

790

static

791

PyObject *PyBool_FromLong(long ok)

792

{

793

PyObject *result = ok ? Py_True : Py_False;

794

Py_INCREF(result);

795

return result;

796

}

797

#endif

798

799

800

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

801

* error manipulation

802

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

803

804

SWIGRUNTIME PyObject*

805

SWIG_Python_ErrorType(int code) {

806

PyObject* type = 0;

807

switch(code) {

808

case SWIG_MemoryError:

809

type = PyExc_MemoryError;

810

break;

811

case SWIG_IOError:

812

type = PyExc_IOError;

813

break;

814

case SWIG_RuntimeError:

815

type = PyExc_RuntimeError;

816

break;

817

case SWIG_IndexError:

818

type = PyExc_IndexError;

819

break;

820

case SWIG_TypeError:

821

type = PyExc_TypeError;

822

break;

823

case SWIG_DivisionByZero:

824

type = PyExc_ZeroDivisionError;

825

break;

826

case SWIG_OverflowError:

827

type = PyExc_OverflowError;

828

break;

829

case SWIG_SyntaxError:

830

type = PyExc_SyntaxError;

831

break;

832

case SWIG_ValueError:

833

type = PyExc_ValueError;

834

break;

835

case SWIG_SystemError:

836

type = PyExc_SystemError;

837

break;

838

case SWIG_AttributeError:

839

type = PyExc_AttributeError;

840

break;

841

default:

842

type = PyExc_RuntimeError;

843

}

844

return type;

845

}

846

847

848

SWIGRUNTIME void

849

SWIG_Python_AddErrorMsg(const char* mesg)

850

{

851

PyObject *type = 0;

852

PyObject *value = 0;

853

PyObject *traceback = 0;

854

855

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

856

if (value) {

857

PyObject *old_str = PyObject_Str(value);

858

PyErr_Clear();

859

Py_XINCREF(type);

860

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

861

Py_DECREF(old_str);

862

Py_DECREF(value);

863

} else {

864

PyErr_Format(PyExc_RuntimeError, mesg);

865

}

866

}

867

868

869

870

#if defined(SWIG_PYTHON_NO_THREADS)

871

# if defined(SWIG_PYTHON_THREADS)

872

# undef SWIG_PYTHON_THREADS

873

# endif

874

#endif

875

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

876

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

877

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

878

# define SWIG_PYTHON_USE_GIL

879

# endif

880

# endif

881

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

882

# ifndef SWIG_PYTHON_INITIALIZE_THREADS

883

# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()

884

# endif

885

# ifdef __cplusplus /* C++ code */

886

class SWIG_Python_Thread_Block {

887

bool status;

888

PyGILState_STATE state;

889

public:

890

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

891

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

892

~SWIG_Python_Thread_Block() { end(); }

893

};

894

class SWIG_Python_Thread_Allow {

895

bool status;

896

PyThreadState *save;

897

public:

898

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

899

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

900

~SWIG_Python_Thread_Allow() { end(); }

901

};

902

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block

903

# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()

904

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow

905

# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()

906

# else /* C code */

907

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()

908

# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)

909

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()

910

# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)

911

# endif

912

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

913

# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)

914

# define SWIG_PYTHON_INITIALIZE_THREADS

915

# endif

916

# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)

917

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK

918

# endif

919

# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)

920

# define SWIG_PYTHON_THREAD_END_BLOCK

921

# endif

922

# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)

923

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW

924

# endif

925

# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)

926

# define SWIG_PYTHON_THREAD_END_ALLOW

927

# endif

928

# endif

929

#else /* No thread support */

930

# define SWIG_PYTHON_INITIALIZE_THREADS

931

# define SWIG_PYTHON_THREAD_BEGIN_BLOCK

932

# define SWIG_PYTHON_THREAD_END_BLOCK

933

# define SWIG_PYTHON_THREAD_BEGIN_ALLOW

934

# define SWIG_PYTHON_THREAD_END_ALLOW

935

#endif

936

937

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

938

* Python API portion that goes into the runtime

939

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

940

941

#ifdef __cplusplus

942

extern "C" {

943

#if 0

944

} /* cc-mode */

945

#endif

946

#endif

947

948

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

949

* Constant declarations

950

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

951

952

/* Constant Types */

953

#define SWIG_PY_POINTER 4

954

#define SWIG_PY_BINARY 5

955

956

/* Constant information structure */

957

typedef struct swig_const_info {

958

int type;

959

char *name;

960

long lvalue;

961

double dvalue;

962

void *pvalue;

963

swig_type_info **ptype;

964

} swig_const_info;

965

966

#ifdef __cplusplus

967

#if 0

968

{ /* cc-mode */

969

#endif

970

}

971

#endif

972

973

974

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

975

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

976

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

977

*

978

* pyrun.swg

979

*

980

* This file contains the runtime support for Python modules

981

* and includes code for managing global variables and pointer

982

* type checking.

983

*

984

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

985

986

/* Common SWIG API */

987

988

#if PY_VERSION_HEX < 0x02050000

989

typedef int Py_ssize_t;

990

#endif

991

992

/* for raw pointers */

993

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

994

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

995

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

996

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

997

#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)

998

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

999

#define swig_owntype int

1000

1001

/* for raw packed data */

1002

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

1003

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

1004

1005

/* for class or struct pointers */

1006

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

1007

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

1008

1009

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

1010

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

1011

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

1012

1013

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

1014

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

1015

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

1016

1017

1018

/* Runtime API */

1019

1020

#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()

1021

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

1022

#define SWIG_NewClientData(obj) PySwigClientData_New(obj)

1023

1024

#define SWIG_SetErrorObj SWIG_Python_SetErrorObj

1025

#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg

1026

#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)

1027

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

1028

#define SWIG_fail goto fail

1029

1030

1031

/* Runtime API implementation */

1032

1033

/* Error manipulation */

1034

1035

SWIGINTERN void

1036

SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {

1037

SWIG_PYTHON_THREAD_BEGIN_BLOCK;

1038

PyErr_SetObject(errtype, obj);

1039

Py_DECREF(obj);

1040

SWIG_PYTHON_THREAD_END_BLOCK;

1041

}

1042

1043

SWIGINTERN void

1044

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

1045

SWIG_PYTHON_THREAD_BEGIN_BLOCK;

1046

PyErr_SetString(errtype, (char *) msg);

1047

SWIG_PYTHON_THREAD_END_BLOCK;

1048

}

1049

1050

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

1051

1052

/* Set a constant value */

1053

1054

SWIGINTERN void

1055

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

1056

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

1057

Py_DECREF(obj);

1058

}

1059

1060

/* Append a value to the result obj */

1061

1062

SWIGINTERN PyObject*

1063

SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {

1064

#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)

1065

if (!result) {

1066

result = obj;

1067

} else if (result == Py_None) {

1068

Py_DECREF(result);

1069

result = obj;

1070

} else {

1071

if (!PyList_Check(result)) {

1072

PyObject *o2 = result;

1073

result = PyList_New(1);

1074

PyList_SetItem(result, 0, o2);

1075

}

1076

PyList_Append(result,obj);

1077

Py_DECREF(obj);

1078

}

1079

return result;

1080

#else

1081

PyObject* o2;

1082

PyObject* o3;

1083

if (!result) {

1084

result = obj;

1085

} else if (result == Py_None) {

1086

Py_DECREF(result);

1087

result = obj;

1088

} else {

1089

if (!PyTuple_Check(result)) {

1090

o2 = result;

1091

result = PyTuple_New(1);

1092

PyTuple_SET_ITEM(result, 0, o2);

1093

}

1094

o3 = PyTuple_New(1);

1095

PyTuple_SET_ITEM(o3, 0, obj);

1096

o2 = result;

1097

result = PySequence_Concat(o2, o3);

1098

Py_DECREF(o2);

1099

Py_DECREF(o3);

1100

}

1101

return result;

1102

#endif

1103

}

1104

1105

/* Unpack the argument tuple */

1106

1107

SWIGINTERN int

1108

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

1109

{

1110

if (!args) {

1111

if (!min && !max) {

1112

return 1;

1113

} else {

1114

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

1115

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

1116

return 0;

1117

}

1118

}

1119

if (!PyTuple_Check(args)) {

1120

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

1121

return 0;

1122

} else {

1123

register int l = PyTuple_GET_SIZE(args);

1124

if (l < min) {

1125

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

1126

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

1127

return 0;

1128

} else if (l > max) {

1129

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

1130

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

1131

return 0;

1132

} else {

1133

register int i;

1134

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

1135

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

1136

}

1137

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

1138

objs[l] = 0;

1139

}

1140

return i + 1;

1141

}

1142

}

1143

}

1144

1145

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

1146

#if PY_VERSION_HEX >= 0x02020000

1147

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

1148

#else

1149

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

1150

#endif

1151

1152

/*

1153

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

1154

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

1155

*/

1156

#ifdef __cplusplus

1157

#define SWIG_STATIC_POINTER(var) var

1158

#else

1159

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

1160

#endif

1161

1162

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

1163

* Pointer declarations

1164

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

1165

1166

/* Flags for new pointer objects */

1167

#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)

1168

#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

1169

1170

#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)

1171

1172

#ifdef __cplusplus

1173

extern "C" {

1174

#if 0

1175

} /* cc-mode */

1176

#endif

1177

#endif

1178

1179

/* How to access Py_None */

1180

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

1181

# ifndef SWIG_PYTHON_NO_BUILD_NONE

1182

# ifndef SWIG_PYTHON_BUILD_NONE

1183

# define SWIG_PYTHON_BUILD_NONE

1184

# endif

1185

# endif

1186

#endif

1187

1188

#ifdef SWIG_PYTHON_BUILD_NONE

1189

# ifdef Py_None

1190

# undef Py_None

1191

# define Py_None SWIG_Py_None()

1192

# endif

1193

SWIGRUNTIMEINLINE PyObject *

1194

_SWIG_Py_None(void)

1195

{

1196

PyObject *none = Py_BuildValue("");

1197

Py_DECREF(none);

1198

return none;

1199

}

1200

SWIGRUNTIME PyObject *

1201

SWIG_Py_None(void)

1202

{

1203

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

1204

return none;

1205

}

1206

#endif

1207

1208

/* The python void return value */

1209

1210

SWIGRUNTIMEINLINE PyObject *

1211

SWIG_Py_Void(void)

1212

{

1213

PyObject *none = Py_None;

1214

Py_INCREF(none);

1215

return none;

1216

}

1217

1218

/* PySwigClientData */

1219

1220

typedef struct {

1221

PyObject *klass;

1222

PyObject *newraw;

1223

PyObject *newargs;

1224

PyObject *destroy;

1225

int delargs;

1226

int implicitconv;

1227

} PySwigClientData;

1228

1229

SWIGRUNTIMEINLINE int

1230

SWIG_Python_CheckImplicit(swig_type_info *ty)

1231

{

1232

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

1233

return data ? data->implicitconv : 0;

1234

}

1235

1236

SWIGRUNTIMEINLINE PyObject *

1237

SWIG_Python_ExceptionType(swig_type_info *desc) {

1238

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

1239

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

1240

return (klass ? klass : PyExc_RuntimeError);

1241

}

1242

1243

1244

SWIGRUNTIME PySwigClientData *

1245

PySwigClientData_New(PyObject* obj)

1246

{

1247

if (!obj) {

1248

return 0;

1249

} else {

1250

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

1251

/* the klass element */

1252

data->klass = obj;

1253

Py_INCREF(data->klass);

1254

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

1255

if (PyClass_Check(obj)) {

1256

data->newraw = 0;

1257

data->newargs = obj;

1258

Py_INCREF(obj);

1259

} else {

1260

#if (PY_VERSION_HEX < 0x02020000)

1261

data->newraw = 0;

1262

#else

1263

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

1264

#endif

1265

if (data->newraw) {

1266

Py_INCREF(data->newraw);

1267

data->newargs = PyTuple_New(1);

1268

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

1269

} else {

1270

data->newargs = obj;

1271

}

1272

Py_INCREF(data->newargs);

1273

}

1274

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

1275

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

1276

if (PyErr_Occurred()) {

1277

PyErr_Clear();

1278

data->destroy = 0;

1279

}

1280

if (data->destroy) {

1281

int flags;

1282

Py_INCREF(data->destroy);

1283

flags = PyCFunction_GET_FLAGS(data->destroy);

1284

#ifdef METH_O

1285

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

1286

#else

1287

data->delargs = 0;

1288

#endif

1289

} else {

1290

data->delargs = 0;

1291

}

1292

data->implicitconv = 0;

1293

return data;

1294

}

1295

}

1296

1297

SWIGRUNTIME void

1298

PySwigClientData_Del(PySwigClientData* data)

1299

{

1300

Py_XDECREF(data->newraw);

1301

Py_XDECREF(data->newargs);

1302

Py_XDECREF(data->destroy);

1303

}

1304

1305

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

1306

1307

typedef struct {

1308

PyObject_HEAD

1309

void *ptr;

1310

swig_type_info *ty;

1311

int own;

1312

PyObject *next;

1313

} PySwigObject;

1314

1315

SWIGRUNTIME PyObject *

1316

PySwigObject_long(PySwigObject *v)

1317

{

1318

return PyLong_FromVoidPtr(v->ptr);

1319

}

1320

1321

SWIGRUNTIME PyObject *

1322

PySwigObject_format(const char* fmt, PySwigObject *v)

1323

{

1324

PyObject *res = NULL;

1325

PyObject *args = PyTuple_New(1);

1326

if (args) {

1327

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

1328

PyObject *ofmt = PyString_FromString(fmt);

1329

if (ofmt) {

1330

res = PyString_Format(ofmt,args);

1331

Py_DECREF(ofmt);

1332

}

1333

Py_DECREF(args);

1334

}

1335

}

1336

return res;

1337

}

1338

1339

SWIGRUNTIME PyObject *

1340

PySwigObject_oct(PySwigObject *v)

1341

{

1342

return PySwigObject_format("%o",v);

1343

}

1344

1345

SWIGRUNTIME PyObject *

1346

PySwigObject_hex(PySwigObject *v)

1347

{

1348

return PySwigObject_format("%x",v);

1349

}

1350

1351

SWIGRUNTIME PyObject *

1352

#ifdef METH_NOARGS

1353

PySwigObject_repr(PySwigObject *v)

1354

#else

1355

PySwigObject_repr(PySwigObject *v, PyObject *args)

1356

#endif

1357

{

1358

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

1359

PyObject *hex = PySwigObject_hex(v);

1360

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

1361

Py_DECREF(hex);

1362

if (v->next) {

1363

#ifdef METH_NOARGS

1364

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

1365

#else

1366

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

1367

#endif

1368

PyString_ConcatAndDel(&repr,nrep);

1369

}

1370

return repr;

1371

}

1372

1373

SWIGRUNTIME int

1374

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

1375

{

1376

#ifdef METH_NOARGS

1377

PyObject *repr = PySwigObject_repr(v);

1378

#else

1379

PyObject *repr = PySwigObject_repr(v, NULL);

1380

#endif

1381

if (repr) {

1382

fputs(PyString_AsString(repr), fp);

1383

Py_DECREF(repr);

1384

return 0;

1385

} else {

1386

return 1;

1387

}

1388

}

1389

1390

SWIGRUNTIME PyObject *

1391

PySwigObject_str(PySwigObject *v)

1392

{

1393

char result[SWIG_BUFFER_SIZE];

1394

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

1395

PyString_FromString(result) : 0;

1396

}

1397

1398

SWIGRUNTIME int

1399

PySwigObject_compare(PySwigObject *v, PySwigObject *w)

1400

{

1401

void *i = v->ptr;

1402

void *j = w->ptr;

1403

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

1404

}

1405

1406

SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);

1407

1408

SWIGRUNTIME PyTypeObject*

1409

PySwigObject_type(void) {

1410

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

1411

return type;

1412

}

1413

1414

SWIGRUNTIMEINLINE int

1415

PySwigObject_Check(PyObject *op) {

1416

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

1417

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

1418

}

1419

1420

SWIGRUNTIME PyObject *

1421

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

1422

1423

SWIGRUNTIME void

1424

PySwigObject_dealloc(PyObject *v)

1425

{

1426

PySwigObject *sobj = (PySwigObject *) v;

1427

PyObject *next = sobj->next;

1428

if (sobj->own) {

1429

swig_type_info *ty = sobj->ty;

1430

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

1431

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

1432

if (destroy) {

1433

/* destroy is always a VARARGS method */

1434

PyObject *res;

1435

if (data->delargs) {

1436

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

1437

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

1438

res = SWIG_Python_CallFunctor(destroy, tmp);

1439

Py_DECREF(tmp);

1440

} else {

1441

PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);

1442

PyObject *mself = PyCFunction_GET_SELF(destroy);

1443

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

1444

}

1445

Py_XDECREF(res);

1446

} else {

1447

const char *name = SWIG_TypePrettyName(ty);

1448

#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)

1449

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

1450

#endif

1451

}

1452

}

1453

Py_XDECREF(next);

1454

PyObject_DEL(v);

1455

}

1456

1457

SWIGRUNTIME PyObject*

1458

PySwigObject_append(PyObject* v, PyObject* next)

1459

{

1460

PySwigObject *sobj = (PySwigObject *) v;

1461

#ifndef METH_O

1462

PyObject *tmp = 0;

1463

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

1464

next = tmp;

1465

#endif

1466

if (!PySwigObject_Check(next)) {

1467

return NULL;

1468

}

1469

sobj->next = next;

1470

Py_INCREF(next);

1471

return SWIG_Py_Void();

1472

}

1473

1474

SWIGRUNTIME PyObject*

1475

#ifdef METH_NOARGS

1476

PySwigObject_next(PyObject* v)

1477

#else

1478

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

1479

#endif

1480

{

1481

PySwigObject *sobj = (PySwigObject *) v;

1482

if (sobj->next) {

1483

Py_INCREF(sobj->next);

1484

return sobj->next;

1485

} else {

1486

return SWIG_Py_Void();

1487

}

1488

}

1489

1490

SWIGINTERN PyObject*

1491

#ifdef METH_NOARGS

1492

PySwigObject_disown(PyObject *v)

1493

#else

1494

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

1495

#endif

1496

{

1497

PySwigObject *sobj = (PySwigObject *)v;

1498

sobj->own = 0;

1499

return SWIG_Py_Void();

1500

}

1501

1502

SWIGINTERN PyObject*

1503

#ifdef METH_NOARGS

1504

PySwigObject_acquire(PyObject *v)

1505

#else

1506

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

1507

#endif

1508

{

1509

PySwigObject *sobj = (PySwigObject *)v;

1510

sobj->own = SWIG_POINTER_OWN;

1511

return SWIG_Py_Void();

1512

}

1513

1514

SWIGINTERN PyObject*

1515

PySwigObject_own(PyObject *v, PyObject *args)

1516

{

1517

PyObject *val = 0;

1518

#if (PY_VERSION_HEX < 0x02020000)

1519

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

1520

#else

1521

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

1522

#endif

1523

{

1524

return NULL;

1525

}

1526

else

1527

{

1528

PySwigObject *sobj = (PySwigObject *)v;

1529

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

1530

if (val) {

1531

#ifdef METH_NOARGS

1532

if (PyObject_IsTrue(val)) {

1533

PySwigObject_acquire(v);

1534

} else {

1535

PySwigObject_disown(v);

1536

}

1537

#else

1538

if (PyObject_IsTrue(val)) {

1539

PySwigObject_acquire(v,args);

1540

} else {

1541

PySwigObject_disown(v,args);

1542

}

1543

#endif

1544

}

1545

return obj;

1546

}

1547

}

1548

1549

#ifdef METH_O

1550

static PyMethodDef

1551

swigobject_methods[] = {

1552

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

1553

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

1554

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

1555

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

1556

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

1557

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

1558

{0, 0, 0, 0}

1559

};

1560

#else

1561

static PyMethodDef

1562

swigobject_methods[] = {

1563

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

1564

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

1565

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

1566

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

1567

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

1568

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

1569

{0, 0, 0, 0}

1570

};

1571

#endif

1572

1573

#if PY_VERSION_HEX < 0x02020000

1574

SWIGINTERN PyObject *

1575

PySwigObject_getattr(PySwigObject *sobj,char *name)

1576

{

1577

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

1578

}

1579

#endif

1580

1581

SWIGRUNTIME PyTypeObject*

1582

_PySwigObject_type(void) {

1583

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

1584

1585

static PyNumberMethods PySwigObject_as_number = {

1586

(binaryfunc)0, /*nb_add*/

1587

(binaryfunc)0, /*nb_subtract*/

1588

(binaryfunc)0, /*nb_multiply*/

1589

(binaryfunc)0, /*nb_divide*/

1590

(binaryfunc)0, /*nb_remainder*/

1591

(binaryfunc)0, /*nb_divmod*/

1592

(ternaryfunc)0,/*nb_power*/

1593

(unaryfunc)0, /*nb_negative*/

1594

(unaryfunc)0, /*nb_positive*/

1595

(unaryfunc)0, /*nb_absolute*/

1596

(inquiry)0, /*nb_nonzero*/

1597

0, /*nb_invert*/

1598

0, /*nb_lshift*/

1599

0, /*nb_rshift*/

1600

0, /*nb_and*/

1601

0, /*nb_xor*/

1602

0, /*nb_or*/

1603

(coercion)0, /*nb_coerce*/

1604

(unaryfunc)PySwigObject_long, /*nb_int*/

1605

(unaryfunc)PySwigObject_long, /*nb_long*/

1606

(unaryfunc)0, /*nb_float*/

1607

(unaryfunc)PySwigObject_oct, /*nb_oct*/

1608

(unaryfunc)PySwigObject_hex, /*nb_hex*/

1609

#if PY_VERSION_HEX >= 0x02020000

1610

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

1611

#elif PY_VERSION_HEX >= 0x02000000

1612

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

1613

#endif

1614

};

1615

1616

static PyTypeObject pyswigobject_type;

1617

static int type_init = 0;

1618

if (!type_init) {

1619

const PyTypeObject tmp

1620

= {

1621

PyObject_HEAD_INIT(NULL)

1622

0, /* ob_size */

1623

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

1624

sizeof(PySwigObject), /* tp_basicsize */

1625

0, /* tp_itemsize */

1626

(destructor)PySwigObject_dealloc, /* tp_dealloc */

1627

(printfunc)PySwigObject_print, /* tp_print */

1628

#if PY_VERSION_HEX < 0x02020000

1629

(getattrfunc)PySwigObject_getattr, /* tp_getattr */

1630

#else

1631

(getattrfunc)0, /* tp_getattr */

1632

#endif

1633

(setattrfunc)0, /* tp_setattr */

1634

(cmpfunc)PySwigObject_compare, /* tp_compare */

1635

(reprfunc)PySwigObject_repr, /* tp_repr */

1636

&PySwigObject_as_number, /* tp_as_number */

1637

0, /* tp_as_sequence */

1638

0, /* tp_as_mapping */

1639

(hashfunc)0, /* tp_hash */

1640

(ternaryfunc)0, /* tp_call */

1641

(reprfunc)PySwigObject_str, /* tp_str */

1642

PyObject_GenericGetAttr, /* tp_getattro */

1643

0, /* tp_setattro */

1644

0, /* tp_as_buffer */

1645

Py_TPFLAGS_DEFAULT, /* tp_flags */

1646

swigobject_doc, /* tp_doc */

1647

0, /* tp_traverse */

1648

0, /* tp_clear */

1649

0, /* tp_richcompare */

1650

0, /* tp_weaklistoffset */

1651

#if PY_VERSION_HEX >= 0x02020000

1652

0, /* tp_iter */

1653

0, /* tp_iternext */

1654

swigobject_methods, /* tp_methods */

1655

0, /* tp_members */

1656

0, /* tp_getset */

1657

0, /* tp_base */

1658

0, /* tp_dict */

1659

0, /* tp_descr_get */

1660

0, /* tp_descr_set */

1661

0, /* tp_dictoffset */

1662

0, /* tp_init */

1663

0, /* tp_alloc */

1664

0, /* tp_new */

1665

0, /* tp_free */

1666

0, /* tp_is_gc */

1667

0, /* tp_bases */

1668

0, /* tp_mro */

1669

0, /* tp_cache */

1670

0, /* tp_subclasses */

1671

0, /* tp_weaklist */

1672

#endif

1673

#if PY_VERSION_HEX >= 0x02030000

1674

0, /* tp_del */

1675

#endif

1676

#ifdef COUNT_ALLOCS

1677

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

1678

#endif

1679

};

1680

pyswigobject_type = tmp;

1681

pyswigobject_type.ob_type = &PyType_Type;

1682

type_init = 1;

1683

}

1684

return &pyswigobject_type;

1685

}

1686

1687

SWIGRUNTIME PyObject *

1688

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

1689

{

1690

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

1691

if (sobj) {

1692

sobj->ptr = ptr;

1693

sobj->ty = ty;

1694

sobj->own = own;

1695

sobj->next = 0;

1696

}

1697

return (PyObject *)sobj;

1698

}

1699

1700

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

1701

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

1702

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

1703

1704

typedef struct {

1705

PyObject_HEAD

1706

void *pack;

1707

swig_type_info *ty;

1708

size_t size;

1709

} PySwigPacked;

1710

1711

SWIGRUNTIME int

1712

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

1713

{

1714

char result[SWIG_BUFFER_SIZE];

1715

fputs("<Swig Packed ", fp);

1716

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

1717

fputs("at ", fp);

1718

fputs(result, fp);

1719

}

1720

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

1721

fputs(">", fp);

1722

return 0;

1723

}

1724

1725

SWIGRUNTIME PyObject *

1726

PySwigPacked_repr(PySwigPacked *v)

1727

{

1728

char result[SWIG_BUFFER_SIZE];

1729

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

1730

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

1731

} else {

1732

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

1733

}

1734

}

1735

1736

SWIGRUNTIME PyObject *

1737

PySwigPacked_str(PySwigPacked *v)

1738

{

1739

char result[SWIG_BUFFER_SIZE];

1740

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

1741

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

1742

} else {

1743

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

1744

}

1745

}

1746

1747

SWIGRUNTIME int

1748

PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)

1749

{

1750

size_t i = v->size;

1751

size_t j = w->size;

1752

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

1753

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

1754

}

1755

1756

SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);

1757

1758

SWIGRUNTIME PyTypeObject*

1759

PySwigPacked_type(void) {

1760

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

1761

return type;

1762

}

1763

1764

SWIGRUNTIMEINLINE int

1765

PySwigPacked_Check(PyObject *op) {

1766

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

1767

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

1768

}

1769

1770

SWIGRUNTIME void

1771

PySwigPacked_dealloc(PyObject *v)

1772

{

1773

if (PySwigPacked_Check(v)) {

1774

PySwigPacked *sobj = (PySwigPacked *) v;

1775

free(sobj->pack);

1776

}

1777

PyObject_DEL(v);

1778

}

1779

1780

SWIGRUNTIME PyTypeObject*

1781

_PySwigPacked_type(void) {

1782

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

1783

static PyTypeObject pyswigpacked_type;

1784

static int type_init = 0;

1785

if (!type_init) {

1786

const PyTypeObject tmp

1787

= {

1788

PyObject_HEAD_INIT(NULL)

1789

0, /* ob_size */

1790

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

1791

sizeof(PySwigPacked), /* tp_basicsize */

1792

0, /* tp_itemsize */

1793

(destructor)PySwigPacked_dealloc, /* tp_dealloc */

1794

(printfunc)PySwigPacked_print, /* tp_print */

1795

(getattrfunc)0, /* tp_getattr */

1796

(setattrfunc)0, /* tp_setattr */

1797

(cmpfunc)PySwigPacked_compare, /* tp_compare */

1798

(reprfunc)PySwigPacked_repr, /* tp_repr */

1799

0, /* tp_as_number */

1800

0, /* tp_as_sequence */

1801

0, /* tp_as_mapping */

1802

(hashfunc)0, /* tp_hash */

1803

(ternaryfunc)0, /* tp_call */

1804

(reprfunc)PySwigPacked_str, /* tp_str */

1805

PyObject_GenericGetAttr, /* tp_getattro */

1806

0, /* tp_setattro */

1807

0, /* tp_as_buffer */

1808

Py_TPFLAGS_DEFAULT, /* tp_flags */

1809

swigpacked_doc, /* tp_doc */

1810

0, /* tp_traverse */

1811

0, /* tp_clear */

1812

0, /* tp_richcompare */

1813

0, /* tp_weaklistoffset */

1814

#if PY_VERSION_HEX >= 0x02020000

1815

0, /* tp_iter */

1816

0, /* tp_iternext */

1817

0, /* tp_methods */

1818

0, /* tp_members */

1819

0, /* tp_getset */

1820

0, /* tp_base */

1821

0, /* tp_dict */

1822

0, /* tp_descr_get */

1823

0, /* tp_descr_set */

1824

0, /* tp_dictoffset */

1825

0, /* tp_init */

1826

0, /* tp_alloc */

1827

0, /* tp_new */

1828

0, /* tp_free */

1829

0, /* tp_is_gc */

1830

0, /* tp_bases */

1831

0, /* tp_mro */

1832

0, /* tp_cache */

1833

0, /* tp_subclasses */

1834

0, /* tp_weaklist */

1835

#endif

1836

#if PY_VERSION_HEX >= 0x02030000

1837

0, /* tp_del */

1838

#endif

1839

#ifdef COUNT_ALLOCS

1840

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

1841

#endif

1842

};

1843

pyswigpacked_type = tmp;

1844

pyswigpacked_type.ob_type = &PyType_Type;

1845

type_init = 1;

1846

}

1847

return &pyswigpacked_type;

1848

}

1849

1850

SWIGRUNTIME PyObject *

1851

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

1852

{

1853

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

1854

if (sobj) {

1855

void *pack = malloc(size);

1856

if (pack) {

1857

memcpy(pack, ptr, size);

1858

sobj->pack = pack;

1859

sobj->ty = ty;

1860

sobj->size = size;

1861

} else {

1862

PyObject_DEL((PyObject *) sobj);

1863

sobj = 0;

1864

}

1865

}

1866

return (PyObject *) sobj;

1867

}

1868

1869

SWIGRUNTIME swig_type_info *

1870

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

1871

{

1872

if (PySwigPacked_Check(obj)) {

1873

PySwigPacked *sobj = (PySwigPacked *)obj;

1874

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

1875

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

1876

return sobj->ty;

1877

} else {

1878

return 0;

1879

}

1880

}

1881

1882

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

1883

* pointers/data manipulation

1884

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

1885

1886

SWIGRUNTIMEINLINE PyObject *

1887

_SWIG_This(void)

1888

{

1889

return PyString_FromString("this");

1890

}

1891

1892

SWIGRUNTIME PyObject *

1893

SWIG_This(void)

1894

{

1895

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

1896

return swig_this;

1897

}

1898

1899

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

1900

1901

SWIGRUNTIME PySwigObject *

1902

SWIG_Python_GetSwigThis(PyObject *pyobj)

1903

{

1904

if (PySwigObject_Check(pyobj)) {

1905

return (PySwigObject *) pyobj;

1906

} else {

1907

PyObject *obj = 0;

1908

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

1909

if (PyInstance_Check(pyobj)) {

1910

obj = _PyInstance_Lookup(pyobj, SWIG_This());

1911

} else {

1912

PyObject **dictptr = _PyObject_GetDictPtr(pyobj);

1913

if (dictptr != NULL) {

1914

PyObject *dict = *dictptr;

1915

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

1916

} else {

1917

#ifdef PyWeakref_CheckProxy

1918

if (PyWeakref_CheckProxy(pyobj)) {

1919

PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);

1920

return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;

1921

}

1922

#endif

1923

obj = PyObject_GetAttr(pyobj,SWIG_This());

1924

if (obj) {

1925

Py_DECREF(obj);

1926

} else {

1927

if (PyErr_Occurred()) PyErr_Clear();

1928

return 0;

1929

}

1930

}

1931

}

1932

#else

1933

obj = PyObject_GetAttr(pyobj,SWIG_This());

1934

if (obj) {

1935

Py_DECREF(obj);

1936

} else {

1937

if (PyErr_Occurred()) PyErr_Clear();

1938

return 0;

1939

}

1940

#endif

1941

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

1942

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

1943

PySwigObject from it */

1944

return SWIG_Python_GetSwigThis(obj);

1945

}

1946

return (PySwigObject *)obj;

1947

}

1948

}

1949

1950

/* Acquire a pointer value */

1951

1952

SWIGRUNTIME int

1953

SWIG_Python_AcquirePtr(PyObject *obj, int own) {

1954

if (own) {

1955

PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);

1956

if (sobj) {

1957

int oldown = sobj->own;

1958

sobj->own = own;

1959

return oldown;

1960

}

1961

}

1962

return 0;

1963

}

1964

1965

/* Convert a pointer value */

1966

1967

SWIGRUNTIME int

1968

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

1969

if (!obj) return SWIG_ERROR;

1970

if (obj == Py_None) {

1971

if (ptr) *ptr = 0;

1972

return SWIG_OK;

1973

} else {

1974

PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);

1975

while (sobj) {

1976

void *vptr = sobj->ptr;

1977

if (ty) {

1978

swig_type_info *to = sobj->ty;

1979

if (to == ty) {

1980

/* no type cast needed */

1981

if (ptr) *ptr = vptr;

1982

break;

1983

} else {

1984

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

1985

if (!tc) {

1986

sobj = (PySwigObject *)sobj->next;

1987

} else {

1988

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

1989

break;

1990

}

1991

}

1992

} else {

1993

if (ptr) *ptr = vptr;

1994

break;

1995

}

1996

}

1997

if (sobj) {

1998

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

1999

if (flags & SWIG_POINTER_DISOWN) {

2000

sobj->own = 0;

2001

}

2002

return SWIG_OK;

2003

} else {

2004

int res = SWIG_ERROR;

2005

if (flags & SWIG_POINTER_IMPLICIT_CONV) {

2006

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

2007

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

2008

PyObject *klass = data->klass;

2009

if (klass) {

2010

PyObject *impconv;

2011

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

2012

impconv = SWIG_Python_CallFunctor(klass, obj);

2013

data->implicitconv = 0;

2014

if (PyErr_Occurred()) {

2015

PyErr_Clear();

2016

impconv = 0;

2017

}

2018

if (impconv) {

2019

PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);

2020

if (iobj) {

2021

void *vptr;

2022

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

2023

if (SWIG_IsOK(res)) {

2024

if (ptr) {

2025

*ptr = vptr;

2026

/* transfer the ownership to 'ptr' */

2027

iobj->own = 0;

2028

res = SWIG_AddCast(res);

2029

res = SWIG_AddNewMask(res);

2030

} else {

2031

res = SWIG_AddCast(res);

2032

}

2033

}

2034

}

2035

Py_DECREF(impconv);

2036

}

2037

}

2038

}

2039

}

2040

return res;

2041

}

2042

}

2043

}

2044

2045

/* Convert a function ptr value */

2046

2047

SWIGRUNTIME int

2048

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

2049

if (!PyCFunction_Check(obj)) {

2050

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

2051

} else {

2052

void *vptr = 0;

2053

2054

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

2055

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

2056

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

2057

if (desc) {

2058

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

2059

if (!desc) return SWIG_ERROR;

2060

}

2061

if (ty) {

2062

swig_cast_info *tc = SWIG_TypeCheck(desc,ty);

2063

if (!tc) return SWIG_ERROR;

2064

*ptr = SWIG_TypeCast(tc,vptr);

2065

} else {

2066

*ptr = vptr;

2067

}

2068

return SWIG_OK;

2069

}

2070

}

2071

2072

/* Convert a packed value value */

2073

2074

SWIGRUNTIME int

2075

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

2076

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

2077

if (!to) return SWIG_ERROR;

2078

if (ty) {

2079

if (to != ty) {

2080

/* check type cast? */

2081

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

2082

if (!tc) return SWIG_ERROR;

2083

}

2084

}

2085

return SWIG_OK;

2086

}

2087

2088

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

2089

* Create a new pointer object

2090

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

2091

2092

/*

2093

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

2094

'this' attribute.

2095

*/

2096

2097

SWIGRUNTIME PyObject*

2098

SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)

2099

{

2100

#if (PY_VERSION_HEX >= 0x02020000)

2101

PyObject *inst = 0;

2102

PyObject *newraw = data->newraw;

2103

if (newraw) {

2104

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

2105

if (inst) {

2106

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)

2107

PyObject **dictptr = _PyObject_GetDictPtr(inst);

2108

if (dictptr != NULL) {

2109

PyObject *dict = *dictptr;

2110

if (dict == NULL) {

2111

dict = PyDict_New();

2112

*dictptr = dict;

2113

PyDict_SetItem(dict, SWIG_This(), swig_this);

2114

}

2115

}

2116

#else

2117

PyObject *key = SWIG_This();

2118

PyObject_SetAttr(inst, key, swig_this);

2119

#endif

2120

}

2121

} else {

2122

PyObject *dict = PyDict_New();

2123

PyDict_SetItem(dict, SWIG_This(), swig_this);

2124

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

2125

Py_DECREF(dict);

2126

}

2127

return inst;

2128

#else

2129

#if (PY_VERSION_HEX >= 0x02010000)

2130

PyObject *inst;

2131

PyObject *dict = PyDict_New();

2132

PyDict_SetItem(dict, SWIG_This(), swig_this);

2133

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

2134

Py_DECREF(dict);

2135

return (PyObject *) inst;

2136

#else

2137

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

2138

if (inst == NULL) {

2139

return NULL;

2140

}

2141

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

2142

Py_INCREF(inst->in_class);

2143

inst->in_dict = PyDict_New();

2144

if (inst->in_dict == NULL) {

2145

Py_DECREF(inst);

2146

return NULL;

2147

}

2148

#ifdef Py_TPFLAGS_HAVE_WEAKREFS

2149

inst->in_weakreflist = NULL;

2150

#endif

2151

#ifdef Py_TPFLAGS_GC

2152

PyObject_GC_Init(inst);

2153

#endif

2154

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

2155

return (PyObject *) inst;

2156

#endif

2157

#endif

2158

}

2159

2160

SWIGRUNTIME void

2161

SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)

2162

{

2163

PyObject *dict;

2164

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

2165

PyObject **dictptr = _PyObject_GetDictPtr(inst);

2166

if (dictptr != NULL) {

2167

dict = *dictptr;

2168

if (dict == NULL) {

2169

dict = PyDict_New();

2170

*dictptr = dict;

2171

}

2172

PyDict_SetItem(dict, SWIG_This(), swig_this);

2173

return;

2174

}

2175

#endif

2176

dict = PyObject_GetAttrString(inst, "__dict__");

2177

PyDict_SetItem(dict, SWIG_This(), swig_this);

2178

Py_DECREF(dict);

2179

}

2180

2181

2182

SWIGINTERN PyObject *

2183

SWIG_Python_InitShadowInstance(PyObject *args) {

2184

PyObject *obj[2];

2185

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

2186

return NULL;

2187

} else {

2188

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

2189

if (sthis) {

2190

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

2191

} else {

2192

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

2193

}

2194

return SWIG_Py_Void();

2195

}

2196

}

2197

2198

/* Create a new pointer object */

2199

2200

SWIGRUNTIME PyObject *

2201

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

2202

if (!ptr) {

2203

return SWIG_Py_Void();

2204

} else {

2205

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

2206

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

2207

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

2208

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

2209

PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);

2210

if (inst) {

2211

Py_DECREF(robj);

2212

robj = inst;

2213

}

2214

}

2215

return robj;

2216

}

2217

}

2218

2219

/* Create a new packed object */

2220

2221

SWIGRUNTIMEINLINE PyObject *

2222

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

2223

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

2224

}

2225

2226

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

2227

* Get type list

2228

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

2229

2230

#ifdef SWIG_LINK_RUNTIME

2231

void *SWIG_ReturnGlobalTypeList(void *);

2232

#endif

2233

2234

SWIGRUNTIME swig_module_info *

2235

SWIG_Python_GetModule(void) {

2236

static void *type_pointer = (void *)0;

2237

/* first check if module already created */

2238

if (!type_pointer) {

2239

#ifdef SWIG_LINK_RUNTIME

2240

type_pointer = SWIG_ReturnGlobalTypeList((void *)0);

2241

#else

2242

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

2243

(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);

2244

if (PyErr_Occurred()) {

2245

PyErr_Clear();

2246

type_pointer = (void *)0;

2247

}

2248

#endif

2249

}

2250

return (swig_module_info *) type_pointer;

2251

}

2252

2253

#if PY_MAJOR_VERSION < 2

2254

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

2255

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

2256

SWIGINTERN int

2257

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

2258

{

2259

PyObject *dict;

2260

if (!PyModule_Check(m)) {

2261

PyErr_SetString(PyExc_TypeError,

2262

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

2263

return SWIG_ERROR;

2264

}

2265

if (!o) {

2266

PyErr_SetString(PyExc_TypeError,

2267

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

2268

return SWIG_ERROR;

2269

}

2270

2271

dict = PyModule_GetDict(m);

2272

if (dict == NULL) {

2273

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

2274

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

2275

PyModule_GetName(m));

2276

return SWIG_ERROR;

2277

}

2278

if (PyDict_SetItemString(dict, name, o))

2279

return SWIG_ERROR;

2280

Py_DECREF(o);

2281

return SWIG_OK;

2282

}

2283

#endif

2284

2285

SWIGRUNTIME void

2286

SWIG_Python_DestroyModule(void *vptr)

2287

{

2288

swig_module_info *swig_module = (swig_module_info *) vptr;

2289

swig_type_info **types = swig_module->types;

2290

size_t i;

2291

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

2292

swig_type_info *ty = types[i];

2293

if (ty->owndata) {

2294

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

2295

if (data) PySwigClientData_Del(data);

2296

}

2297

}

2298

Py_DECREF(SWIG_This());

2299

}

2300

2301

SWIGRUNTIME void

2302

SWIG_Python_SetModule(swig_module_info *swig_module) {

2303

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

2304

2305

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

2306

swig_empty_runtime_method_table);

2307

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

2308

if (pointer && module) {

2309

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

2310

} else {

2311

Py_XDECREF(pointer);

2312

}

2313

}

2314

2315

/* The python cached type query */

2316

SWIGRUNTIME PyObject *

2317

SWIG_Python_TypeCache() {

2318

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

2319

return cache;

2320

}

2321

2322

SWIGRUNTIME swig_type_info *

2323

SWIG_Python_TypeQuery(const char *type)

2324

{

2325

PyObject *cache = SWIG_Python_TypeCache();

2326

PyObject *key = PyString_FromString(type);

2327

PyObject *obj = PyDict_GetItem(cache, key);

2328

swig_type_info *descriptor;

2329

if (obj) {

2330

descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);

2331

} else {

2332

swig_module_info *swig_module = SWIG_Python_GetModule();

2333

descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);

2334

if (descriptor) {

2335

obj = PyCObject_FromVoidPtr(descriptor, NULL);

2336

PyDict_SetItem(cache, key, obj);

2337

Py_DECREF(obj);

2338

}

2339

}

2340

Py_DECREF(key);

2341

return descriptor;

2342

}

2343

2344

/*

2345

For backward compatibility only

2346

*/

2347

#define SWIG_POINTER_EXCEPTION 0

2348

#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)

2349

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

2350

2351

SWIGRUNTIME int

2352

SWIG_Python_AddErrMesg(const char* mesg, int infront)

2353

{

2354

if (PyErr_Occurred()) {

2355

PyObject *type = 0;

2356

PyObject *value = 0;

2357

PyObject *traceback = 0;

2358

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

2359

if (value) {

2360

PyObject *old_str = PyObject_Str(value);

2361

Py_XINCREF(type);

2362

PyErr_Clear();

2363

if (infront) {

2364

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

2365

} else {

2366

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

2367

}

2368

Py_DECREF(old_str);

2369

}

2370

return 1;

2371

} else {

2372

return 0;

2373

}

2374

}

2375

2376

SWIGRUNTIME int

2377

SWIG_Python_ArgFail(int argnum)

2378

{

2379

if (PyErr_Occurred()) {

2380

/* add information about failing argument */

2381

char mesg[256];

2382

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

2383

return SWIG_Python_AddErrMesg(mesg, 1);

2384

} else {

2385

return 0;

2386

}

2387

}

2388

2389

SWIGRUNTIMEINLINE const char *

2390

PySwigObject_GetDesc(PyObject *self)

2391

{

2392

PySwigObject *v = (PySwigObject *)self;

2393

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

2394

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

2395

}

2396

2397

SWIGRUNTIME void

2398

SWIG_Python_TypeError(const char *type, PyObject *obj)

2399

{

2400

if (type) {

2401

#if defined(SWIG_COBJECT_TYPES)

2402

if (obj && PySwigObject_Check(obj)) {

2403

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

2404

if (otype) {

2405

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

2406

type, otype);

2407

return;

2408

}

2409

} else

2410

#endif

2411

{

2412

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

2413

if (otype) {

2414

PyObject *str = PyObject_Str(obj);

2415

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

2416

if (cstr) {

2417

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

2418

type, otype, cstr);

2419

} else {

2420

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

2421

type, otype);

2422

}

2423

Py_XDECREF(str);

2424

return;

2425

}

2426

}

2427

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

2428

} else {

2429

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

2430

}

2431

}

2432

2433

2434

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

2435

SWIGRUNTIME void *

2436

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

2437

void *result;

2438

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

2439

PyErr_Clear();

2440

if (flags & SWIG_POINTER_EXCEPTION) {

2441

SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);

2442

SWIG_Python_ArgFail(argnum);

2443

}

2444

}

2445

return result;

2446

}

2447

2448

2449

#ifdef __cplusplus

2450

#if 0

2451

{ /* cc-mode */

2452

#endif

2453

}

2454

#endif

2455

2456

2457

2458

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

2459

2460

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

2461

2462

2463

2464

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

2465

2466

#define SWIGTYPE_p_char swig_types[0]

2467

#define SWIGTYPE_p_double swig_types[1]

2468

#define SWIGTYPE_p_form_ops_t swig_types[2]

2469

#define SWIGTYPE_p_int swig_types[3]

2470

#define SWIGTYPE_p_long swig_types[4]

2471

#define SWIGTYPE_p_p_wxRichTextBox swig_types[5]

2472

#define SWIGTYPE_p_p_wxRichTextBuffer swig_types[6]

2473

#define SWIGTYPE_p_p_wxRichTextCompositeObject swig_types[7]

2474

#define SWIGTYPE_p_p_wxRichTextImage swig_types[8]

2475

#define SWIGTYPE_p_p_wxRichTextObject swig_types[9]

2476

#define SWIGTYPE_p_p_wxRichTextParagraph swig_types[10]

2477

#define SWIGTYPE_p_p_wxRichTextParagraphLayoutBox swig_types[11]

2478

#define SWIGTYPE_p_p_wxRichTextPlainText swig_types[12]

2479

#define SWIGTYPE_p_unsigned_char swig_types[13]

2480

#define SWIGTYPE_p_unsigned_int swig_types[14]

2481

#define SWIGTYPE_p_unsigned_long swig_types[15]

2482

#define SWIGTYPE_p_wxANIHandler swig_types[16]

2483

#define SWIGTYPE_p_wxAcceleratorTable swig_types[17]

2484

#define SWIGTYPE_p_wxActivateEvent swig_types[18]

2485

#define SWIGTYPE_p_wxArrayInt swig_types[19]

2486

#define SWIGTYPE_p_wxArrayString swig_types[20]

2487

#define SWIGTYPE_p_wxBMPHandler swig_types[21]

2488

#define SWIGTYPE_p_wxBitmap swig_types[22]

2489

#define SWIGTYPE_p_wxBoxSizer swig_types[23]

2490

#define SWIGTYPE_p_wxCURHandler swig_types[24]

2491

#define SWIGTYPE_p_wxCalculateLayoutEvent swig_types[25]

2492

#define SWIGTYPE_p_wxChar swig_types[26]

2493

#define SWIGTYPE_p_wxChildFocusEvent swig_types[27]

2494

#define SWIGTYPE_p_wxClipboardTextEvent swig_types[28]

2495

#define SWIGTYPE_p_wxCloseEvent swig_types[29]

2496

#define SWIGTYPE_p_wxColour swig_types[30]

2497

#define SWIGTYPE_p_wxColourData swig_types[31]

2498

#define SWIGTYPE_p_wxColourDialog swig_types[32]

2499

#define SWIGTYPE_p_wxCommandEvent swig_types[33]

2500

#define SWIGTYPE_p_wxCommandProcessor swig_types[34]

2501

#define SWIGTYPE_p_wxContextMenuEvent swig_types[35]

2502

#define SWIGTYPE_p_wxControl swig_types[36]

2503

#define SWIGTYPE_p_wxControlWithItems swig_types[37]

2504

#define SWIGTYPE_p_wxCursor swig_types[38]

2505

#define SWIGTYPE_p_wxDC swig_types[39]

2506

#define SWIGTYPE_p_wxDateEvent swig_types[40]

2507

#define SWIGTYPE_p_wxDialog swig_types[41]

2508

#define SWIGTYPE_p_wxDirDialog swig_types[42]

2509

#define SWIGTYPE_p_wxDisplayChangedEvent swig_types[43]

2510

#define SWIGTYPE_p_wxDropFilesEvent swig_types[44]

2511

#define SWIGTYPE_p_wxDuplexMode swig_types[45]

2512

#define SWIGTYPE_p_wxEraseEvent swig_types[46]

2513

#define SWIGTYPE_p_wxEvent swig_types[47]

2514

#define SWIGTYPE_p_wxEvtHandler swig_types[48]

2515

#define SWIGTYPE_p_wxFSFile swig_types[49]

2516

#define SWIGTYPE_p_wxFileDialog swig_types[50]

2517

#define SWIGTYPE_p_wxFileSystem swig_types[51]

2518

#define SWIGTYPE_p_wxFindDialogEvent swig_types[52]

2519

#define SWIGTYPE_p_wxFindReplaceData swig_types[53]

2520

#define SWIGTYPE_p_wxFindReplaceDialog swig_types[54]

2521

#define SWIGTYPE_p_wxFlexGridSizer swig_types[55]

2522

#define SWIGTYPE_p_wxFocusEvent swig_types[56]

2523

#define SWIGTYPE_p_wxFont swig_types[57]

2524

#define SWIGTYPE_p_wxFontData swig_types[58]

2525

#define SWIGTYPE_p_wxFontDialog swig_types[59]

2526

#define SWIGTYPE_p_wxFrame swig_types[60]

2527

#define SWIGTYPE_p_wxGBSizerItem swig_types[61]

2528

#define SWIGTYPE_p_wxGIFHandler swig_types[62]

2529

#define SWIGTYPE_p_wxGridBagSizer swig_types[63]

2530

#define SWIGTYPE_p_wxGridSizer swig_types[64]

2531

#define SWIGTYPE_p_wxICOHandler swig_types[65]

2532

#define SWIGTYPE_p_wxIconizeEvent swig_types[66]

2533

#define SWIGTYPE_p_wxIdleEvent swig_types[67]

2534

#define SWIGTYPE_p_wxImage swig_types[68]

2535

#define SWIGTYPE_p_wxImageHandler swig_types[69]

2536

#define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[70]

2537

#define SWIGTYPE_p_wxInitDialogEvent swig_types[71]

2538

#define SWIGTYPE_p_wxInputStream swig_types[72]

2539

#define SWIGTYPE_p_wxJPEGHandler swig_types[73]

2540

#define SWIGTYPE_p_wxKeyEvent swig_types[74]

2541

#define SWIGTYPE_p_wxLayoutAlgorithm swig_types[75]

2542

#define SWIGTYPE_p_wxLayoutConstraints swig_types[76]

2543

#define SWIGTYPE_p_wxList swig_types[77]

2544

#define SWIGTYPE_p_wxMDIChildFrame swig_types[78]

2545

#define SWIGTYPE_p_wxMDIClientWindow swig_types[79]

2546

#define SWIGTYPE_p_wxMDIParentFrame swig_types[80]

2547

#define SWIGTYPE_p_wxMaximizeEvent swig_types[81]

2548

#define SWIGTYPE_p_wxMenu swig_types[82]

2549

#define SWIGTYPE_p_wxMenuBar swig_types[83]

2550

#define SWIGTYPE_p_wxMenuEvent swig_types[84]

2551

#define SWIGTYPE_p_wxMenuItem swig_types[85]

2552

#define SWIGTYPE_p_wxMessageDialog swig_types[86]

2553

#define SWIGTYPE_p_wxMiniFrame swig_types[87]

2554

#define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[88]

2555

#define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[89]

2556

#define SWIGTYPE_p_wxMouseEvent swig_types[90]

2557

#define SWIGTYPE_p_wxMoveEvent swig_types[91]

2558

#define SWIGTYPE_p_wxMultiChoiceDialog swig_types[92]

2559

#define SWIGTYPE_p_wxNavigationKeyEvent swig_types[93]

2560

#define SWIGTYPE_p_wxNcPaintEvent swig_types[94]

2561

#define SWIGTYPE_p_wxNotifyEvent swig_types[95]

2562

#define SWIGTYPE_p_wxNumberEntryDialog swig_types[96]

2563

#define SWIGTYPE_p_wxObject swig_types[97]

2564

#define SWIGTYPE_p_wxOutputStream swig_types[98]

2565

#define SWIGTYPE_p_wxPCXHandler swig_types[99]

2566

#define SWIGTYPE_p_wxPNGHandler swig_types[100]

2567

#define SWIGTYPE_p_wxPNMHandler swig_types[101]

2568

#define SWIGTYPE_p_wxPageSetupData swig_types[102]

2569

#define SWIGTYPE_p_wxPageSetupDialog swig_types[103]

2570

#define SWIGTYPE_p_wxPageSetupDialogData swig_types[104]

2571

#define SWIGTYPE_p_wxPaintEvent swig_types[105]

2572

#define SWIGTYPE_p_wxPaletteChangedEvent swig_types[106]

2573

#define SWIGTYPE_p_wxPanel swig_types[107]

2574

#define SWIGTYPE_p_wxPaperSize swig_types[108]

2575

#define SWIGTYPE_p_wxPasswordEntryDialog swig_types[109]

2576

#define SWIGTYPE_p_wxPoint swig_types[110]

2577

#define SWIGTYPE_p_wxPopupWindow swig_types[111]

2578

#define SWIGTYPE_p_wxPreviewCanvas swig_types[112]

2579

#define SWIGTYPE_p_wxPreviewControlBar swig_types[113]

2580

#define SWIGTYPE_p_wxPreviewFrame swig_types[114]

2581

#define SWIGTYPE_p_wxPrintData swig_types[115]

2582

#define SWIGTYPE_p_wxPrintDialog swig_types[116]

2583

#define SWIGTYPE_p_wxPrintDialogData swig_types[117]

2584

#define SWIGTYPE_p_wxPrintPreview swig_types[118]

2585

#define SWIGTYPE_p_wxPrinter swig_types[119]

2586

#define SWIGTYPE_p_wxProgressDialog swig_types[120]

2587

#define SWIGTYPE_p_wxPyApp swig_types[121]

2588

#define SWIGTYPE_p_wxPyCommandEvent swig_types[122]

2589

#define SWIGTYPE_p_wxPyEvent swig_types[123]

2590

#define SWIGTYPE_p_wxPyEvtHandler swig_types[124]

2591

#define SWIGTYPE_p_wxPyHtmlListBox swig_types[125]

2592

#define SWIGTYPE_p_wxPyImageHandler swig_types[126]

2593

#define SWIGTYPE_p_wxPyPanel swig_types[127]

2594

#define SWIGTYPE_p_wxPyPopupTransientWindow swig_types[128]

2595

#define SWIGTYPE_p_wxPyPreviewControlBar swig_types[129]

2596

#define SWIGTYPE_p_wxPyPreviewFrame swig_types[130]

2597

#define SWIGTYPE_p_wxPyPrintPreview swig_types[131]

2598

#define SWIGTYPE_p_wxPyPrintout swig_types[132]

2599

#define SWIGTYPE_p_wxPyScrolledWindow swig_types[133]

2600

#define SWIGTYPE_p_wxPySizer swig_types[134]

2601

#define SWIGTYPE_p_wxPyTaskBarIcon swig_types[135]

2602

#define SWIGTYPE_p_wxPyVListBox swig_types[136]

2603

#define SWIGTYPE_p_wxPyVScrolledWindow swig_types[137]

2604

#define SWIGTYPE_p_wxPyValidator swig_types[138]

2605

#define SWIGTYPE_p_wxPyWindow swig_types[139]

2606

#define SWIGTYPE_p_wxQueryLayoutInfoEvent swig_types[140]

2607

#define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[141]

2608

#define SWIGTYPE_p_wxRect swig_types[142]

2609

#define SWIGTYPE_p_wxRichTextAction swig_types[143]

2610

#define SWIGTYPE_p_wxRichTextAttr swig_types[144]

2611

#define SWIGTYPE_p_wxRichTextBox swig_types[145]

2612

#define SWIGTYPE_p_wxRichTextBuffer swig_types[146]

2613

#define SWIGTYPE_p_wxRichTextCommand swig_types[147]

2614

#define SWIGTYPE_p_wxRichTextCompositeObject swig_types[148]

2615

#define SWIGTYPE_p_wxRichTextCtrl swig_types[149]

2616

#define SWIGTYPE_p_wxRichTextEvent swig_types[150]

2617

#define SWIGTYPE_p_wxRichTextFileHandler swig_types[151]

2618

#define SWIGTYPE_p_wxRichTextFileHandlerList swig_types[152]

2619

#define SWIGTYPE_p_wxRichTextFileHandlerList_iterator swig_types[153]

2620

#define SWIGTYPE_p_wxRichTextHTMLHandler swig_types[154]

2621

#define SWIGTYPE_p_wxRichTextHeaderFooterData swig_types[155]

2622

#define SWIGTYPE_p_wxRichTextImage swig_types[156]

2623

#define SWIGTYPE_p_wxRichTextImageBlock swig_types[157]

2624

#define SWIGTYPE_p_wxRichTextLine swig_types[158]

2625

#define SWIGTYPE_p_wxRichTextLineList swig_types[159]

2626

#define SWIGTYPE_p_wxRichTextListStyleDefinition swig_types[160]

2627

#define SWIGTYPE_p_wxRichTextObject swig_types[161]

2628

#define SWIGTYPE_p_wxRichTextObjectList swig_types[162]

2629

#define SWIGTYPE_p_wxRichTextObjectList_iterator swig_types[163]

2630

#define SWIGTYPE_p_wxRichTextParagraph swig_types[164]

2631

#define SWIGTYPE_p_wxRichTextParagraphLayoutBox swig_types[165]

2632

#define SWIGTYPE_p_wxRichTextPlainText swig_types[166]

2633

#define SWIGTYPE_p_wxRichTextPlainTextHandler swig_types[167]

2634

#define SWIGTYPE_p_wxRichTextPrinting swig_types[168]

2635

#define SWIGTYPE_p_wxRichTextPrintout swig_types[169]

2636

#define SWIGTYPE_p_wxRichTextRange swig_types[170]

2637

#define SWIGTYPE_p_wxRichTextRenderer swig_types[171]

2638

#define SWIGTYPE_p_wxRichTextStdRenderer swig_types[172]

2639

#define SWIGTYPE_p_wxRichTextStyleDefinition swig_types[173]

2640

#define SWIGTYPE_p_wxRichTextStyleSheet swig_types[174]

2641

#define SWIGTYPE_p_wxRichTextXMLHandler swig_types[175]

2642

#define SWIGTYPE_p_wxSashEvent swig_types[176]

2643

#define SWIGTYPE_p_wxSashLayoutWindow swig_types[177]

2644

#define SWIGTYPE_p_wxSashWindow swig_types[178]

2645

#define SWIGTYPE_p_wxScrollEvent swig_types[179]

2646

#define SWIGTYPE_p_wxScrollWinEvent swig_types[180]

2647

#define SWIGTYPE_p_wxScrolledWindow swig_types[181]

2648

#define SWIGTYPE_p_wxSetCursorEvent swig_types[182]

2649

#define SWIGTYPE_p_wxShowEvent swig_types[183]

2650

#define SWIGTYPE_p_wxSimpleHtmlListBox swig_types[184]

2651

#define SWIGTYPE_p_wxSingleChoiceDialog swig_types[185]

2652

#define SWIGTYPE_p_wxSize swig_types[186]

2653

#define SWIGTYPE_p_wxSizeEvent swig_types[187]

2654

#define SWIGTYPE_p_wxSizer swig_types[188]

2655

#define SWIGTYPE_p_wxSizerItem swig_types[189]

2656

#define SWIGTYPE_p_wxSplashScreen swig_types[190]

2657

#define SWIGTYPE_p_wxSplashScreenWindow swig_types[191]

2658

#define SWIGTYPE_p_wxSplitterEvent swig_types[192]

2659

#define SWIGTYPE_p_wxSplitterWindow swig_types[193]

2660

#define SWIGTYPE_p_wxStaticBoxSizer swig_types[194]

2661

#define SWIGTYPE_p_wxStatusBar swig_types[195]

2662

#define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[196]

2663

#define SWIGTYPE_p_wxSysColourChangedEvent swig_types[197]

2664

#define SWIGTYPE_p_wxTGAHandler swig_types[198]

2665

#define SWIGTYPE_p_wxTIFFHandler swig_types[199]

2666

#define SWIGTYPE_p_wxTaskBarIconEvent swig_types[200]

2667

#define SWIGTYPE_p_wxTextAttrEx swig_types[201]

2668

#define SWIGTYPE_p_wxTextCoord swig_types[202]

2669

#define SWIGTYPE_p_wxTextEntryDialog swig_types[203]

2670

#define SWIGTYPE_p_wxTipWindow swig_types[204]

2671

#define SWIGTYPE_p_wxTopLevelWindow swig_types[205]

2672

#define SWIGTYPE_p_wxUpdateUIEvent swig_types[206]

2673

#define SWIGTYPE_p_wxValidator swig_types[207]

2674

#define SWIGTYPE_p_wxWindow swig_types[208]

2675

#define SWIGTYPE_p_wxWindowCreateEvent swig_types[209]

2676

#define SWIGTYPE_p_wxWindowDestroyEvent swig_types[210]

2677

#define SWIGTYPE_p_wxXPMHandler swig_types[211]

2678

static swig_type_info *swig_types[213];

2679

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

2680

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

2681

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

2682

2683

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

2684

2685

#if (PY_VERSION_HEX <= 0x02000000)

2686

# if !defined(SWIG_PYTHON_CLASSIC)

2687

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

2688

# endif

2689

#endif

2690

#if (PY_VERSION_HEX <= 0x02020000)

2691

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

2692

#endif

2693

#if (PY_VERSION_HEX <= 0x02020000)

2694

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

2695

#endif

2696

#ifndef METH_O

2697

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

2698

#endif

2699

2700

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

2701

@(target):= _richtext.so

2702

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

2703

#define SWIG_init init_richtext

2704

2705

#define SWIG_name "_richtext"

2706

2707

#define SWIGVERSION 0x010329

2708

2709

2710

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

2711

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

2712

2713

2714

#include <stdexcept>

2715

2716

2717

namespace swig {

2718

class PyObject_ptr {

2719

protected:

2720

PyObject *_obj;

2721

2722

public:

2723

PyObject_ptr() :_obj(0)

2724

{

2725

}

2726

2727

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

2728

{

2729

Py_XINCREF(_obj);

2730

}

2731

2732

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

2733

{

2734

if (initial_ref) Py_XINCREF(_obj);

2735

}

2736

2737

PyObject_ptr & operator=(const PyObject_ptr& item)

2738

{

2739

Py_XINCREF(item._obj);

2740

Py_XDECREF(_obj);

2741

_obj = item._obj;

2742

return *this;

2743

}

2744

2745

~PyObject_ptr()

2746

{

2747

Py_XDECREF(_obj);

2748

}

2749

2750

operator PyObject *() const

2751

{

2752

return _obj;

2753

}

2754

2755

PyObject *operator->() const

2756

{

2757

return _obj;

2758

}

2759

};

2760

}

2761

2762

2763

namespace swig {

2764

struct PyObject_var : PyObject_ptr {

2765

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

2766

2767

PyObject_var & operator = (PyObject* obj)

2768

{

2769

Py_XDECREF(_obj);

2770

_obj = obj;

2771

return *this;

2772

}

2773

};

2774

}

2775

2776

2777

#include "wx/wxPython/wxPython.h"

2778

#include "wx/wxPython/pyclasses.h"

2779

#include "wx/wxPython/printfw.h"

2780

#include "wx/wxPython/twoitem.h"

2781

2782

#include <wx/richtext/richtextctrl.h>

2783

2784

2785

class wxEffects;

2786

class wxBufferedDC;

2787

class wxBufferedPaintDC;

2788

class wxMetaFile;

2789

class wxMetaFileDC;

2790

class wxPrinterDC;

2791

2792

2793

2794

#define SWIG_From_long PyInt_FromLong

2795

2796

2797

SWIGINTERNINLINE PyObject *

2798

SWIG_From_int (int value)

2799

{

2800

return SWIG_From_long (value);

2801

}

2802

2803

static const wxString wxPyEmptyString(wxEmptyString);

2804

2805

#include <wx/sstream.h>

2806

#include "wx/wxPython/pyistream.h"

2807

2808

2809

bool wxRichTextRange_helper(PyObject* source, wxRichTextRange** obj)

2810

{

2811

if (source == Py_None) {

2812

**obj = wxRICHTEXT_NONE;

2813

return true;

2814

}

2815

return wxPyTwoIntItem_helper(source, obj, wxT("wxRichTextRange"));

2816

}

2817

2818

2819

SWIGINTERN int

2820

SWIG_AsVal_long (PyObject* obj, long* val)

2821

{

2822

if (PyNumber_Check(obj)) {

2823

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

2824

return SWIG_OK;

2825

}

2826

return SWIG_TypeError;

2827

}

2828

2829

SWIGINTERN bool wxRichTextRange___eq__(wxRichTextRange *self,PyObject *other){

2830

wxRichTextRange temp, *obj = &temp;

2831

if ( other == Py_None ) return false;

2832

if ( ! wxRichTextRange_helper(other, &obj) ) {

2833

PyErr_Clear();

2834

return false;

2835

}

2836

return self->operator==(*obj);

2837

}

2838

SWIGINTERN PyObject *wxRichTextRange_Get(wxRichTextRange *self){

2839

PyObject* tup = PyTuple_New(2);

2840

PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetStart()));

2841

PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetEnd()));

2842

return tup;

2843

}

2844

2845

wxRichTextRange wxPy_RTR_ALL(wxRICHTEXT_ALL);

2846

wxRichTextRange wxPy_RTR_NONE(wxRICHTEXT_NONE);

2847

2848

2849

#include <limits.h>

2850

#ifndef LLONG_MIN

2851

# define LLONG_MIN LONG_LONG_MIN

2852

#endif

2853

#ifndef LLONG_MAX

2854

# define LLONG_MAX LONG_LONG_MAX

2855

#endif

2856

#ifndef ULLONG_MAX

2857

# define ULLONG_MAX ULONG_LONG_MAX

2858

#endif

2859

2860

2861

SWIGINTERN int

2862

SWIG_AsVal_int (PyObject * obj, int *val)

2863

{

2864

long v;

2865

int res = SWIG_AsVal_long (obj, &v);

2866

if (SWIG_IsOK(res)) {

2867

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

2868

return SWIG_OverflowError;

2869

} else {

2870

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

2871

}

2872

}

2873

return res;

2874

}

2875

2876

2877

SWIGINTERN int

2878

SWIG_AsVal_bool (PyObject *obj, bool *val)

2879

{

2880

if (obj == Py_True) {

2881

if (val) *val = true;

2882

return SWIG_OK;

2883

} else if (obj == Py_False) {

2884

if (val) *val = false;

2885

return SWIG_OK;

2886

} else {

2887

long v = 0;

2888

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

2889

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

2890

return res;

2891

}

2892

}

2893

2894

SWIGINTERN void wxTextAttrEx_SetFontSize(wxTextAttrEx *self,int pointSize){

2895

wxFont f = self->GetFont();

2896

f.SetPointSize(pointSize);

2897

self->SetFont(f);

2898

}

2899

SWIGINTERN void wxTextAttrEx_SetFontStyle(wxTextAttrEx *self,int fontStyle){

2900

wxFont f = self->GetFont();

2901

f.SetStyle(fontStyle);

2902

self->SetFont(f);

2903

}

2904

SWIGINTERN void wxTextAttrEx_SetFontWeight(wxTextAttrEx *self,int fontWeight){

2905

wxFont f = self->GetFont();

2906

f.SetWeight(fontWeight);

2907

self->SetFont(f);

2908

}

2909

SWIGINTERN void wxTextAttrEx_SetFontFaceName(wxTextAttrEx *self,wxString const &faceName){

2910

wxFont f = self->GetFont();

2911

f.SetFaceName(faceName);

2912

self->SetFont(f);

2913

}

2914

SWIGINTERN void wxTextAttrEx_SetFontUnderlined(wxTextAttrEx *self,bool underlined){

2915

wxFont f = self->GetFont();

2916

f.SetUnderlined(underlined);

2917

self->SetFont(f);

2918

}

2919

SWIGINTERN wxString wxRichTextObject_Dump(wxRichTextObject *self){

2920

wxStringOutputStream strstream;

2921

wxTextOutputStream txtstream(strstream);

2922

self->Dump(txtstream);

2923

return strstream.GetString();

2924

}

2925

2926

class wxRichTextObjectList_iterator

2927

{

2928

public:

2929

wxRichTextObjectList_iterator(wxRichTextObjectList::compatibility_iterator start)

2930

: m_node(start) {}

2931

2932

wxRichTextObject* next() {

2933

wxRichTextObject* obj = NULL;

2934

if (m_node) {

2935

obj = m_node->GetData();

2936

m_node = m_node->GetNext();

2937

}

2938

else PyErr_SetString(PyExc_StopIteration, "");

2939

return (wxRichTextObject*)obj;

2940

}

2941

private:

2942

wxRichTextObjectList::compatibility_iterator m_node;

2943

};

2944

2945

SWIGINTERN size_t wxRichTextObjectList___len__(wxRichTextObjectList *self){

2946

return self->size();

2947

}

2948

2949

SWIGINTERNINLINE PyObject*

2950

SWIG_From_unsigned_SS_long (unsigned long value)

2951

{

2952

return (value > LONG_MAX) ?

2953

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

2954

}

2955

2956

2957

SWIGINTERNINLINE PyObject *

2958

SWIG_From_size_t (size_t value)

2959

{

2960

return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));

2961

}

2962

2963

2964

SWIGINTERN int

2965

SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)

2966

{

2967

long v = 0;

2968

int res = SWIG_AsVal_long(obj, &v);

2969

if (SWIG_IsOK(res)) {

2970

if ( v < 0) {

2971

return SWIG_ValueError;

2972

}

2973

else if (val)

2974

*val = (unsigned long)v;

2975

}

2976

return res;

2977

}

2978

2979

2980

SWIGINTERNINLINE int

2981

SWIG_AsVal_size_t (PyObject * obj, size_t *val)

2982

{

2983

unsigned long v;

2984

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

2985

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

2986

return res;

2987

}

2988

2989

SWIGINTERN wxRichTextObject *wxRichTextObjectList___getitem__(wxRichTextObjectList *self,size_t index){

2990

if (index < self->size()) {

2991

wxRichTextObjectList::compatibility_iterator node = self->Item(index);

2992

if (node) return (wxRichTextObject*)node->GetData();

2993

}

2994

PyErr_SetString(PyExc_IndexError, "sequence index out of range");

2995

return NULL;

2996

}

2997

SWIGINTERN bool wxRichTextObjectList___contains__(wxRichTextObjectList *self,wxRichTextObject const *obj){

2998

wxRichTextObjectList::compatibility_iterator node;

2999

node = self->Find((wxRichTextObject*)obj);

3000

return node;

3001

}

3002

SWIGINTERN wxRichTextObjectList_iterator *wxRichTextObjectList___iter__(wxRichTextObjectList *self){

3003

return new wxRichTextObjectList_iterator(self->GetFirst());

3004

}

3005

SWIGINTERN int wxRichTextObjectList_index(wxRichTextObjectList *self,wxRichTextObject *obj){

3006

int idx = self->IndexOf((wxRichTextObject*)obj);

3007

if (idx == wxNOT_FOUND)

3008

PyErr_SetString(PyExc_ValueError,

3009

"sequence.index(x): x not in sequence");

3010

return idx;

3011

}

3012

SWIGINTERN bool wxRichTextParagraphLayoutBox_FindNextParagraphNumber(wxRichTextParagraphLayoutBox const *self,wxRichTextParagraph *previousParagraph,wxTextAttrEx &attr){

3013

wxRichTextAttr rta;

3014

bool rval;

3015

rval = self->FindNextParagraphNumber(previousParagraph, rta);

3016

attr = rta;

3017

return rval;

3018

}

3019

SWIGINTERN wxTextAttrEx wxRichTextParagraph_GetCombinedAttributes(wxRichTextParagraph *self,wxTextAttrEx *contentStyle=NULL){

3020

if (contentStyle)

3021

return self->GetCombinedAttributes(*contentStyle);

3022

else

3023

return self->GetCombinedAttributes();

3024

}

3025

3026

class wxRichTextFileHandlerList

3027

{

3028

public:

3029

wxRichTextFileHandlerList(wxList* theList)

3030

: m_list(theList) {}

3031

~wxRichTextFileHandlerList() {}

3032

public:

3033

wxList* m_list;

3034

};

3035

3036

class wxRichTextFileHandlerList_iterator

3037

{

3038

public:

3039

wxRichTextFileHandlerList_iterator(wxList::compatibility_iterator start)

3040

: m_node(start) {}

3041

3042

wxRichTextFileHandler* next() {

3043

wxRichTextFileHandler* obj = NULL;

3044

if (m_node) {

3045

obj = (wxRichTextFileHandler*)m_node->GetData();

3046

m_node = m_node->GetNext();

3047

}

3048

else PyErr_SetString(PyExc_StopIteration, "");

3049

return obj;

3050

}

3051

private:

3052

wxList::compatibility_iterator m_node;

3053

};

3054

3055

SWIGINTERN size_t wxRichTextFileHandlerList___len__(wxRichTextFileHandlerList *self){

3056

return self->m_list->size();

3057

}

3058

SWIGINTERN wxRichTextFileHandler *wxRichTextFileHandlerList___getitem__(wxRichTextFileHandlerList *self,size_t index){

3059

if (index < self->m_list->size()) {

3060

wxList::compatibility_iterator node = self->m_list->Item(index);

3061

if (node) return (wxRichTextFileHandler*)node->GetData();

3062

}

3063

PyErr_SetString(PyExc_IndexError, "Invalid list index");

3064

return NULL;

3065

}

3066

SWIGINTERN bool wxRichTextFileHandlerList___contains__(wxRichTextFileHandlerList *self,wxRichTextFileHandler const *obj){

3067

return self->m_list->Find(obj) != NULL;

3068

}

3069

SWIGINTERN wxRichTextFileHandlerList_iterator *wxRichTextFileHandlerList___iter__(wxRichTextFileHandlerList *self){

3070

return new wxRichTextFileHandlerList_iterator(self->m_list->GetFirst());

3071

}

3072

3073

typedef wxList wxRichTextFileHandlerList_t;

3074

3075

SWIGINTERN PyObject *wxRichTextBuffer_GetExtWildcard(bool combine=false,bool save=false){

3076

wxString wildcards;

3077

wxArrayInt types;

3078

wildcards = wxRichTextBuffer::GetExtWildcard(combine, save, &types);

3079

PyObject* tup = PyTuple_New(2);

3080

PyTuple_SET_ITEM(tup, 0, wx2PyString(wildcards));

3081

PyTuple_SET_ITEM(tup, 1, wxArrayInt2PyList_helper(types));

3082

return tup;

3083

}

3084

3085

#define SWIG_From_double PyFloat_FromDouble

3086

3087

3088

SWIGINTERNINLINE PyObject *

3089

SWIG_From_float (float value)

3090

{

3091

return SWIG_From_double (value);

3092

}

3093

3094

3095

#include <float.h>

3096

3097

3098

SWIGINTERN int

3099

SWIG_AsVal_double (PyObject *obj, double* val)

3100

{

3101

if (PyNumber_Check(obj)) {

3102

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

3103

return SWIG_OK;

3104

}

3105

return SWIG_TypeError;

3106

}

3107

3108

3109

SWIGINTERN int

3110

SWIG_AsVal_float (PyObject * obj, float *val)

3111

{

3112

double v;

3113

int res = SWIG_AsVal_double (obj, &v);

3114

if (SWIG_IsOK(res)) {

3115

if ((v < -FLT_MAX || v > FLT_MAX)) {

3116

return SWIG_OverflowError;

3117

} else {

3118

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

3119

}

3120

}

3121

return res;

3122

}

3123

3124

static const wxString wxPyTextName(wxT("Text"));

3125

static const wxString wxPyTextExt(wxT("txt"));

3126

3127

3128

static const wxString wxPyRichTextCtrlNameStr(wxT("richText"));

3129

3130

#include <wx/richtext/richtexthtml.h>

3131

3132

static const wxString wxPyHtmlName(wxT("HTML"));

3133

static const wxString wxPyHtmlExt(wxT("html"));

3134

3135

#include <wx/richtext/richtextxml.h>

3136

3137

static const wxString wxPyXmlName(wxT("XML"));

3138

static const wxString wxPyXmlExt(wxT("xml"));

3139

3140

#include <wx/richtext/richtextprint.h>

3141

3142

#ifdef __cplusplus

3143

extern "C" {

3144

#endif

3145

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

3146

PyObject *resultobj = 0;

3147

long arg1 = (long) 0 ;

3148

long arg2 = (long) 0 ;

3149

wxRichTextRange *result = 0 ;

3150

long val1 ;

3151

int ecode1 = 0 ;

3152

long val2 ;

3153

int ecode2 = 0 ;

3154

PyObject * obj0 = 0 ;

3155

PyObject * obj1 = 0 ;

3156

char * kwnames[] = {

3157

(char *) "start",(char *) "end", NULL

3158

};

3159

3160

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

3161

if (obj0) {

3162

ecode1 = SWIG_AsVal_long(obj0, &val1);

3163

if (!SWIG_IsOK(ecode1)) {

3164

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RichTextRange" "', expected argument " "1"" of type '" "long""'");

3165

}

3166

arg1 = static_cast< long >(val1);

3167

}

3168

if (obj1) {

3169

ecode2 = SWIG_AsVal_long(obj1, &val2);

3170

if (!SWIG_IsOK(ecode2)) {

3171

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

3172

}

3173

arg2 = static_cast< long >(val2);

3174

}

3175

{

3176

result = (wxRichTextRange *)new wxRichTextRange(arg1,arg2);

3177

if (PyErr_Occurred()) SWIG_fail;

3178

}

3179

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

3180

return resultobj;

3181

fail:

3182

return NULL;

3183

}

3184

3185

3186

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

3187

PyObject *resultobj = 0;

3188

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3189

void *argp1 = 0 ;

3190

int res1 = 0 ;

3191

PyObject *swig_obj[1] ;

3192

3193

if (!args) SWIG_fail;

3194

swig_obj[0] = args;

3195

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

3196

if (!SWIG_IsOK(res1)) {

3197

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

3198

}

3199

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3200

{

3201

delete arg1;

3202

3203

if (PyErr_Occurred()) SWIG_fail;

3204

}

3205

resultobj = SWIG_Py_Void();

3206

return resultobj;

3207

fail:

3208

return NULL;

3209

}

3210

3211

3212

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

3213

PyObject *resultobj = 0;

3214

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3215

PyObject *arg2 = (PyObject *) 0 ;

3216

bool result;

3217

void *argp1 = 0 ;

3218

int res1 = 0 ;

3219

PyObject * obj0 = 0 ;

3220

PyObject * obj1 = 0 ;

3221

char * kwnames[] = {

3222

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

3223

};

3224

3225

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

3226

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

3227

if (!SWIG_IsOK(res1)) {

3228

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

3229

}

3230

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3231

arg2 = obj1;

3232

{

3233

result = (bool)wxRichTextRange___eq__(arg1,arg2);

3234

if (PyErr_Occurred()) SWIG_fail;

3235

}

3236

{

3237

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

3238

}

3239

return resultobj;

3240

fail:

3241

return NULL;

3242

}

3243

3244

3245

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

3246

PyObject *resultobj = 0;

3247

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3248

wxRichTextRange *arg2 = 0 ;

3249

wxRichTextRange result;

3250

void *argp1 = 0 ;

3251

int res1 = 0 ;

3252

wxRichTextRange temp2 ;

3253

PyObject * obj0 = 0 ;

3254

PyObject * obj1 = 0 ;

3255

char * kwnames[] = {

3256

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

3257

};

3258

3259

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

3260

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

3261

if (!SWIG_IsOK(res1)) {

3262

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

3263

}

3264

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3265

{

3266

arg2 = &temp2;

3267

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

3268

}

3269

{

3270

result = ((wxRichTextRange const *)arg1)->operator -((wxRichTextRange const &)*arg2);

3271

if (PyErr_Occurred()) SWIG_fail;

3272

}

3273

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

3274

return resultobj;

3275

fail:

3276

return NULL;

3277

}

3278

3279

3280

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

3281

PyObject *resultobj = 0;

3282

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3283

wxRichTextRange *arg2 = 0 ;

3284

wxRichTextRange result;

3285

void *argp1 = 0 ;

3286

int res1 = 0 ;

3287

wxRichTextRange temp2 ;

3288

PyObject * obj0 = 0 ;

3289

PyObject * obj1 = 0 ;

3290

char * kwnames[] = {

3291

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

3292

};

3293

3294

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

3295

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

3296

if (!SWIG_IsOK(res1)) {

3297

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

3298

}

3299

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3300

{

3301

arg2 = &temp2;

3302

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

3303

}

3304

{

3305

result = ((wxRichTextRange const *)arg1)->operator +((wxRichTextRange const &)*arg2);

3306

if (PyErr_Occurred()) SWIG_fail;

3307

}

3308

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

3309

return resultobj;

3310

fail:

3311

return NULL;

3312

}

3313

3314

3315

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

3316

PyObject *resultobj = 0;

3317

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3318

long arg2 ;

3319

long arg3 ;

3320

void *argp1 = 0 ;

3321

int res1 = 0 ;

3322

long val2 ;

3323

int ecode2 = 0 ;

3324

long val3 ;

3325

int ecode3 = 0 ;

3326

PyObject * obj0 = 0 ;

3327

PyObject * obj1 = 0 ;

3328

PyObject * obj2 = 0 ;

3329

char * kwnames[] = {

3330

(char *) "self",(char *) "start",(char *) "end", NULL

3331

};

3332

3333

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

3334

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

3335

if (!SWIG_IsOK(res1)) {

3336

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

3337

}

3338

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3339

ecode2 = SWIG_AsVal_long(obj1, &val2);

3340

if (!SWIG_IsOK(ecode2)) {

3341

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

3342

}

3343

arg2 = static_cast< long >(val2);

3344

ecode3 = SWIG_AsVal_long(obj2, &val3);

3345

if (!SWIG_IsOK(ecode3)) {

3346

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

3347

}

3348

arg3 = static_cast< long >(val3);

3349

{

3350

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

3351

if (PyErr_Occurred()) SWIG_fail;

3352

}

3353

resultobj = SWIG_Py_Void();

3354

return resultobj;

3355

fail:

3356

return NULL;

3357

}

3358

3359

3360

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

3361

PyObject *resultobj = 0;

3362

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3363

long arg2 ;

3364

void *argp1 = 0 ;

3365

int res1 = 0 ;

3366

long val2 ;

3367

int ecode2 = 0 ;

3368

PyObject * obj0 = 0 ;

3369

PyObject * obj1 = 0 ;

3370

char * kwnames[] = {

3371

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

3372

};

3373

3374

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

3375

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

3376

if (!SWIG_IsOK(res1)) {

3377

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

3378

}

3379

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3380

ecode2 = SWIG_AsVal_long(obj1, &val2);

3381

if (!SWIG_IsOK(ecode2)) {

3382

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

3383

}

3384

arg2 = static_cast< long >(val2);

3385

{

3386

(arg1)->SetStart(arg2);

3387

if (PyErr_Occurred()) SWIG_fail;

3388

}

3389

resultobj = SWIG_Py_Void();

3390

return resultobj;

3391

fail:

3392

return NULL;

3393

}

3394

3395

3396

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

3397

PyObject *resultobj = 0;

3398

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3399

long result;

3400

void *argp1 = 0 ;

3401

int res1 = 0 ;

3402

PyObject *swig_obj[1] ;

3403

3404

if (!args) SWIG_fail;

3405

swig_obj[0] = args;

3406

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

3407

if (!SWIG_IsOK(res1)) {

3408

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

3409

}

3410

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3411

{

3412

result = (long)((wxRichTextRange const *)arg1)->GetStart();

3413

if (PyErr_Occurred()) SWIG_fail;

3414

}

3415

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

3416

return resultobj;

3417

fail:

3418

return NULL;

3419

}

3420

3421

3422

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

3423

PyObject *resultobj = 0;

3424

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3425

long arg2 ;

3426

void *argp1 = 0 ;

3427

int res1 = 0 ;

3428

long val2 ;

3429

int ecode2 = 0 ;

3430

PyObject * obj0 = 0 ;

3431

PyObject * obj1 = 0 ;

3432

char * kwnames[] = {

3433

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

3434

};

3435

3436

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

3437

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

3438

if (!SWIG_IsOK(res1)) {

3439

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

3440

}

3441

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3442

ecode2 = SWIG_AsVal_long(obj1, &val2);

3443

if (!SWIG_IsOK(ecode2)) {

3444

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

3445

}

3446

arg2 = static_cast< long >(val2);

3447

{

3448

(arg1)->SetEnd(arg2);

3449

if (PyErr_Occurred()) SWIG_fail;

3450

}

3451

resultobj = SWIG_Py_Void();

3452

return resultobj;

3453

fail:

3454

return NULL;

3455

}

3456

3457

3458

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

3459

PyObject *resultobj = 0;

3460

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3461

long result;

3462

void *argp1 = 0 ;

3463

int res1 = 0 ;

3464

PyObject *swig_obj[1] ;

3465

3466

if (!args) SWIG_fail;

3467

swig_obj[0] = args;

3468

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

3469

if (!SWIG_IsOK(res1)) {

3470

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

3471

}

3472

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3473

{

3474

result = (long)((wxRichTextRange const *)arg1)->GetEnd();

3475

if (PyErr_Occurred()) SWIG_fail;

3476

}

3477

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

3478

return resultobj;

3479

fail:

3480

return NULL;

3481

}

3482

3483

3484

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

3485

PyObject *resultobj = 0;

3486

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3487

wxRichTextRange *arg2 = 0 ;

3488

bool result;

3489

void *argp1 = 0 ;

3490

int res1 = 0 ;

3491

wxRichTextRange temp2 ;

3492

PyObject * obj0 = 0 ;

3493

PyObject * obj1 = 0 ;

3494

char * kwnames[] = {

3495

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

3496

};

3497

3498

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

3499

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

3500

if (!SWIG_IsOK(res1)) {

3501

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

3502

}

3503

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3504

{

3505

arg2 = &temp2;

3506

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

3507

}

3508

{

3509

result = (bool)((wxRichTextRange const *)arg1)->IsOutside((wxRichTextRange const &)*arg2);

3510

if (PyErr_Occurred()) SWIG_fail;

3511

}

3512

{

3513

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

3514

}

3515

return resultobj;

3516

fail:

3517

return NULL;

3518

}

3519

3520

3521

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

3522

PyObject *resultobj = 0;

3523

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3524

wxRichTextRange *arg2 = 0 ;

3525

bool result;

3526

void *argp1 = 0 ;

3527

int res1 = 0 ;

3528

wxRichTextRange temp2 ;

3529

PyObject * obj0 = 0 ;

3530

PyObject * obj1 = 0 ;

3531

char * kwnames[] = {

3532

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

3533

};

3534

3535

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

3536

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

3537

if (!SWIG_IsOK(res1)) {

3538

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

3539

}

3540

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3541

{

3542

arg2 = &temp2;

3543

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

3544

}

3545

{

3546

result = (bool)((wxRichTextRange const *)arg1)->IsWithin((wxRichTextRange const &)*arg2);

3547

if (PyErr_Occurred()) SWIG_fail;

3548

}

3549

{

3550

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

3551

}

3552

return resultobj;

3553

fail:

3554

return NULL;

3555

}

3556

3557

3558

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

3559

PyObject *resultobj = 0;

3560

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3561

long arg2 ;

3562

bool result;

3563

void *argp1 = 0 ;

3564

int res1 = 0 ;

3565

long val2 ;

3566

int ecode2 = 0 ;

3567

PyObject * obj0 = 0 ;

3568

PyObject * obj1 = 0 ;

3569

char * kwnames[] = {

3570

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

3571

};

3572

3573

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

3574

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

3575

if (!SWIG_IsOK(res1)) {

3576

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

3577

}

3578

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3579

ecode2 = SWIG_AsVal_long(obj1, &val2);

3580

if (!SWIG_IsOK(ecode2)) {

3581

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

3582

}

3583

arg2 = static_cast< long >(val2);

3584

{

3585

result = (bool)((wxRichTextRange const *)arg1)->Contains(arg2);

3586

if (PyErr_Occurred()) SWIG_fail;

3587

}

3588

{

3589

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

3590

}

3591

return resultobj;

3592

fail:

3593

return NULL;

3594

}

3595

3596

3597

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

3598

PyObject *resultobj = 0;

3599

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3600

wxRichTextRange *arg2 = 0 ;

3601

bool result;

3602

void *argp1 = 0 ;

3603

int res1 = 0 ;

3604

wxRichTextRange temp2 ;

3605

PyObject * obj0 = 0 ;

3606

PyObject * obj1 = 0 ;

3607

char * kwnames[] = {

3608

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

3609

};

3610

3611

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

3612

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

3613

if (!SWIG_IsOK(res1)) {

3614

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

3615

}

3616

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3617

{

3618

arg2 = &temp2;

3619

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

3620

}

3621

{

3622

result = (bool)(arg1)->LimitTo((wxRichTextRange const &)*arg2);

3623

if (PyErr_Occurred()) SWIG_fail;

3624

}

3625

{

3626

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

3627

}

3628

return resultobj;

3629

fail:

3630

return NULL;

3631

}

3632

3633

3634

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

3635

PyObject *resultobj = 0;

3636

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3637

long result;

3638

void *argp1 = 0 ;

3639

int res1 = 0 ;

3640

PyObject *swig_obj[1] ;

3641

3642

if (!args) SWIG_fail;

3643

swig_obj[0] = args;

3644

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

3645

if (!SWIG_IsOK(res1)) {

3646

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

3647

}

3648

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3649

{

3650

result = (long)((wxRichTextRange const *)arg1)->GetLength();

3651

if (PyErr_Occurred()) SWIG_fail;

3652

}

3653

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

3654

return resultobj;

3655

fail:

3656

return NULL;

3657

}

3658

3659

3660

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

3661

PyObject *resultobj = 0;

3662

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3663

void *argp1 = 0 ;

3664

int res1 = 0 ;

3665

PyObject *swig_obj[1] ;

3666

3667

if (!args) SWIG_fail;

3668

swig_obj[0] = args;

3669

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

3670

if (!SWIG_IsOK(res1)) {

3671

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

3672

}

3673

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3674

{

3675

(arg1)->Swap();

3676

if (PyErr_Occurred()) SWIG_fail;

3677

}

3678

resultobj = SWIG_Py_Void();

3679

return resultobj;

3680

fail:

3681

return NULL;

3682

}

3683

3684

3685

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

3686

PyObject *resultobj = 0;

3687

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3688

wxRichTextRange result;

3689

void *argp1 = 0 ;

3690

int res1 = 0 ;

3691

PyObject *swig_obj[1] ;

3692

3693

if (!args) SWIG_fail;

3694

swig_obj[0] = args;

3695

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

3696

if (!SWIG_IsOK(res1)) {

3697

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

3698

}

3699

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3700

{

3701

result = ((wxRichTextRange const *)arg1)->ToInternal();

3702

if (PyErr_Occurred()) SWIG_fail;

3703

}

3704

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

3705

return resultobj;

3706

fail:

3707

return NULL;

3708

}

3709

3710

3711

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

3712

PyObject *resultobj = 0;

3713

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3714

wxRichTextRange result;

3715

void *argp1 = 0 ;

3716

int res1 = 0 ;

3717

PyObject *swig_obj[1] ;

3718

3719

if (!args) SWIG_fail;

3720

swig_obj[0] = args;

3721

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

3722

if (!SWIG_IsOK(res1)) {

3723

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

3724

}

3725

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3726

{

3727

result = ((wxRichTextRange const *)arg1)->FromInternal();

3728

if (PyErr_Occurred()) SWIG_fail;

3729

}

3730

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

3731

return resultobj;

3732

fail:

3733

return NULL;

3734

}

3735

3736

3737

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

3738

PyObject *resultobj = 0;

3739

wxRichTextRange *arg1 = (wxRichTextRange *) 0 ;

3740

PyObject *result = 0 ;

3741

void *argp1 = 0 ;

3742

int res1 = 0 ;

3743

PyObject *swig_obj[1] ;

3744

3745

if (!args) SWIG_fail;

3746

swig_obj[0] = args;

3747

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

3748

if (!SWIG_IsOK(res1)) {

3749

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

3750

}

3751

arg1 = reinterpret_cast< wxRichTextRange * >(argp1);

3752

{

3753

result = (PyObject *)wxRichTextRange_Get(arg1);

3754

if (PyErr_Occurred()) SWIG_fail;

3755

}

3756

resultobj = result;

3757

return resultobj;

3758

fail:

3759

return NULL;

3760

}

3761

3762

3763

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

3764

PyObject *obj;

3765

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

3766

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextRange, SWIG_NewClientData(obj));

3767

return SWIG_Py_Void();

3768

}

3769

3770

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

3771

return SWIG_Python_InitShadowInstance(args);

3772

}

3773

3774

SWIGINTERN int RICHTEXT_ALL_set(PyObject *) {

3775

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

3776

return 1;

3777

}

3778

3779

3780

SWIGINTERN PyObject *RICHTEXT_ALL_get(void) {

3781

PyObject *pyobj = 0;

3782

3783

pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxPy_RTR_ALL), SWIGTYPE_p_wxRichTextRange, 0 );

3784

return pyobj;

3785

}

3786

3787

3788

SWIGINTERN int RICHTEXT_NONE_set(PyObject *) {

3789

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

3790

return 1;

3791

}

3792

3793

3794

SWIGINTERN PyObject *RICHTEXT_NONE_get(void) {

3795

PyObject *pyobj = 0;

3796

3797

pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxPy_RTR_NONE), SWIGTYPE_p_wxRichTextRange, 0 );

3798

return pyobj;

3799

}

3800

3801

3802

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

3803

PyObject *resultobj = 0;

3804

wxTextAttrEx *result = 0 ;

3805

3806

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

3807

{

3808

PyThreadState* __tstate = wxPyBeginAllowThreads();

3809

result = (wxTextAttrEx *)new wxTextAttrEx();

3810

wxPyEndAllowThreads(__tstate);

3811

if (PyErr_Occurred()) SWIG_fail;

3812

}

3813

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

3814

return resultobj;

3815

fail:

3816

return NULL;

3817

}

3818

3819

3820

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

3821

PyObject *resultobj = 0;

3822

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

3823

void *argp1 = 0 ;

3824

int res1 = 0 ;

3825

PyObject *swig_obj[1] ;

3826

3827

if (!args) SWIG_fail;

3828

swig_obj[0] = args;

3829

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

3830

if (!SWIG_IsOK(res1)) {

3831

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

3832

}

3833

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

3834

{

3835

PyThreadState* __tstate = wxPyBeginAllowThreads();

3836

delete arg1;

3837

3838

wxPyEndAllowThreads(__tstate);

3839

if (PyErr_Occurred()) SWIG_fail;

3840

}

3841

resultobj = SWIG_Py_Void();

3842

return resultobj;

3843

fail:

3844

return NULL;

3845

}

3846

3847

3848

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

3849

PyObject *resultobj = 0;

3850

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

3851

void *argp1 = 0 ;

3852

int res1 = 0 ;

3853

PyObject *swig_obj[1] ;

3854

3855

if (!args) SWIG_fail;

3856

swig_obj[0] = args;

3857

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

3858

if (!SWIG_IsOK(res1)) {

3859

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

3860

}

3861

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

3862

{

3863

PyThreadState* __tstate = wxPyBeginAllowThreads();

3864

(arg1)->Init();

3865

wxPyEndAllowThreads(__tstate);

3866

if (PyErr_Occurred()) SWIG_fail;

3867

}

3868

resultobj = SWIG_Py_Void();

3869

return resultobj;

3870

fail:

3871

return NULL;

3872

}

3873

3874

3875

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

3876

PyObject *resultobj = 0;

3877

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

3878

wxTextAttrEx *arg2 = 0 ;

3879

void *argp1 = 0 ;

3880

int res1 = 0 ;

3881

void *argp2 = 0 ;

3882

int res2 = 0 ;

3883

PyObject * obj0 = 0 ;

3884

PyObject * obj1 = 0 ;

3885

char * kwnames[] = {

3886

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

3887

};

3888

3889

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

3890

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

3891

if (!SWIG_IsOK(res1)) {

3892

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

3893

}

3894

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

3895

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

3896

if (!SWIG_IsOK(res2)) {

3897

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

3898

}

3899

if (!argp2) {

3900

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

3901

}

3902

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

3903

{

3904

PyThreadState* __tstate = wxPyBeginAllowThreads();

3905

(arg1)->Copy((wxTextAttrEx const &)*arg2);

3906

wxPyEndAllowThreads(__tstate);

3907

if (PyErr_Occurred()) SWIG_fail;

3908

}

3909

resultobj = SWIG_Py_Void();

3910

return resultobj;

3911

fail:

3912

return NULL;

3913

}

3914

3915

3916

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

3917

PyObject *resultobj = 0;

3918

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

3919

wxColour *arg2 = 0 ;

3920

void *argp1 = 0 ;

3921

int res1 = 0 ;

3922

wxColour temp2 ;

3923

PyObject * obj0 = 0 ;

3924

PyObject * obj1 = 0 ;

3925

char * kwnames[] = {

3926

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

3927

};

3928

3929

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

3930

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

3931

if (!SWIG_IsOK(res1)) {

3932

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

3933

}

3934

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

3935

{

3936

arg2 = &temp2;

3937

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

3938

}

3939

{

3940

PyThreadState* __tstate = wxPyBeginAllowThreads();

3941

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

3942

wxPyEndAllowThreads(__tstate);

3943

if (PyErr_Occurred()) SWIG_fail;

3944

}

3945

resultobj = SWIG_Py_Void();

3946

return resultobj;

3947

fail:

3948

return NULL;

3949

}

3950

3951

3952

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

3953

PyObject *resultobj = 0;

3954

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

3955

wxColour *arg2 = 0 ;

3956

void *argp1 = 0 ;

3957

int res1 = 0 ;

3958

wxColour temp2 ;

3959

PyObject * obj0 = 0 ;

3960

PyObject * obj1 = 0 ;

3961

char * kwnames[] = {

3962

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

3963

};

3964

3965

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

3966

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

3967

if (!SWIG_IsOK(res1)) {

3968

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

3969

}

3970

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

3971

{

3972

arg2 = &temp2;

3973

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

3974

}

3975

{

3976

PyThreadState* __tstate = wxPyBeginAllowThreads();

3977

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

3978

wxPyEndAllowThreads(__tstate);

3979

if (PyErr_Occurred()) SWIG_fail;

3980

}

3981

resultobj = SWIG_Py_Void();

3982

return resultobj;

3983

fail:

3984

return NULL;

3985

}

3986

3987

3988

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

3989

PyObject *resultobj = 0;

3990

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

3991

wxFont *arg2 = 0 ;

3992

long arg3 = (long) wxTEXT_ATTR_FONT ;

3993

void *argp1 = 0 ;

3994

int res1 = 0 ;

3995

void *argp2 = 0 ;

3996

int res2 = 0 ;

3997

long val3 ;

3998

int ecode3 = 0 ;

3999

PyObject * obj0 = 0 ;

4000

PyObject * obj1 = 0 ;

4001

PyObject * obj2 = 0 ;

4002

char * kwnames[] = {

4003

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

4004

};

4005

4006

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

4007

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

4008

if (!SWIG_IsOK(res1)) {

4009

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

4010

}

4011

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4012

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

4013

if (!SWIG_IsOK(res2)) {

4014

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

4015

}

4016

if (!argp2) {

4017

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

4018

}

4019

arg2 = reinterpret_cast< wxFont * >(argp2);

4020

if (obj2) {

4021

ecode3 = SWIG_AsVal_long(obj2, &val3);

4022

if (!SWIG_IsOK(ecode3)) {

4023

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

4024

}

4025

arg3 = static_cast< long >(val3);

4026

}

4027

{

4028

PyThreadState* __tstate = wxPyBeginAllowThreads();

4029

(arg1)->SetFont((wxFont const &)*arg2,arg3);

4030

wxPyEndAllowThreads(__tstate);

4031

if (PyErr_Occurred()) SWIG_fail;

4032

}

4033

resultobj = SWIG_Py_Void();

4034

return resultobj;

4035

fail:

4036

return NULL;

4037

}

4038

4039

4040

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

4041

PyObject *resultobj = 0;

4042

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4043

wxTextAttrAlignment arg2 ;

4044

void *argp1 = 0 ;

4045

int res1 = 0 ;

4046

int val2 ;

4047

int ecode2 = 0 ;

4048

PyObject * obj0 = 0 ;

4049

PyObject * obj1 = 0 ;

4050

char * kwnames[] = {

4051

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

4052

};

4053

4054

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

4055

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

4056

if (!SWIG_IsOK(res1)) {

4057

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

4058

}

4059

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4060

ecode2 = SWIG_AsVal_int(obj1, &val2);

4061

if (!SWIG_IsOK(ecode2)) {

4062

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

4063

}

4064

arg2 = static_cast< wxTextAttrAlignment >(val2);

4065

{

4066

PyThreadState* __tstate = wxPyBeginAllowThreads();

4067

(arg1)->SetAlignment(arg2);

4068

wxPyEndAllowThreads(__tstate);

4069

if (PyErr_Occurred()) SWIG_fail;

4070

}

4071

resultobj = SWIG_Py_Void();

4072

return resultobj;

4073

fail:

4074

return NULL;

4075

}

4076

4077

4078

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

4079

PyObject *resultobj = 0;

4080

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4081

wxArrayInt *arg2 = 0 ;

4082

void *argp1 = 0 ;

4083

int res1 = 0 ;

4084

bool temp2 = false ;

4085

PyObject * obj0 = 0 ;

4086

PyObject * obj1 = 0 ;

4087

char * kwnames[] = {

4088

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

4089

};

4090

4091

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

4092

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

4093

if (!SWIG_IsOK(res1)) {

4094

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

4095

}

4096

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4097

{

4098

if (! PySequence_Check(obj1)) {

4099

PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");

4100

SWIG_fail;

4101

}

4102

arg2 = new wxArrayInt;

4103

temp2 = true;

4104

int i, len=PySequence_Length(obj1);

4105

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

4106

PyObject* item = PySequence_GetItem(obj1, i);

4107

PyObject* number = PyNumber_Int(item);

4108

if (!number) {

4109

PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");

4110

SWIG_fail;

4111

}

4112

arg2->Add(PyInt_AS_LONG(number));

4113

Py_DECREF(item);

4114

Py_DECREF(number);

4115

}

4116

}

4117

{

4118

PyThreadState* __tstate = wxPyBeginAllowThreads();

4119

(arg1)->SetTabs((wxArrayInt const &)*arg2);

4120

wxPyEndAllowThreads(__tstate);

4121

if (PyErr_Occurred()) SWIG_fail;

4122

}

4123

resultobj = SWIG_Py_Void();

4124

{

4125

if (temp2) delete arg2;

4126

}

4127

return resultobj;

4128

fail:

4129

{

4130

if (temp2) delete arg2;

4131

}

4132

return NULL;

4133

}

4134

4135

4136

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

4137

PyObject *resultobj = 0;

4138

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4139

int arg2 ;

4140

int arg3 = (int) 0 ;

4141

void *argp1 = 0 ;

4142

int res1 = 0 ;

4143

int val2 ;

4144

int ecode2 = 0 ;

4145

int val3 ;

4146

int ecode3 = 0 ;

4147

PyObject * obj0 = 0 ;

4148

PyObject * obj1 = 0 ;

4149

PyObject * obj2 = 0 ;

4150

char * kwnames[] = {

4151

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

4152

};

4153

4154

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

4155

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

4156

if (!SWIG_IsOK(res1)) {

4157

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

4158

}

4159

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4160

ecode2 = SWIG_AsVal_int(obj1, &val2);

4161

if (!SWIG_IsOK(ecode2)) {

4162

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

4163

}

4164

arg2 = static_cast< int >(val2);

4165

if (obj2) {

4166

ecode3 = SWIG_AsVal_int(obj2, &val3);

4167

if (!SWIG_IsOK(ecode3)) {

4168

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

4169

}

4170

arg3 = static_cast< int >(val3);

4171

}

4172

{

4173

PyThreadState* __tstate = wxPyBeginAllowThreads();

4174

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

4175

wxPyEndAllowThreads(__tstate);

4176

if (PyErr_Occurred()) SWIG_fail;

4177

}

4178

resultobj = SWIG_Py_Void();

4179

return resultobj;

4180

fail:

4181

return NULL;

4182

}

4183

4184

4185

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

4186

PyObject *resultobj = 0;

4187

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4188

int arg2 ;

4189

void *argp1 = 0 ;

4190

int res1 = 0 ;

4191

int val2 ;

4192

int ecode2 = 0 ;

4193

PyObject * obj0 = 0 ;

4194

PyObject * obj1 = 0 ;

4195

char * kwnames[] = {

4196

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

4197

};

4198

4199

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

4200

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

4201

if (!SWIG_IsOK(res1)) {

4202

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

4203

}

4204

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4205

ecode2 = SWIG_AsVal_int(obj1, &val2);

4206

if (!SWIG_IsOK(ecode2)) {

4207

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

4208

}

4209

arg2 = static_cast< int >(val2);

4210

{

4211

PyThreadState* __tstate = wxPyBeginAllowThreads();

4212

(arg1)->SetRightIndent(arg2);

4213

wxPyEndAllowThreads(__tstate);

4214

if (PyErr_Occurred()) SWIG_fail;

4215

}

4216

resultobj = SWIG_Py_Void();

4217

return resultobj;

4218

fail:

4219

return NULL;

4220

}

4221

4222

4223

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

4224

PyObject *resultobj = 0;

4225

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4226

long arg2 ;

4227

void *argp1 = 0 ;

4228

int res1 = 0 ;

4229

long val2 ;

4230

int ecode2 = 0 ;

4231

PyObject * obj0 = 0 ;

4232

PyObject * obj1 = 0 ;

4233

char * kwnames[] = {

4234

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

4235

};

4236

4237

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

4238

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

4239

if (!SWIG_IsOK(res1)) {

4240

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

4241

}

4242

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4243

ecode2 = SWIG_AsVal_long(obj1, &val2);

4244

if (!SWIG_IsOK(ecode2)) {

4245

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

4246

}

4247

arg2 = static_cast< long >(val2);

4248

{

4249

PyThreadState* __tstate = wxPyBeginAllowThreads();

4250

(arg1)->SetFlags(arg2);

4251

wxPyEndAllowThreads(__tstate);

4252

if (PyErr_Occurred()) SWIG_fail;

4253

}

4254

resultobj = SWIG_Py_Void();

4255

return resultobj;

4256

fail:

4257

return NULL;

4258

}

4259

4260

4261

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

4262

PyObject *resultobj = 0;

4263

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4264

bool result;

4265

void *argp1 = 0 ;

4266

int res1 = 0 ;

4267

PyObject *swig_obj[1] ;

4268

4269

if (!args) SWIG_fail;

4270

swig_obj[0] = args;

4271

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

4272

if (!SWIG_IsOK(res1)) {

4273

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

4274

}

4275

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4276

{

4277

PyThreadState* __tstate = wxPyBeginAllowThreads();

4278

result = (bool)((wxTextAttrEx const *)arg1)->HasTextColour();

4279

wxPyEndAllowThreads(__tstate);

4280

if (PyErr_Occurred()) SWIG_fail;

4281

}

4282

{

4283

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

4284

}

4285

return resultobj;

4286

fail:

4287

return NULL;

4288

}

4289

4290

4291

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

4292

PyObject *resultobj = 0;

4293

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4294

bool result;

4295

void *argp1 = 0 ;

4296

int res1 = 0 ;

4297

PyObject *swig_obj[1] ;

4298

4299

if (!args) SWIG_fail;

4300

swig_obj[0] = args;

4301

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

4302

if (!SWIG_IsOK(res1)) {

4303

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

4304

}

4305

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4306

{

4307

PyThreadState* __tstate = wxPyBeginAllowThreads();

4308

result = (bool)((wxTextAttrEx const *)arg1)->HasBackgroundColour();

4309

wxPyEndAllowThreads(__tstate);

4310

if (PyErr_Occurred()) SWIG_fail;

4311

}

4312

{

4313

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

4314

}

4315

return resultobj;

4316

fail:

4317

return NULL;

4318

}

4319

4320

4321

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

4322

PyObject *resultobj = 0;

4323

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4324

bool result;

4325

void *argp1 = 0 ;

4326

int res1 = 0 ;

4327

PyObject *swig_obj[1] ;

4328

4329

if (!args) SWIG_fail;

4330

swig_obj[0] = args;

4331

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

4332

if (!SWIG_IsOK(res1)) {

4333

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

4334

}

4335

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4336

{

4337

PyThreadState* __tstate = wxPyBeginAllowThreads();

4338

result = (bool)((wxTextAttrEx const *)arg1)->HasFont();

4339

wxPyEndAllowThreads(__tstate);

4340

if (PyErr_Occurred()) SWIG_fail;

4341

}

4342

{

4343

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

4344

}

4345

return resultobj;

4346

fail:

4347

return NULL;

4348

}

4349

4350

4351

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

4352

PyObject *resultobj = 0;

4353

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4354

bool result;

4355

void *argp1 = 0 ;

4356

int res1 = 0 ;

4357

PyObject *swig_obj[1] ;

4358

4359

if (!args) SWIG_fail;

4360

swig_obj[0] = args;

4361

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

4362

if (!SWIG_IsOK(res1)) {

4363

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

4364

}

4365

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4366

{

4367

PyThreadState* __tstate = wxPyBeginAllowThreads();

4368

result = (bool)((wxTextAttrEx const *)arg1)->HasAlignment();

4369

wxPyEndAllowThreads(__tstate);

4370

if (PyErr_Occurred()) SWIG_fail;

4371

}

4372

{

4373

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

4374

}

4375

return resultobj;

4376

fail:

4377

return NULL;

4378

}

4379

4380

4381

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

4382

PyObject *resultobj = 0;

4383

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4384

bool result;

4385

void *argp1 = 0 ;

4386

int res1 = 0 ;

4387

PyObject *swig_obj[1] ;

4388

4389

if (!args) SWIG_fail;

4390

swig_obj[0] = args;

4391

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

4392

if (!SWIG_IsOK(res1)) {

4393

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

4394

}

4395

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4396

{

4397

PyThreadState* __tstate = wxPyBeginAllowThreads();

4398

result = (bool)((wxTextAttrEx const *)arg1)->HasTabs();

4399

wxPyEndAllowThreads(__tstate);

4400

if (PyErr_Occurred()) SWIG_fail;

4401

}

4402

{

4403

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

4404

}

4405

return resultobj;

4406

fail:

4407

return NULL;

4408

}

4409

4410

4411

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

4412

PyObject *resultobj = 0;

4413

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4414

bool result;

4415

void *argp1 = 0 ;

4416

int res1 = 0 ;

4417

PyObject *swig_obj[1] ;

4418

4419

if (!args) SWIG_fail;

4420

swig_obj[0] = args;

4421

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

4422

if (!SWIG_IsOK(res1)) {

4423

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

4424

}

4425

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4426

{

4427

PyThreadState* __tstate = wxPyBeginAllowThreads();

4428

result = (bool)((wxTextAttrEx const *)arg1)->HasLeftIndent();

4429

wxPyEndAllowThreads(__tstate);

4430

if (PyErr_Occurred()) SWIG_fail;

4431

}

4432

{

4433

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

4434

}

4435

return resultobj;

4436

fail:

4437

return NULL;

4438

}

4439

4440

4441

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

4442

PyObject *resultobj = 0;

4443

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4444

bool result;

4445

void *argp1 = 0 ;

4446

int res1 = 0 ;

4447

PyObject *swig_obj[1] ;

4448

4449

if (!args) SWIG_fail;

4450

swig_obj[0] = args;

4451

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

4452

if (!SWIG_IsOK(res1)) {

4453

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

4454

}

4455

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4456

{

4457

PyThreadState* __tstate = wxPyBeginAllowThreads();

4458

result = (bool)((wxTextAttrEx const *)arg1)->HasRightIndent();

4459

wxPyEndAllowThreads(__tstate);

4460

if (PyErr_Occurred()) SWIG_fail;

4461

}

4462

{

4463

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

4464

}

4465

return resultobj;

4466

fail:

4467

return NULL;

4468

}

4469

4470

4471

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

4472

PyObject *resultobj = 0;

4473

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4474

long arg2 ;

4475

bool result;

4476

void *argp1 = 0 ;

4477

int res1 = 0 ;

4478

long val2 ;

4479

int ecode2 = 0 ;

4480

PyObject * obj0 = 0 ;

4481

PyObject * obj1 = 0 ;

4482

char * kwnames[] = {

4483

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

4484

};

4485

4486

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

4487

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

4488

if (!SWIG_IsOK(res1)) {

4489

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

4490

}

4491

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4492

ecode2 = SWIG_AsVal_long(obj1, &val2);

4493

if (!SWIG_IsOK(ecode2)) {

4494

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

4495

}

4496

arg2 = static_cast< long >(val2);

4497

{

4498

PyThreadState* __tstate = wxPyBeginAllowThreads();

4499

result = (bool)((wxTextAttrEx const *)arg1)->HasFlag(arg2);

4500

wxPyEndAllowThreads(__tstate);

4501

if (PyErr_Occurred()) SWIG_fail;

4502

}

4503

{

4504

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

4505

}

4506

return resultobj;

4507

fail:

4508

return NULL;

4509

}

4510

4511

4512

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

4513

PyObject *resultobj = 0;

4514

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4515

wxColour *result = 0 ;

4516

void *argp1 = 0 ;

4517

int res1 = 0 ;

4518

PyObject *swig_obj[1] ;

4519

4520

if (!args) SWIG_fail;

4521

swig_obj[0] = args;

4522

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

4523

if (!SWIG_IsOK(res1)) {

4524

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

4525

}

4526

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4527

{

4528

PyThreadState* __tstate = wxPyBeginAllowThreads();

4529

{

4530

wxColour const &_result_ref = ((wxTextAttrEx const *)arg1)->GetTextColour();

4531

result = (wxColour *) &_result_ref;

4532

}

4533

wxPyEndAllowThreads(__tstate);

4534

if (PyErr_Occurred()) SWIG_fail;

4535

}

4536

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

4537

return resultobj;

4538

fail:

4539

return NULL;

4540

}

4541

4542

4543

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

4544

PyObject *resultobj = 0;

4545

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4546

wxColour *result = 0 ;

4547

void *argp1 = 0 ;

4548

int res1 = 0 ;

4549

PyObject *swig_obj[1] ;

4550

4551

if (!args) SWIG_fail;

4552

swig_obj[0] = args;

4553

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

4554

if (!SWIG_IsOK(res1)) {

4555

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

4556

}

4557

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4558

{

4559

PyThreadState* __tstate = wxPyBeginAllowThreads();

4560

{

4561

wxColour const &_result_ref = ((wxTextAttrEx const *)arg1)->GetBackgroundColour();

4562

result = (wxColour *) &_result_ref;

4563

}

4564

wxPyEndAllowThreads(__tstate);

4565

if (PyErr_Occurred()) SWIG_fail;

4566

}

4567

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

4568

return resultobj;

4569

fail:

4570

return NULL;

4571

}

4572

4573

4574

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

4575

PyObject *resultobj = 0;

4576

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4577

wxFont *result = 0 ;

4578

void *argp1 = 0 ;

4579

int res1 = 0 ;

4580

PyObject *swig_obj[1] ;

4581

4582

if (!args) SWIG_fail;

4583

swig_obj[0] = args;

4584

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

4585

if (!SWIG_IsOK(res1)) {

4586

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

4587

}

4588

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4589

{

4590

PyThreadState* __tstate = wxPyBeginAllowThreads();

4591

{

4592

wxFont const &_result_ref = ((wxTextAttrEx const *)arg1)->GetFont();

4593

result = (wxFont *) &_result_ref;

4594

}

4595

wxPyEndAllowThreads(__tstate);

4596

if (PyErr_Occurred()) SWIG_fail;

4597

}

4598

{

4599

wxFont* resultptr = new wxFont(*result);

4600

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

4601

}

4602

return resultobj;

4603

fail:

4604

return NULL;

4605

}

4606

4607

4608

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

4609

PyObject *resultobj = 0;

4610

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4611

wxTextAttrAlignment result;

4612

void *argp1 = 0 ;

4613

int res1 = 0 ;

4614

PyObject *swig_obj[1] ;

4615

4616

if (!args) SWIG_fail;

4617

swig_obj[0] = args;

4618

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

4619

if (!SWIG_IsOK(res1)) {

4620

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

4621

}

4622

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4623

{

4624

PyThreadState* __tstate = wxPyBeginAllowThreads();

4625

result = (wxTextAttrAlignment)((wxTextAttrEx const *)arg1)->GetAlignment();

4626

wxPyEndAllowThreads(__tstate);

4627

if (PyErr_Occurred()) SWIG_fail;

4628

}

4629

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

4630

return resultobj;

4631

fail:

4632

return NULL;

4633

}

4634

4635

4636

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

4637

PyObject *resultobj = 0;

4638

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4639

wxArrayInt *result = 0 ;

4640

void *argp1 = 0 ;

4641

int res1 = 0 ;

4642

PyObject *swig_obj[1] ;

4643

4644

if (!args) SWIG_fail;

4645

swig_obj[0] = args;

4646

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

4647

if (!SWIG_IsOK(res1)) {

4648

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

4649

}

4650

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4651

{

4652

PyThreadState* __tstate = wxPyBeginAllowThreads();

4653

{

4654

wxArrayInt const &_result_ref = ((wxTextAttrEx const *)arg1)->GetTabs();

4655

result = (wxArrayInt *) &_result_ref;

4656

}

4657

wxPyEndAllowThreads(__tstate);

4658

if (PyErr_Occurred()) SWIG_fail;

4659

}

4660

{

4661

resultobj = wxArrayInt2PyList_helper(*result);

4662

}

4663

return resultobj;

4664

fail:

4665

return NULL;

4666

}

4667

4668

4669

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

4670

PyObject *resultobj = 0;

4671

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4672

long result;

4673

void *argp1 = 0 ;

4674

int res1 = 0 ;

4675

PyObject *swig_obj[1] ;

4676

4677

if (!args) SWIG_fail;

4678

swig_obj[0] = args;

4679

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

4680

if (!SWIG_IsOK(res1)) {

4681

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

4682

}

4683

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4684

{

4685

PyThreadState* __tstate = wxPyBeginAllowThreads();

4686

result = (long)((wxTextAttrEx const *)arg1)->GetLeftIndent();

4687

wxPyEndAllowThreads(__tstate);

4688

if (PyErr_Occurred()) SWIG_fail;

4689

}

4690

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

4691

return resultobj;

4692

fail:

4693

return NULL;

4694

}

4695

4696

4697

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

4698

PyObject *resultobj = 0;

4699

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4700

long result;

4701

void *argp1 = 0 ;

4702

int res1 = 0 ;

4703

PyObject *swig_obj[1] ;

4704

4705

if (!args) SWIG_fail;

4706

swig_obj[0] = args;

4707

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

4708

if (!SWIG_IsOK(res1)) {

4709

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

4710

}

4711

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4712

{

4713

PyThreadState* __tstate = wxPyBeginAllowThreads();

4714

result = (long)((wxTextAttrEx const *)arg1)->GetLeftSubIndent();

4715

wxPyEndAllowThreads(__tstate);

4716

if (PyErr_Occurred()) SWIG_fail;

4717

}

4718

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

4719

return resultobj;

4720

fail:

4721

return NULL;

4722

}

4723

4724

4725

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

4726

PyObject *resultobj = 0;

4727

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4728

long result;

4729

void *argp1 = 0 ;

4730

int res1 = 0 ;

4731

PyObject *swig_obj[1] ;

4732

4733

if (!args) SWIG_fail;

4734

swig_obj[0] = args;

4735

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

4736

if (!SWIG_IsOK(res1)) {

4737

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

4738

}

4739

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4740

{

4741

PyThreadState* __tstate = wxPyBeginAllowThreads();

4742

result = (long)((wxTextAttrEx const *)arg1)->GetRightIndent();

4743

wxPyEndAllowThreads(__tstate);

4744

if (PyErr_Occurred()) SWIG_fail;

4745

}

4746

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

4747

return resultobj;

4748

fail:

4749

return NULL;

4750

}

4751

4752

4753

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

4754

PyObject *resultobj = 0;

4755

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4756

long result;

4757

void *argp1 = 0 ;

4758

int res1 = 0 ;

4759

PyObject *swig_obj[1] ;

4760

4761

if (!args) SWIG_fail;

4762

swig_obj[0] = args;

4763

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

4764

if (!SWIG_IsOK(res1)) {

4765

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

4766

}

4767

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4768

{

4769

PyThreadState* __tstate = wxPyBeginAllowThreads();

4770

result = (long)((wxTextAttrEx const *)arg1)->GetFlags();

4771

wxPyEndAllowThreads(__tstate);

4772

if (PyErr_Occurred()) SWIG_fail;

4773

}

4774

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

4775

return resultobj;

4776

fail:

4777

return NULL;

4778

}

4779

4780

4781

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

4782

PyObject *resultobj = 0;

4783

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4784

wxString *arg2 = 0 ;

4785

void *argp1 = 0 ;

4786

int res1 = 0 ;

4787

bool temp2 = false ;

4788

PyObject * obj0 = 0 ;

4789

PyObject * obj1 = 0 ;

4790

char * kwnames[] = {

4791

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

4792

};

4793

4794

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

4795

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

4796

if (!SWIG_IsOK(res1)) {

4797

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

4798

}

4799

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4800

{

4801

arg2 = wxString_in_helper(obj1);

4802

if (arg2 == NULL) SWIG_fail;

4803

temp2 = true;

4804

}

4805

{

4806

PyThreadState* __tstate = wxPyBeginAllowThreads();

4807

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

4808

wxPyEndAllowThreads(__tstate);

4809

if (PyErr_Occurred()) SWIG_fail;

4810

}

4811

resultobj = SWIG_Py_Void();

4812

{

4813

if (temp2)

4814

delete arg2;

4815

}

4816

return resultobj;

4817

fail:

4818

{

4819

if (temp2)

4820

delete arg2;

4821

}

4822

return NULL;

4823

}

4824

4825

4826

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

4827

PyObject *resultobj = 0;

4828

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4829

wxString *arg2 = 0 ;

4830

void *argp1 = 0 ;

4831

int res1 = 0 ;

4832

bool temp2 = false ;

4833

PyObject * obj0 = 0 ;

4834

PyObject * obj1 = 0 ;

4835

char * kwnames[] = {

4836

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

4837

};

4838

4839

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

4840

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

4841

if (!SWIG_IsOK(res1)) {

4842

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

4843

}

4844

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4845

{

4846

arg2 = wxString_in_helper(obj1);

4847

if (arg2 == NULL) SWIG_fail;

4848

temp2 = true;

4849

}

4850

{

4851

PyThreadState* __tstate = wxPyBeginAllowThreads();

4852

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

4853

wxPyEndAllowThreads(__tstate);

4854

if (PyErr_Occurred()) SWIG_fail;

4855

}

4856

resultobj = SWIG_Py_Void();

4857

{

4858

if (temp2)

4859

delete arg2;

4860

}

4861

return resultobj;

4862

fail:

4863

{

4864

if (temp2)

4865

delete arg2;

4866

}

4867

return NULL;

4868

}

4869

4870

4871

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

4872

PyObject *resultobj = 0;

4873

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4874

wxString *arg2 = 0 ;

4875

void *argp1 = 0 ;

4876

int res1 = 0 ;

4877

bool temp2 = false ;

4878

PyObject * obj0 = 0 ;

4879

PyObject * obj1 = 0 ;

4880

char * kwnames[] = {

4881

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

4882

};

4883

4884

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

4885

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

4886

if (!SWIG_IsOK(res1)) {

4887

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

4888

}

4889

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4890

{

4891

arg2 = wxString_in_helper(obj1);

4892

if (arg2 == NULL) SWIG_fail;

4893

temp2 = true;

4894

}

4895

{

4896

PyThreadState* __tstate = wxPyBeginAllowThreads();

4897

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

4898

wxPyEndAllowThreads(__tstate);

4899

if (PyErr_Occurred()) SWIG_fail;

4900

}

4901

resultobj = SWIG_Py_Void();

4902

{

4903

if (temp2)

4904

delete arg2;

4905

}

4906

return resultobj;

4907

fail:

4908

{

4909

if (temp2)

4910

delete arg2;

4911

}

4912

return NULL;

4913

}

4914

4915

4916

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

4917

PyObject *resultobj = 0;

4918

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4919

int arg2 ;

4920

void *argp1 = 0 ;

4921

int res1 = 0 ;

4922

int val2 ;

4923

int ecode2 = 0 ;

4924

PyObject * obj0 = 0 ;

4925

PyObject * obj1 = 0 ;

4926

char * kwnames[] = {

4927

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

4928

};

4929

4930

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

4931

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

4932

if (!SWIG_IsOK(res1)) {

4933

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

4934

}

4935

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4936

ecode2 = SWIG_AsVal_int(obj1, &val2);

4937

if (!SWIG_IsOK(ecode2)) {

4938

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

4939

}

4940

arg2 = static_cast< int >(val2);

4941

{

4942

PyThreadState* __tstate = wxPyBeginAllowThreads();

4943

(arg1)->SetParagraphSpacingAfter(arg2);

4944

wxPyEndAllowThreads(__tstate);

4945

if (PyErr_Occurred()) SWIG_fail;

4946

}

4947

resultobj = SWIG_Py_Void();

4948

return resultobj;

4949

fail:

4950

return NULL;

4951

}

4952

4953

4954

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

4955

PyObject *resultobj = 0;

4956

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4957

int arg2 ;

4958

void *argp1 = 0 ;

4959

int res1 = 0 ;

4960

int val2 ;

4961

int ecode2 = 0 ;

4962

PyObject * obj0 = 0 ;

4963

PyObject * obj1 = 0 ;

4964

char * kwnames[] = {

4965

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

4966

};

4967

4968

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

4969

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

4970

if (!SWIG_IsOK(res1)) {

4971

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

4972

}

4973

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

4974

ecode2 = SWIG_AsVal_int(obj1, &val2);

4975

if (!SWIG_IsOK(ecode2)) {

4976

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

4977

}

4978

arg2 = static_cast< int >(val2);

4979

{

4980

PyThreadState* __tstate = wxPyBeginAllowThreads();

4981

(arg1)->SetParagraphSpacingBefore(arg2);

4982

wxPyEndAllowThreads(__tstate);

4983

if (PyErr_Occurred()) SWIG_fail;

4984

}

4985

resultobj = SWIG_Py_Void();

4986

return resultobj;

4987

fail:

4988

return NULL;

4989

}

4990

4991

4992

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

4993

PyObject *resultobj = 0;

4994

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

4995

int arg2 ;

4996

void *argp1 = 0 ;

4997

int res1 = 0 ;

4998

int val2 ;

4999

int ecode2 = 0 ;

5000

PyObject * obj0 = 0 ;

5001

PyObject * obj1 = 0 ;

5002

char * kwnames[] = {

5003

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

5004

};

5005

5006

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

5007

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

5008

if (!SWIG_IsOK(res1)) {

5009

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

5010

}

5011

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5012

ecode2 = SWIG_AsVal_int(obj1, &val2);

5013

if (!SWIG_IsOK(ecode2)) {

5014

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

5015

}

5016

arg2 = static_cast< int >(val2);

5017

{

5018

PyThreadState* __tstate = wxPyBeginAllowThreads();

5019

(arg1)->SetLineSpacing(arg2);

5020

wxPyEndAllowThreads(__tstate);

5021

if (PyErr_Occurred()) SWIG_fail;

5022

}

5023

resultobj = SWIG_Py_Void();

5024

return resultobj;

5025

fail:

5026

return NULL;

5027

}

5028

5029

5030

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

5031

PyObject *resultobj = 0;

5032

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5033

int arg2 ;

5034

void *argp1 = 0 ;

5035

int res1 = 0 ;

5036

int val2 ;

5037

int ecode2 = 0 ;

5038

PyObject * obj0 = 0 ;

5039

PyObject * obj1 = 0 ;

5040

char * kwnames[] = {

5041

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

5042

};

5043

5044

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

5045

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

5046

if (!SWIG_IsOK(res1)) {

5047

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

5048

}

5049

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5050

ecode2 = SWIG_AsVal_int(obj1, &val2);

5051

if (!SWIG_IsOK(ecode2)) {

5052

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

5053

}

5054

arg2 = static_cast< int >(val2);

5055

{

5056

PyThreadState* __tstate = wxPyBeginAllowThreads();

5057

(arg1)->SetBulletStyle(arg2);

5058

wxPyEndAllowThreads(__tstate);

5059

if (PyErr_Occurred()) SWIG_fail;

5060

}

5061

resultobj = SWIG_Py_Void();

5062

return resultobj;

5063

fail:

5064

return NULL;

5065

}

5066

5067

5068

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

5069

PyObject *resultobj = 0;

5070

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5071

int arg2 ;

5072

void *argp1 = 0 ;

5073

int res1 = 0 ;

5074

int val2 ;

5075

int ecode2 = 0 ;

5076

PyObject * obj0 = 0 ;

5077

PyObject * obj1 = 0 ;

5078

char * kwnames[] = {

5079

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

5080

};

5081

5082

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

5083

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

5084

if (!SWIG_IsOK(res1)) {

5085

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

5086

}

5087

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5088

ecode2 = SWIG_AsVal_int(obj1, &val2);

5089

if (!SWIG_IsOK(ecode2)) {

5090

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

5091

}

5092

arg2 = static_cast< int >(val2);

5093

{

5094

PyThreadState* __tstate = wxPyBeginAllowThreads();

5095

(arg1)->SetBulletNumber(arg2);

5096

wxPyEndAllowThreads(__tstate);

5097

if (PyErr_Occurred()) SWIG_fail;

5098

}

5099

resultobj = SWIG_Py_Void();

5100

return resultobj;

5101

fail:

5102

return NULL;

5103

}

5104

5105

5106

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

5107

PyObject *resultobj = 0;

5108

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5109

wxString *arg2 = 0 ;

5110

void *argp1 = 0 ;

5111

int res1 = 0 ;

5112

bool temp2 = false ;

5113

PyObject * obj0 = 0 ;

5114

PyObject * obj1 = 0 ;

5115

char * kwnames[] = {

5116

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

5117

};

5118

5119

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

5120

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

5121

if (!SWIG_IsOK(res1)) {

5122

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

5123

}

5124

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5125

{

5126

arg2 = wxString_in_helper(obj1);

5127

if (arg2 == NULL) SWIG_fail;

5128

temp2 = true;

5129

}

5130

{

5131

PyThreadState* __tstate = wxPyBeginAllowThreads();

5132

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

5133

wxPyEndAllowThreads(__tstate);

5134

if (PyErr_Occurred()) SWIG_fail;

5135

}

5136

resultobj = SWIG_Py_Void();

5137

{

5138

if (temp2)

5139

delete arg2;

5140

}

5141

return resultobj;

5142

fail:

5143

{

5144

if (temp2)

5145

delete arg2;

5146

}

5147

return NULL;

5148

}

5149

5150

5151

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

5152

PyObject *resultobj = 0;

5153

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5154

wxString *arg2 = 0 ;

5155

void *argp1 = 0 ;

5156

int res1 = 0 ;

5157

bool temp2 = false ;

5158

PyObject * obj0 = 0 ;

5159

PyObject * obj1 = 0 ;

5160

char * kwnames[] = {

5161

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

5162

};

5163

5164

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

5165

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

5166

if (!SWIG_IsOK(res1)) {

5167

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

5168

}

5169

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5170

{

5171

arg2 = wxString_in_helper(obj1);

5172

if (arg2 == NULL) SWIG_fail;

5173

temp2 = true;

5174

}

5175

{

5176

PyThreadState* __tstate = wxPyBeginAllowThreads();

5177

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

5178

wxPyEndAllowThreads(__tstate);

5179

if (PyErr_Occurred()) SWIG_fail;

5180

}

5181

resultobj = SWIG_Py_Void();

5182

{

5183

if (temp2)

5184

delete arg2;

5185

}

5186

return resultobj;

5187

fail:

5188

{

5189

if (temp2)

5190

delete arg2;

5191

}

5192

return NULL;

5193

}

5194

5195

5196

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

5197

PyObject *resultobj = 0;

5198

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5199

wxString *arg2 = 0 ;

5200

void *argp1 = 0 ;

5201

int res1 = 0 ;

5202

bool temp2 = false ;

5203

PyObject * obj0 = 0 ;

5204

PyObject * obj1 = 0 ;

5205

char * kwnames[] = {

5206

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

5207

};

5208

5209

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

5210

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

5211

if (!SWIG_IsOK(res1)) {

5212

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

5213

}

5214

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5215

{

5216

arg2 = wxString_in_helper(obj1);

5217

if (arg2 == NULL) SWIG_fail;

5218

temp2 = true;

5219

}

5220

{

5221

PyThreadState* __tstate = wxPyBeginAllowThreads();

5222

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

5223

wxPyEndAllowThreads(__tstate);

5224

if (PyErr_Occurred()) SWIG_fail;

5225

}

5226

resultobj = SWIG_Py_Void();

5227

{

5228

if (temp2)

5229

delete arg2;

5230

}

5231

return resultobj;

5232

fail:

5233

{

5234

if (temp2)

5235

delete arg2;

5236

}

5237

return NULL;

5238

}

5239

5240

5241

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

5242

PyObject *resultobj = 0;

5243

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5244

wxString *arg2 = 0 ;

5245

void *argp1 = 0 ;

5246

int res1 = 0 ;

5247

bool temp2 = false ;

5248

PyObject * obj0 = 0 ;

5249

PyObject * obj1 = 0 ;

5250

char * kwnames[] = {

5251

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

5252

};

5253

5254

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

5255

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

5256

if (!SWIG_IsOK(res1)) {

5257

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

5258

}

5259

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5260

{

5261

arg2 = wxString_in_helper(obj1);

5262

if (arg2 == NULL) SWIG_fail;

5263

temp2 = true;

5264

}

5265

{

5266

PyThreadState* __tstate = wxPyBeginAllowThreads();

5267

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

5268

wxPyEndAllowThreads(__tstate);

5269

if (PyErr_Occurred()) SWIG_fail;

5270

}

5271

resultobj = SWIG_Py_Void();

5272

{

5273

if (temp2)

5274

delete arg2;

5275

}

5276

return resultobj;

5277

fail:

5278

{

5279

if (temp2)

5280

delete arg2;

5281

}

5282

return NULL;

5283

}

5284

5285

5286

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

5287

PyObject *resultobj = 0;

5288

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5289

bool arg2 = (bool) true ;

5290

void *argp1 = 0 ;

5291

int res1 = 0 ;

5292

bool val2 ;

5293

int ecode2 = 0 ;

5294

PyObject * obj0 = 0 ;

5295

PyObject * obj1 = 0 ;

5296

char * kwnames[] = {

5297

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

5298

};

5299

5300

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

5301

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

5302

if (!SWIG_IsOK(res1)) {

5303

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

5304

}

5305

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5306

if (obj1) {

5307

ecode2 = SWIG_AsVal_bool(obj1, &val2);

5308

if (!SWIG_IsOK(ecode2)) {

5309

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

5310

}

5311

arg2 = static_cast< bool >(val2);

5312

}

5313

{

5314

PyThreadState* __tstate = wxPyBeginAllowThreads();

5315

(arg1)->SetPageBreak(arg2);

5316

wxPyEndAllowThreads(__tstate);

5317

if (PyErr_Occurred()) SWIG_fail;

5318

}

5319

resultobj = SWIG_Py_Void();

5320

return resultobj;

5321

fail:

5322

return NULL;

5323

}

5324

5325

5326

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

5327

PyObject *resultobj = 0;

5328

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5329

int arg2 ;

5330

void *argp1 = 0 ;

5331

int res1 = 0 ;

5332

int val2 ;

5333

int ecode2 = 0 ;

5334

PyObject * obj0 = 0 ;

5335

PyObject * obj1 = 0 ;

5336

char * kwnames[] = {

5337

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

5338

};

5339

5340

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

5341

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

5342

if (!SWIG_IsOK(res1)) {

5343

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

5344

}

5345

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5346

ecode2 = SWIG_AsVal_int(obj1, &val2);

5347

if (!SWIG_IsOK(ecode2)) {

5348

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

5349

}

5350

arg2 = static_cast< int >(val2);

5351

{

5352

PyThreadState* __tstate = wxPyBeginAllowThreads();

5353

(arg1)->SetTextEffects(arg2);

5354

wxPyEndAllowThreads(__tstate);

5355

if (PyErr_Occurred()) SWIG_fail;

5356

}

5357

resultobj = SWIG_Py_Void();

5358

return resultobj;

5359

fail:

5360

return NULL;

5361

}

5362

5363

5364

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

5365

PyObject *resultobj = 0;

5366

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5367

int arg2 ;

5368

void *argp1 = 0 ;

5369

int res1 = 0 ;

5370

int val2 ;

5371

int ecode2 = 0 ;

5372

PyObject * obj0 = 0 ;

5373

PyObject * obj1 = 0 ;

5374

char * kwnames[] = {

5375

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

5376

};

5377

5378

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

5379

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

5380

if (!SWIG_IsOK(res1)) {

5381

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

5382

}

5383

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5384

ecode2 = SWIG_AsVal_int(obj1, &val2);

5385

if (!SWIG_IsOK(ecode2)) {

5386

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

5387

}

5388

arg2 = static_cast< int >(val2);

5389

{

5390

PyThreadState* __tstate = wxPyBeginAllowThreads();

5391

(arg1)->SetTextEffectFlags(arg2);

5392

wxPyEndAllowThreads(__tstate);

5393

if (PyErr_Occurred()) SWIG_fail;

5394

}

5395

resultobj = SWIG_Py_Void();

5396

return resultobj;

5397

fail:

5398

return NULL;

5399

}

5400

5401

5402

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

5403

PyObject *resultobj = 0;

5404

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5405

int arg2 ;

5406

void *argp1 = 0 ;

5407

int res1 = 0 ;

5408

int val2 ;

5409

int ecode2 = 0 ;

5410

PyObject * obj0 = 0 ;

5411

PyObject * obj1 = 0 ;

5412

char * kwnames[] = {

5413

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

5414

};

5415

5416

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

5417

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

5418

if (!SWIG_IsOK(res1)) {

5419

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

5420

}

5421

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5422

ecode2 = SWIG_AsVal_int(obj1, &val2);

5423

if (!SWIG_IsOK(ecode2)) {

5424

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

5425

}

5426

arg2 = static_cast< int >(val2);

5427

{

5428

PyThreadState* __tstate = wxPyBeginAllowThreads();

5429

(arg1)->SetOutlineLevel(arg2);

5430

wxPyEndAllowThreads(__tstate);

5431

if (PyErr_Occurred()) SWIG_fail;

5432

}

5433

resultobj = SWIG_Py_Void();

5434

return resultobj;

5435

fail:

5436

return NULL;

5437

}

5438

5439

5440

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

5441

PyObject *resultobj = 0;

5442

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5443

int arg2 ;

5444

void *argp1 = 0 ;

5445

int res1 = 0 ;

5446

int val2 ;

5447

int ecode2 = 0 ;

5448

PyObject * obj0 = 0 ;

5449

PyObject * obj1 = 0 ;

5450

char * kwnames[] = {

5451

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

5452

};

5453

5454

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

5455

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

5456

if (!SWIG_IsOK(res1)) {

5457

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

5458

}

5459

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5460

ecode2 = SWIG_AsVal_int(obj1, &val2);

5461

if (!SWIG_IsOK(ecode2)) {

5462

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

5463

}

5464

arg2 = static_cast< int >(val2);

5465

{

5466

PyThreadState* __tstate = wxPyBeginAllowThreads();

5467

wxTextAttrEx_SetFontSize(arg1,arg2);

5468

wxPyEndAllowThreads(__tstate);

5469

if (PyErr_Occurred()) SWIG_fail;

5470

}

5471

resultobj = SWIG_Py_Void();

5472

return resultobj;

5473

fail:

5474

return NULL;

5475

}

5476

5477

5478

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

5479

PyObject *resultobj = 0;

5480

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5481

int arg2 ;

5482

void *argp1 = 0 ;

5483

int res1 = 0 ;

5484

int val2 ;

5485

int ecode2 = 0 ;

5486

PyObject * obj0 = 0 ;

5487

PyObject * obj1 = 0 ;

5488

char * kwnames[] = {

5489

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

5490

};

5491

5492

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

5493

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

5494

if (!SWIG_IsOK(res1)) {

5495

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

5496

}

5497

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5498

ecode2 = SWIG_AsVal_int(obj1, &val2);

5499

if (!SWIG_IsOK(ecode2)) {

5500

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

5501

}

5502

arg2 = static_cast< int >(val2);

5503

{

5504

PyThreadState* __tstate = wxPyBeginAllowThreads();

5505

wxTextAttrEx_SetFontStyle(arg1,arg2);

5506

wxPyEndAllowThreads(__tstate);

5507

if (PyErr_Occurred()) SWIG_fail;

5508

}

5509

resultobj = SWIG_Py_Void();

5510

return resultobj;

5511

fail:

5512

return NULL;

5513

}

5514

5515

5516

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

5517

PyObject *resultobj = 0;

5518

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5519

int arg2 ;

5520

void *argp1 = 0 ;

5521

int res1 = 0 ;

5522

int val2 ;

5523

int ecode2 = 0 ;

5524

PyObject * obj0 = 0 ;

5525

PyObject * obj1 = 0 ;

5526

char * kwnames[] = {

5527

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

5528

};

5529

5530

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

5531

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

5532

if (!SWIG_IsOK(res1)) {

5533

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

5534

}

5535

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5536

ecode2 = SWIG_AsVal_int(obj1, &val2);

5537

if (!SWIG_IsOK(ecode2)) {

5538

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

5539

}

5540

arg2 = static_cast< int >(val2);

5541

{

5542

PyThreadState* __tstate = wxPyBeginAllowThreads();

5543

wxTextAttrEx_SetFontWeight(arg1,arg2);

5544

wxPyEndAllowThreads(__tstate);

5545

if (PyErr_Occurred()) SWIG_fail;

5546

}

5547

resultobj = SWIG_Py_Void();

5548

return resultobj;

5549

fail:

5550

return NULL;

5551

}

5552

5553

5554

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

5555

PyObject *resultobj = 0;

5556

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5557

wxString *arg2 = 0 ;

5558

void *argp1 = 0 ;

5559

int res1 = 0 ;

5560

bool temp2 = false ;

5561

PyObject * obj0 = 0 ;

5562

PyObject * obj1 = 0 ;

5563

char * kwnames[] = {

5564

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

5565

};

5566

5567

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

5568

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

5569

if (!SWIG_IsOK(res1)) {

5570

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

5571

}

5572

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5573

{

5574

arg2 = wxString_in_helper(obj1);

5575

if (arg2 == NULL) SWIG_fail;

5576

temp2 = true;

5577

}

5578

{

5579

PyThreadState* __tstate = wxPyBeginAllowThreads();

5580

wxTextAttrEx_SetFontFaceName(arg1,(wxString const &)*arg2);

5581

wxPyEndAllowThreads(__tstate);

5582

if (PyErr_Occurred()) SWIG_fail;

5583

}

5584

resultobj = SWIG_Py_Void();

5585

{

5586

if (temp2)

5587

delete arg2;

5588

}

5589

return resultobj;

5590

fail:

5591

{

5592

if (temp2)

5593

delete arg2;

5594

}

5595

return NULL;

5596

}

5597

5598

5599

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

5600

PyObject *resultobj = 0;

5601

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5602

bool arg2 ;

5603

void *argp1 = 0 ;

5604

int res1 = 0 ;

5605

bool val2 ;

5606

int ecode2 = 0 ;

5607

PyObject * obj0 = 0 ;

5608

PyObject * obj1 = 0 ;

5609

char * kwnames[] = {

5610

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

5611

};

5612

5613

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

5614

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

5615

if (!SWIG_IsOK(res1)) {

5616

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

5617

}

5618

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5619

ecode2 = SWIG_AsVal_bool(obj1, &val2);

5620

if (!SWIG_IsOK(ecode2)) {

5621

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

5622

}

5623

arg2 = static_cast< bool >(val2);

5624

{

5625

PyThreadState* __tstate = wxPyBeginAllowThreads();

5626

wxTextAttrEx_SetFontUnderlined(arg1,arg2);

5627

wxPyEndAllowThreads(__tstate);

5628

if (PyErr_Occurred()) SWIG_fail;

5629

}

5630

resultobj = SWIG_Py_Void();

5631

return resultobj;

5632

fail:

5633

return NULL;

5634

}

5635

5636

5637

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

5638

PyObject *resultobj = 0;

5639

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5640

wxString *result = 0 ;

5641

void *argp1 = 0 ;

5642

int res1 = 0 ;

5643

PyObject *swig_obj[1] ;

5644

5645

if (!args) SWIG_fail;

5646

swig_obj[0] = args;

5647

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

5648

if (!SWIG_IsOK(res1)) {

5649

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

5650

}

5651

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5652

{

5653

PyThreadState* __tstate = wxPyBeginAllowThreads();

5654

{

5655

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetCharacterStyleName();

5656

result = (wxString *) &_result_ref;

5657

}

5658

wxPyEndAllowThreads(__tstate);

5659

if (PyErr_Occurred()) SWIG_fail;

5660

}

5661

{

5662

#if wxUSE_UNICODE

5663

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

5664

#else

5665

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

5666

#endif

5667

}

5668

return resultobj;

5669

fail:

5670

return NULL;

5671

}

5672

5673

5674

SWIGINTERN PyObject *_wrap_TextAttrEx_GetParagraphStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5675

PyObject *resultobj = 0;

5676

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5677

wxString *result = 0 ;

5678

void *argp1 = 0 ;

5679

int res1 = 0 ;

5680

PyObject *swig_obj[1] ;

5681

5682

if (!args) SWIG_fail;

5683

swig_obj[0] = args;

5684

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5685

if (!SWIG_IsOK(res1)) {

5686

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetParagraphStyleName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5687

}

5688

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5689

{

5690

PyThreadState* __tstate = wxPyBeginAllowThreads();

5691

{

5692

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetParagraphStyleName();

5693

result = (wxString *) &_result_ref;

5694

}

5695

wxPyEndAllowThreads(__tstate);

5696

if (PyErr_Occurred()) SWIG_fail;

5697

}

5698

{

5699

#if wxUSE_UNICODE

5700

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

5701

#else

5702

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

5703

#endif

5704

}

5705

return resultobj;

5706

fail:

5707

return NULL;

5708

}

5709

5710

5711

SWIGINTERN PyObject *_wrap_TextAttrEx_GetListStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5712

PyObject *resultobj = 0;

5713

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5714

wxString *result = 0 ;

5715

void *argp1 = 0 ;

5716

int res1 = 0 ;

5717

PyObject *swig_obj[1] ;

5718

5719

if (!args) SWIG_fail;

5720

swig_obj[0] = args;

5721

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5722

if (!SWIG_IsOK(res1)) {

5723

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetListStyleName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5724

}

5725

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5726

{

5727

PyThreadState* __tstate = wxPyBeginAllowThreads();

5728

{

5729

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetListStyleName();

5730

result = (wxString *) &_result_ref;

5731

}

5732

wxPyEndAllowThreads(__tstate);

5733

if (PyErr_Occurred()) SWIG_fail;

5734

}

5735

{

5736

#if wxUSE_UNICODE

5737

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

5738

#else

5739

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

5740

#endif

5741

}

5742

return resultobj;

5743

fail:

5744

return NULL;

5745

}

5746

5747

5748

SWIGINTERN PyObject *_wrap_TextAttrEx_GetParagraphSpacingAfter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5749

PyObject *resultobj = 0;

5750

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5751

int result;

5752

void *argp1 = 0 ;

5753

int res1 = 0 ;

5754

PyObject *swig_obj[1] ;

5755

5756

if (!args) SWIG_fail;

5757

swig_obj[0] = args;

5758

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5759

if (!SWIG_IsOK(res1)) {

5760

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetParagraphSpacingAfter" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5761

}

5762

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5763

{

5764

PyThreadState* __tstate = wxPyBeginAllowThreads();

5765

result = (int)((wxTextAttrEx const *)arg1)->GetParagraphSpacingAfter();

5766

wxPyEndAllowThreads(__tstate);

5767

if (PyErr_Occurred()) SWIG_fail;

5768

}

5769

resultobj = SWIG_From_int(static_cast< int >(result));

5770

return resultobj;

5771

fail:

5772

return NULL;

5773

}

5774

5775

5776

SWIGINTERN PyObject *_wrap_TextAttrEx_GetParagraphSpacingBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5777

PyObject *resultobj = 0;

5778

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5779

int result;

5780

void *argp1 = 0 ;

5781

int res1 = 0 ;

5782

PyObject *swig_obj[1] ;

5783

5784

if (!args) SWIG_fail;

5785

swig_obj[0] = args;

5786

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5787

if (!SWIG_IsOK(res1)) {

5788

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetParagraphSpacingBefore" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5789

}

5790

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5791

{

5792

PyThreadState* __tstate = wxPyBeginAllowThreads();

5793

result = (int)((wxTextAttrEx const *)arg1)->GetParagraphSpacingBefore();

5794

wxPyEndAllowThreads(__tstate);

5795

if (PyErr_Occurred()) SWIG_fail;

5796

}

5797

resultobj = SWIG_From_int(static_cast< int >(result));

5798

return resultobj;

5799

fail:

5800

return NULL;

5801

}

5802

5803

5804

SWIGINTERN PyObject *_wrap_TextAttrEx_GetLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5805

PyObject *resultobj = 0;

5806

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5807

int result;

5808

void *argp1 = 0 ;

5809

int res1 = 0 ;

5810

PyObject *swig_obj[1] ;

5811

5812

if (!args) SWIG_fail;

5813

swig_obj[0] = args;

5814

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5815

if (!SWIG_IsOK(res1)) {

5816

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetLineSpacing" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5817

}

5818

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5819

{

5820

PyThreadState* __tstate = wxPyBeginAllowThreads();

5821

result = (int)((wxTextAttrEx const *)arg1)->GetLineSpacing();

5822

wxPyEndAllowThreads(__tstate);

5823

if (PyErr_Occurred()) SWIG_fail;

5824

}

5825

resultobj = SWIG_From_int(static_cast< int >(result));

5826

return resultobj;

5827

fail:

5828

return NULL;

5829

}

5830

5831

5832

SWIGINTERN PyObject *_wrap_TextAttrEx_GetBulletStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5833

PyObject *resultobj = 0;

5834

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5835

int result;

5836

void *argp1 = 0 ;

5837

int res1 = 0 ;

5838

PyObject *swig_obj[1] ;

5839

5840

if (!args) SWIG_fail;

5841

swig_obj[0] = args;

5842

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5843

if (!SWIG_IsOK(res1)) {

5844

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetBulletStyle" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5845

}

5846

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5847

{

5848

PyThreadState* __tstate = wxPyBeginAllowThreads();

5849

result = (int)((wxTextAttrEx const *)arg1)->GetBulletStyle();

5850

wxPyEndAllowThreads(__tstate);

5851

if (PyErr_Occurred()) SWIG_fail;

5852

}

5853

resultobj = SWIG_From_int(static_cast< int >(result));

5854

return resultobj;

5855

fail:

5856

return NULL;

5857

}

5858

5859

5860

SWIGINTERN PyObject *_wrap_TextAttrEx_GetBulletNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5861

PyObject *resultobj = 0;

5862

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5863

int result;

5864

void *argp1 = 0 ;

5865

int res1 = 0 ;

5866

PyObject *swig_obj[1] ;

5867

5868

if (!args) SWIG_fail;

5869

swig_obj[0] = args;

5870

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5871

if (!SWIG_IsOK(res1)) {

5872

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetBulletNumber" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5873

}

5874

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5875

{

5876

PyThreadState* __tstate = wxPyBeginAllowThreads();

5877

result = (int)((wxTextAttrEx const *)arg1)->GetBulletNumber();

5878

wxPyEndAllowThreads(__tstate);

5879

if (PyErr_Occurred()) SWIG_fail;

5880

}

5881

resultobj = SWIG_From_int(static_cast< int >(result));

5882

return resultobj;

5883

fail:

5884

return NULL;

5885

}

5886

5887

5888

SWIGINTERN PyObject *_wrap_TextAttrEx_GetBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5889

PyObject *resultobj = 0;

5890

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5891

wxString *result = 0 ;

5892

void *argp1 = 0 ;

5893

int res1 = 0 ;

5894

PyObject *swig_obj[1] ;

5895

5896

if (!args) SWIG_fail;

5897

swig_obj[0] = args;

5898

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5899

if (!SWIG_IsOK(res1)) {

5900

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetBulletText" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5901

}

5902

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5903

{

5904

PyThreadState* __tstate = wxPyBeginAllowThreads();

5905

{

5906

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetBulletText();

5907

result = (wxString *) &_result_ref;

5908

}

5909

wxPyEndAllowThreads(__tstate);

5910

if (PyErr_Occurred()) SWIG_fail;

5911

}

5912

{

5913

#if wxUSE_UNICODE

5914

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

5915

#else

5916

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

5917

#endif

5918

}

5919

return resultobj;

5920

fail:

5921

return NULL;

5922

}

5923

5924

5925

SWIGINTERN PyObject *_wrap_TextAttrEx_GetBulletName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5926

PyObject *resultobj = 0;

5927

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5928

wxString *result = 0 ;

5929

void *argp1 = 0 ;

5930

int res1 = 0 ;

5931

PyObject *swig_obj[1] ;

5932

5933

if (!args) SWIG_fail;

5934

swig_obj[0] = args;

5935

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5936

if (!SWIG_IsOK(res1)) {

5937

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetBulletName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5938

}

5939

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5940

{

5941

PyThreadState* __tstate = wxPyBeginAllowThreads();

5942

{

5943

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetBulletName();

5944

result = (wxString *) &_result_ref;

5945

}

5946

wxPyEndAllowThreads(__tstate);

5947

if (PyErr_Occurred()) SWIG_fail;

5948

}

5949

{

5950

#if wxUSE_UNICODE

5951

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

5952

#else

5953

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

5954

#endif

5955

}

5956

return resultobj;

5957

fail:

5958

return NULL;

5959

}

5960

5961

5962

SWIGINTERN PyObject *_wrap_TextAttrEx_GetBulletFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

5963

PyObject *resultobj = 0;

5964

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

5965

wxString *result = 0 ;

5966

void *argp1 = 0 ;

5967

int res1 = 0 ;

5968

PyObject *swig_obj[1] ;

5969

5970

if (!args) SWIG_fail;

5971

swig_obj[0] = args;

5972

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

5973

if (!SWIG_IsOK(res1)) {

5974

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetBulletFont" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

5975

}

5976

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

5977

{

5978

PyThreadState* __tstate = wxPyBeginAllowThreads();

5979

{

5980

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetBulletFont();

5981

result = (wxString *) &_result_ref;

5982

}

5983

wxPyEndAllowThreads(__tstate);

5984

if (PyErr_Occurred()) SWIG_fail;

5985

}

5986

{

5987

#if wxUSE_UNICODE

5988

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

5989

#else

5990

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

5991

#endif

5992

}

5993

return resultobj;

5994

fail:

5995

return NULL;

5996

}

5997

5998

5999

SWIGINTERN PyObject *_wrap_TextAttrEx_GetURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6000

PyObject *resultobj = 0;

6001

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6002

wxString *result = 0 ;

6003

void *argp1 = 0 ;

6004

int res1 = 0 ;

6005

PyObject *swig_obj[1] ;

6006

6007

if (!args) SWIG_fail;

6008

swig_obj[0] = args;

6009

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6010

if (!SWIG_IsOK(res1)) {

6011

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetURL" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6012

}

6013

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6014

{

6015

PyThreadState* __tstate = wxPyBeginAllowThreads();

6016

{

6017

wxString const &_result_ref = ((wxTextAttrEx const *)arg1)->GetURL();

6018

result = (wxString *) &_result_ref;

6019

}

6020

wxPyEndAllowThreads(__tstate);

6021

if (PyErr_Occurred()) SWIG_fail;

6022

}

6023

{

6024

#if wxUSE_UNICODE

6025

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

6026

#else

6027

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

6028

#endif

6029

}

6030

return resultobj;

6031

fail:

6032

return NULL;

6033

}

6034

6035

6036

SWIGINTERN PyObject *_wrap_TextAttrEx_GetTextEffects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6037

PyObject *resultobj = 0;

6038

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6039

int result;

6040

void *argp1 = 0 ;

6041

int res1 = 0 ;

6042

PyObject *swig_obj[1] ;

6043

6044

if (!args) SWIG_fail;

6045

swig_obj[0] = args;

6046

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6047

if (!SWIG_IsOK(res1)) {

6048

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetTextEffects" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6049

}

6050

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6051

{

6052

PyThreadState* __tstate = wxPyBeginAllowThreads();

6053

result = (int)((wxTextAttrEx const *)arg1)->GetTextEffects();

6054

wxPyEndAllowThreads(__tstate);

6055

if (PyErr_Occurred()) SWIG_fail;

6056

}

6057

resultobj = SWIG_From_int(static_cast< int >(result));

6058

return resultobj;

6059

fail:

6060

return NULL;

6061

}

6062

6063

6064

SWIGINTERN PyObject *_wrap_TextAttrEx_GetTextEffectFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6065

PyObject *resultobj = 0;

6066

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6067

int result;

6068

void *argp1 = 0 ;

6069

int res1 = 0 ;

6070

PyObject *swig_obj[1] ;

6071

6072

if (!args) SWIG_fail;

6073

swig_obj[0] = args;

6074

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6075

if (!SWIG_IsOK(res1)) {

6076

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetTextEffectFlags" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6077

}

6078

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6079

{

6080

PyThreadState* __tstate = wxPyBeginAllowThreads();

6081

result = (int)((wxTextAttrEx const *)arg1)->GetTextEffectFlags();

6082

wxPyEndAllowThreads(__tstate);

6083

if (PyErr_Occurred()) SWIG_fail;

6084

}

6085

resultobj = SWIG_From_int(static_cast< int >(result));

6086

return resultobj;

6087

fail:

6088

return NULL;

6089

}

6090

6091

6092

SWIGINTERN PyObject *_wrap_TextAttrEx_GetOutlineLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6093

PyObject *resultobj = 0;

6094

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6095

int result;

6096

void *argp1 = 0 ;

6097

int res1 = 0 ;

6098

PyObject *swig_obj[1] ;

6099

6100

if (!args) SWIG_fail;

6101

swig_obj[0] = args;

6102

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6103

if (!SWIG_IsOK(res1)) {

6104

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_GetOutlineLevel" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6105

}

6106

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6107

{

6108

PyThreadState* __tstate = wxPyBeginAllowThreads();

6109

result = (int)((wxTextAttrEx const *)arg1)->GetOutlineLevel();

6110

wxPyEndAllowThreads(__tstate);

6111

if (PyErr_Occurred()) SWIG_fail;

6112

}

6113

resultobj = SWIG_From_int(static_cast< int >(result));

6114

return resultobj;

6115

fail:

6116

return NULL;

6117

}

6118

6119

6120

SWIGINTERN PyObject *_wrap_TextAttrEx_HasFontWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6121

PyObject *resultobj = 0;

6122

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6123

bool result;

6124

void *argp1 = 0 ;

6125

int res1 = 0 ;

6126

PyObject *swig_obj[1] ;

6127

6128

if (!args) SWIG_fail;

6129

swig_obj[0] = args;

6130

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6131

if (!SWIG_IsOK(res1)) {

6132

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasFontWeight" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6133

}

6134

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6135

{

6136

PyThreadState* __tstate = wxPyBeginAllowThreads();

6137

result = (bool)((wxTextAttrEx const *)arg1)->HasFontWeight();

6138

wxPyEndAllowThreads(__tstate);

6139

if (PyErr_Occurred()) SWIG_fail;

6140

}

6141

{

6142

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6143

}

6144

return resultobj;

6145

fail:

6146

return NULL;

6147

}

6148

6149

6150

SWIGINTERN PyObject *_wrap_TextAttrEx_HasFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6151

PyObject *resultobj = 0;

6152

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6153

bool result;

6154

void *argp1 = 0 ;

6155

int res1 = 0 ;

6156

PyObject *swig_obj[1] ;

6157

6158

if (!args) SWIG_fail;

6159

swig_obj[0] = args;

6160

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6161

if (!SWIG_IsOK(res1)) {

6162

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasFontSize" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6163

}

6164

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6165

{

6166

PyThreadState* __tstate = wxPyBeginAllowThreads();

6167

result = (bool)((wxTextAttrEx const *)arg1)->HasFontSize();

6168

wxPyEndAllowThreads(__tstate);

6169

if (PyErr_Occurred()) SWIG_fail;

6170

}

6171

{

6172

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6173

}

6174

return resultobj;

6175

fail:

6176

return NULL;

6177

}

6178

6179

6180

SWIGINTERN PyObject *_wrap_TextAttrEx_HasFontItalic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6181

PyObject *resultobj = 0;

6182

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6183

bool result;

6184

void *argp1 = 0 ;

6185

int res1 = 0 ;

6186

PyObject *swig_obj[1] ;

6187

6188

if (!args) SWIG_fail;

6189

swig_obj[0] = args;

6190

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6191

if (!SWIG_IsOK(res1)) {

6192

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasFontItalic" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6193

}

6194

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6195

{

6196

PyThreadState* __tstate = wxPyBeginAllowThreads();

6197

result = (bool)((wxTextAttrEx const *)arg1)->HasFontItalic();

6198

wxPyEndAllowThreads(__tstate);

6199

if (PyErr_Occurred()) SWIG_fail;

6200

}

6201

{

6202

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6203

}

6204

return resultobj;

6205

fail:

6206

return NULL;

6207

}

6208

6209

6210

SWIGINTERN PyObject *_wrap_TextAttrEx_HasFontUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6211

PyObject *resultobj = 0;

6212

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6213

bool result;

6214

void *argp1 = 0 ;

6215

int res1 = 0 ;

6216

PyObject *swig_obj[1] ;

6217

6218

if (!args) SWIG_fail;

6219

swig_obj[0] = args;

6220

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6221

if (!SWIG_IsOK(res1)) {

6222

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasFontUnderlined" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6223

}

6224

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6225

{

6226

PyThreadState* __tstate = wxPyBeginAllowThreads();

6227

result = (bool)((wxTextAttrEx const *)arg1)->HasFontUnderlined();

6228

wxPyEndAllowThreads(__tstate);

6229

if (PyErr_Occurred()) SWIG_fail;

6230

}

6231

{

6232

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6233

}

6234

return resultobj;

6235

fail:

6236

return NULL;

6237

}

6238

6239

6240

SWIGINTERN PyObject *_wrap_TextAttrEx_HasFontFaceName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6241

PyObject *resultobj = 0;

6242

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6243

bool result;

6244

void *argp1 = 0 ;

6245

int res1 = 0 ;

6246

PyObject *swig_obj[1] ;

6247

6248

if (!args) SWIG_fail;

6249

swig_obj[0] = args;

6250

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6251

if (!SWIG_IsOK(res1)) {

6252

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasFontFaceName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6253

}

6254

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6255

{

6256

PyThreadState* __tstate = wxPyBeginAllowThreads();

6257

result = (bool)((wxTextAttrEx const *)arg1)->HasFontFaceName();

6258

wxPyEndAllowThreads(__tstate);

6259

if (PyErr_Occurred()) SWIG_fail;

6260

}

6261

{

6262

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6263

}

6264

return resultobj;

6265

fail:

6266

return NULL;

6267

}

6268

6269

6270

SWIGINTERN PyObject *_wrap_TextAttrEx_HasParagraphSpacingAfter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6271

PyObject *resultobj = 0;

6272

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6273

bool result;

6274

void *argp1 = 0 ;

6275

int res1 = 0 ;

6276

PyObject *swig_obj[1] ;

6277

6278

if (!args) SWIG_fail;

6279

swig_obj[0] = args;

6280

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6281

if (!SWIG_IsOK(res1)) {

6282

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasParagraphSpacingAfter" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6283

}

6284

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6285

{

6286

PyThreadState* __tstate = wxPyBeginAllowThreads();

6287

result = (bool)((wxTextAttrEx const *)arg1)->HasParagraphSpacingAfter();

6288

wxPyEndAllowThreads(__tstate);

6289

if (PyErr_Occurred()) SWIG_fail;

6290

}

6291

{

6292

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6293

}

6294

return resultobj;

6295

fail:

6296

return NULL;

6297

}

6298

6299

6300

SWIGINTERN PyObject *_wrap_TextAttrEx_HasParagraphSpacingBefore(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6301

PyObject *resultobj = 0;

6302

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6303

bool result;

6304

void *argp1 = 0 ;

6305

int res1 = 0 ;

6306

PyObject *swig_obj[1] ;

6307

6308

if (!args) SWIG_fail;

6309

swig_obj[0] = args;

6310

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6311

if (!SWIG_IsOK(res1)) {

6312

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasParagraphSpacingBefore" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6313

}

6314

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6315

{

6316

PyThreadState* __tstate = wxPyBeginAllowThreads();

6317

result = (bool)((wxTextAttrEx const *)arg1)->HasParagraphSpacingBefore();

6318

wxPyEndAllowThreads(__tstate);

6319

if (PyErr_Occurred()) SWIG_fail;

6320

}

6321

{

6322

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6323

}

6324

return resultobj;

6325

fail:

6326

return NULL;

6327

}

6328

6329

6330

SWIGINTERN PyObject *_wrap_TextAttrEx_HasLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6331

PyObject *resultobj = 0;

6332

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6333

bool result;

6334

void *argp1 = 0 ;

6335

int res1 = 0 ;

6336

PyObject *swig_obj[1] ;

6337

6338

if (!args) SWIG_fail;

6339

swig_obj[0] = args;

6340

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6341

if (!SWIG_IsOK(res1)) {

6342

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasLineSpacing" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6343

}

6344

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6345

{

6346

PyThreadState* __tstate = wxPyBeginAllowThreads();

6347

result = (bool)((wxTextAttrEx const *)arg1)->HasLineSpacing();

6348

wxPyEndAllowThreads(__tstate);

6349

if (PyErr_Occurred()) SWIG_fail;

6350

}

6351

{

6352

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6353

}

6354

return resultobj;

6355

fail:

6356

return NULL;

6357

}

6358

6359

6360

SWIGINTERN PyObject *_wrap_TextAttrEx_HasCharacterStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6361

PyObject *resultobj = 0;

6362

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6363

bool result;

6364

void *argp1 = 0 ;

6365

int res1 = 0 ;

6366

PyObject *swig_obj[1] ;

6367

6368

if (!args) SWIG_fail;

6369

swig_obj[0] = args;

6370

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6371

if (!SWIG_IsOK(res1)) {

6372

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasCharacterStyleName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6373

}

6374

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6375

{

6376

PyThreadState* __tstate = wxPyBeginAllowThreads();

6377

result = (bool)((wxTextAttrEx const *)arg1)->HasCharacterStyleName();

6378

wxPyEndAllowThreads(__tstate);

6379

if (PyErr_Occurred()) SWIG_fail;

6380

}

6381

{

6382

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6383

}

6384

return resultobj;

6385

fail:

6386

return NULL;

6387

}

6388

6389

6390

SWIGINTERN PyObject *_wrap_TextAttrEx_HasParagraphStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6391

PyObject *resultobj = 0;

6392

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6393

bool result;

6394

void *argp1 = 0 ;

6395

int res1 = 0 ;

6396

PyObject *swig_obj[1] ;

6397

6398

if (!args) SWIG_fail;

6399

swig_obj[0] = args;

6400

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6401

if (!SWIG_IsOK(res1)) {

6402

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasParagraphStyleName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6403

}

6404

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6405

{

6406

PyThreadState* __tstate = wxPyBeginAllowThreads();

6407

result = (bool)((wxTextAttrEx const *)arg1)->HasParagraphStyleName();

6408

wxPyEndAllowThreads(__tstate);

6409

if (PyErr_Occurred()) SWIG_fail;

6410

}

6411

{

6412

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6413

}

6414

return resultobj;

6415

fail:

6416

return NULL;

6417

}

6418

6419

6420

SWIGINTERN PyObject *_wrap_TextAttrEx_HasListStyleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6421

PyObject *resultobj = 0;

6422

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6423

bool result;

6424

void *argp1 = 0 ;

6425

int res1 = 0 ;

6426

PyObject *swig_obj[1] ;

6427

6428

if (!args) SWIG_fail;

6429

swig_obj[0] = args;

6430

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6431

if (!SWIG_IsOK(res1)) {

6432

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasListStyleName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6433

}

6434

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6435

{

6436

PyThreadState* __tstate = wxPyBeginAllowThreads();

6437

result = (bool)((wxTextAttrEx const *)arg1)->HasListStyleName();

6438

wxPyEndAllowThreads(__tstate);

6439

if (PyErr_Occurred()) SWIG_fail;

6440

}

6441

{

6442

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6443

}

6444

return resultobj;

6445

fail:

6446

return NULL;

6447

}

6448

6449

6450

SWIGINTERN PyObject *_wrap_TextAttrEx_HasBulletStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6451

PyObject *resultobj = 0;

6452

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6453

bool result;

6454

void *argp1 = 0 ;

6455

int res1 = 0 ;

6456

PyObject *swig_obj[1] ;

6457

6458

if (!args) SWIG_fail;

6459

swig_obj[0] = args;

6460

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6461

if (!SWIG_IsOK(res1)) {

6462

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasBulletStyle" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6463

}

6464

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6465

{

6466

PyThreadState* __tstate = wxPyBeginAllowThreads();

6467

result = (bool)((wxTextAttrEx const *)arg1)->HasBulletStyle();

6468

wxPyEndAllowThreads(__tstate);

6469

if (PyErr_Occurred()) SWIG_fail;

6470

}

6471

{

6472

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6473

}

6474

return resultobj;

6475

fail:

6476

return NULL;

6477

}

6478

6479

6480

SWIGINTERN PyObject *_wrap_TextAttrEx_HasBulletNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6481

PyObject *resultobj = 0;

6482

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6483

bool result;

6484

void *argp1 = 0 ;

6485

int res1 = 0 ;

6486

PyObject *swig_obj[1] ;

6487

6488

if (!args) SWIG_fail;

6489

swig_obj[0] = args;

6490

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6491

if (!SWIG_IsOK(res1)) {

6492

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasBulletNumber" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6493

}

6494

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6495

{

6496

PyThreadState* __tstate = wxPyBeginAllowThreads();

6497

result = (bool)((wxTextAttrEx const *)arg1)->HasBulletNumber();

6498

wxPyEndAllowThreads(__tstate);

6499

if (PyErr_Occurred()) SWIG_fail;

6500

}

6501

{

6502

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6503

}

6504

return resultobj;

6505

fail:

6506

return NULL;

6507

}

6508

6509

6510

SWIGINTERN PyObject *_wrap_TextAttrEx_HasBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6511

PyObject *resultobj = 0;

6512

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6513

bool result;

6514

void *argp1 = 0 ;

6515

int res1 = 0 ;

6516

PyObject *swig_obj[1] ;

6517

6518

if (!args) SWIG_fail;

6519

swig_obj[0] = args;

6520

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6521

if (!SWIG_IsOK(res1)) {

6522

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasBulletText" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6523

}

6524

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6525

{

6526

PyThreadState* __tstate = wxPyBeginAllowThreads();

6527

result = (bool)((wxTextAttrEx const *)arg1)->HasBulletText();

6528

wxPyEndAllowThreads(__tstate);

6529

if (PyErr_Occurred()) SWIG_fail;

6530

}

6531

{

6532

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6533

}

6534

return resultobj;

6535

fail:

6536

return NULL;

6537

}

6538

6539

6540

SWIGINTERN PyObject *_wrap_TextAttrEx_HasBulletName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6541

PyObject *resultobj = 0;

6542

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6543

bool result;

6544

void *argp1 = 0 ;

6545

int res1 = 0 ;

6546

PyObject *swig_obj[1] ;

6547

6548

if (!args) SWIG_fail;

6549

swig_obj[0] = args;

6550

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6551

if (!SWIG_IsOK(res1)) {

6552

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasBulletName" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6553

}

6554

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6555

{

6556

PyThreadState* __tstate = wxPyBeginAllowThreads();

6557

result = (bool)((wxTextAttrEx const *)arg1)->HasBulletName();

6558

wxPyEndAllowThreads(__tstate);

6559

if (PyErr_Occurred()) SWIG_fail;

6560

}

6561

{

6562

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6563

}

6564

return resultobj;

6565

fail:

6566

return NULL;

6567

}

6568

6569

6570

SWIGINTERN PyObject *_wrap_TextAttrEx_HasURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6571

PyObject *resultobj = 0;

6572

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6573

bool result;

6574

void *argp1 = 0 ;

6575

int res1 = 0 ;

6576

PyObject *swig_obj[1] ;

6577

6578

if (!args) SWIG_fail;

6579

swig_obj[0] = args;

6580

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6581

if (!SWIG_IsOK(res1)) {

6582

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasURL" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6583

}

6584

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6585

{

6586

PyThreadState* __tstate = wxPyBeginAllowThreads();

6587

result = (bool)((wxTextAttrEx const *)arg1)->HasURL();

6588

wxPyEndAllowThreads(__tstate);

6589

if (PyErr_Occurred()) SWIG_fail;

6590

}

6591

{

6592

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6593

}

6594

return resultobj;

6595

fail:

6596

return NULL;

6597

}

6598

6599

6600

SWIGINTERN PyObject *_wrap_TextAttrEx_HasPageBreak(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6601

PyObject *resultobj = 0;

6602

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6603

bool result;

6604

void *argp1 = 0 ;

6605

int res1 = 0 ;

6606

PyObject *swig_obj[1] ;

6607

6608

if (!args) SWIG_fail;

6609

swig_obj[0] = args;

6610

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6611

if (!SWIG_IsOK(res1)) {

6612

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasPageBreak" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6613

}

6614

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6615

{

6616

PyThreadState* __tstate = wxPyBeginAllowThreads();

6617

result = (bool)((wxTextAttrEx const *)arg1)->HasPageBreak();

6618

wxPyEndAllowThreads(__tstate);

6619

if (PyErr_Occurred()) SWIG_fail;

6620

}

6621

{

6622

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6623

}

6624

return resultobj;

6625

fail:

6626

return NULL;

6627

}

6628

6629

6630

SWIGINTERN PyObject *_wrap_TextAttrEx_HasTextEffects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6631

PyObject *resultobj = 0;

6632

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6633

bool result;

6634

void *argp1 = 0 ;

6635

int res1 = 0 ;

6636

PyObject *swig_obj[1] ;

6637

6638

if (!args) SWIG_fail;

6639

swig_obj[0] = args;

6640

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6641

if (!SWIG_IsOK(res1)) {

6642

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasTextEffects" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6643

}

6644

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6645

{

6646

PyThreadState* __tstate = wxPyBeginAllowThreads();

6647

result = (bool)((wxTextAttrEx const *)arg1)->HasTextEffects();

6648

wxPyEndAllowThreads(__tstate);

6649

if (PyErr_Occurred()) SWIG_fail;

6650

}

6651

{

6652

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6653

}

6654

return resultobj;

6655

fail:

6656

return NULL;

6657

}

6658

6659

6660

SWIGINTERN PyObject *_wrap_TextAttrEx_HasTextEffect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6661

PyObject *resultobj = 0;

6662

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6663

int arg2 ;

6664

bool result;

6665

void *argp1 = 0 ;

6666

int res1 = 0 ;

6667

int val2 ;

6668

int ecode2 = 0 ;

6669

PyObject * obj0 = 0 ;

6670

PyObject * obj1 = 0 ;

6671

char * kwnames[] = {

6672

(char *) "self",(char *) "effect", NULL

6673

};

6674

6675

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextAttrEx_HasTextEffect",kwnames,&obj0,&obj1)) SWIG_fail;

6676

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6677

if (!SWIG_IsOK(res1)) {

6678

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasTextEffect" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6679

}

6680

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6681

ecode2 = SWIG_AsVal_int(obj1, &val2);

6682

if (!SWIG_IsOK(ecode2)) {

6683

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TextAttrEx_HasTextEffect" "', expected argument " "2"" of type '" "int""'");

6684

}

6685

arg2 = static_cast< int >(val2);

6686

{

6687

PyThreadState* __tstate = wxPyBeginAllowThreads();

6688

result = (bool)((wxTextAttrEx const *)arg1)->HasTextEffect(arg2);

6689

wxPyEndAllowThreads(__tstate);

6690

if (PyErr_Occurred()) SWIG_fail;

6691

}

6692

{

6693

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6694

}

6695

return resultobj;

6696

fail:

6697

return NULL;

6698

}

6699

6700

6701

SWIGINTERN PyObject *_wrap_TextAttrEx_HasOutlineLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6702

PyObject *resultobj = 0;

6703

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6704

bool result;

6705

void *argp1 = 0 ;

6706

int res1 = 0 ;

6707

PyObject *swig_obj[1] ;

6708

6709

if (!args) SWIG_fail;

6710

swig_obj[0] = args;

6711

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6712

if (!SWIG_IsOK(res1)) {

6713

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_HasOutlineLevel" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6714

}

6715

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6716

{

6717

PyThreadState* __tstate = wxPyBeginAllowThreads();

6718

result = (bool)((wxTextAttrEx const *)arg1)->HasOutlineLevel();

6719

wxPyEndAllowThreads(__tstate);

6720

if (PyErr_Occurred()) SWIG_fail;

6721

}

6722

{

6723

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6724

}

6725

return resultobj;

6726

fail:

6727

return NULL;

6728

}

6729

6730

6731

SWIGINTERN PyObject *_wrap_TextAttrEx_IsCharacterStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6732

PyObject *resultobj = 0;

6733

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6734

bool result;

6735

void *argp1 = 0 ;

6736

int res1 = 0 ;

6737

PyObject *swig_obj[1] ;

6738

6739

if (!args) SWIG_fail;

6740

swig_obj[0] = args;

6741

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6742

if (!SWIG_IsOK(res1)) {

6743

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_IsCharacterStyle" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6744

}

6745

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6746

{

6747

PyThreadState* __tstate = wxPyBeginAllowThreads();

6748

result = (bool)((wxTextAttrEx const *)arg1)->IsCharacterStyle();

6749

wxPyEndAllowThreads(__tstate);

6750

if (PyErr_Occurred()) SWIG_fail;

6751

}

6752

{

6753

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6754

}

6755

return resultobj;

6756

fail:

6757

return NULL;

6758

}

6759

6760

6761

SWIGINTERN PyObject *_wrap_TextAttrEx_IsParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6762

PyObject *resultobj = 0;

6763

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6764

bool result;

6765

void *argp1 = 0 ;

6766

int res1 = 0 ;

6767

PyObject *swig_obj[1] ;

6768

6769

if (!args) SWIG_fail;

6770

swig_obj[0] = args;

6771

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6772

if (!SWIG_IsOK(res1)) {

6773

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_IsParagraphStyle" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6774

}

6775

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6776

{

6777

PyThreadState* __tstate = wxPyBeginAllowThreads();

6778

result = (bool)((wxTextAttrEx const *)arg1)->IsParagraphStyle();

6779

wxPyEndAllowThreads(__tstate);

6780

if (PyErr_Occurred()) SWIG_fail;

6781

}

6782

{

6783

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6784

}

6785

return resultobj;

6786

fail:

6787

return NULL;

6788

}

6789

6790

6791

SWIGINTERN PyObject *_wrap_TextAttrEx_IsDefault(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6792

PyObject *resultobj = 0;

6793

wxTextAttrEx *arg1 = (wxTextAttrEx *) 0 ;

6794

bool result;

6795

void *argp1 = 0 ;

6796

int res1 = 0 ;

6797

PyObject *swig_obj[1] ;

6798

6799

if (!args) SWIG_fail;

6800

swig_obj[0] = args;

6801

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

6802

if (!SWIG_IsOK(res1)) {

6803

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_IsDefault" "', expected argument " "1"" of type '" "wxTextAttrEx const *""'");

6804

}

6805

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6806

{

6807

PyThreadState* __tstate = wxPyBeginAllowThreads();

6808

result = (bool)((wxTextAttrEx const *)arg1)->IsDefault();

6809

wxPyEndAllowThreads(__tstate);

6810

if (PyErr_Occurred()) SWIG_fail;

6811

}

6812

{

6813

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6814

}

6815

return resultobj;

6816

fail:

6817

return NULL;

6818

}

6819

6820

6821

SWIGINTERN PyObject *_wrap_TextAttrEx_CombineEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6822

PyObject *resultobj = 0;

6823

wxTextAttrEx *arg1 = 0 ;

6824

wxTextAttrEx *arg2 = 0 ;

6825

wxRichTextCtrl *arg3 = (wxRichTextCtrl *) 0 ;

6826

wxTextAttrEx result;

6827

void *argp1 = 0 ;

6828

int res1 = 0 ;

6829

void *argp2 = 0 ;

6830

int res2 = 0 ;

6831

void *argp3 = 0 ;

6832

int res3 = 0 ;

6833

PyObject * obj0 = 0 ;

6834

PyObject * obj1 = 0 ;

6835

PyObject * obj2 = 0 ;

6836

char * kwnames[] = {

6837

(char *) "attr",(char *) "attrDef",(char *) "text", NULL

6838

};

6839

6840

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextAttrEx_CombineEx",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

6841

res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

6842

if (!SWIG_IsOK(res1)) {

6843

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TextAttrEx_CombineEx" "', expected argument " "1"" of type '" "wxTextAttrEx const &""'");

6844

}

6845

if (!argp1) {

6846

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttrEx_CombineEx" "', expected argument " "1"" of type '" "wxTextAttrEx const &""'");

6847

}

6848

arg1 = reinterpret_cast< wxTextAttrEx * >(argp1);

6849

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

6850

if (!SWIG_IsOK(res2)) {

6851

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TextAttrEx_CombineEx" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

6852

}

6853

if (!argp2) {

6854

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TextAttrEx_CombineEx" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

6855

}

6856

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

6857

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

6858

if (!SWIG_IsOK(res3)) {

6859

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TextAttrEx_CombineEx" "', expected argument " "3"" of type '" "wxRichTextCtrl const *""'");

6860

}

6861

arg3 = reinterpret_cast< wxRichTextCtrl * >(argp3);

6862

{

6863

PyThreadState* __tstate = wxPyBeginAllowThreads();

6864

result = wxTextAttrEx::CombineEx((wxTextAttrEx const &)*arg1,(wxTextAttrEx const &)*arg2,(wxRichTextCtrl const *)arg3);

6865

wxPyEndAllowThreads(__tstate);

6866

if (PyErr_Occurred()) SWIG_fail;

6867

}

6868

resultobj = SWIG_NewPointerObj((new wxTextAttrEx(static_cast< const wxTextAttrEx& >(result))), SWIGTYPE_p_wxTextAttrEx, SWIG_POINTER_OWN | 0 );

6869

return resultobj;

6870

fail:

6871

return NULL;

6872

}

6873

6874

6875

SWIGINTERN PyObject *TextAttrEx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6876

PyObject *obj;

6877

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

6878

SWIG_TypeNewClientData(SWIGTYPE_p_wxTextAttrEx, SWIG_NewClientData(obj));

6879

return SWIG_Py_Void();

6880

}

6881

6882

SWIGINTERN PyObject *TextAttrEx_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6883

return SWIG_Python_InitShadowInstance(args);

6884

}

6885

6886

SWIGINTERN PyObject *_wrap_delete_RichTextObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

6887

PyObject *resultobj = 0;

6888

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

6889

void *argp1 = 0 ;

6890

int res1 = 0 ;

6891

PyObject *swig_obj[1] ;

6892

6893

if (!args) SWIG_fail;

6894

swig_obj[0] = args;

6895

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, SWIG_POINTER_DISOWN | 0 );

6896

if (!SWIG_IsOK(res1)) {

6897

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextObject" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

6898

}

6899

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

6900

{

6901

PyThreadState* __tstate = wxPyBeginAllowThreads();

6902

delete arg1;

6903

6904

wxPyEndAllowThreads(__tstate);

6905

if (PyErr_Occurred()) SWIG_fail;

6906

}

6907

resultobj = SWIG_Py_Void();

6908

return resultobj;

6909

fail:

6910

return NULL;

6911

}

6912

6913

6914

SWIGINTERN PyObject *_wrap_RichTextObject_Draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6915

PyObject *resultobj = 0;

6916

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

6917

wxDC *arg2 = 0 ;

6918

wxRichTextRange *arg3 = 0 ;

6919

wxRichTextRange *arg4 = 0 ;

6920

wxRect *arg5 = 0 ;

6921

int arg6 ;

6922

int arg7 ;

6923

bool result;

6924

void *argp1 = 0 ;

6925

int res1 = 0 ;

6926

void *argp2 = 0 ;

6927

int res2 = 0 ;

6928

wxRichTextRange temp3 ;

6929

wxRichTextRange temp4 ;

6930

wxRect temp5 ;

6931

int val6 ;

6932

int ecode6 = 0 ;

6933

int val7 ;

6934

int ecode7 = 0 ;

6935

PyObject * obj0 = 0 ;

6936

PyObject * obj1 = 0 ;

6937

PyObject * obj2 = 0 ;

6938

PyObject * obj3 = 0 ;

6939

PyObject * obj4 = 0 ;

6940

PyObject * obj5 = 0 ;

6941

PyObject * obj6 = 0 ;

6942

char * kwnames[] = {

6943

(char *) "self",(char *) "dc",(char *) "range",(char *) "selectionRange",(char *) "rect",(char *) "descent",(char *) "style", NULL

6944

};

6945

6946

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:RichTextObject_Draw",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;

6947

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

6948

if (!SWIG_IsOK(res1)) {

6949

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Draw" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

6950

}

6951

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

6952

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

6953

if (!SWIG_IsOK(res2)) {

6954

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_Draw" "', expected argument " "2"" of type '" "wxDC &""'");

6955

}

6956

if (!argp2) {

6957

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_Draw" "', expected argument " "2"" of type '" "wxDC &""'");

6958

}

6959

arg2 = reinterpret_cast< wxDC * >(argp2);

6960

{

6961

arg3 = &temp3;

6962

if ( ! wxRichTextRange_helper(obj2, &arg3)) SWIG_fail;

6963

}

6964

{

6965

arg4 = &temp4;

6966

if ( ! wxRichTextRange_helper(obj3, &arg4)) SWIG_fail;

6967

}

6968

{

6969

arg5 = &temp5;

6970

if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;

6971

}

6972

ecode6 = SWIG_AsVal_int(obj5, &val6);

6973

if (!SWIG_IsOK(ecode6)) {

6974

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextObject_Draw" "', expected argument " "6"" of type '" "int""'");

6975

}

6976

arg6 = static_cast< int >(val6);

6977

ecode7 = SWIG_AsVal_int(obj6, &val7);

6978

if (!SWIG_IsOK(ecode7)) {

6979

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RichTextObject_Draw" "', expected argument " "7"" of type '" "int""'");

6980

}

6981

arg7 = static_cast< int >(val7);

6982

{

6983

PyThreadState* __tstate = wxPyBeginAllowThreads();

6984

result = (bool)(arg1)->Draw(*arg2,(wxRichTextRange const &)*arg3,(wxRichTextRange const &)*arg4,(wxRect const &)*arg5,arg6,arg7);

6985

wxPyEndAllowThreads(__tstate);

6986

if (PyErr_Occurred()) SWIG_fail;

6987

}

6988

{

6989

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

6990

}

6991

return resultobj;

6992

fail:

6993

return NULL;

6994

}

6995

6996

6997

SWIGINTERN PyObject *_wrap_RichTextObject_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

6998

PyObject *resultobj = 0;

6999

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7000

wxDC *arg2 = 0 ;

7001

wxRect *arg3 = 0 ;

7002

int arg4 ;

7003

bool result;

7004

void *argp1 = 0 ;

7005

int res1 = 0 ;

7006

void *argp2 = 0 ;

7007

int res2 = 0 ;

7008

wxRect temp3 ;

7009

int val4 ;

7010

int ecode4 = 0 ;

7011

PyObject * obj0 = 0 ;

7012

PyObject * obj1 = 0 ;

7013

PyObject * obj2 = 0 ;

7014

PyObject * obj3 = 0 ;

7015

char * kwnames[] = {

7016

(char *) "self",(char *) "dc",(char *) "rect",(char *) "style", NULL

7017

};

7018

7019

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RichTextObject_Layout",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

7020

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7021

if (!SWIG_IsOK(res1)) {

7022

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Layout" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7023

}

7024

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7025

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

7026

if (!SWIG_IsOK(res2)) {

7027

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_Layout" "', expected argument " "2"" of type '" "wxDC &""'");

7028

}

7029

if (!argp2) {

7030

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_Layout" "', expected argument " "2"" of type '" "wxDC &""'");

7031

}

7032

arg2 = reinterpret_cast< wxDC * >(argp2);

7033

{

7034

arg3 = &temp3;

7035

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

7036

}

7037

ecode4 = SWIG_AsVal_int(obj3, &val4);

7038

if (!SWIG_IsOK(ecode4)) {

7039

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextObject_Layout" "', expected argument " "4"" of type '" "int""'");

7040

}

7041

arg4 = static_cast< int >(val4);

7042

{

7043

PyThreadState* __tstate = wxPyBeginAllowThreads();

7044

result = (bool)(arg1)->Layout(*arg2,(wxRect const &)*arg3,arg4);

7045

wxPyEndAllowThreads(__tstate);

7046

if (PyErr_Occurred()) SWIG_fail;

7047

}

7048

{

7049

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7050

}

7051

return resultobj;

7052

fail:

7053

return NULL;

7054

}

7055

7056

7057

SWIGINTERN PyObject *_wrap_RichTextObject_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7058

PyObject *resultobj = 0;

7059

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7060

wxDC *arg2 = 0 ;

7061

wxPoint *arg3 = 0 ;

7062

long *arg4 = 0 ;

7063

int result;

7064

void *argp1 = 0 ;

7065

int res1 = 0 ;

7066

void *argp2 = 0 ;

7067

int res2 = 0 ;

7068

wxPoint temp3 ;

7069

long temp4 ;

7070

int res4 = SWIG_TMPOBJ ;

7071

PyObject * obj0 = 0 ;

7072

PyObject * obj1 = 0 ;

7073

PyObject * obj2 = 0 ;

7074

char * kwnames[] = {

7075

(char *) "self",(char *) "dc",(char *) "pt", NULL

7076

};

7077

7078

arg4 = &temp4;

7079

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextObject_HitTest",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

7080

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7081

if (!SWIG_IsOK(res1)) {

7082

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_HitTest" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7083

}

7084

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7085

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

7086

if (!SWIG_IsOK(res2)) {

7087

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_HitTest" "', expected argument " "2"" of type '" "wxDC &""'");

7088

}

7089

if (!argp2) {

7090

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_HitTest" "', expected argument " "2"" of type '" "wxDC &""'");

7091

}

7092

arg2 = reinterpret_cast< wxDC * >(argp2);

7093

{

7094

arg3 = &temp3;

7095

if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;

7096

}

7097

{

7098

PyThreadState* __tstate = wxPyBeginAllowThreads();

7099

result = (int)(arg1)->HitTest(*arg2,(wxPoint const &)*arg3,*arg4);

7100

wxPyEndAllowThreads(__tstate);

7101

if (PyErr_Occurred()) SWIG_fail;

7102

}

7103

resultobj = SWIG_From_int(static_cast< int >(result));

7104

if (SWIG_IsTmpObj(res4)) {

7105

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));

7106

} else {

7107

int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

7108

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));

7109

}

7110

return resultobj;

7111

fail:

7112

return NULL;

7113

}

7114

7115

7116

SWIGINTERN PyObject *_wrap_RichTextObject_FindPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7117

PyObject *resultobj = 0;

7118

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7119

wxDC *arg2 = 0 ;

7120

long arg3 ;

7121

wxPoint *arg4 = 0 ;

7122

int *arg5 = (int *) 0 ;

7123

bool arg6 ;

7124

bool result;

7125

void *argp1 = 0 ;

7126

int res1 = 0 ;

7127

void *argp2 = 0 ;

7128

int res2 = 0 ;

7129

long val3 ;

7130

int ecode3 = 0 ;

7131

wxPoint temp4 ;

7132

int temp5 ;

7133

int res5 = SWIG_TMPOBJ ;

7134

bool val6 ;

7135

int ecode6 = 0 ;

7136

PyObject * obj0 = 0 ;

7137

PyObject * obj1 = 0 ;

7138

PyObject * obj2 = 0 ;

7139

PyObject * obj3 = 0 ;

7140

char * kwnames[] = {

7141

(char *) "self",(char *) "dc",(char *) "index",(char *) "forceLineStart", NULL

7142

};

7143

7144

arg4 = &temp4;

7145

arg5 = &temp5;

7146

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RichTextObject_FindPosition",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

7147

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7148

if (!SWIG_IsOK(res1)) {

7149

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_FindPosition" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7150

}

7151

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7152

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

7153

if (!SWIG_IsOK(res2)) {

7154

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_FindPosition" "', expected argument " "2"" of type '" "wxDC &""'");

7155

}

7156

if (!argp2) {

7157

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_FindPosition" "', expected argument " "2"" of type '" "wxDC &""'");

7158

}

7159

arg2 = reinterpret_cast< wxDC * >(argp2);

7160

ecode3 = SWIG_AsVal_long(obj2, &val3);

7161

if (!SWIG_IsOK(ecode3)) {

7162

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextObject_FindPosition" "', expected argument " "3"" of type '" "long""'");

7163

}

7164

arg3 = static_cast< long >(val3);

7165

ecode6 = SWIG_AsVal_bool(obj3, &val6);

7166

if (!SWIG_IsOK(ecode6)) {

7167

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextObject_FindPosition" "', expected argument " "6"" of type '" "bool""'");

7168

}

7169

arg6 = static_cast< bool >(val6);

7170

{

7171

PyThreadState* __tstate = wxPyBeginAllowThreads();

7172

result = (bool)(arg1)->FindPosition(*arg2,arg3,*arg4,arg5,arg6);

7173

wxPyEndAllowThreads(__tstate);

7174

if (PyErr_Occurred()) SWIG_fail;

7175

}

7176

{

7177

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7178

}

7179

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)new wxPoint(*arg4), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN));

7180

if (SWIG_IsTmpObj(res5)) {

7181

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));

7182

} else {

7183

int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

7184

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));

7185

}

7186

return resultobj;

7187

fail:

7188

return NULL;

7189

}

7190

7191

7192

SWIGINTERN PyObject *_wrap_RichTextObject_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7193

PyObject *resultobj = 0;

7194

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7195

wxSize result;

7196

void *argp1 = 0 ;

7197

int res1 = 0 ;

7198

PyObject *swig_obj[1] ;

7199

7200

if (!args) SWIG_fail;

7201

swig_obj[0] = args;

7202

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7203

if (!SWIG_IsOK(res1)) {

7204

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetBestSize" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7205

}

7206

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7207

{

7208

PyThreadState* __tstate = wxPyBeginAllowThreads();

7209

result = ((wxRichTextObject const *)arg1)->GetBestSize();

7210

wxPyEndAllowThreads(__tstate);

7211

if (PyErr_Occurred()) SWIG_fail;

7212

}

7213

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

7214

return resultobj;

7215

fail:

7216

return NULL;

7217

}

7218

7219

7220

SWIGINTERN PyObject *_wrap_RichTextObject_GetRangeSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7221

PyObject *resultobj = 0;

7222

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7223

wxRichTextRange *arg2 = 0 ;

7224

wxSize *arg3 = 0 ;

7225

int *arg4 = 0 ;

7226

wxDC *arg5 = 0 ;

7227

int arg6 ;

7228

wxPoint arg7 = (wxPoint) wxPoint(0,0) ;

7229

bool result;

7230

void *argp1 = 0 ;

7231

int res1 = 0 ;

7232

wxRichTextRange temp2 ;

7233

wxSize temp3 ;

7234

int temp4 ;

7235

int res4 = SWIG_TMPOBJ ;

7236

void *argp5 = 0 ;

7237

int res5 = 0 ;

7238

int val6 ;

7239

int ecode6 = 0 ;

7240

void *argp7 ;

7241

int res7 = 0 ;

7242

PyObject * obj0 = 0 ;

7243

PyObject * obj1 = 0 ;

7244

PyObject * obj2 = 0 ;

7245

PyObject * obj3 = 0 ;

7246

PyObject * obj4 = 0 ;

7247

char * kwnames[] = {

7248

(char *) "self",(char *) "range",(char *) "dc",(char *) "flags",(char *) "position", NULL

7249

};

7250

7251

arg3 = &temp3;

7252

arg4 = &temp4;

7253

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextObject_GetRangeSize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

7254

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7255

if (!SWIG_IsOK(res1)) {

7256

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetRangeSize" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7257

}

7258

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7259

{

7260

arg2 = &temp2;

7261

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

7262

}

7263

res5 = SWIG_ConvertPtr(obj2, &argp5, SWIGTYPE_p_wxDC, 0 );

7264

if (!SWIG_IsOK(res5)) {

7265

SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RichTextObject_GetRangeSize" "', expected argument " "5"" of type '" "wxDC &""'");

7266

}

7267

if (!argp5) {

7268

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_GetRangeSize" "', expected argument " "5"" of type '" "wxDC &""'");

7269

}

7270

arg5 = reinterpret_cast< wxDC * >(argp5);

7271

ecode6 = SWIG_AsVal_int(obj3, &val6);

7272

if (!SWIG_IsOK(ecode6)) {

7273

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextObject_GetRangeSize" "', expected argument " "6"" of type '" "int""'");

7274

}

7275

arg6 = static_cast< int >(val6);

7276

if (obj4) {

7277

{

7278

res7 = SWIG_ConvertPtr(obj4, &argp7, SWIGTYPE_p_wxPoint, 0 | 0);

7279

if (!SWIG_IsOK(res7)) {

7280

SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "RichTextObject_GetRangeSize" "', expected argument " "7"" of type '" "wxPoint""'");

7281

}

7282

if (!argp7) {

7283

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_GetRangeSize" "', expected argument " "7"" of type '" "wxPoint""'");

7284

} else {

7285

wxPoint * temp = reinterpret_cast< wxPoint * >(argp7);

7286

arg7 = *temp;

7287

if (SWIG_IsNewObj(res7)) delete temp;

7288

}

7289

}

7290

}

7291

{

7292

PyThreadState* __tstate = wxPyBeginAllowThreads();

7293

result = (bool)((wxRichTextObject const *)arg1)->GetRangeSize((wxRichTextRange const &)*arg2,*arg3,*arg4,*arg5,arg6,arg7);

7294

wxPyEndAllowThreads(__tstate);

7295

if (PyErr_Occurred()) SWIG_fail;

7296

}

7297

{

7298

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7299

}

7300

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)new wxSize(*arg3), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN));

7301

if (SWIG_IsTmpObj(res4)) {

7302

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));

7303

} else {

7304

int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

7305

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));

7306

}

7307

return resultobj;

7308

fail:

7309

return NULL;

7310

}

7311

7312

7313

SWIGINTERN PyObject *_wrap_RichTextObject_DoSplit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7314

PyObject *resultobj = 0;

7315

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7316

long arg2 ;

7317

wxRichTextObject *result = 0 ;

7318

void *argp1 = 0 ;

7319

int res1 = 0 ;

7320

long val2 ;

7321

int ecode2 = 0 ;

7322

PyObject * obj0 = 0 ;

7323

PyObject * obj1 = 0 ;

7324

char * kwnames[] = {

7325

(char *) "self",(char *) "pos", NULL

7326

};

7327

7328

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_DoSplit",kwnames,&obj0,&obj1)) SWIG_fail;

7329

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7330

if (!SWIG_IsOK(res1)) {

7331

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_DoSplit" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7332

}

7333

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7334

ecode2 = SWIG_AsVal_long(obj1, &val2);

7335

if (!SWIG_IsOK(ecode2)) {

7336

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_DoSplit" "', expected argument " "2"" of type '" "long""'");

7337

}

7338

arg2 = static_cast< long >(val2);

7339

{

7340

PyThreadState* __tstate = wxPyBeginAllowThreads();

7341

result = (wxRichTextObject *)(arg1)->DoSplit(arg2);

7342

wxPyEndAllowThreads(__tstate);

7343

if (PyErr_Occurred()) SWIG_fail;

7344

}

7345

{

7346

resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);

7347

}

7348

return resultobj;

7349

fail:

7350

return NULL;

7351

}

7352

7353

7354

SWIGINTERN PyObject *_wrap_RichTextObject_CalculateRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7355

PyObject *resultobj = 0;

7356

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7357

long arg2 ;

7358

long *arg3 = 0 ;

7359

void *argp1 = 0 ;

7360

int res1 = 0 ;

7361

long val2 ;

7362

int ecode2 = 0 ;

7363

long temp3 ;

7364

int res3 = SWIG_TMPOBJ ;

7365

PyObject * obj0 = 0 ;

7366

PyObject * obj1 = 0 ;

7367

char * kwnames[] = {

7368

(char *) "self",(char *) "start", NULL

7369

};

7370

7371

arg3 = &temp3;

7372

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_CalculateRange",kwnames,&obj0,&obj1)) SWIG_fail;

7373

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7374

if (!SWIG_IsOK(res1)) {

7375

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_CalculateRange" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7376

}

7377

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7378

ecode2 = SWIG_AsVal_long(obj1, &val2);

7379

if (!SWIG_IsOK(ecode2)) {

7380

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_CalculateRange" "', expected argument " "2"" of type '" "long""'");

7381

}

7382

arg2 = static_cast< long >(val2);

7383

{

7384

PyThreadState* __tstate = wxPyBeginAllowThreads();

7385

(arg1)->CalculateRange(arg2,*arg3);

7386

wxPyEndAllowThreads(__tstate);

7387

if (PyErr_Occurred()) SWIG_fail;

7388

}

7389

resultobj = SWIG_Py_Void();

7390

if (SWIG_IsTmpObj(res3)) {

7391

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));

7392

} else {

7393

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

7394

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));

7395

}

7396

return resultobj;

7397

fail:

7398

return NULL;

7399

}

7400

7401

7402

SWIGINTERN PyObject *_wrap_RichTextObject_DeleteRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7403

PyObject *resultobj = 0;

7404

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7405

wxRichTextRange *arg2 = 0 ;

7406

bool result;

7407

void *argp1 = 0 ;

7408

int res1 = 0 ;

7409

wxRichTextRange temp2 ;

7410

PyObject * obj0 = 0 ;

7411

PyObject * obj1 = 0 ;

7412

char * kwnames[] = {

7413

(char *) "self",(char *) "range", NULL

7414

};

7415

7416

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_DeleteRange",kwnames,&obj0,&obj1)) SWIG_fail;

7417

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7418

if (!SWIG_IsOK(res1)) {

7419

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_DeleteRange" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7420

}

7421

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7422

{

7423

arg2 = &temp2;

7424

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

7425

}

7426

{

7427

PyThreadState* __tstate = wxPyBeginAllowThreads();

7428

result = (bool)(arg1)->DeleteRange((wxRichTextRange const &)*arg2);

7429

wxPyEndAllowThreads(__tstate);

7430

if (PyErr_Occurred()) SWIG_fail;

7431

}

7432

{

7433

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7434

}

7435

return resultobj;

7436

fail:

7437

return NULL;

7438

}

7439

7440

7441

SWIGINTERN PyObject *_wrap_RichTextObject_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7442

PyObject *resultobj = 0;

7443

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7444

bool result;

7445

void *argp1 = 0 ;

7446

int res1 = 0 ;

7447

PyObject *swig_obj[1] ;

7448

7449

if (!args) SWIG_fail;

7450

swig_obj[0] = args;

7451

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7452

if (!SWIG_IsOK(res1)) {

7453

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_IsEmpty" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7454

}

7455

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7456

{

7457

PyThreadState* __tstate = wxPyBeginAllowThreads();

7458

result = (bool)((wxRichTextObject const *)arg1)->IsEmpty();

7459

wxPyEndAllowThreads(__tstate);

7460

if (PyErr_Occurred()) SWIG_fail;

7461

}

7462

{

7463

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7464

}

7465

return resultobj;

7466

fail:

7467

return NULL;

7468

}

7469

7470

7471

SWIGINTERN PyObject *_wrap_RichTextObject_GetTextForRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7472

PyObject *resultobj = 0;

7473

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7474

wxRichTextRange *arg2 = 0 ;

7475

wxString result;

7476

void *argp1 = 0 ;

7477

int res1 = 0 ;

7478

wxRichTextRange temp2 ;

7479

PyObject * obj0 = 0 ;

7480

PyObject * obj1 = 0 ;

7481

char * kwnames[] = {

7482

(char *) "self",(char *) "range", NULL

7483

};

7484

7485

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_GetTextForRange",kwnames,&obj0,&obj1)) SWIG_fail;

7486

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7487

if (!SWIG_IsOK(res1)) {

7488

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetTextForRange" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7489

}

7490

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7491

{

7492

arg2 = &temp2;

7493

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

7494

}

7495

{

7496

PyThreadState* __tstate = wxPyBeginAllowThreads();

7497

result = ((wxRichTextObject const *)arg1)->GetTextForRange((wxRichTextRange const &)*arg2);

7498

wxPyEndAllowThreads(__tstate);

7499

if (PyErr_Occurred()) SWIG_fail;

7500

}

7501

{

7502

#if wxUSE_UNICODE

7503

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

7504

#else

7505

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

7506

#endif

7507

}

7508

return resultobj;

7509

fail:

7510

return NULL;

7511

}

7512

7513

7514

SWIGINTERN PyObject *_wrap_RichTextObject_CanMerge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7515

PyObject *resultobj = 0;

7516

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7517

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

7518

bool result;

7519

void *argp1 = 0 ;

7520

int res1 = 0 ;

7521

void *argp2 = 0 ;

7522

int res2 = 0 ;

7523

PyObject * obj0 = 0 ;

7524

PyObject * obj1 = 0 ;

7525

char * kwnames[] = {

7526

(char *) "self",(char *) "object", NULL

7527

};

7528

7529

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_CanMerge",kwnames,&obj0,&obj1)) SWIG_fail;

7530

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7531

if (!SWIG_IsOK(res1)) {

7532

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_CanMerge" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7533

}

7534

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7535

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7536

if (!SWIG_IsOK(res2)) {

7537

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_CanMerge" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

7538

}

7539

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

7540

{

7541

PyThreadState* __tstate = wxPyBeginAllowThreads();

7542

result = (bool)((wxRichTextObject const *)arg1)->CanMerge(arg2);

7543

wxPyEndAllowThreads(__tstate);

7544

if (PyErr_Occurred()) SWIG_fail;

7545

}

7546

{

7547

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7548

}

7549

return resultobj;

7550

fail:

7551

return NULL;

7552

}

7553

7554

7555

SWIGINTERN PyObject *_wrap_RichTextObject_Merge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7556

PyObject *resultobj = 0;

7557

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7558

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

7559

bool result;

7560

void *argp1 = 0 ;

7561

int res1 = 0 ;

7562

void *argp2 = 0 ;

7563

int res2 = 0 ;

7564

PyObject * obj0 = 0 ;

7565

PyObject * obj1 = 0 ;

7566

char * kwnames[] = {

7567

(char *) "self",(char *) "object", NULL

7568

};

7569

7570

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_Merge",kwnames,&obj0,&obj1)) SWIG_fail;

7571

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7572

if (!SWIG_IsOK(res1)) {

7573

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Merge" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7574

}

7575

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7576

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7577

if (!SWIG_IsOK(res2)) {

7578

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_Merge" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

7579

}

7580

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

7581

{

7582

PyThreadState* __tstate = wxPyBeginAllowThreads();

7583

result = (bool)(arg1)->Merge(arg2);

7584

wxPyEndAllowThreads(__tstate);

7585

if (PyErr_Occurred()) SWIG_fail;

7586

}

7587

{

7588

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7589

}

7590

return resultobj;

7591

fail:

7592

return NULL;

7593

}

7594

7595

7596

SWIGINTERN PyObject *_wrap_RichTextObject_Dump(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7597

PyObject *resultobj = 0;

7598

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7599

wxString result;

7600

void *argp1 = 0 ;

7601

int res1 = 0 ;

7602

PyObject *swig_obj[1] ;

7603

7604

if (!args) SWIG_fail;

7605

swig_obj[0] = args;

7606

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7607

if (!SWIG_IsOK(res1)) {

7608

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Dump" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7609

}

7610

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7611

{

7612

PyThreadState* __tstate = wxPyBeginAllowThreads();

7613

result = wxRichTextObject_Dump(arg1);

7614

wxPyEndAllowThreads(__tstate);

7615

if (PyErr_Occurred()) SWIG_fail;

7616

}

7617

{

7618

#if wxUSE_UNICODE

7619

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

7620

#else

7621

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

7622

#endif

7623

}

7624

return resultobj;

7625

fail:

7626

return NULL;

7627

}

7628

7629

7630

SWIGINTERN PyObject *_wrap_RichTextObject_GetCachedSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7631

PyObject *resultobj = 0;

7632

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7633

wxSize result;

7634

void *argp1 = 0 ;

7635

int res1 = 0 ;

7636

PyObject *swig_obj[1] ;

7637

7638

if (!args) SWIG_fail;

7639

swig_obj[0] = args;

7640

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7641

if (!SWIG_IsOK(res1)) {

7642

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetCachedSize" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7643

}

7644

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7645

{

7646

PyThreadState* __tstate = wxPyBeginAllowThreads();

7647

result = ((wxRichTextObject const *)arg1)->GetCachedSize();

7648

wxPyEndAllowThreads(__tstate);

7649

if (PyErr_Occurred()) SWIG_fail;

7650

}

7651

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

7652

return resultobj;

7653

fail:

7654

return NULL;

7655

}

7656

7657

7658

SWIGINTERN PyObject *_wrap_RichTextObject_SetCachedSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7659

PyObject *resultobj = 0;

7660

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7661

wxSize *arg2 = 0 ;

7662

void *argp1 = 0 ;

7663

int res1 = 0 ;

7664

wxSize temp2 ;

7665

PyObject * obj0 = 0 ;

7666

PyObject * obj1 = 0 ;

7667

char * kwnames[] = {

7668

(char *) "self",(char *) "sz", NULL

7669

};

7670

7671

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetCachedSize",kwnames,&obj0,&obj1)) SWIG_fail;

7672

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7673

if (!SWIG_IsOK(res1)) {

7674

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetCachedSize" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7675

}

7676

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7677

{

7678

arg2 = &temp2;

7679

if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;

7680

}

7681

{

7682

PyThreadState* __tstate = wxPyBeginAllowThreads();

7683

(arg1)->SetCachedSize((wxSize const &)*arg2);

7684

wxPyEndAllowThreads(__tstate);

7685

if (PyErr_Occurred()) SWIG_fail;

7686

}

7687

resultobj = SWIG_Py_Void();

7688

return resultobj;

7689

fail:

7690

return NULL;

7691

}

7692

7693

7694

SWIGINTERN PyObject *_wrap_RichTextObject_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7695

PyObject *resultobj = 0;

7696

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7697

wxPoint result;

7698

void *argp1 = 0 ;

7699

int res1 = 0 ;

7700

PyObject *swig_obj[1] ;

7701

7702

if (!args) SWIG_fail;

7703

swig_obj[0] = args;

7704

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7705

if (!SWIG_IsOK(res1)) {

7706

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetPosition" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7707

}

7708

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7709

{

7710

PyThreadState* __tstate = wxPyBeginAllowThreads();

7711

result = ((wxRichTextObject const *)arg1)->GetPosition();

7712

wxPyEndAllowThreads(__tstate);

7713

if (PyErr_Occurred()) SWIG_fail;

7714

}

7715

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

7716

return resultobj;

7717

fail:

7718

return NULL;

7719

}

7720

7721

7722

SWIGINTERN PyObject *_wrap_RichTextObject_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7723

PyObject *resultobj = 0;

7724

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7725

wxPoint *arg2 = 0 ;

7726

void *argp1 = 0 ;

7727

int res1 = 0 ;

7728

wxPoint temp2 ;

7729

PyObject * obj0 = 0 ;

7730

PyObject * obj1 = 0 ;

7731

char * kwnames[] = {

7732

(char *) "self",(char *) "pos", NULL

7733

};

7734

7735

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;

7736

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7737

if (!SWIG_IsOK(res1)) {

7738

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetPosition" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7739

}

7740

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7741

{

7742

arg2 = &temp2;

7743

if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;

7744

}

7745

{

7746

PyThreadState* __tstate = wxPyBeginAllowThreads();

7747

(arg1)->SetPosition((wxPoint const &)*arg2);

7748

wxPyEndAllowThreads(__tstate);

7749

if (PyErr_Occurred()) SWIG_fail;

7750

}

7751

resultobj = SWIG_Py_Void();

7752

return resultobj;

7753

fail:

7754

return NULL;

7755

}

7756

7757

7758

SWIGINTERN PyObject *_wrap_RichTextObject_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7759

PyObject *resultobj = 0;

7760

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7761

wxRect result;

7762

void *argp1 = 0 ;

7763

int res1 = 0 ;

7764

PyObject *swig_obj[1] ;

7765

7766

if (!args) SWIG_fail;

7767

swig_obj[0] = args;

7768

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7769

if (!SWIG_IsOK(res1)) {

7770

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetRect" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7771

}

7772

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7773

{

7774

PyThreadState* __tstate = wxPyBeginAllowThreads();

7775

result = ((wxRichTextObject const *)arg1)->GetRect();

7776

wxPyEndAllowThreads(__tstate);

7777

if (PyErr_Occurred()) SWIG_fail;

7778

}

7779

resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );

7780

return resultobj;

7781

fail:

7782

return NULL;

7783

}

7784

7785

7786

SWIGINTERN PyObject *_wrap_RichTextObject_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7787

PyObject *resultobj = 0;

7788

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7789

wxRichTextRange *arg2 = 0 ;

7790

void *argp1 = 0 ;

7791

int res1 = 0 ;

7792

wxRichTextRange temp2 ;

7793

PyObject * obj0 = 0 ;

7794

PyObject * obj1 = 0 ;

7795

char * kwnames[] = {

7796

(char *) "self",(char *) "range", NULL

7797

};

7798

7799

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetRange",kwnames,&obj0,&obj1)) SWIG_fail;

7800

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7801

if (!SWIG_IsOK(res1)) {

7802

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetRange" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7803

}

7804

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7805

{

7806

arg2 = &temp2;

7807

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

7808

}

7809

{

7810

PyThreadState* __tstate = wxPyBeginAllowThreads();

7811

(arg1)->SetRange((wxRichTextRange const &)*arg2);

7812

wxPyEndAllowThreads(__tstate);

7813

if (PyErr_Occurred()) SWIG_fail;

7814

}

7815

resultobj = SWIG_Py_Void();

7816

return resultobj;

7817

fail:

7818

return NULL;

7819

}

7820

7821

7822

SWIGINTERN PyObject *_wrap_RichTextObject_GetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7823

PyObject *resultobj = 0;

7824

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7825

wxRichTextRange result;

7826

void *argp1 = 0 ;

7827

int res1 = 0 ;

7828

PyObject *swig_obj[1] ;

7829

7830

if (!args) SWIG_fail;

7831

swig_obj[0] = args;

7832

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7833

if (!SWIG_IsOK(res1)) {

7834

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetRange" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7835

}

7836

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7837

{

7838

PyThreadState* __tstate = wxPyBeginAllowThreads();

7839

result = (arg1)->GetRange();

7840

wxPyEndAllowThreads(__tstate);

7841

if (PyErr_Occurred()) SWIG_fail;

7842

}

7843

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

7844

return resultobj;

7845

fail:

7846

return NULL;

7847

}

7848

7849

7850

SWIGINTERN PyObject *_wrap_RichTextObject_GetDirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7851

PyObject *resultobj = 0;

7852

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7853

bool result;

7854

void *argp1 = 0 ;

7855

int res1 = 0 ;

7856

PyObject *swig_obj[1] ;

7857

7858

if (!args) SWIG_fail;

7859

swig_obj[0] = args;

7860

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7861

if (!SWIG_IsOK(res1)) {

7862

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetDirty" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7863

}

7864

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7865

{

7866

PyThreadState* __tstate = wxPyBeginAllowThreads();

7867

result = (bool)((wxRichTextObject const *)arg1)->GetDirty();

7868

wxPyEndAllowThreads(__tstate);

7869

if (PyErr_Occurred()) SWIG_fail;

7870

}

7871

{

7872

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7873

}

7874

return resultobj;

7875

fail:

7876

return NULL;

7877

}

7878

7879

7880

SWIGINTERN PyObject *_wrap_RichTextObject_SetDirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7881

PyObject *resultobj = 0;

7882

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7883

bool arg2 ;

7884

void *argp1 = 0 ;

7885

int res1 = 0 ;

7886

bool val2 ;

7887

int ecode2 = 0 ;

7888

PyObject * obj0 = 0 ;

7889

PyObject * obj1 = 0 ;

7890

char * kwnames[] = {

7891

(char *) "self",(char *) "dirty", NULL

7892

};

7893

7894

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetDirty",kwnames,&obj0,&obj1)) SWIG_fail;

7895

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7896

if (!SWIG_IsOK(res1)) {

7897

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetDirty" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7898

}

7899

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7900

ecode2 = SWIG_AsVal_bool(obj1, &val2);

7901

if (!SWIG_IsOK(ecode2)) {

7902

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_SetDirty" "', expected argument " "2"" of type '" "bool""'");

7903

}

7904

arg2 = static_cast< bool >(val2);

7905

{

7906

PyThreadState* __tstate = wxPyBeginAllowThreads();

7907

(arg1)->SetDirty(arg2);

7908

wxPyEndAllowThreads(__tstate);

7909

if (PyErr_Occurred()) SWIG_fail;

7910

}

7911

resultobj = SWIG_Py_Void();

7912

return resultobj;

7913

fail:

7914

return NULL;

7915

}

7916

7917

7918

SWIGINTERN PyObject *_wrap_RichTextObject_IsComposite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7919

PyObject *resultobj = 0;

7920

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7921

bool result;

7922

void *argp1 = 0 ;

7923

int res1 = 0 ;

7924

PyObject *swig_obj[1] ;

7925

7926

if (!args) SWIG_fail;

7927

swig_obj[0] = args;

7928

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7929

if (!SWIG_IsOK(res1)) {

7930

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_IsComposite" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7931

}

7932

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7933

{

7934

PyThreadState* __tstate = wxPyBeginAllowThreads();

7935

result = (bool)((wxRichTextObject const *)arg1)->IsComposite();

7936

wxPyEndAllowThreads(__tstate);

7937

if (PyErr_Occurred()) SWIG_fail;

7938

}

7939

{

7940

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

7941

}

7942

return resultobj;

7943

fail:

7944

return NULL;

7945

}

7946

7947

7948

SWIGINTERN PyObject *_wrap_RichTextObject_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

7949

PyObject *resultobj = 0;

7950

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7951

wxRichTextObject *result = 0 ;

7952

void *argp1 = 0 ;

7953

int res1 = 0 ;

7954

PyObject *swig_obj[1] ;

7955

7956

if (!args) SWIG_fail;

7957

swig_obj[0] = args;

7958

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7959

if (!SWIG_IsOK(res1)) {

7960

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetParent" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

7961

}

7962

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7963

{

7964

PyThreadState* __tstate = wxPyBeginAllowThreads();

7965

result = (wxRichTextObject *)((wxRichTextObject const *)arg1)->GetParent();

7966

wxPyEndAllowThreads(__tstate);

7967

if (PyErr_Occurred()) SWIG_fail;

7968

}

7969

{

7970

resultobj = wxPyMake_wxObject(result, (bool)0);

7971

}

7972

return resultobj;

7973

fail:

7974

return NULL;

7975

}

7976

7977

7978

SWIGINTERN PyObject *_wrap_RichTextObject_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

7979

PyObject *resultobj = 0;

7980

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

7981

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

7982

void *argp1 = 0 ;

7983

int res1 = 0 ;

7984

void *argp2 = 0 ;

7985

int res2 = 0 ;

7986

PyObject * obj0 = 0 ;

7987

PyObject * obj1 = 0 ;

7988

char * kwnames[] = {

7989

(char *) "self",(char *) "parent", NULL

7990

};

7991

7992

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;

7993

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7994

if (!SWIG_IsOK(res1)) {

7995

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetParent" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

7996

}

7997

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

7998

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

7999

if (!SWIG_IsOK(res2)) {

8000

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_SetParent" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

8001

}

8002

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

8003

{

8004

PyThreadState* __tstate = wxPyBeginAllowThreads();

8005

(arg1)->SetParent(arg2);

8006

wxPyEndAllowThreads(__tstate);

8007

if (PyErr_Occurred()) SWIG_fail;

8008

}

8009

resultobj = SWIG_Py_Void();

8010

return resultobj;

8011

fail:

8012

return NULL;

8013

}

8014

8015

8016

SWIGINTERN PyObject *_wrap_RichTextObject_SetSameMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8017

PyObject *resultobj = 0;

8018

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8019

int arg2 ;

8020

void *argp1 = 0 ;

8021

int res1 = 0 ;

8022

int val2 ;

8023

int ecode2 = 0 ;

8024

PyObject * obj0 = 0 ;

8025

PyObject * obj1 = 0 ;

8026

char * kwnames[] = {

8027

(char *) "self",(char *) "margin", NULL

8028

};

8029

8030

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetSameMargins",kwnames,&obj0,&obj1)) SWIG_fail;

8031

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8032

if (!SWIG_IsOK(res1)) {

8033

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetSameMargins" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8034

}

8035

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8036

ecode2 = SWIG_AsVal_int(obj1, &val2);

8037

if (!SWIG_IsOK(ecode2)) {

8038

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_SetSameMargins" "', expected argument " "2"" of type '" "int""'");

8039

}

8040

arg2 = static_cast< int >(val2);

8041

{

8042

PyThreadState* __tstate = wxPyBeginAllowThreads();

8043

(arg1)->SetMargins(arg2);

8044

wxPyEndAllowThreads(__tstate);

8045

if (PyErr_Occurred()) SWIG_fail;

8046

}

8047

resultobj = SWIG_Py_Void();

8048

return resultobj;

8049

fail:

8050

return NULL;

8051

}

8052

8053

8054

SWIGINTERN PyObject *_wrap_RichTextObject_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8055

PyObject *resultobj = 0;

8056

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8057

int arg2 ;

8058

int arg3 ;

8059

int arg4 ;

8060

int arg5 ;

8061

void *argp1 = 0 ;

8062

int res1 = 0 ;

8063

int val2 ;

8064

int ecode2 = 0 ;

8065

int val3 ;

8066

int ecode3 = 0 ;

8067

int val4 ;

8068

int ecode4 = 0 ;

8069

int val5 ;

8070

int ecode5 = 0 ;

8071

PyObject * obj0 = 0 ;

8072

PyObject * obj1 = 0 ;

8073

PyObject * obj2 = 0 ;

8074

PyObject * obj3 = 0 ;

8075

PyObject * obj4 = 0 ;

8076

char * kwnames[] = {

8077

(char *) "self",(char *) "leftMargin",(char *) "rightMargin",(char *) "topMargin",(char *) "bottomMargin", NULL

8078

};

8079

8080

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:RichTextObject_SetMargins",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

8081

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8082

if (!SWIG_IsOK(res1)) {

8083

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetMargins" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8084

}

8085

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8086

ecode2 = SWIG_AsVal_int(obj1, &val2);

8087

if (!SWIG_IsOK(ecode2)) {

8088

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_SetMargins" "', expected argument " "2"" of type '" "int""'");

8089

}

8090

arg2 = static_cast< int >(val2);

8091

ecode3 = SWIG_AsVal_int(obj2, &val3);

8092

if (!SWIG_IsOK(ecode3)) {

8093

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextObject_SetMargins" "', expected argument " "3"" of type '" "int""'");

8094

}

8095

arg3 = static_cast< int >(val3);

8096

ecode4 = SWIG_AsVal_int(obj3, &val4);

8097

if (!SWIG_IsOK(ecode4)) {

8098

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextObject_SetMargins" "', expected argument " "4"" of type '" "int""'");

8099

}

8100

arg4 = static_cast< int >(val4);

8101

ecode5 = SWIG_AsVal_int(obj4, &val5);

8102

if (!SWIG_IsOK(ecode5)) {

8103

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextObject_SetMargins" "', expected argument " "5"" of type '" "int""'");

8104

}

8105

arg5 = static_cast< int >(val5);

8106

{

8107

PyThreadState* __tstate = wxPyBeginAllowThreads();

8108

(arg1)->SetMargins(arg2,arg3,arg4,arg5);

8109

wxPyEndAllowThreads(__tstate);

8110

if (PyErr_Occurred()) SWIG_fail;

8111

}

8112

resultobj = SWIG_Py_Void();

8113

return resultobj;

8114

fail:

8115

return NULL;

8116

}

8117

8118

8119

SWIGINTERN PyObject *_wrap_RichTextObject_GetLeftMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8120

PyObject *resultobj = 0;

8121

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8122

int result;

8123

void *argp1 = 0 ;

8124

int res1 = 0 ;

8125

PyObject *swig_obj[1] ;

8126

8127

if (!args) SWIG_fail;

8128

swig_obj[0] = args;

8129

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8130

if (!SWIG_IsOK(res1)) {

8131

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetLeftMargin" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8132

}

8133

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8134

{

8135

PyThreadState* __tstate = wxPyBeginAllowThreads();

8136

result = (int)((wxRichTextObject const *)arg1)->GetLeftMargin();

8137

wxPyEndAllowThreads(__tstate);

8138

if (PyErr_Occurred()) SWIG_fail;

8139

}

8140

resultobj = SWIG_From_int(static_cast< int >(result));

8141

return resultobj;

8142

fail:

8143

return NULL;

8144

}

8145

8146

8147

SWIGINTERN PyObject *_wrap_RichTextObject_GetRightMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8148

PyObject *resultobj = 0;

8149

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8150

int result;

8151

void *argp1 = 0 ;

8152

int res1 = 0 ;

8153

PyObject *swig_obj[1] ;

8154

8155

if (!args) SWIG_fail;

8156

swig_obj[0] = args;

8157

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8158

if (!SWIG_IsOK(res1)) {

8159

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetRightMargin" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8160

}

8161

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8162

{

8163

PyThreadState* __tstate = wxPyBeginAllowThreads();

8164

result = (int)((wxRichTextObject const *)arg1)->GetRightMargin();

8165

wxPyEndAllowThreads(__tstate);

8166

if (PyErr_Occurred()) SWIG_fail;

8167

}

8168

resultobj = SWIG_From_int(static_cast< int >(result));

8169

return resultobj;

8170

fail:

8171

return NULL;

8172

}

8173

8174

8175

SWIGINTERN PyObject *_wrap_RichTextObject_GetTopMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8176

PyObject *resultobj = 0;

8177

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8178

int result;

8179

void *argp1 = 0 ;

8180

int res1 = 0 ;

8181

PyObject *swig_obj[1] ;

8182

8183

if (!args) SWIG_fail;

8184

swig_obj[0] = args;

8185

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8186

if (!SWIG_IsOK(res1)) {

8187

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetTopMargin" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8188

}

8189

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8190

{

8191

PyThreadState* __tstate = wxPyBeginAllowThreads();

8192

result = (int)((wxRichTextObject const *)arg1)->GetTopMargin();

8193

wxPyEndAllowThreads(__tstate);

8194

if (PyErr_Occurred()) SWIG_fail;

8195

}

8196

resultobj = SWIG_From_int(static_cast< int >(result));

8197

return resultobj;

8198

fail:

8199

return NULL;

8200

}

8201

8202

8203

SWIGINTERN PyObject *_wrap_RichTextObject_GetBottomMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8204

PyObject *resultobj = 0;

8205

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8206

int result;

8207

void *argp1 = 0 ;

8208

int res1 = 0 ;

8209

PyObject *swig_obj[1] ;

8210

8211

if (!args) SWIG_fail;

8212

swig_obj[0] = args;

8213

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8214

if (!SWIG_IsOK(res1)) {

8215

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetBottomMargin" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8216

}

8217

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8218

{

8219

PyThreadState* __tstate = wxPyBeginAllowThreads();

8220

result = (int)((wxRichTextObject const *)arg1)->GetBottomMargin();

8221

wxPyEndAllowThreads(__tstate);

8222

if (PyErr_Occurred()) SWIG_fail;

8223

}

8224

resultobj = SWIG_From_int(static_cast< int >(result));

8225

return resultobj;

8226

fail:

8227

return NULL;

8228

}

8229

8230

8231

SWIGINTERN PyObject *_wrap_RichTextObject_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8232

PyObject *resultobj = 0;

8233

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8234

wxTextAttrEx *arg2 = 0 ;

8235

void *argp1 = 0 ;

8236

int res1 = 0 ;

8237

void *argp2 = 0 ;

8238

int res2 = 0 ;

8239

PyObject * obj0 = 0 ;

8240

PyObject * obj1 = 0 ;

8241

char * kwnames[] = {

8242

(char *) "self",(char *) "attr", NULL

8243

};

8244

8245

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetAttributes",kwnames,&obj0,&obj1)) SWIG_fail;

8246

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8247

if (!SWIG_IsOK(res1)) {

8248

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetAttributes" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8249

}

8250

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8251

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

8252

if (!SWIG_IsOK(res2)) {

8253

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_SetAttributes" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

8254

}

8255

if (!argp2) {

8256

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_SetAttributes" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

8257

}

8258

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

8259

{

8260

PyThreadState* __tstate = wxPyBeginAllowThreads();

8261

(arg1)->SetAttributes((wxTextAttrEx const &)*arg2);

8262

wxPyEndAllowThreads(__tstate);

8263

if (PyErr_Occurred()) SWIG_fail;

8264

}

8265

resultobj = SWIG_Py_Void();

8266

return resultobj;

8267

fail:

8268

return NULL;

8269

}

8270

8271

8272

SWIGINTERN PyObject *_wrap_RichTextObject_GetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8273

PyObject *resultobj = 0;

8274

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8275

wxTextAttrEx result;

8276

void *argp1 = 0 ;

8277

int res1 = 0 ;

8278

PyObject *swig_obj[1] ;

8279

8280

if (!args) SWIG_fail;

8281

swig_obj[0] = args;

8282

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8283

if (!SWIG_IsOK(res1)) {

8284

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetAttributes" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8285

}

8286

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8287

{

8288

PyThreadState* __tstate = wxPyBeginAllowThreads();

8289

result = (arg1)->GetAttributes();

8290

wxPyEndAllowThreads(__tstate);

8291

if (PyErr_Occurred()) SWIG_fail;

8292

}

8293

resultobj = SWIG_NewPointerObj((new wxTextAttrEx(static_cast< const wxTextAttrEx& >(result))), SWIGTYPE_p_wxTextAttrEx, SWIG_POINTER_OWN | 0 );

8294

return resultobj;

8295

fail:

8296

return NULL;

8297

}

8298

8299

8300

SWIGINTERN PyObject *_wrap_RichTextObject_SetDescent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8301

PyObject *resultobj = 0;

8302

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8303

int arg2 ;

8304

void *argp1 = 0 ;

8305

int res1 = 0 ;

8306

int val2 ;

8307

int ecode2 = 0 ;

8308

PyObject * obj0 = 0 ;

8309

PyObject * obj1 = 0 ;

8310

char * kwnames[] = {

8311

(char *) "self",(char *) "descent", NULL

8312

};

8313

8314

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_SetDescent",kwnames,&obj0,&obj1)) SWIG_fail;

8315

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8316

if (!SWIG_IsOK(res1)) {

8317

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_SetDescent" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8318

}

8319

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8320

ecode2 = SWIG_AsVal_int(obj1, &val2);

8321

if (!SWIG_IsOK(ecode2)) {

8322

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_SetDescent" "', expected argument " "2"" of type '" "int""'");

8323

}

8324

arg2 = static_cast< int >(val2);

8325

{

8326

PyThreadState* __tstate = wxPyBeginAllowThreads();

8327

(arg1)->SetDescent(arg2);

8328

wxPyEndAllowThreads(__tstate);

8329

if (PyErr_Occurred()) SWIG_fail;

8330

}

8331

resultobj = SWIG_Py_Void();

8332

return resultobj;

8333

fail:

8334

return NULL;

8335

}

8336

8337

8338

SWIGINTERN PyObject *_wrap_RichTextObject_GetDescent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8339

PyObject *resultobj = 0;

8340

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8341

int result;

8342

void *argp1 = 0 ;

8343

int res1 = 0 ;

8344

PyObject *swig_obj[1] ;

8345

8346

if (!args) SWIG_fail;

8347

swig_obj[0] = args;

8348

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8349

if (!SWIG_IsOK(res1)) {

8350

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetDescent" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8351

}

8352

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8353

{

8354

PyThreadState* __tstate = wxPyBeginAllowThreads();

8355

result = (int)((wxRichTextObject const *)arg1)->GetDescent();

8356

wxPyEndAllowThreads(__tstate);

8357

if (PyErr_Occurred()) SWIG_fail;

8358

}

8359

resultobj = SWIG_From_int(static_cast< int >(result));

8360

return resultobj;

8361

fail:

8362

return NULL;

8363

}

8364

8365

8366

SWIGINTERN PyObject *_wrap_RichTextObject_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8367

PyObject *resultobj = 0;

8368

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8369

wxRichTextBuffer *result = 0 ;

8370

void *argp1 = 0 ;

8371

int res1 = 0 ;

8372

PyObject *swig_obj[1] ;

8373

8374

if (!args) SWIG_fail;

8375

swig_obj[0] = args;

8376

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8377

if (!SWIG_IsOK(res1)) {

8378

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_GetBuffer" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8379

}

8380

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8381

{

8382

PyThreadState* __tstate = wxPyBeginAllowThreads();

8383

result = (wxRichTextBuffer *)((wxRichTextObject const *)arg1)->GetBuffer();

8384

wxPyEndAllowThreads(__tstate);

8385

if (PyErr_Occurred()) SWIG_fail;

8386

}

8387

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

8388

return resultobj;

8389

fail:

8390

return NULL;

8391

}

8392

8393

8394

SWIGINTERN PyObject *_wrap_RichTextObject_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8395

PyObject *resultobj = 0;

8396

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8397

wxRichTextObject *result = 0 ;

8398

void *argp1 = 0 ;

8399

int res1 = 0 ;

8400

PyObject *swig_obj[1] ;

8401

8402

if (!args) SWIG_fail;

8403

swig_obj[0] = args;

8404

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8405

if (!SWIG_IsOK(res1)) {

8406

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Clone" "', expected argument " "1"" of type '" "wxRichTextObject const *""'");

8407

}

8408

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8409

{

8410

PyThreadState* __tstate = wxPyBeginAllowThreads();

8411

result = (wxRichTextObject *)((wxRichTextObject const *)arg1)->Clone();

8412

wxPyEndAllowThreads(__tstate);

8413

if (PyErr_Occurred()) SWIG_fail;

8414

}

8415

{

8416

resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);

8417

}

8418

return resultobj;

8419

fail:

8420

return NULL;

8421

}

8422

8423

8424

SWIGINTERN PyObject *_wrap_RichTextObject_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8425

PyObject *resultobj = 0;

8426

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8427

wxRichTextObject *arg2 = 0 ;

8428

void *argp1 = 0 ;

8429

int res1 = 0 ;

8430

void *argp2 = 0 ;

8431

int res2 = 0 ;

8432

PyObject * obj0 = 0 ;

8433

PyObject * obj1 = 0 ;

8434

char * kwnames[] = {

8435

(char *) "self",(char *) "obj", NULL

8436

};

8437

8438

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

8439

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8440

if (!SWIG_IsOK(res1)) {

8441

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Copy" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8442

}

8443

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8444

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextObject, 0 | 0);

8445

if (!SWIG_IsOK(res2)) {

8446

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_Copy" "', expected argument " "2"" of type '" "wxRichTextObject const &""'");

8447

}

8448

if (!argp2) {

8449

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_Copy" "', expected argument " "2"" of type '" "wxRichTextObject const &""'");

8450

}

8451

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

8452

{

8453

PyThreadState* __tstate = wxPyBeginAllowThreads();

8454

(arg1)->Copy((wxRichTextObject const &)*arg2);

8455

wxPyEndAllowThreads(__tstate);

8456

if (PyErr_Occurred()) SWIG_fail;

8457

}

8458

resultobj = SWIG_Py_Void();

8459

return resultobj;

8460

fail:

8461

return NULL;

8462

}

8463

8464

8465

SWIGINTERN PyObject *_wrap_RichTextObject_Reference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8466

PyObject *resultobj = 0;

8467

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8468

void *argp1 = 0 ;

8469

int res1 = 0 ;

8470

PyObject *swig_obj[1] ;

8471

8472

if (!args) SWIG_fail;

8473

swig_obj[0] = args;

8474

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8475

if (!SWIG_IsOK(res1)) {

8476

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Reference" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8477

}

8478

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8479

{

8480

PyThreadState* __tstate = wxPyBeginAllowThreads();

8481

(arg1)->Reference();

8482

wxPyEndAllowThreads(__tstate);

8483

if (PyErr_Occurred()) SWIG_fail;

8484

}

8485

resultobj = SWIG_Py_Void();

8486

return resultobj;

8487

fail:

8488

return NULL;

8489

}

8490

8491

8492

SWIGINTERN PyObject *_wrap_RichTextObject_Dereference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8493

PyObject *resultobj = 0;

8494

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8495

void *argp1 = 0 ;

8496

int res1 = 0 ;

8497

PyObject *swig_obj[1] ;

8498

8499

if (!args) SWIG_fail;

8500

swig_obj[0] = args;

8501

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8502

if (!SWIG_IsOK(res1)) {

8503

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_Dereference" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8504

}

8505

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8506

{

8507

PyThreadState* __tstate = wxPyBeginAllowThreads();

8508

(arg1)->Dereference();

8509

wxPyEndAllowThreads(__tstate);

8510

if (PyErr_Occurred()) SWIG_fail;

8511

}

8512

resultobj = SWIG_Py_Void();

8513

return resultobj;

8514

fail:

8515

return NULL;

8516

}

8517

8518

8519

SWIGINTERN PyObject *_wrap_RichTextObject_ConvertTenthsMMToPixelsDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8520

PyObject *resultobj = 0;

8521

wxRichTextObject *arg1 = (wxRichTextObject *) 0 ;

8522

wxDC *arg2 = 0 ;

8523

int arg3 ;

8524

int result;

8525

void *argp1 = 0 ;

8526

int res1 = 0 ;

8527

void *argp2 = 0 ;

8528

int res2 = 0 ;

8529

int val3 ;

8530

int ecode3 = 0 ;

8531

PyObject * obj0 = 0 ;

8532

PyObject * obj1 = 0 ;

8533

PyObject * obj2 = 0 ;

8534

char * kwnames[] = {

8535

(char *) "self",(char *) "dc",(char *) "units", NULL

8536

};

8537

8538

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextObject_ConvertTenthsMMToPixelsDC",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

8539

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8540

if (!SWIG_IsOK(res1)) {

8541

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObject_ConvertTenthsMMToPixelsDC" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

8542

}

8543

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

8544

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );

8545

if (!SWIG_IsOK(res2)) {

8546

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObject_ConvertTenthsMMToPixelsDC" "', expected argument " "2"" of type '" "wxDC &""'");

8547

}

8548

if (!argp2) {

8549

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextObject_ConvertTenthsMMToPixelsDC" "', expected argument " "2"" of type '" "wxDC &""'");

8550

}

8551

arg2 = reinterpret_cast< wxDC * >(argp2);

8552

ecode3 = SWIG_AsVal_int(obj2, &val3);

8553

if (!SWIG_IsOK(ecode3)) {

8554

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextObject_ConvertTenthsMMToPixelsDC" "', expected argument " "3"" of type '" "int""'");

8555

}

8556

arg3 = static_cast< int >(val3);

8557

{

8558

PyThreadState* __tstate = wxPyBeginAllowThreads();

8559

result = (int)(arg1)->ConvertTenthsMMToPixels(*arg2,arg3);

8560

wxPyEndAllowThreads(__tstate);

8561

if (PyErr_Occurred()) SWIG_fail;

8562

}

8563

resultobj = SWIG_From_int(static_cast< int >(result));

8564

return resultobj;

8565

fail:

8566

return NULL;

8567

}

8568

8569

8570

SWIGINTERN PyObject *_wrap_RichTextObject_ConvertTenthsMMToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8571

PyObject *resultobj = 0;

8572

int arg1 ;

8573

int arg2 ;

8574

int result;

8575

int val1 ;

8576

int ecode1 = 0 ;

8577

int val2 ;

8578

int ecode2 = 0 ;

8579

PyObject * obj0 = 0 ;

8580

PyObject * obj1 = 0 ;

8581

char * kwnames[] = {

8582

(char *) "ppi",(char *) "units", NULL

8583

};

8584

8585

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObject_ConvertTenthsMMToPixels",kwnames,&obj0,&obj1)) SWIG_fail;

8586

ecode1 = SWIG_AsVal_int(obj0, &val1);

8587

if (!SWIG_IsOK(ecode1)) {

8588

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RichTextObject_ConvertTenthsMMToPixels" "', expected argument " "1"" of type '" "int""'");

8589

}

8590

arg1 = static_cast< int >(val1);

8591

ecode2 = SWIG_AsVal_int(obj1, &val2);

8592

if (!SWIG_IsOK(ecode2)) {

8593

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObject_ConvertTenthsMMToPixels" "', expected argument " "2"" of type '" "int""'");

8594

}

8595

arg2 = static_cast< int >(val2);

8596

{

8597

PyThreadState* __tstate = wxPyBeginAllowThreads();

8598

result = (int)wxRichTextObject::ConvertTenthsMMToPixels(arg1,arg2);

8599

wxPyEndAllowThreads(__tstate);

8600

if (PyErr_Occurred()) SWIG_fail;

8601

}

8602

resultobj = SWIG_From_int(static_cast< int >(result));

8603

return resultobj;

8604

fail:

8605

return NULL;

8606

}

8607

8608

8609

SWIGINTERN PyObject *RichTextObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8610

PyObject *obj;

8611

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

8612

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextObject, SWIG_NewClientData(obj));

8613

return SWIG_Py_Void();

8614

}

8615

8616

SWIGINTERN PyObject *_wrap_delete_RichTextObjectList_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8617

PyObject *resultobj = 0;

8618

wxRichTextObjectList_iterator *arg1 = (wxRichTextObjectList_iterator *) 0 ;

8619

void *argp1 = 0 ;

8620

int res1 = 0 ;

8621

PyObject *swig_obj[1] ;

8622

8623

if (!args) SWIG_fail;

8624

swig_obj[0] = args;

8625

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObjectList_iterator, SWIG_POINTER_DISOWN | 0 );

8626

if (!SWIG_IsOK(res1)) {

8627

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextObjectList_iterator" "', expected argument " "1"" of type '" "wxRichTextObjectList_iterator *""'");

8628

}

8629

arg1 = reinterpret_cast< wxRichTextObjectList_iterator * >(argp1);

8630

{

8631

PyThreadState* __tstate = wxPyBeginAllowThreads();

8632

delete arg1;

8633

8634

wxPyEndAllowThreads(__tstate);

8635

if (PyErr_Occurred()) SWIG_fail;

8636

}

8637

resultobj = SWIG_Py_Void();

8638

return resultobj;

8639

fail:

8640

return NULL;

8641

}

8642

8643

8644

SWIGINTERN PyObject *_wrap_RichTextObjectList_iterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8645

PyObject *resultobj = 0;

8646

wxRichTextObjectList_iterator *arg1 = (wxRichTextObjectList_iterator *) 0 ;

8647

wxRichTextObject *result = 0 ;

8648

void *argp1 = 0 ;

8649

int res1 = 0 ;

8650

PyObject *swig_obj[1] ;

8651

8652

if (!args) SWIG_fail;

8653

swig_obj[0] = args;

8654

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObjectList_iterator, 0 | 0 );

8655

if (!SWIG_IsOK(res1)) {

8656

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObjectList_iterator_next" "', expected argument " "1"" of type '" "wxRichTextObjectList_iterator *""'");

8657

}

8658

arg1 = reinterpret_cast< wxRichTextObjectList_iterator * >(argp1);

8659

{

8660

result = (wxRichTextObject *)(arg1)->next();

8661

if (PyErr_Occurred()) SWIG_fail;

8662

}

8663

{

8664

resultobj = wxPyMake_wxObject(result, (bool)0);

8665

}

8666

return resultobj;

8667

fail:

8668

return NULL;

8669

}

8670

8671

8672

SWIGINTERN PyObject *RichTextObjectList_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8673

PyObject *obj;

8674

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

8675

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextObjectList_iterator, SWIG_NewClientData(obj));

8676

return SWIG_Py_Void();

8677

}

8678

8679

SWIGINTERN PyObject *_wrap_delete_RichTextObjectList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8680

PyObject *resultobj = 0;

8681

wxRichTextObjectList *arg1 = (wxRichTextObjectList *) 0 ;

8682

void *argp1 = 0 ;

8683

int res1 = 0 ;

8684

PyObject *swig_obj[1] ;

8685

8686

if (!args) SWIG_fail;

8687

swig_obj[0] = args;

8688

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObjectList, SWIG_POINTER_DISOWN | 0 );

8689

if (!SWIG_IsOK(res1)) {

8690

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextObjectList" "', expected argument " "1"" of type '" "wxRichTextObjectList *""'");

8691

}

8692

arg1 = reinterpret_cast< wxRichTextObjectList * >(argp1);

8693

{

8694

PyThreadState* __tstate = wxPyBeginAllowThreads();

8695

delete arg1;

8696

8697

wxPyEndAllowThreads(__tstate);

8698

if (PyErr_Occurred()) SWIG_fail;

8699

}

8700

resultobj = SWIG_Py_Void();

8701

return resultobj;

8702

fail:

8703

return NULL;

8704

}

8705

8706

8707

SWIGINTERN PyObject *_wrap_RichTextObjectList___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8708

PyObject *resultobj = 0;

8709

wxRichTextObjectList *arg1 = (wxRichTextObjectList *) 0 ;

8710

size_t 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_wxRichTextObjectList, 0 | 0 );

8718

if (!SWIG_IsOK(res1)) {

8719

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObjectList___len__" "', expected argument " "1"" of type '" "wxRichTextObjectList *""'");

8720

}

8721

arg1 = reinterpret_cast< wxRichTextObjectList * >(argp1);

8722

{

8723

result = (size_t)wxRichTextObjectList___len__(arg1);

8724

if (PyErr_Occurred()) SWIG_fail;

8725

}

8726

resultobj = SWIG_From_size_t(static_cast< size_t >(result));

8727

return resultobj;

8728

fail:

8729

return NULL;

8730

}

8731

8732

8733

SWIGINTERN PyObject *_wrap_RichTextObjectList___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8734

PyObject *resultobj = 0;

8735

wxRichTextObjectList *arg1 = (wxRichTextObjectList *) 0 ;

8736

size_t arg2 ;

8737

wxRichTextObject *result = 0 ;

8738

void *argp1 = 0 ;

8739

int res1 = 0 ;

8740

size_t val2 ;

8741

int ecode2 = 0 ;

8742

PyObject * obj0 = 0 ;

8743

PyObject * obj1 = 0 ;

8744

char * kwnames[] = {

8745

(char *) "self",(char *) "index", NULL

8746

};

8747

8748

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObjectList___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;

8749

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObjectList, 0 | 0 );

8750

if (!SWIG_IsOK(res1)) {

8751

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObjectList___getitem__" "', expected argument " "1"" of type '" "wxRichTextObjectList *""'");

8752

}

8753

arg1 = reinterpret_cast< wxRichTextObjectList * >(argp1);

8754

ecode2 = SWIG_AsVal_size_t(obj1, &val2);

8755

if (!SWIG_IsOK(ecode2)) {

8756

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextObjectList___getitem__" "', expected argument " "2"" of type '" "size_t""'");

8757

}

8758

arg2 = static_cast< size_t >(val2);

8759

{

8760

result = (wxRichTextObject *)wxRichTextObjectList___getitem__(arg1,arg2);

8761

if (PyErr_Occurred()) SWIG_fail;

8762

}

8763

{

8764

resultobj = wxPyMake_wxObject(result, (bool)0);

8765

}

8766

return resultobj;

8767

fail:

8768

return NULL;

8769

}

8770

8771

8772

SWIGINTERN PyObject *_wrap_RichTextObjectList___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8773

PyObject *resultobj = 0;

8774

wxRichTextObjectList *arg1 = (wxRichTextObjectList *) 0 ;

8775

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

8776

bool result;

8777

void *argp1 = 0 ;

8778

int res1 = 0 ;

8779

void *argp2 = 0 ;

8780

int res2 = 0 ;

8781

PyObject * obj0 = 0 ;

8782

PyObject * obj1 = 0 ;

8783

char * kwnames[] = {

8784

(char *) "self",(char *) "obj", NULL

8785

};

8786

8787

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObjectList___contains__",kwnames,&obj0,&obj1)) SWIG_fail;

8788

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObjectList, 0 | 0 );

8789

if (!SWIG_IsOK(res1)) {

8790

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObjectList___contains__" "', expected argument " "1"" of type '" "wxRichTextObjectList *""'");

8791

}

8792

arg1 = reinterpret_cast< wxRichTextObjectList * >(argp1);

8793

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8794

if (!SWIG_IsOK(res2)) {

8795

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObjectList___contains__" "', expected argument " "2"" of type '" "wxRichTextObject const *""'");

8796

}

8797

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

8798

{

8799

result = (bool)wxRichTextObjectList___contains__(arg1,(wxRichTextObject const *)arg2);

8800

if (PyErr_Occurred()) SWIG_fail;

8801

}

8802

{

8803

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

8804

}

8805

return resultobj;

8806

fail:

8807

return NULL;

8808

}

8809

8810

8811

SWIGINTERN PyObject *_wrap_RichTextObjectList___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8812

PyObject *resultobj = 0;

8813

wxRichTextObjectList *arg1 = (wxRichTextObjectList *) 0 ;

8814

wxRichTextObjectList_iterator *result = 0 ;

8815

void *argp1 = 0 ;

8816

int res1 = 0 ;

8817

PyObject *swig_obj[1] ;

8818

8819

if (!args) SWIG_fail;

8820

swig_obj[0] = args;

8821

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextObjectList, 0 | 0 );

8822

if (!SWIG_IsOK(res1)) {

8823

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObjectList___iter__" "', expected argument " "1"" of type '" "wxRichTextObjectList *""'");

8824

}

8825

arg1 = reinterpret_cast< wxRichTextObjectList * >(argp1);

8826

{

8827

result = (wxRichTextObjectList_iterator *)wxRichTextObjectList___iter__(arg1);

8828

if (PyErr_Occurred()) SWIG_fail;

8829

}

8830

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextObjectList_iterator, SWIG_POINTER_OWN | 0 );

8831

return resultobj;

8832

fail:

8833

return NULL;

8834

}

8835

8836

8837

SWIGINTERN PyObject *_wrap_RichTextObjectList_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8838

PyObject *resultobj = 0;

8839

wxRichTextObjectList *arg1 = (wxRichTextObjectList *) 0 ;

8840

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

8841

int result;

8842

void *argp1 = 0 ;

8843

int res1 = 0 ;

8844

void *argp2 = 0 ;

8845

int res2 = 0 ;

8846

PyObject * obj0 = 0 ;

8847

PyObject * obj1 = 0 ;

8848

char * kwnames[] = {

8849

(char *) "self",(char *) "obj", NULL

8850

};

8851

8852

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextObjectList_index",kwnames,&obj0,&obj1)) SWIG_fail;

8853

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObjectList, 0 | 0 );

8854

if (!SWIG_IsOK(res1)) {

8855

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextObjectList_index" "', expected argument " "1"" of type '" "wxRichTextObjectList *""'");

8856

}

8857

arg1 = reinterpret_cast< wxRichTextObjectList * >(argp1);

8858

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

8859

if (!SWIG_IsOK(res2)) {

8860

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextObjectList_index" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

8861

}

8862

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

8863

{

8864

result = (int)wxRichTextObjectList_index(arg1,arg2);

8865

if (PyErr_Occurred()) SWIG_fail;

8866

}

8867

resultobj = SWIG_From_int(static_cast< int >(result));

8868

return resultobj;

8869

fail:

8870

return NULL;

8871

}

8872

8873

8874

SWIGINTERN PyObject *RichTextObjectList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8875

PyObject *obj;

8876

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

8877

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextObjectList, SWIG_NewClientData(obj));

8878

return SWIG_Py_Void();

8879

}

8880

8881

SWIGINTERN PyObject *_wrap_delete_RichTextCompositeObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8882

PyObject *resultobj = 0;

8883

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

8884

void *argp1 = 0 ;

8885

int res1 = 0 ;

8886

PyObject *swig_obj[1] ;

8887

8888

if (!args) SWIG_fail;

8889

swig_obj[0] = args;

8890

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCompositeObject, SWIG_POINTER_DISOWN | 0 );

8891

if (!SWIG_IsOK(res1)) {

8892

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextCompositeObject" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

8893

}

8894

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

8895

{

8896

PyThreadState* __tstate = wxPyBeginAllowThreads();

8897

delete arg1;

8898

8899

wxPyEndAllowThreads(__tstate);

8900

if (PyErr_Occurred()) SWIG_fail;

8901

}

8902

resultobj = SWIG_Py_Void();

8903

return resultobj;

8904

fail:

8905

return NULL;

8906

}

8907

8908

8909

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8910

PyObject *resultobj = 0;

8911

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

8912

wxRichTextObjectList *result = 0 ;

8913

void *argp1 = 0 ;

8914

int res1 = 0 ;

8915

PyObject *swig_obj[1] ;

8916

8917

if (!args) SWIG_fail;

8918

swig_obj[0] = args;

8919

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

8920

if (!SWIG_IsOK(res1)) {

8921

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_GetChildren" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

8922

}

8923

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

8924

{

8925

PyThreadState* __tstate = wxPyBeginAllowThreads();

8926

{

8927

wxRichTextObjectList &_result_ref = (arg1)->GetChildren();

8928

result = (wxRichTextObjectList *) &_result_ref;

8929

}

8930

wxPyEndAllowThreads(__tstate);

8931

if (PyErr_Occurred()) SWIG_fail;

8932

}

8933

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextObjectList, 0 | 0 );

8934

return resultobj;

8935

fail:

8936

return NULL;

8937

}

8938

8939

8940

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_GetChildCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

8941

PyObject *resultobj = 0;

8942

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

8943

size_t result;

8944

void *argp1 = 0 ;

8945

int res1 = 0 ;

8946

PyObject *swig_obj[1] ;

8947

8948

if (!args) SWIG_fail;

8949

swig_obj[0] = args;

8950

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

8951

if (!SWIG_IsOK(res1)) {

8952

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_GetChildCount" "', expected argument " "1"" of type '" "wxRichTextCompositeObject const *""'");

8953

}

8954

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

8955

{

8956

PyThreadState* __tstate = wxPyBeginAllowThreads();

8957

result = (size_t)((wxRichTextCompositeObject const *)arg1)->GetChildCount();

8958

wxPyEndAllowThreads(__tstate);

8959

if (PyErr_Occurred()) SWIG_fail;

8960

}

8961

resultobj = SWIG_From_size_t(static_cast< size_t >(result));

8962

return resultobj;

8963

fail:

8964

return NULL;

8965

}

8966

8967

8968

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_GetChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

8969

PyObject *resultobj = 0;

8970

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

8971

size_t arg2 ;

8972

wxRichTextObject *result = 0 ;

8973

void *argp1 = 0 ;

8974

int res1 = 0 ;

8975

size_t val2 ;

8976

int ecode2 = 0 ;

8977

PyObject * obj0 = 0 ;

8978

PyObject * obj1 = 0 ;

8979

char * kwnames[] = {

8980

(char *) "self",(char *) "n", NULL

8981

};

8982

8983

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCompositeObject_GetChild",kwnames,&obj0,&obj1)) SWIG_fail;

8984

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

8985

if (!SWIG_IsOK(res1)) {

8986

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_GetChild" "', expected argument " "1"" of type '" "wxRichTextCompositeObject const *""'");

8987

}

8988

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

8989

ecode2 = SWIG_AsVal_size_t(obj1, &val2);

8990

if (!SWIG_IsOK(ecode2)) {

8991

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCompositeObject_GetChild" "', expected argument " "2"" of type '" "size_t""'");

8992

}

8993

arg2 = static_cast< size_t >(val2);

8994

{

8995

PyThreadState* __tstate = wxPyBeginAllowThreads();

8996

result = (wxRichTextObject *)((wxRichTextCompositeObject const *)arg1)->GetChild(arg2);

8997

wxPyEndAllowThreads(__tstate);

8998

if (PyErr_Occurred()) SWIG_fail;

8999

}

9000

{

9001

resultobj = wxPyMake_wxObject(result, (bool)0);

9002

}

9003

return resultobj;

9004

fail:

9005

return NULL;

9006

}

9007

9008

9009

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9010

PyObject *resultobj = 0;

9011

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

9012

wxRichTextCompositeObject *arg2 = 0 ;

9013

void *argp1 = 0 ;

9014

int res1 = 0 ;

9015

void *argp2 = 0 ;

9016

int res2 = 0 ;

9017

PyObject * obj0 = 0 ;

9018

PyObject * obj1 = 0 ;

9019

char * kwnames[] = {

9020

(char *) "self",(char *) "obj", NULL

9021

};

9022

9023

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCompositeObject_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

9024

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

9025

if (!SWIG_IsOK(res1)) {

9026

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_Copy" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

9027

}

9028

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

9029

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0);

9030

if (!SWIG_IsOK(res2)) {

9031

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCompositeObject_Copy" "', expected argument " "2"" of type '" "wxRichTextCompositeObject const &""'");

9032

}

9033

if (!argp2) {

9034

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCompositeObject_Copy" "', expected argument " "2"" of type '" "wxRichTextCompositeObject const &""'");

9035

}

9036

arg2 = reinterpret_cast< wxRichTextCompositeObject * >(argp2);

9037

{

9038

PyThreadState* __tstate = wxPyBeginAllowThreads();

9039

(arg1)->Copy((wxRichTextCompositeObject const &)*arg2);

9040

wxPyEndAllowThreads(__tstate);

9041

if (PyErr_Occurred()) SWIG_fail;

9042

}

9043

resultobj = SWIG_Py_Void();

9044

return resultobj;

9045

fail:

9046

return NULL;

9047

}

9048

9049

9050

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_AppendChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9051

PyObject *resultobj = 0;

9052

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

9053

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

9054

size_t result;

9055

void *argp1 = 0 ;

9056

int res1 = 0 ;

9057

int res2 = 0 ;

9058

PyObject * obj0 = 0 ;

9059

PyObject * obj1 = 0 ;

9060

char * kwnames[] = {

9061

(char *) "self",(char *) "child", NULL

9062

};

9063

9064

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCompositeObject_AppendChild",kwnames,&obj0,&obj1)) SWIG_fail;

9065

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

9066

if (!SWIG_IsOK(res1)) {

9067

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_AppendChild" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

9068

}

9069

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

9070

res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxRichTextObject, SWIG_POINTER_DISOWN | 0 );

9071

if (!SWIG_IsOK(res2)) {

9072

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCompositeObject_AppendChild" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

9073

}

9074

{

9075

PyThreadState* __tstate = wxPyBeginAllowThreads();

9076

result = (size_t)(arg1)->AppendChild(arg2);

9077

wxPyEndAllowThreads(__tstate);

9078

if (PyErr_Occurred()) SWIG_fail;

9079

}

9080

resultobj = SWIG_From_size_t(static_cast< size_t >(result));

9081

return resultobj;

9082

fail:

9083

return NULL;

9084

}

9085

9086

9087

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_InsertChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9088

PyObject *resultobj = 0;

9089

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

9090

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

9091

wxRichTextObject *arg3 = (wxRichTextObject *) 0 ;

9092

bool result;

9093

void *argp1 = 0 ;

9094

int res1 = 0 ;

9095

int res2 = 0 ;

9096

void *argp3 = 0 ;

9097

int res3 = 0 ;

9098

PyObject * obj0 = 0 ;

9099

PyObject * obj1 = 0 ;

9100

PyObject * obj2 = 0 ;

9101

char * kwnames[] = {

9102

(char *) "self",(char *) "child",(char *) "inFrontOf", NULL

9103

};

9104

9105

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCompositeObject_InsertChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9106

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

9107

if (!SWIG_IsOK(res1)) {

9108

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_InsertChild" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

9109

}

9110

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

9111

res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxRichTextObject, SWIG_POINTER_DISOWN | 0 );

9112

if (!SWIG_IsOK(res2)) {

9113

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCompositeObject_InsertChild" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

9114

}

9115

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

9116

if (!SWIG_IsOK(res3)) {

9117

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCompositeObject_InsertChild" "', expected argument " "3"" of type '" "wxRichTextObject *""'");

9118

}

9119

arg3 = reinterpret_cast< wxRichTextObject * >(argp3);

9120

{

9121

PyThreadState* __tstate = wxPyBeginAllowThreads();

9122

result = (bool)(arg1)->InsertChild(arg2,arg3);

9123

wxPyEndAllowThreads(__tstate);

9124

if (PyErr_Occurred()) SWIG_fail;

9125

}

9126

{

9127

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9128

}

9129

return resultobj;

9130

fail:

9131

return NULL;

9132

}

9133

9134

9135

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9136

PyObject *resultobj = 0;

9137

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

9138

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

9139

bool arg3 = (bool) false ;

9140

bool result;

9141

void *argp1 = 0 ;

9142

int res1 = 0 ;

9143

void *argp2 = 0 ;

9144

int res2 = 0 ;

9145

bool val3 ;

9146

int ecode3 = 0 ;

9147

PyObject * obj0 = 0 ;

9148

PyObject * obj1 = 0 ;

9149

PyObject * obj2 = 0 ;

9150

char * kwnames[] = {

9151

(char *) "self",(char *) "child",(char *) "deleteChild", NULL

9152

};

9153

9154

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCompositeObject_RemoveChild",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9155

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

9156

if (!SWIG_IsOK(res1)) {

9157

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_RemoveChild" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

9158

}

9159

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

9160

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

9161

if (!SWIG_IsOK(res2)) {

9162

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCompositeObject_RemoveChild" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

9163

}

9164

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

9165

if (obj2) {

9166

ecode3 = SWIG_AsVal_bool(obj2, &val3);

9167

if (!SWIG_IsOK(ecode3)) {

9168

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCompositeObject_RemoveChild" "', expected argument " "3"" of type '" "bool""'");

9169

}

9170

arg3 = static_cast< bool >(val3);

9171

}

9172

{

9173

PyThreadState* __tstate = wxPyBeginAllowThreads();

9174

result = (bool)(arg1)->RemoveChild(arg2,arg3);

9175

wxPyEndAllowThreads(__tstate);

9176

if (PyErr_Occurred()) SWIG_fail;

9177

}

9178

{

9179

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9180

}

9181

return resultobj;

9182

fail:

9183

return NULL;

9184

}

9185

9186

9187

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_DeleteChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9188

PyObject *resultobj = 0;

9189

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

9190

bool result;

9191

void *argp1 = 0 ;

9192

int res1 = 0 ;

9193

PyObject *swig_obj[1] ;

9194

9195

if (!args) SWIG_fail;

9196

swig_obj[0] = args;

9197

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

9198

if (!SWIG_IsOK(res1)) {

9199

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_DeleteChildren" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

9200

}

9201

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

9202

{

9203

PyThreadState* __tstate = wxPyBeginAllowThreads();

9204

result = (bool)(arg1)->DeleteChildren();

9205

wxPyEndAllowThreads(__tstate);

9206

if (PyErr_Occurred()) SWIG_fail;

9207

}

9208

{

9209

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9210

}

9211

return resultobj;

9212

fail:

9213

return NULL;

9214

}

9215

9216

9217

SWIGINTERN PyObject *_wrap_RichTextCompositeObject_Defragment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9218

PyObject *resultobj = 0;

9219

wxRichTextCompositeObject *arg1 = (wxRichTextCompositeObject *) 0 ;

9220

bool result;

9221

void *argp1 = 0 ;

9222

int res1 = 0 ;

9223

PyObject *swig_obj[1] ;

9224

9225

if (!args) SWIG_fail;

9226

swig_obj[0] = args;

9227

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCompositeObject, 0 | 0 );

9228

if (!SWIG_IsOK(res1)) {

9229

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCompositeObject_Defragment" "', expected argument " "1"" of type '" "wxRichTextCompositeObject *""'");

9230

}

9231

arg1 = reinterpret_cast< wxRichTextCompositeObject * >(argp1);

9232

{

9233

PyThreadState* __tstate = wxPyBeginAllowThreads();

9234

result = (bool)(arg1)->Defragment();

9235

wxPyEndAllowThreads(__tstate);

9236

if (PyErr_Occurred()) SWIG_fail;

9237

}

9238

{

9239

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9240

}

9241

return resultobj;

9242

fail:

9243

return NULL;

9244

}

9245

9246

9247

SWIGINTERN PyObject *RichTextCompositeObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9248

PyObject *obj;

9249

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

9250

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextCompositeObject, SWIG_NewClientData(obj));

9251

return SWIG_Py_Void();

9252

}

9253

9254

SWIGINTERN PyObject *_wrap_new_RichTextBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9255

PyObject *resultobj = 0;

9256

wxRichTextObject *arg1 = (wxRichTextObject *) NULL ;

9257

wxRichTextBox *result = 0 ;

9258

void *argp1 = 0 ;

9259

int res1 = 0 ;

9260

PyObject * obj0 = 0 ;

9261

char * kwnames[] = {

9262

(char *) "parent", NULL

9263

};

9264

9265

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_RichTextBox",kwnames,&obj0)) SWIG_fail;

9266

if (obj0) {

9267

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

9268

if (!SWIG_IsOK(res1)) {

9269

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RichTextBox" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

9270

}

9271

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

9272

}

9273

{

9274

PyThreadState* __tstate = wxPyBeginAllowThreads();

9275

result = (wxRichTextBox *)new wxRichTextBox(arg1);

9276

wxPyEndAllowThreads(__tstate);

9277

if (PyErr_Occurred()) SWIG_fail;

9278

}

9279

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBox, SWIG_POINTER_NEW | 0 );

9280

return resultobj;

9281

fail:

9282

return NULL;

9283

}

9284

9285

9286

SWIGINTERN PyObject *_wrap_RichTextBox_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9287

PyObject *resultobj = 0;

9288

wxRichTextBox *arg1 = (wxRichTextBox *) 0 ;

9289

wxRichTextBox *arg2 = 0 ;

9290

void *argp1 = 0 ;

9291

int res1 = 0 ;

9292

void *argp2 = 0 ;

9293

int res2 = 0 ;

9294

PyObject * obj0 = 0 ;

9295

PyObject * obj1 = 0 ;

9296

char * kwnames[] = {

9297

(char *) "self",(char *) "obj", NULL

9298

};

9299

9300

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBox_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

9301

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBox, 0 | 0 );

9302

if (!SWIG_IsOK(res1)) {

9303

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBox_Copy" "', expected argument " "1"" of type '" "wxRichTextBox *""'");

9304

}

9305

arg1 = reinterpret_cast< wxRichTextBox * >(argp1);

9306

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextBox, 0 | 0);

9307

if (!SWIG_IsOK(res2)) {

9308

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBox_Copy" "', expected argument " "2"" of type '" "wxRichTextBox const &""'");

9309

}

9310

if (!argp2) {

9311

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBox_Copy" "', expected argument " "2"" of type '" "wxRichTextBox const &""'");

9312

}

9313

arg2 = reinterpret_cast< wxRichTextBox * >(argp2);

9314

{

9315

PyThreadState* __tstate = wxPyBeginAllowThreads();

9316

(arg1)->Copy((wxRichTextBox const &)*arg2);

9317

wxPyEndAllowThreads(__tstate);

9318

if (PyErr_Occurred()) SWIG_fail;

9319

}

9320

resultobj = SWIG_Py_Void();

9321

return resultobj;

9322

fail:

9323

return NULL;

9324

}

9325

9326

9327

SWIGINTERN PyObject *RichTextBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9328

PyObject *obj;

9329

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

9330

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextBox, SWIG_NewClientData(obj));

9331

return SWIG_Py_Void();

9332

}

9333

9334

SWIGINTERN PyObject *RichTextBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9335

return SWIG_Python_InitShadowInstance(args);

9336

}

9337

9338

SWIGINTERN PyObject *_wrap_new_RichTextParagraphLayoutBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9339

PyObject *resultobj = 0;

9340

wxRichTextObject *arg1 = (wxRichTextObject *) NULL ;

9341

wxRichTextParagraphLayoutBox *result = 0 ;

9342

void *argp1 = 0 ;

9343

int res1 = 0 ;

9344

PyObject * obj0 = 0 ;

9345

char * kwnames[] = {

9346

(char *) "parent", NULL

9347

};

9348

9349

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_RichTextParagraphLayoutBox",kwnames,&obj0)) SWIG_fail;

9350

if (obj0) {

9351

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

9352

if (!SWIG_IsOK(res1)) {

9353

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RichTextParagraphLayoutBox" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

9354

}

9355

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

9356

}

9357

{

9358

PyThreadState* __tstate = wxPyBeginAllowThreads();

9359

result = (wxRichTextParagraphLayoutBox *)new wxRichTextParagraphLayoutBox(arg1);

9360

wxPyEndAllowThreads(__tstate);

9361

if (PyErr_Occurred()) SWIG_fail;

9362

}

9363

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextParagraphLayoutBox, SWIG_POINTER_NEW | 0 );

9364

return resultobj;

9365

fail:

9366

return NULL;

9367

}

9368

9369

9370

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_SetRichTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9371

PyObject *resultobj = 0;

9372

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9373

wxRichTextCtrl *arg2 = (wxRichTextCtrl *) 0 ;

9374

void *argp1 = 0 ;

9375

int res1 = 0 ;

9376

void *argp2 = 0 ;

9377

int res2 = 0 ;

9378

PyObject * obj0 = 0 ;

9379

PyObject * obj1 = 0 ;

9380

char * kwnames[] = {

9381

(char *) "self",(char *) "ctrl", NULL

9382

};

9383

9384

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_SetRichTextCtrl",kwnames,&obj0,&obj1)) SWIG_fail;

9385

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9386

if (!SWIG_IsOK(res1)) {

9387

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_SetRichTextCtrl" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9388

}

9389

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9390

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

9391

if (!SWIG_IsOK(res2)) {

9392

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_SetRichTextCtrl" "', expected argument " "2"" of type '" "wxRichTextCtrl *""'");

9393

}

9394

arg2 = reinterpret_cast< wxRichTextCtrl * >(argp2);

9395

{

9396

PyThreadState* __tstate = wxPyBeginAllowThreads();

9397

(arg1)->SetRichTextCtrl(arg2);

9398

wxPyEndAllowThreads(__tstate);

9399

if (PyErr_Occurred()) SWIG_fail;

9400

}

9401

resultobj = SWIG_Py_Void();

9402

return resultobj;

9403

fail:

9404

return NULL;

9405

}

9406

9407

9408

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetRichTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9409

PyObject *resultobj = 0;

9410

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9411

wxRichTextCtrl *result = 0 ;

9412

void *argp1 = 0 ;

9413

int res1 = 0 ;

9414

PyObject *swig_obj[1] ;

9415

9416

if (!args) SWIG_fail;

9417

swig_obj[0] = args;

9418

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9419

if (!SWIG_IsOK(res1)) {

9420

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetRichTextCtrl" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9421

}

9422

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9423

{

9424

PyThreadState* __tstate = wxPyBeginAllowThreads();

9425

result = (wxRichTextCtrl *)((wxRichTextParagraphLayoutBox const *)arg1)->GetRichTextCtrl();

9426

wxPyEndAllowThreads(__tstate);

9427

if (PyErr_Occurred()) SWIG_fail;

9428

}

9429

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

9430

return resultobj;

9431

fail:

9432

return NULL;

9433

}

9434

9435

9436

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_SetPartialParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9437

PyObject *resultobj = 0;

9438

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9439

bool arg2 ;

9440

void *argp1 = 0 ;

9441

int res1 = 0 ;

9442

bool val2 ;

9443

int ecode2 = 0 ;

9444

PyObject * obj0 = 0 ;

9445

PyObject * obj1 = 0 ;

9446

char * kwnames[] = {

9447

(char *) "self",(char *) "partialPara", NULL

9448

};

9449

9450

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_SetPartialParagraph",kwnames,&obj0,&obj1)) SWIG_fail;

9451

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9452

if (!SWIG_IsOK(res1)) {

9453

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_SetPartialParagraph" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9454

}

9455

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9456

ecode2 = SWIG_AsVal_bool(obj1, &val2);

9457

if (!SWIG_IsOK(ecode2)) {

9458

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_SetPartialParagraph" "', expected argument " "2"" of type '" "bool""'");

9459

}

9460

arg2 = static_cast< bool >(val2);

9461

{

9462

PyThreadState* __tstate = wxPyBeginAllowThreads();

9463

(arg1)->SetPartialParagraph(arg2);

9464

wxPyEndAllowThreads(__tstate);

9465

if (PyErr_Occurred()) SWIG_fail;

9466

}

9467

resultobj = SWIG_Py_Void();

9468

return resultobj;

9469

fail:

9470

return NULL;

9471

}

9472

9473

9474

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetPartialParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9475

PyObject *resultobj = 0;

9476

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9477

bool result;

9478

void *argp1 = 0 ;

9479

int res1 = 0 ;

9480

PyObject *swig_obj[1] ;

9481

9482

if (!args) SWIG_fail;

9483

swig_obj[0] = args;

9484

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9485

if (!SWIG_IsOK(res1)) {

9486

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetPartialParagraph" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9487

}

9488

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9489

{

9490

PyThreadState* __tstate = wxPyBeginAllowThreads();

9491

result = (bool)((wxRichTextParagraphLayoutBox const *)arg1)->GetPartialParagraph();

9492

wxPyEndAllowThreads(__tstate);

9493

if (PyErr_Occurred()) SWIG_fail;

9494

}

9495

{

9496

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

9497

}

9498

return resultobj;

9499

fail:

9500

return NULL;

9501

}

9502

9503

9504

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9505

PyObject *resultobj = 0;

9506

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9507

wxRichTextStyleSheet *result = 0 ;

9508

void *argp1 = 0 ;

9509

int res1 = 0 ;

9510

PyObject *swig_obj[1] ;

9511

9512

if (!args) SWIG_fail;

9513

swig_obj[0] = args;

9514

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9515

if (!SWIG_IsOK(res1)) {

9516

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetStyleSheet" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9517

}

9518

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9519

{

9520

PyThreadState* __tstate = wxPyBeginAllowThreads();

9521

result = (wxRichTextStyleSheet *)((wxRichTextParagraphLayoutBox const *)arg1)->GetStyleSheet();

9522

wxPyEndAllowThreads(__tstate);

9523

if (PyErr_Occurred()) SWIG_fail;

9524

}

9525

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

9526

return resultobj;

9527

fail:

9528

return NULL;

9529

}

9530

9531

9532

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9533

PyObject *resultobj = 0;

9534

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9535

void *argp1 = 0 ;

9536

int res1 = 0 ;

9537

PyObject *swig_obj[1] ;

9538

9539

if (!args) SWIG_fail;

9540

swig_obj[0] = args;

9541

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9542

if (!SWIG_IsOK(res1)) {

9543

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_Init" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9544

}

9545

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9546

{

9547

PyThreadState* __tstate = wxPyBeginAllowThreads();

9548

(arg1)->Init();

9549

wxPyEndAllowThreads(__tstate);

9550

if (PyErr_Occurred()) SWIG_fail;

9551

}

9552

resultobj = SWIG_Py_Void();

9553

return resultobj;

9554

fail:

9555

return NULL;

9556

}

9557

9558

9559

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9560

PyObject *resultobj = 0;

9561

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9562

void *argp1 = 0 ;

9563

int res1 = 0 ;

9564

PyObject *swig_obj[1] ;

9565

9566

if (!args) SWIG_fail;

9567

swig_obj[0] = args;

9568

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9569

if (!SWIG_IsOK(res1)) {

9570

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_Clear" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9571

}

9572

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9573

{

9574

PyThreadState* __tstate = wxPyBeginAllowThreads();

9575

(arg1)->Clear();

9576

wxPyEndAllowThreads(__tstate);

9577

if (PyErr_Occurred()) SWIG_fail;

9578

}

9579

resultobj = SWIG_Py_Void();

9580

return resultobj;

9581

fail:

9582

return NULL;

9583

}

9584

9585

9586

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

9587

PyObject *resultobj = 0;

9588

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9589

void *argp1 = 0 ;

9590

int res1 = 0 ;

9591

PyObject *swig_obj[1] ;

9592

9593

if (!args) SWIG_fail;

9594

swig_obj[0] = args;

9595

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9596

if (!SWIG_IsOK(res1)) {

9597

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_Reset" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9598

}

9599

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9600

{

9601

PyThreadState* __tstate = wxPyBeginAllowThreads();

9602

(arg1)->Reset();

9603

wxPyEndAllowThreads(__tstate);

9604

if (PyErr_Occurred()) SWIG_fail;

9605

}

9606

resultobj = SWIG_Py_Void();

9607

return resultobj;

9608

fail:

9609

return NULL;

9610

}

9611

9612

9613

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_AddParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9614

PyObject *resultobj = 0;

9615

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9616

wxString *arg2 = 0 ;

9617

wxTextAttrEx *arg3 = (wxTextAttrEx *) NULL ;

9618

wxRichTextRange result;

9619

void *argp1 = 0 ;

9620

int res1 = 0 ;

9621

bool temp2 = false ;

9622

void *argp3 = 0 ;

9623

int res3 = 0 ;

9624

PyObject * obj0 = 0 ;

9625

PyObject * obj1 = 0 ;

9626

PyObject * obj2 = 0 ;

9627

char * kwnames[] = {

9628

(char *) "self",(char *) "text",(char *) "paraStyle", NULL

9629

};

9630

9631

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_AddParagraph",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9632

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9633

if (!SWIG_IsOK(res1)) {

9634

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_AddParagraph" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9635

}

9636

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9637

{

9638

arg2 = wxString_in_helper(obj1);

9639

if (arg2 == NULL) SWIG_fail;

9640

temp2 = true;

9641

}

9642

if (obj2) {

9643

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

9644

if (!SWIG_IsOK(res3)) {

9645

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_AddParagraph" "', expected argument " "3"" of type '" "wxTextAttrEx *""'");

9646

}

9647

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

9648

}

9649

{

9650

PyThreadState* __tstate = wxPyBeginAllowThreads();

9651

result = (arg1)->AddParagraph((wxString const &)*arg2,arg3);

9652

wxPyEndAllowThreads(__tstate);

9653

if (PyErr_Occurred()) SWIG_fail;

9654

}

9655

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

9656

{

9657

if (temp2)

9658

delete arg2;

9659

}

9660

return resultobj;

9661

fail:

9662

{

9663

if (temp2)

9664

delete arg2;

9665

}

9666

return NULL;

9667

}

9668

9669

9670

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_AddImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9671

PyObject *resultobj = 0;

9672

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9673

wxImage *arg2 = 0 ;

9674

wxTextAttrEx *arg3 = (wxTextAttrEx *) NULL ;

9675

wxRichTextRange result;

9676

void *argp1 = 0 ;

9677

int res1 = 0 ;

9678

void *argp2 = 0 ;

9679

int res2 = 0 ;

9680

void *argp3 = 0 ;

9681

int res3 = 0 ;

9682

PyObject * obj0 = 0 ;

9683

PyObject * obj1 = 0 ;

9684

PyObject * obj2 = 0 ;

9685

char * kwnames[] = {

9686

(char *) "self",(char *) "image",(char *) "paraStyle", NULL

9687

};

9688

9689

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_AddImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9690

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9691

if (!SWIG_IsOK(res1)) {

9692

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_AddImage" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9693

}

9694

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9695

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);

9696

if (!SWIG_IsOK(res2)) {

9697

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_AddImage" "', expected argument " "2"" of type '" "wxImage const &""'");

9698

}

9699

if (!argp2) {

9700

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_AddImage" "', expected argument " "2"" of type '" "wxImage const &""'");

9701

}

9702

arg2 = reinterpret_cast< wxImage * >(argp2);

9703

if (obj2) {

9704

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

9705

if (!SWIG_IsOK(res3)) {

9706

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_AddImage" "', expected argument " "3"" of type '" "wxTextAttrEx *""'");

9707

}

9708

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

9709

}

9710

{

9711

PyThreadState* __tstate = wxPyBeginAllowThreads();

9712

result = (arg1)->AddImage((wxImage const &)*arg2,arg3);

9713

wxPyEndAllowThreads(__tstate);

9714

if (PyErr_Occurred()) SWIG_fail;

9715

}

9716

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

9717

return resultobj;

9718

fail:

9719

return NULL;

9720

}

9721

9722

9723

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_AddParagraphs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9724

PyObject *resultobj = 0;

9725

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9726

wxString *arg2 = 0 ;

9727

wxTextAttrEx *arg3 = (wxTextAttrEx *) NULL ;

9728

wxRichTextRange result;

9729

void *argp1 = 0 ;

9730

int res1 = 0 ;

9731

bool temp2 = false ;

9732

void *argp3 = 0 ;

9733

int res3 = 0 ;

9734

PyObject * obj0 = 0 ;

9735

PyObject * obj1 = 0 ;

9736

PyObject * obj2 = 0 ;

9737

char * kwnames[] = {

9738

(char *) "self",(char *) "text",(char *) "paraStyle", NULL

9739

};

9740

9741

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_AddParagraphs",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9742

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9743

if (!SWIG_IsOK(res1)) {

9744

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_AddParagraphs" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

9745

}

9746

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9747

{

9748

arg2 = wxString_in_helper(obj1);

9749

if (arg2 == NULL) SWIG_fail;

9750

temp2 = true;

9751

}

9752

if (obj2) {

9753

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

9754

if (!SWIG_IsOK(res3)) {

9755

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_AddParagraphs" "', expected argument " "3"" of type '" "wxTextAttrEx *""'");

9756

}

9757

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

9758

}

9759

{

9760

PyThreadState* __tstate = wxPyBeginAllowThreads();

9761

result = (arg1)->AddParagraphs((wxString const &)*arg2,arg3);

9762

wxPyEndAllowThreads(__tstate);

9763

if (PyErr_Occurred()) SWIG_fail;

9764

}

9765

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

9766

{

9767

if (temp2)

9768

delete arg2;

9769

}

9770

return resultobj;

9771

fail:

9772

{

9773

if (temp2)

9774

delete arg2;

9775

}

9776

return NULL;

9777

}

9778

9779

9780

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetLineAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9781

PyObject *resultobj = 0;

9782

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9783

long arg2 ;

9784

bool arg3 = (bool) false ;

9785

wxRichTextLine *result = 0 ;

9786

void *argp1 = 0 ;

9787

int res1 = 0 ;

9788

long val2 ;

9789

int ecode2 = 0 ;

9790

bool val3 ;

9791

int ecode3 = 0 ;

9792

PyObject * obj0 = 0 ;

9793

PyObject * obj1 = 0 ;

9794

PyObject * obj2 = 0 ;

9795

char * kwnames[] = {

9796

(char *) "self",(char *) "pos",(char *) "caretPosition", NULL

9797

};

9798

9799

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_GetLineAtPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9800

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9801

if (!SWIG_IsOK(res1)) {

9802

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetLineAtPosition" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9803

}

9804

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9805

ecode2 = SWIG_AsVal_long(obj1, &val2);

9806

if (!SWIG_IsOK(ecode2)) {

9807

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetLineAtPosition" "', expected argument " "2"" of type '" "long""'");

9808

}

9809

arg2 = static_cast< long >(val2);

9810

if (obj2) {

9811

ecode3 = SWIG_AsVal_bool(obj2, &val3);

9812

if (!SWIG_IsOK(ecode3)) {

9813

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextParagraphLayoutBox_GetLineAtPosition" "', expected argument " "3"" of type '" "bool""'");

9814

}

9815

arg3 = static_cast< bool >(val3);

9816

}

9817

{

9818

PyThreadState* __tstate = wxPyBeginAllowThreads();

9819

result = (wxRichTextLine *)((wxRichTextParagraphLayoutBox const *)arg1)->GetLineAtPosition(arg2,arg3);

9820

wxPyEndAllowThreads(__tstate);

9821

if (PyErr_Occurred()) SWIG_fail;

9822

}

9823

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, 0 | 0 );

9824

return resultobj;

9825

fail:

9826

return NULL;

9827

}

9828

9829

9830

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetLineAtYPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9831

PyObject *resultobj = 0;

9832

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9833

int arg2 ;

9834

wxRichTextLine *result = 0 ;

9835

void *argp1 = 0 ;

9836

int res1 = 0 ;

9837

int val2 ;

9838

int ecode2 = 0 ;

9839

PyObject * obj0 = 0 ;

9840

PyObject * obj1 = 0 ;

9841

char * kwnames[] = {

9842

(char *) "self",(char *) "y", NULL

9843

};

9844

9845

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetLineAtYPosition",kwnames,&obj0,&obj1)) SWIG_fail;

9846

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9847

if (!SWIG_IsOK(res1)) {

9848

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetLineAtYPosition" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9849

}

9850

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9851

ecode2 = SWIG_AsVal_int(obj1, &val2);

9852

if (!SWIG_IsOK(ecode2)) {

9853

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetLineAtYPosition" "', expected argument " "2"" of type '" "int""'");

9854

}

9855

arg2 = static_cast< int >(val2);

9856

{

9857

PyThreadState* __tstate = wxPyBeginAllowThreads();

9858

result = (wxRichTextLine *)((wxRichTextParagraphLayoutBox const *)arg1)->GetLineAtYPosition(arg2);

9859

wxPyEndAllowThreads(__tstate);

9860

if (PyErr_Occurred()) SWIG_fail;

9861

}

9862

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, 0 | 0 );

9863

return resultobj;

9864

fail:

9865

return NULL;

9866

}

9867

9868

9869

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetParagraphAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9870

PyObject *resultobj = 0;

9871

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9872

long arg2 ;

9873

bool arg3 = (bool) false ;

9874

wxRichTextParagraph *result = 0 ;

9875

void *argp1 = 0 ;

9876

int res1 = 0 ;

9877

long val2 ;

9878

int ecode2 = 0 ;

9879

bool val3 ;

9880

int ecode3 = 0 ;

9881

PyObject * obj0 = 0 ;

9882

PyObject * obj1 = 0 ;

9883

PyObject * obj2 = 0 ;

9884

char * kwnames[] = {

9885

(char *) "self",(char *) "pos",(char *) "caretPosition", NULL

9886

};

9887

9888

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_GetParagraphAtPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9889

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9890

if (!SWIG_IsOK(res1)) {

9891

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetParagraphAtPosition" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9892

}

9893

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9894

ecode2 = SWIG_AsVal_long(obj1, &val2);

9895

if (!SWIG_IsOK(ecode2)) {

9896

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetParagraphAtPosition" "', expected argument " "2"" of type '" "long""'");

9897

}

9898

arg2 = static_cast< long >(val2);

9899

if (obj2) {

9900

ecode3 = SWIG_AsVal_bool(obj2, &val3);

9901

if (!SWIG_IsOK(ecode3)) {

9902

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextParagraphLayoutBox_GetParagraphAtPosition" "', expected argument " "3"" of type '" "bool""'");

9903

}

9904

arg3 = static_cast< bool >(val3);

9905

}

9906

{

9907

PyThreadState* __tstate = wxPyBeginAllowThreads();

9908

result = (wxRichTextParagraph *)((wxRichTextParagraphLayoutBox const *)arg1)->GetParagraphAtPosition(arg2,arg3);

9909

wxPyEndAllowThreads(__tstate);

9910

if (PyErr_Occurred()) SWIG_fail;

9911

}

9912

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

9913

return resultobj;

9914

fail:

9915

return NULL;

9916

}

9917

9918

9919

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetLineSizeAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9920

PyObject *resultobj = 0;

9921

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9922

long arg2 ;

9923

bool arg3 = (bool) false ;

9924

wxSize result;

9925

void *argp1 = 0 ;

9926

int res1 = 0 ;

9927

long val2 ;

9928

int ecode2 = 0 ;

9929

bool val3 ;

9930

int ecode3 = 0 ;

9931

PyObject * obj0 = 0 ;

9932

PyObject * obj1 = 0 ;

9933

PyObject * obj2 = 0 ;

9934

char * kwnames[] = {

9935

(char *) "self",(char *) "pos",(char *) "caretPosition", NULL

9936

};

9937

9938

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_GetLineSizeAtPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

9939

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9940

if (!SWIG_IsOK(res1)) {

9941

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetLineSizeAtPosition" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9942

}

9943

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9944

ecode2 = SWIG_AsVal_long(obj1, &val2);

9945

if (!SWIG_IsOK(ecode2)) {

9946

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetLineSizeAtPosition" "', expected argument " "2"" of type '" "long""'");

9947

}

9948

arg2 = static_cast< long >(val2);

9949

if (obj2) {

9950

ecode3 = SWIG_AsVal_bool(obj2, &val3);

9951

if (!SWIG_IsOK(ecode3)) {

9952

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextParagraphLayoutBox_GetLineSizeAtPosition" "', expected argument " "3"" of type '" "bool""'");

9953

}

9954

arg3 = static_cast< bool >(val3);

9955

}

9956

{

9957

PyThreadState* __tstate = wxPyBeginAllowThreads();

9958

result = ((wxRichTextParagraphLayoutBox const *)arg1)->GetLineSizeAtPosition(arg2,arg3);

9959

wxPyEndAllowThreads(__tstate);

9960

if (PyErr_Occurred()) SWIG_fail;

9961

}

9962

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

9963

return resultobj;

9964

fail:

9965

return NULL;

9966

}

9967

9968

9969

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetVisibleLineNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

9970

PyObject *resultobj = 0;

9971

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

9972

long arg2 ;

9973

bool arg3 = (bool) false ;

9974

bool arg4 = (bool) false ;

9975

long result;

9976

void *argp1 = 0 ;

9977

int res1 = 0 ;

9978

long val2 ;

9979

int ecode2 = 0 ;

9980

bool val3 ;

9981

int ecode3 = 0 ;

9982

bool val4 ;

9983

int ecode4 = 0 ;

9984

PyObject * obj0 = 0 ;

9985

PyObject * obj1 = 0 ;

9986

PyObject * obj2 = 0 ;

9987

PyObject * obj3 = 0 ;

9988

char * kwnames[] = {

9989

(char *) "self",(char *) "pos",(char *) "caretPosition",(char *) "startOfLine", NULL

9990

};

9991

9992

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextParagraphLayoutBox_GetVisibleLineNumber",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

9993

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

9994

if (!SWIG_IsOK(res1)) {

9995

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetVisibleLineNumber" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

9996

}

9997

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

9998

ecode2 = SWIG_AsVal_long(obj1, &val2);

9999

if (!SWIG_IsOK(ecode2)) {

10000

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetVisibleLineNumber" "', expected argument " "2"" of type '" "long""'");

10001

}

10002

arg2 = static_cast< long >(val2);

10003

if (obj2) {

10004

ecode3 = SWIG_AsVal_bool(obj2, &val3);

10005

if (!SWIG_IsOK(ecode3)) {

10006

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextParagraphLayoutBox_GetVisibleLineNumber" "', expected argument " "3"" of type '" "bool""'");

10007

}

10008

arg3 = static_cast< bool >(val3);

10009

}

10010

if (obj3) {

10011

ecode4 = SWIG_AsVal_bool(obj3, &val4);

10012

if (!SWIG_IsOK(ecode4)) {

10013

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraphLayoutBox_GetVisibleLineNumber" "', expected argument " "4"" of type '" "bool""'");

10014

}

10015

arg4 = static_cast< bool >(val4);

10016

}

10017

{

10018

PyThreadState* __tstate = wxPyBeginAllowThreads();

10019

result = (long)((wxRichTextParagraphLayoutBox const *)arg1)->GetVisibleLineNumber(arg2,arg3,arg4);

10020

wxPyEndAllowThreads(__tstate);

10021

if (PyErr_Occurred()) SWIG_fail;

10022

}

10023

resultobj = SWIG_From_long(static_cast< long >(result));

10024

return resultobj;

10025

fail:

10026

return NULL;

10027

}

10028

10029

10030

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetLineForVisibleLineNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10031

PyObject *resultobj = 0;

10032

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10033

long arg2 ;

10034

wxRichTextLine *result = 0 ;

10035

void *argp1 = 0 ;

10036

int res1 = 0 ;

10037

long val2 ;

10038

int ecode2 = 0 ;

10039

PyObject * obj0 = 0 ;

10040

PyObject * obj1 = 0 ;

10041

char * kwnames[] = {

10042

(char *) "self",(char *) "lineNumber", NULL

10043

};

10044

10045

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetLineForVisibleLineNumber",kwnames,&obj0,&obj1)) SWIG_fail;

10046

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10047

if (!SWIG_IsOK(res1)) {

10048

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetLineForVisibleLineNumber" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10049

}

10050

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10051

ecode2 = SWIG_AsVal_long(obj1, &val2);

10052

if (!SWIG_IsOK(ecode2)) {

10053

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetLineForVisibleLineNumber" "', expected argument " "2"" of type '" "long""'");

10054

}

10055

arg2 = static_cast< long >(val2);

10056

{

10057

PyThreadState* __tstate = wxPyBeginAllowThreads();

10058

result = (wxRichTextLine *)((wxRichTextParagraphLayoutBox const *)arg1)->GetLineForVisibleLineNumber(arg2);

10059

wxPyEndAllowThreads(__tstate);

10060

if (PyErr_Occurred()) SWIG_fail;

10061

}

10062

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, 0 | 0 );

10063

return resultobj;

10064

fail:

10065

return NULL;

10066

}

10067

10068

10069

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetLeafObjectAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10070

PyObject *resultobj = 0;

10071

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10072

long arg2 ;

10073

wxRichTextObject *result = 0 ;

10074

void *argp1 = 0 ;

10075

int res1 = 0 ;

10076

long val2 ;

10077

int ecode2 = 0 ;

10078

PyObject * obj0 = 0 ;

10079

PyObject * obj1 = 0 ;

10080

char * kwnames[] = {

10081

(char *) "self",(char *) "position", NULL

10082

};

10083

10084

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetLeafObjectAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;

10085

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10086

if (!SWIG_IsOK(res1)) {

10087

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetLeafObjectAtPosition" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10088

}

10089

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10090

ecode2 = SWIG_AsVal_long(obj1, &val2);

10091

if (!SWIG_IsOK(ecode2)) {

10092

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetLeafObjectAtPosition" "', expected argument " "2"" of type '" "long""'");

10093

}

10094

arg2 = static_cast< long >(val2);

10095

{

10096

PyThreadState* __tstate = wxPyBeginAllowThreads();

10097

result = (wxRichTextObject *)((wxRichTextParagraphLayoutBox const *)arg1)->GetLeafObjectAtPosition(arg2);

10098

wxPyEndAllowThreads(__tstate);

10099

if (PyErr_Occurred()) SWIG_fail;

10100

}

10101

{

10102

resultobj = wxPyMake_wxObject(result, (bool)0);

10103

}

10104

return resultobj;

10105

fail:

10106

return NULL;

10107

}

10108

10109

10110

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetParagraphAtLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10111

PyObject *resultobj = 0;

10112

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10113

long arg2 ;

10114

wxRichTextParagraph *result = 0 ;

10115

void *argp1 = 0 ;

10116

int res1 = 0 ;

10117

long val2 ;

10118

int ecode2 = 0 ;

10119

PyObject * obj0 = 0 ;

10120

PyObject * obj1 = 0 ;

10121

char * kwnames[] = {

10122

(char *) "self",(char *) "paragraphNumber", NULL

10123

};

10124

10125

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetParagraphAtLine",kwnames,&obj0,&obj1)) SWIG_fail;

10126

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10127

if (!SWIG_IsOK(res1)) {

10128

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetParagraphAtLine" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10129

}

10130

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10131

ecode2 = SWIG_AsVal_long(obj1, &val2);

10132

if (!SWIG_IsOK(ecode2)) {

10133

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetParagraphAtLine" "', expected argument " "2"" of type '" "long""'");

10134

}

10135

arg2 = static_cast< long >(val2);

10136

{

10137

PyThreadState* __tstate = wxPyBeginAllowThreads();

10138

result = (wxRichTextParagraph *)((wxRichTextParagraphLayoutBox const *)arg1)->GetParagraphAtLine(arg2);

10139

wxPyEndAllowThreads(__tstate);

10140

if (PyErr_Occurred()) SWIG_fail;

10141

}

10142

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

10143

return resultobj;

10144

fail:

10145

return NULL;

10146

}

10147

10148

10149

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetParagraphForLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10150

PyObject *resultobj = 0;

10151

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10152

wxRichTextLine *arg2 = (wxRichTextLine *) 0 ;

10153

wxRichTextParagraph *result = 0 ;

10154

void *argp1 = 0 ;

10155

int res1 = 0 ;

10156

void *argp2 = 0 ;

10157

int res2 = 0 ;

10158

PyObject * obj0 = 0 ;

10159

PyObject * obj1 = 0 ;

10160

char * kwnames[] = {

10161

(char *) "self",(char *) "line", NULL

10162

};

10163

10164

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetParagraphForLine",kwnames,&obj0,&obj1)) SWIG_fail;

10165

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10166

if (!SWIG_IsOK(res1)) {

10167

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetParagraphForLine" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10168

}

10169

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10170

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

10171

if (!SWIG_IsOK(res2)) {

10172

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_GetParagraphForLine" "', expected argument " "2"" of type '" "wxRichTextLine *""'");

10173

}

10174

arg2 = reinterpret_cast< wxRichTextLine * >(argp2);

10175

{

10176

PyThreadState* __tstate = wxPyBeginAllowThreads();

10177

result = (wxRichTextParagraph *)((wxRichTextParagraphLayoutBox const *)arg1)->GetParagraphForLine(arg2);

10178

wxPyEndAllowThreads(__tstate);

10179

if (PyErr_Occurred()) SWIG_fail;

10180

}

10181

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

10182

return resultobj;

10183

fail:

10184

return NULL;

10185

}

10186

10187

10188

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetParagraphLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10189

PyObject *resultobj = 0;

10190

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10191

long arg2 ;

10192

int result;

10193

void *argp1 = 0 ;

10194

int res1 = 0 ;

10195

long val2 ;

10196

int ecode2 = 0 ;

10197

PyObject * obj0 = 0 ;

10198

PyObject * obj1 = 0 ;

10199

char * kwnames[] = {

10200

(char *) "self",(char *) "paragraphNumber", NULL

10201

};

10202

10203

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetParagraphLength",kwnames,&obj0,&obj1)) SWIG_fail;

10204

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10205

if (!SWIG_IsOK(res1)) {

10206

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetParagraphLength" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10207

}

10208

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10209

ecode2 = SWIG_AsVal_long(obj1, &val2);

10210

if (!SWIG_IsOK(ecode2)) {

10211

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetParagraphLength" "', expected argument " "2"" of type '" "long""'");

10212

}

10213

arg2 = static_cast< long >(val2);

10214

{

10215

PyThreadState* __tstate = wxPyBeginAllowThreads();

10216

result = (int)((wxRichTextParagraphLayoutBox const *)arg1)->GetParagraphLength(arg2);

10217

wxPyEndAllowThreads(__tstate);

10218

if (PyErr_Occurred()) SWIG_fail;

10219

}

10220

resultobj = SWIG_From_int(static_cast< int >(result));

10221

return resultobj;

10222

fail:

10223

return NULL;

10224

}

10225

10226

10227

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetParagraphCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10228

PyObject *resultobj = 0;

10229

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10230

int result;

10231

void *argp1 = 0 ;

10232

int res1 = 0 ;

10233

PyObject *swig_obj[1] ;

10234

10235

if (!args) SWIG_fail;

10236

swig_obj[0] = args;

10237

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10238

if (!SWIG_IsOK(res1)) {

10239

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetParagraphCount" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10240

}

10241

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10242

{

10243

PyThreadState* __tstate = wxPyBeginAllowThreads();

10244

result = (int)((wxRichTextParagraphLayoutBox const *)arg1)->GetParagraphCount();

10245

wxPyEndAllowThreads(__tstate);

10246

if (PyErr_Occurred()) SWIG_fail;

10247

}

10248

resultobj = SWIG_From_int(static_cast< int >(result));

10249

return resultobj;

10250

fail:

10251

return NULL;

10252

}

10253

10254

10255

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetLineCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

10256

PyObject *resultobj = 0;

10257

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10258

int result;

10259

void *argp1 = 0 ;

10260

int res1 = 0 ;

10261

PyObject *swig_obj[1] ;

10262

10263

if (!args) SWIG_fail;

10264

swig_obj[0] = args;

10265

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10266

if (!SWIG_IsOK(res1)) {

10267

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetLineCount" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10268

}

10269

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10270

{

10271

PyThreadState* __tstate = wxPyBeginAllowThreads();

10272

result = (int)((wxRichTextParagraphLayoutBox const *)arg1)->GetLineCount();

10273

wxPyEndAllowThreads(__tstate);

10274

if (PyErr_Occurred()) SWIG_fail;

10275

}

10276

resultobj = SWIG_From_int(static_cast< int >(result));

10277

return resultobj;

10278

fail:

10279

return NULL;

10280

}

10281

10282

10283

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetParagraphText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10284

PyObject *resultobj = 0;

10285

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10286

long arg2 ;

10287

wxString result;

10288

void *argp1 = 0 ;

10289

int res1 = 0 ;

10290

long val2 ;

10291

int ecode2 = 0 ;

10292

PyObject * obj0 = 0 ;

10293

PyObject * obj1 = 0 ;

10294

char * kwnames[] = {

10295

(char *) "self",(char *) "paragraphNumber", NULL

10296

};

10297

10298

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_GetParagraphText",kwnames,&obj0,&obj1)) SWIG_fail;

10299

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10300

if (!SWIG_IsOK(res1)) {

10301

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetParagraphText" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10302

}

10303

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10304

ecode2 = SWIG_AsVal_long(obj1, &val2);

10305

if (!SWIG_IsOK(ecode2)) {

10306

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetParagraphText" "', expected argument " "2"" of type '" "long""'");

10307

}

10308

arg2 = static_cast< long >(val2);

10309

{

10310

PyThreadState* __tstate = wxPyBeginAllowThreads();

10311

result = ((wxRichTextParagraphLayoutBox const *)arg1)->GetParagraphText(arg2);

10312

wxPyEndAllowThreads(__tstate);

10313

if (PyErr_Occurred()) SWIG_fail;

10314

}

10315

{

10316

#if wxUSE_UNICODE

10317

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

10318

#else

10319

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

10320

#endif

10321

}

10322

return resultobj;

10323

fail:

10324

return NULL;

10325

}

10326

10327

10328

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_XYToPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10329

PyObject *resultobj = 0;

10330

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10331

long arg2 ;

10332

long arg3 ;

10333

long result;

10334

void *argp1 = 0 ;

10335

int res1 = 0 ;

10336

long val2 ;

10337

int ecode2 = 0 ;

10338

long val3 ;

10339

int ecode3 = 0 ;

10340

PyObject * obj0 = 0 ;

10341

PyObject * obj1 = 0 ;

10342

PyObject * obj2 = 0 ;

10343

char * kwnames[] = {

10344

(char *) "self",(char *) "x",(char *) "y", NULL

10345

};

10346

10347

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_XYToPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10348

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10349

if (!SWIG_IsOK(res1)) {

10350

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_XYToPosition" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10351

}

10352

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10353

ecode2 = SWIG_AsVal_long(obj1, &val2);

10354

if (!SWIG_IsOK(ecode2)) {

10355

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_XYToPosition" "', expected argument " "2"" of type '" "long""'");

10356

}

10357

arg2 = static_cast< long >(val2);

10358

ecode3 = SWIG_AsVal_long(obj2, &val3);

10359

if (!SWIG_IsOK(ecode3)) {

10360

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextParagraphLayoutBox_XYToPosition" "', expected argument " "3"" of type '" "long""'");

10361

}

10362

arg3 = static_cast< long >(val3);

10363

{

10364

PyThreadState* __tstate = wxPyBeginAllowThreads();

10365

result = (long)((wxRichTextParagraphLayoutBox const *)arg1)->XYToPosition(arg2,arg3);

10366

wxPyEndAllowThreads(__tstate);

10367

if (PyErr_Occurred()) SWIG_fail;

10368

}

10369

resultobj = SWIG_From_long(static_cast< long >(result));

10370

return resultobj;

10371

fail:

10372

return NULL;

10373

}

10374

10375

10376

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_PositionToXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10377

PyObject *resultobj = 0;

10378

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10379

long arg2 ;

10380

long *arg3 = (long *) 0 ;

10381

long *arg4 = (long *) 0 ;

10382

bool result;

10383

void *argp1 = 0 ;

10384

int res1 = 0 ;

10385

long val2 ;

10386

int ecode2 = 0 ;

10387

void *argp3 = 0 ;

10388

int res3 = 0 ;

10389

void *argp4 = 0 ;

10390

int res4 = 0 ;

10391

PyObject * obj0 = 0 ;

10392

PyObject * obj1 = 0 ;

10393

PyObject * obj2 = 0 ;

10394

PyObject * obj3 = 0 ;

10395

char * kwnames[] = {

10396

(char *) "self",(char *) "pos",(char *) "x",(char *) "y", NULL

10397

};

10398

10399

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RichTextParagraphLayoutBox_PositionToXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

10400

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10401

if (!SWIG_IsOK(res1)) {

10402

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_PositionToXY" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

10403

}

10404

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10405

ecode2 = SWIG_AsVal_long(obj1, &val2);

10406

if (!SWIG_IsOK(ecode2)) {

10407

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_PositionToXY" "', expected argument " "2"" of type '" "long""'");

10408

}

10409

arg2 = static_cast< long >(val2);

10410

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 | 0 );

10411

if (!SWIG_IsOK(res3)) {

10412

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_PositionToXY" "', expected argument " "3"" of type '" "long *""'");

10413

}

10414

arg3 = reinterpret_cast< long * >(argp3);

10415

res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_long, 0 | 0 );

10416

if (!SWIG_IsOK(res4)) {

10417

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextParagraphLayoutBox_PositionToXY" "', expected argument " "4"" of type '" "long *""'");

10418

}

10419

arg4 = reinterpret_cast< long * >(argp4);

10420

{

10421

PyThreadState* __tstate = wxPyBeginAllowThreads();

10422

result = (bool)((wxRichTextParagraphLayoutBox const *)arg1)->PositionToXY(arg2,arg3,arg4);

10423

wxPyEndAllowThreads(__tstate);

10424

if (PyErr_Occurred()) SWIG_fail;

10425

}

10426

{

10427

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10428

}

10429

return resultobj;

10430

fail:

10431

return NULL;

10432

}

10433

10434

10435

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10436

PyObject *resultobj = 0;

10437

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10438

wxRichTextRange *arg2 = 0 ;

10439

wxTextAttrEx *arg3 = 0 ;

10440

int arg4 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

10441

bool result;

10442

void *argp1 = 0 ;

10443

int res1 = 0 ;

10444

wxRichTextRange temp2 ;

10445

void *argp3 = 0 ;

10446

int res3 = 0 ;

10447

int val4 ;

10448

int ecode4 = 0 ;

10449

PyObject * obj0 = 0 ;

10450

PyObject * obj1 = 0 ;

10451

PyObject * obj2 = 0 ;

10452

PyObject * obj3 = 0 ;

10453

char * kwnames[] = {

10454

(char *) "self",(char *) "range",(char *) "style",(char *) "flags", NULL

10455

};

10456

10457

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:RichTextParagraphLayoutBox_SetStyle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

10458

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10459

if (!SWIG_IsOK(res1)) {

10460

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_SetStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10461

}

10462

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10463

{

10464

arg2 = &temp2;

10465

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

10466

}

10467

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

10468

if (!SWIG_IsOK(res3)) {

10469

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_SetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

10470

}

10471

if (!argp3) {

10472

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_SetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

10473

}

10474

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

10475

if (obj3) {

10476

ecode4 = SWIG_AsVal_int(obj3, &val4);

10477

if (!SWIG_IsOK(ecode4)) {

10478

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraphLayoutBox_SetStyle" "', expected argument " "4"" of type '" "int""'");

10479

}

10480

arg4 = static_cast< int >(val4);

10481

}

10482

{

10483

PyThreadState* __tstate = wxPyBeginAllowThreads();

10484

result = (bool)(arg1)->SetStyle((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3,arg4);

10485

wxPyEndAllowThreads(__tstate);

10486

if (PyErr_Occurred()) SWIG_fail;

10487

}

10488

{

10489

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10490

}

10491

return resultobj;

10492

fail:

10493

return NULL;

10494

}

10495

10496

10497

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10498

PyObject *resultobj = 0;

10499

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10500

long arg2 ;

10501

wxTextAttrEx *arg3 = 0 ;

10502

bool result;

10503

void *argp1 = 0 ;

10504

int res1 = 0 ;

10505

long val2 ;

10506

int ecode2 = 0 ;

10507

void *argp3 = 0 ;

10508

int res3 = 0 ;

10509

PyObject * obj0 = 0 ;

10510

PyObject * obj1 = 0 ;

10511

PyObject * obj2 = 0 ;

10512

char * kwnames[] = {

10513

(char *) "self",(char *) "position",(char *) "style", NULL

10514

};

10515

10516

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_GetStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10517

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10518

if (!SWIG_IsOK(res1)) {

10519

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10520

}

10521

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10522

ecode2 = SWIG_AsVal_long(obj1, &val2);

10523

if (!SWIG_IsOK(ecode2)) {

10524

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetStyle" "', expected argument " "2"" of type '" "long""'");

10525

}

10526

arg2 = static_cast< long >(val2);

10527

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

10528

if (!SWIG_IsOK(res3)) {

10529

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_GetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

10530

}

10531

if (!argp3) {

10532

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_GetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

10533

}

10534

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

10535

{

10536

PyThreadState* __tstate = wxPyBeginAllowThreads();

10537

result = (bool)(arg1)->GetStyle(arg2,*arg3);

10538

wxPyEndAllowThreads(__tstate);

10539

if (PyErr_Occurred()) SWIG_fail;

10540

}

10541

{

10542

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10543

}

10544

return resultobj;

10545

fail:

10546

return NULL;

10547

}

10548

10549

10550

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetUncombinedStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10551

PyObject *resultobj = 0;

10552

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10553

long arg2 ;

10554

wxTextAttrEx *arg3 = 0 ;

10555

bool result;

10556

void *argp1 = 0 ;

10557

int res1 = 0 ;

10558

long val2 ;

10559

int ecode2 = 0 ;

10560

void *argp3 = 0 ;

10561

int res3 = 0 ;

10562

PyObject * obj0 = 0 ;

10563

PyObject * obj1 = 0 ;

10564

PyObject * obj2 = 0 ;

10565

char * kwnames[] = {

10566

(char *) "self",(char *) "position",(char *) "style", NULL

10567

};

10568

10569

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_GetUncombinedStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10570

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10571

if (!SWIG_IsOK(res1)) {

10572

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetUncombinedStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10573

}

10574

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10575

ecode2 = SWIG_AsVal_long(obj1, &val2);

10576

if (!SWIG_IsOK(ecode2)) {

10577

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetUncombinedStyle" "', expected argument " "2"" of type '" "long""'");

10578

}

10579

arg2 = static_cast< long >(val2);

10580

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

10581

if (!SWIG_IsOK(res3)) {

10582

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_GetUncombinedStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

10583

}

10584

if (!argp3) {

10585

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_GetUncombinedStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

10586

}

10587

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

10588

{

10589

PyThreadState* __tstate = wxPyBeginAllowThreads();

10590

result = (bool)(arg1)->GetUncombinedStyle(arg2,*arg3);

10591

wxPyEndAllowThreads(__tstate);

10592

if (PyErr_Occurred()) SWIG_fail;

10593

}

10594

{

10595

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10596

}

10597

return resultobj;

10598

fail:

10599

return NULL;

10600

}

10601

10602

10603

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetStyleForRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10604

PyObject *resultobj = 0;

10605

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10606

wxRichTextRange *arg2 = 0 ;

10607

wxTextAttrEx *arg3 = 0 ;

10608

bool result;

10609

void *argp1 = 0 ;

10610

int res1 = 0 ;

10611

wxRichTextRange temp2 ;

10612

void *argp3 = 0 ;

10613

int res3 = 0 ;

10614

PyObject * obj0 = 0 ;

10615

PyObject * obj1 = 0 ;

10616

PyObject * obj2 = 0 ;

10617

char * kwnames[] = {

10618

(char *) "self",(char *) "range",(char *) "style", NULL

10619

};

10620

10621

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_GetStyleForRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10622

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10623

if (!SWIG_IsOK(res1)) {

10624

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetStyleForRange" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10625

}

10626

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10627

{

10628

arg2 = &temp2;

10629

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

10630

}

10631

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

10632

if (!SWIG_IsOK(res3)) {

10633

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_GetStyleForRange" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

10634

}

10635

if (!argp3) {

10636

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_GetStyleForRange" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

10637

}

10638

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

10639

{

10640

PyThreadState* __tstate = wxPyBeginAllowThreads();

10641

result = (bool)(arg1)->GetStyleForRange((wxRichTextRange const &)*arg2,*arg3);

10642

wxPyEndAllowThreads(__tstate);

10643

if (PyErr_Occurred()) SWIG_fail;

10644

}

10645

{

10646

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10647

}

10648

return resultobj;

10649

fail:

10650

return NULL;

10651

}

10652

10653

10654

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_CollectStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10655

PyObject *resultobj = 0;

10656

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10657

wxTextAttrEx *arg2 = 0 ;

10658

wxTextAttrEx *arg3 = 0 ;

10659

long *arg4 = 0 ;

10660

int *arg5 = 0 ;

10661

bool result;

10662

void *argp1 = 0 ;

10663

int res1 = 0 ;

10664

void *argp2 = 0 ;

10665

int res2 = 0 ;

10666

void *argp3 = 0 ;

10667

int res3 = 0 ;

10668

void *argp4 = 0 ;

10669

int res4 = 0 ;

10670

void *argp5 = 0 ;

10671

int res5 = 0 ;

10672

PyObject * obj0 = 0 ;

10673

PyObject * obj1 = 0 ;

10674

PyObject * obj2 = 0 ;

10675

PyObject * obj3 = 0 ;

10676

PyObject * obj4 = 0 ;

10677

char * kwnames[] = {

10678

(char *) "self",(char *) "currentStyle",(char *) "style",(char *) "multipleStyleAttributes",(char *) "multipleTextEffectAttributes", NULL

10679

};

10680

10681

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:RichTextParagraphLayoutBox_CollectStyle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

10682

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10683

if (!SWIG_IsOK(res1)) {

10684

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10685

}

10686

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10687

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 );

10688

if (!SWIG_IsOK(res2)) {

10689

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "2"" of type '" "wxTextAttrEx &""'");

10690

}

10691

if (!argp2) {

10692

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "2"" of type '" "wxTextAttrEx &""'");

10693

}

10694

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

10695

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

10696

if (!SWIG_IsOK(res3)) {

10697

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

10698

}

10699

if (!argp3) {

10700

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

10701

}

10702

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

10703

res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_long, 0 );

10704

if (!SWIG_IsOK(res4)) {

10705

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "4"" of type '" "long &""'");

10706

}

10707

if (!argp4) {

10708

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "4"" of type '" "long &""'");

10709

}

10710

arg4 = reinterpret_cast< long * >(argp4);

10711

res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int, 0 );

10712

if (!SWIG_IsOK(res5)) {

10713

SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "5"" of type '" "int &""'");

10714

}

10715

if (!argp5) {

10716

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_CollectStyle" "', expected argument " "5"" of type '" "int &""'");

10717

}

10718

arg5 = reinterpret_cast< int * >(argp5);

10719

{

10720

PyThreadState* __tstate = wxPyBeginAllowThreads();

10721

result = (bool)(arg1)->CollectStyle(*arg2,(wxTextAttrEx const &)*arg3,*arg4,*arg5);

10722

wxPyEndAllowThreads(__tstate);

10723

if (PyErr_Occurred()) SWIG_fail;

10724

}

10725

{

10726

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10727

}

10728

return resultobj;

10729

fail:

10730

return NULL;

10731

}

10732

10733

10734

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_SetListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10735

PyObject *resultobj = 0;

10736

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10737

wxRichTextRange *arg2 = 0 ;

10738

wxString *arg3 = 0 ;

10739

int arg4 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

10740

int arg5 = (int) 1 ;

10741

int arg6 = (int) -1 ;

10742

bool result;

10743

void *argp1 = 0 ;

10744

int res1 = 0 ;

10745

wxRichTextRange temp2 ;

10746

bool temp3 = false ;

10747

int val4 ;

10748

int ecode4 = 0 ;

10749

int val5 ;

10750

int ecode5 = 0 ;

10751

int val6 ;

10752

int ecode6 = 0 ;

10753

PyObject * obj0 = 0 ;

10754

PyObject * obj1 = 0 ;

10755

PyObject * obj2 = 0 ;

10756

PyObject * obj3 = 0 ;

10757

PyObject * obj4 = 0 ;

10758

PyObject * obj5 = 0 ;

10759

char * kwnames[] = {

10760

(char *) "self",(char *) "range",(char *) "defName",(char *) "flags",(char *) "startFrom",(char *) "specifiedLevel", NULL

10761

};

10762

10763

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:RichTextParagraphLayoutBox_SetListStyle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

10764

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10765

if (!SWIG_IsOK(res1)) {

10766

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_SetListStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10767

}

10768

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10769

{

10770

arg2 = &temp2;

10771

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

10772

}

10773

{

10774

arg3 = wxString_in_helper(obj2);

10775

if (arg3 == NULL) SWIG_fail;

10776

temp3 = true;

10777

}

10778

if (obj3) {

10779

ecode4 = SWIG_AsVal_int(obj3, &val4);

10780

if (!SWIG_IsOK(ecode4)) {

10781

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraphLayoutBox_SetListStyle" "', expected argument " "4"" of type '" "int""'");

10782

}

10783

arg4 = static_cast< int >(val4);

10784

}

10785

if (obj4) {

10786

ecode5 = SWIG_AsVal_int(obj4, &val5);

10787

if (!SWIG_IsOK(ecode5)) {

10788

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextParagraphLayoutBox_SetListStyle" "', expected argument " "5"" of type '" "int""'");

10789

}

10790

arg5 = static_cast< int >(val5);

10791

}

10792

if (obj5) {

10793

ecode6 = SWIG_AsVal_int(obj5, &val6);

10794

if (!SWIG_IsOK(ecode6)) {

10795

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextParagraphLayoutBox_SetListStyle" "', expected argument " "6"" of type '" "int""'");

10796

}

10797

arg6 = static_cast< int >(val6);

10798

}

10799

{

10800

PyThreadState* __tstate = wxPyBeginAllowThreads();

10801

result = (bool)(arg1)->SetListStyle((wxRichTextRange const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);

10802

wxPyEndAllowThreads(__tstate);

10803

if (PyErr_Occurred()) SWIG_fail;

10804

}

10805

{

10806

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10807

}

10808

{

10809

if (temp3)

10810

delete arg3;

10811

}

10812

return resultobj;

10813

fail:

10814

{

10815

if (temp3)

10816

delete arg3;

10817

}

10818

return NULL;

10819

}

10820

10821

10822

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_ClearListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10823

PyObject *resultobj = 0;

10824

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10825

wxRichTextRange *arg2 = 0 ;

10826

int arg3 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

10827

bool result;

10828

void *argp1 = 0 ;

10829

int res1 = 0 ;

10830

wxRichTextRange temp2 ;

10831

int val3 ;

10832

int ecode3 = 0 ;

10833

PyObject * obj0 = 0 ;

10834

PyObject * obj1 = 0 ;

10835

PyObject * obj2 = 0 ;

10836

char * kwnames[] = {

10837

(char *) "self",(char *) "range",(char *) "flags", NULL

10838

};

10839

10840

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraphLayoutBox_ClearListStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

10841

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10842

if (!SWIG_IsOK(res1)) {

10843

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_ClearListStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10844

}

10845

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10846

{

10847

arg2 = &temp2;

10848

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

10849

}

10850

if (obj2) {

10851

ecode3 = SWIG_AsVal_int(obj2, &val3);

10852

if (!SWIG_IsOK(ecode3)) {

10853

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextParagraphLayoutBox_ClearListStyle" "', expected argument " "3"" of type '" "int""'");

10854

}

10855

arg3 = static_cast< int >(val3);

10856

}

10857

{

10858

PyThreadState* __tstate = wxPyBeginAllowThreads();

10859

result = (bool)(arg1)->ClearListStyle((wxRichTextRange const &)*arg2,arg3);

10860

wxPyEndAllowThreads(__tstate);

10861

if (PyErr_Occurred()) SWIG_fail;

10862

}

10863

{

10864

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10865

}

10866

return resultobj;

10867

fail:

10868

return NULL;

10869

}

10870

10871

10872

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_NumberList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10873

PyObject *resultobj = 0;

10874

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10875

wxRichTextRange *arg2 = 0 ;

10876

wxString *arg3 = 0 ;

10877

int arg4 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

10878

int arg5 = (int) 1 ;

10879

int arg6 = (int) -1 ;

10880

bool result;

10881

void *argp1 = 0 ;

10882

int res1 = 0 ;

10883

wxRichTextRange temp2 ;

10884

bool temp3 = false ;

10885

int val4 ;

10886

int ecode4 = 0 ;

10887

int val5 ;

10888

int ecode5 = 0 ;

10889

int val6 ;

10890

int ecode6 = 0 ;

10891

PyObject * obj0 = 0 ;

10892

PyObject * obj1 = 0 ;

10893

PyObject * obj2 = 0 ;

10894

PyObject * obj3 = 0 ;

10895

PyObject * obj4 = 0 ;

10896

PyObject * obj5 = 0 ;

10897

char * kwnames[] = {

10898

(char *) "self",(char *) "range",(char *) "defName",(char *) "flags",(char *) "startFrom",(char *) "specifiedLevel", NULL

10899

};

10900

10901

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:RichTextParagraphLayoutBox_NumberList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

10902

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10903

if (!SWIG_IsOK(res1)) {

10904

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_NumberList" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10905

}

10906

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10907

{

10908

arg2 = &temp2;

10909

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

10910

}

10911

{

10912

arg3 = wxString_in_helper(obj2);

10913

if (arg3 == NULL) SWIG_fail;

10914

temp3 = true;

10915

}

10916

if (obj3) {

10917

ecode4 = SWIG_AsVal_int(obj3, &val4);

10918

if (!SWIG_IsOK(ecode4)) {

10919

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraphLayoutBox_NumberList" "', expected argument " "4"" of type '" "int""'");

10920

}

10921

arg4 = static_cast< int >(val4);

10922

}

10923

if (obj4) {

10924

ecode5 = SWIG_AsVal_int(obj4, &val5);

10925

if (!SWIG_IsOK(ecode5)) {

10926

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextParagraphLayoutBox_NumberList" "', expected argument " "5"" of type '" "int""'");

10927

}

10928

arg5 = static_cast< int >(val5);

10929

}

10930

if (obj5) {

10931

ecode6 = SWIG_AsVal_int(obj5, &val6);

10932

if (!SWIG_IsOK(ecode6)) {

10933

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextParagraphLayoutBox_NumberList" "', expected argument " "6"" of type '" "int""'");

10934

}

10935

arg6 = static_cast< int >(val6);

10936

}

10937

{

10938

PyThreadState* __tstate = wxPyBeginAllowThreads();

10939

result = (bool)(arg1)->NumberList((wxRichTextRange const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);

10940

wxPyEndAllowThreads(__tstate);

10941

if (PyErr_Occurred()) SWIG_fail;

10942

}

10943

{

10944

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

10945

}

10946

{

10947

if (temp3)

10948

delete arg3;

10949

}

10950

return resultobj;

10951

fail:

10952

{

10953

if (temp3)

10954

delete arg3;

10955

}

10956

return NULL;

10957

}

10958

10959

10960

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_PromoteList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

10961

PyObject *resultobj = 0;

10962

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

10963

int arg2 ;

10964

wxRichTextRange *arg3 = 0 ;

10965

wxString *arg4 = 0 ;

10966

int arg5 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

10967

int arg6 = (int) -1 ;

10968

bool result;

10969

void *argp1 = 0 ;

10970

int res1 = 0 ;

10971

int val2 ;

10972

int ecode2 = 0 ;

10973

wxRichTextRange temp3 ;

10974

bool temp4 = false ;

10975

int val5 ;

10976

int ecode5 = 0 ;

10977

int val6 ;

10978

int ecode6 = 0 ;

10979

PyObject * obj0 = 0 ;

10980

PyObject * obj1 = 0 ;

10981

PyObject * obj2 = 0 ;

10982

PyObject * obj3 = 0 ;

10983

PyObject * obj4 = 0 ;

10984

PyObject * obj5 = 0 ;

10985

char * kwnames[] = {

10986

(char *) "self",(char *) "promoteBy",(char *) "range",(char *) "defName",(char *) "flags",(char *) "specifiedLevel", NULL

10987

};

10988

10989

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:RichTextParagraphLayoutBox_PromoteList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

10990

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

10991

if (!SWIG_IsOK(res1)) {

10992

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_PromoteList" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

10993

}

10994

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

10995

ecode2 = SWIG_AsVal_int(obj1, &val2);

10996

if (!SWIG_IsOK(ecode2)) {

10997

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_PromoteList" "', expected argument " "2"" of type '" "int""'");

10998

}

10999

arg2 = static_cast< int >(val2);

11000

{

11001

arg3 = &temp3;

11002

if ( ! wxRichTextRange_helper(obj2, &arg3)) SWIG_fail;

11003

}

11004

{

11005

arg4 = wxString_in_helper(obj3);

11006

if (arg4 == NULL) SWIG_fail;

11007

temp4 = true;

11008

}

11009

if (obj4) {

11010

ecode5 = SWIG_AsVal_int(obj4, &val5);

11011

if (!SWIG_IsOK(ecode5)) {

11012

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextParagraphLayoutBox_PromoteList" "', expected argument " "5"" of type '" "int""'");

11013

}

11014

arg5 = static_cast< int >(val5);

11015

}

11016

if (obj5) {

11017

ecode6 = SWIG_AsVal_int(obj5, &val6);

11018

if (!SWIG_IsOK(ecode6)) {

11019

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextParagraphLayoutBox_PromoteList" "', expected argument " "6"" of type '" "int""'");

11020

}

11021

arg6 = static_cast< int >(val6);

11022

}

11023

{

11024

PyThreadState* __tstate = wxPyBeginAllowThreads();

11025

result = (bool)(arg1)->PromoteList(arg2,(wxRichTextRange const &)*arg3,(wxString const &)*arg4,arg5,arg6);

11026

wxPyEndAllowThreads(__tstate);

11027

if (PyErr_Occurred()) SWIG_fail;

11028

}

11029

{

11030

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11031

}

11032

{

11033

if (temp4)

11034

delete arg4;

11035

}

11036

return resultobj;

11037

fail:

11038

{

11039

if (temp4)

11040

delete arg4;

11041

}

11042

return NULL;

11043

}

11044

11045

11046

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_DoNumberList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11047

PyObject *resultobj = 0;

11048

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11049

wxRichTextRange *arg2 = 0 ;

11050

wxRichTextRange *arg3 = 0 ;

11051

int arg4 ;

11052

wxRichTextListStyleDefinition *arg5 = (wxRichTextListStyleDefinition *) 0 ;

11053

int arg6 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

11054

int arg7 = (int) 1 ;

11055

int arg8 = (int) -1 ;

11056

bool result;

11057

void *argp1 = 0 ;

11058

int res1 = 0 ;

11059

wxRichTextRange temp2 ;

11060

wxRichTextRange temp3 ;

11061

int val4 ;

11062

int ecode4 = 0 ;

11063

void *argp5 = 0 ;

11064

int res5 = 0 ;

11065

int val6 ;

11066

int ecode6 = 0 ;

11067

int val7 ;

11068

int ecode7 = 0 ;

11069

int val8 ;

11070

int ecode8 = 0 ;

11071

PyObject * obj0 = 0 ;

11072

PyObject * obj1 = 0 ;

11073

PyObject * obj2 = 0 ;

11074

PyObject * obj3 = 0 ;

11075

PyObject * obj4 = 0 ;

11076

PyObject * obj5 = 0 ;

11077

PyObject * obj6 = 0 ;

11078

PyObject * obj7 = 0 ;

11079

char * kwnames[] = {

11080

(char *) "self",(char *) "range",(char *) "promotionRange",(char *) "promoteBy",(char *) "def",(char *) "flags",(char *) "startFrom",(char *) "specifiedLevel", NULL

11081

};

11082

11083

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:RichTextParagraphLayoutBox_DoNumberList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;

11084

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11085

if (!SWIG_IsOK(res1)) {

11086

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_DoNumberList" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11087

}

11088

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11089

{

11090

arg2 = &temp2;

11091

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

11092

}

11093

{

11094

arg3 = &temp3;

11095

if ( ! wxRichTextRange_helper(obj2, &arg3)) SWIG_fail;

11096

}

11097

ecode4 = SWIG_AsVal_int(obj3, &val4);

11098

if (!SWIG_IsOK(ecode4)) {

11099

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraphLayoutBox_DoNumberList" "', expected argument " "4"" of type '" "int""'");

11100

}

11101

arg4 = static_cast< int >(val4);

11102

res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxRichTextListStyleDefinition, 0 | 0 );

11103

if (!SWIG_IsOK(res5)) {

11104

SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RichTextParagraphLayoutBox_DoNumberList" "', expected argument " "5"" of type '" "wxRichTextListStyleDefinition *""'");

11105

}

11106

arg5 = reinterpret_cast< wxRichTextListStyleDefinition * >(argp5);

11107

if (obj5) {

11108

ecode6 = SWIG_AsVal_int(obj5, &val6);

11109

if (!SWIG_IsOK(ecode6)) {

11110

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextParagraphLayoutBox_DoNumberList" "', expected argument " "6"" of type '" "int""'");

11111

}

11112

arg6 = static_cast< int >(val6);

11113

}

11114

if (obj6) {

11115

ecode7 = SWIG_AsVal_int(obj6, &val7);

11116

if (!SWIG_IsOK(ecode7)) {

11117

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RichTextParagraphLayoutBox_DoNumberList" "', expected argument " "7"" of type '" "int""'");

11118

}

11119

arg7 = static_cast< int >(val7);

11120

}

11121

if (obj7) {

11122

ecode8 = SWIG_AsVal_int(obj7, &val8);

11123

if (!SWIG_IsOK(ecode8)) {

11124

SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "RichTextParagraphLayoutBox_DoNumberList" "', expected argument " "8"" of type '" "int""'");

11125

}

11126

arg8 = static_cast< int >(val8);

11127

}

11128

{

11129

PyThreadState* __tstate = wxPyBeginAllowThreads();

11130

result = (bool)(arg1)->DoNumberList((wxRichTextRange const &)*arg2,(wxRichTextRange const &)*arg3,arg4,arg5,arg6,arg7,arg8);

11131

wxPyEndAllowThreads(__tstate);

11132

if (PyErr_Occurred()) SWIG_fail;

11133

}

11134

{

11135

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11136

}

11137

return resultobj;

11138

fail:

11139

return NULL;

11140

}

11141

11142

11143

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_FindNextParagraphNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11144

PyObject *resultobj = 0;

11145

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11146

wxRichTextParagraph *arg2 = (wxRichTextParagraph *) 0 ;

11147

wxTextAttrEx *arg3 = 0 ;

11148

bool result;

11149

void *argp1 = 0 ;

11150

int res1 = 0 ;

11151

void *argp2 = 0 ;

11152

int res2 = 0 ;

11153

void *argp3 = 0 ;

11154

int res3 = 0 ;

11155

PyObject * obj0 = 0 ;

11156

PyObject * obj1 = 0 ;

11157

PyObject * obj2 = 0 ;

11158

char * kwnames[] = {

11159

(char *) "self",(char *) "previousParagraph",(char *) "attr", NULL

11160

};

11161

11162

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_FindNextParagraphNumber",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11163

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11164

if (!SWIG_IsOK(res1)) {

11165

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_FindNextParagraphNumber" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11166

}

11167

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11168

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

11169

if (!SWIG_IsOK(res2)) {

11170

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_FindNextParagraphNumber" "', expected argument " "2"" of type '" "wxRichTextParagraph *""'");

11171

}

11172

arg2 = reinterpret_cast< wxRichTextParagraph * >(argp2);

11173

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

11174

if (!SWIG_IsOK(res3)) {

11175

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_FindNextParagraphNumber" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

11176

}

11177

if (!argp3) {

11178

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_FindNextParagraphNumber" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

11179

}

11180

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

11181

{

11182

PyThreadState* __tstate = wxPyBeginAllowThreads();

11183

result = (bool)wxRichTextParagraphLayoutBox_FindNextParagraphNumber((wxRichTextParagraphLayoutBox const *)arg1,arg2,*arg3);

11184

wxPyEndAllowThreads(__tstate);

11185

if (PyErr_Occurred()) SWIG_fail;

11186

}

11187

{

11188

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11189

}

11190

return resultobj;

11191

fail:

11192

return NULL;

11193

}

11194

11195

11196

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_HasCharacterAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11197

PyObject *resultobj = 0;

11198

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11199

wxRichTextRange *arg2 = 0 ;

11200

wxTextAttrEx *arg3 = 0 ;

11201

bool result;

11202

void *argp1 = 0 ;

11203

int res1 = 0 ;

11204

wxRichTextRange temp2 ;

11205

void *argp3 = 0 ;

11206

int res3 = 0 ;

11207

PyObject * obj0 = 0 ;

11208

PyObject * obj1 = 0 ;

11209

PyObject * obj2 = 0 ;

11210

char * kwnames[] = {

11211

(char *) "self",(char *) "range",(char *) "style", NULL

11212

};

11213

11214

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_HasCharacterAttributes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11215

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11216

if (!SWIG_IsOK(res1)) {

11217

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_HasCharacterAttributes" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11218

}

11219

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11220

{

11221

arg2 = &temp2;

11222

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

11223

}

11224

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

11225

if (!SWIG_IsOK(res3)) {

11226

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_HasCharacterAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

11227

}

11228

if (!argp3) {

11229

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_HasCharacterAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

11230

}

11231

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

11232

{

11233

PyThreadState* __tstate = wxPyBeginAllowThreads();

11234

result = (bool)((wxRichTextParagraphLayoutBox const *)arg1)->HasCharacterAttributes((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3);

11235

wxPyEndAllowThreads(__tstate);

11236

if (PyErr_Occurred()) SWIG_fail;

11237

}

11238

{

11239

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11240

}

11241

return resultobj;

11242

fail:

11243

return NULL;

11244

}

11245

11246

11247

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_HasParagraphAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11248

PyObject *resultobj = 0;

11249

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11250

wxRichTextRange *arg2 = 0 ;

11251

wxTextAttrEx *arg3 = 0 ;

11252

bool result;

11253

void *argp1 = 0 ;

11254

int res1 = 0 ;

11255

wxRichTextRange temp2 ;

11256

void *argp3 = 0 ;

11257

int res3 = 0 ;

11258

PyObject * obj0 = 0 ;

11259

PyObject * obj1 = 0 ;

11260

PyObject * obj2 = 0 ;

11261

char * kwnames[] = {

11262

(char *) "self",(char *) "range",(char *) "style", NULL

11263

};

11264

11265

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_HasParagraphAttributes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11266

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11267

if (!SWIG_IsOK(res1)) {

11268

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_HasParagraphAttributes" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11269

}

11270

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11271

{

11272

arg2 = &temp2;

11273

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

11274

}

11275

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

11276

if (!SWIG_IsOK(res3)) {

11277

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_HasParagraphAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

11278

}

11279

if (!argp3) {

11280

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_HasParagraphAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

11281

}

11282

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

11283

{

11284

PyThreadState* __tstate = wxPyBeginAllowThreads();

11285

result = (bool)((wxRichTextParagraphLayoutBox const *)arg1)->HasParagraphAttributes((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3);

11286

wxPyEndAllowThreads(__tstate);

11287

if (PyErr_Occurred()) SWIG_fail;

11288

}

11289

{

11290

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11291

}

11292

return resultobj;

11293

fail:

11294

return NULL;

11295

}

11296

11297

11298

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_InsertFragment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11299

PyObject *resultobj = 0;

11300

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11301

long arg2 ;

11302

wxRichTextParagraphLayoutBox *arg3 = 0 ;

11303

bool result;

11304

void *argp1 = 0 ;

11305

int res1 = 0 ;

11306

long val2 ;

11307

int ecode2 = 0 ;

11308

void *argp3 = 0 ;

11309

int res3 = 0 ;

11310

PyObject * obj0 = 0 ;

11311

PyObject * obj1 = 0 ;

11312

PyObject * obj2 = 0 ;

11313

char * kwnames[] = {

11314

(char *) "self",(char *) "position",(char *) "fragment", NULL

11315

};

11316

11317

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_InsertFragment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11318

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11319

if (!SWIG_IsOK(res1)) {

11320

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_InsertFragment" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11321

}

11322

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11323

ecode2 = SWIG_AsVal_long(obj1, &val2);

11324

if (!SWIG_IsOK(ecode2)) {

11325

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_InsertFragment" "', expected argument " "2"" of type '" "long""'");

11326

}

11327

arg2 = static_cast< long >(val2);

11328

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 );

11329

if (!SWIG_IsOK(res3)) {

11330

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_InsertFragment" "', expected argument " "3"" of type '" "wxRichTextParagraphLayoutBox &""'");

11331

}

11332

if (!argp3) {

11333

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_InsertFragment" "', expected argument " "3"" of type '" "wxRichTextParagraphLayoutBox &""'");

11334

}

11335

arg3 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp3);

11336

{

11337

PyThreadState* __tstate = wxPyBeginAllowThreads();

11338

result = (bool)(arg1)->InsertFragment(arg2,*arg3);

11339

wxPyEndAllowThreads(__tstate);

11340

if (PyErr_Occurred()) SWIG_fail;

11341

}

11342

{

11343

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11344

}

11345

return resultobj;

11346

fail:

11347

return NULL;

11348

}

11349

11350

11351

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_CopyFragment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11352

PyObject *resultobj = 0;

11353

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11354

wxRichTextRange *arg2 = 0 ;

11355

wxRichTextParagraphLayoutBox *arg3 = 0 ;

11356

bool result;

11357

void *argp1 = 0 ;

11358

int res1 = 0 ;

11359

wxRichTextRange temp2 ;

11360

void *argp3 = 0 ;

11361

int res3 = 0 ;

11362

PyObject * obj0 = 0 ;

11363

PyObject * obj1 = 0 ;

11364

PyObject * obj2 = 0 ;

11365

char * kwnames[] = {

11366

(char *) "self",(char *) "range",(char *) "fragment", NULL

11367

};

11368

11369

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraphLayoutBox_CopyFragment",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

11370

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11371

if (!SWIG_IsOK(res1)) {

11372

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_CopyFragment" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11373

}

11374

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11375

{

11376

arg2 = &temp2;

11377

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

11378

}

11379

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 );

11380

if (!SWIG_IsOK(res3)) {

11381

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraphLayoutBox_CopyFragment" "', expected argument " "3"" of type '" "wxRichTextParagraphLayoutBox &""'");

11382

}

11383

if (!argp3) {

11384

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_CopyFragment" "', expected argument " "3"" of type '" "wxRichTextParagraphLayoutBox &""'");

11385

}

11386

arg3 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp3);

11387

{

11388

PyThreadState* __tstate = wxPyBeginAllowThreads();

11389

result = (bool)(arg1)->CopyFragment((wxRichTextRange const &)*arg2,*arg3);

11390

wxPyEndAllowThreads(__tstate);

11391

if (PyErr_Occurred()) SWIG_fail;

11392

}

11393

{

11394

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11395

}

11396

return resultobj;

11397

fail:

11398

return NULL;

11399

}

11400

11401

11402

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_ApplyStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11403

PyObject *resultobj = 0;

11404

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11405

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

11406

bool result;

11407

void *argp1 = 0 ;

11408

int res1 = 0 ;

11409

void *argp2 = 0 ;

11410

int res2 = 0 ;

11411

PyObject * obj0 = 0 ;

11412

PyObject * obj1 = 0 ;

11413

char * kwnames[] = {

11414

(char *) "self",(char *) "styleSheet", NULL

11415

};

11416

11417

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_ApplyStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

11418

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11419

if (!SWIG_IsOK(res1)) {

11420

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_ApplyStyleSheet" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11421

}

11422

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11423

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

11424

if (!SWIG_IsOK(res2)) {

11425

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_ApplyStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

11426

}

11427

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

11428

{

11429

PyThreadState* __tstate = wxPyBeginAllowThreads();

11430

result = (bool)(arg1)->ApplyStyleSheet(arg2);

11431

wxPyEndAllowThreads(__tstate);

11432

if (PyErr_Occurred()) SWIG_fail;

11433

}

11434

{

11435

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11436

}

11437

return resultobj;

11438

fail:

11439

return NULL;

11440

}

11441

11442

11443

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11444

PyObject *resultobj = 0;

11445

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11446

wxRichTextParagraphLayoutBox *arg2 = 0 ;

11447

void *argp1 = 0 ;

11448

int res1 = 0 ;

11449

void *argp2 = 0 ;

11450

int res2 = 0 ;

11451

PyObject * obj0 = 0 ;

11452

PyObject * obj1 = 0 ;

11453

char * kwnames[] = {

11454

(char *) "self",(char *) "obj", NULL

11455

};

11456

11457

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

11458

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11459

if (!SWIG_IsOK(res1)) {

11460

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_Copy" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11461

}

11462

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11463

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0);

11464

if (!SWIG_IsOK(res2)) {

11465

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_Copy" "', expected argument " "2"" of type '" "wxRichTextParagraphLayoutBox const &""'");

11466

}

11467

if (!argp2) {

11468

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_Copy" "', expected argument " "2"" of type '" "wxRichTextParagraphLayoutBox const &""'");

11469

}

11470

arg2 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp2);

11471

{

11472

PyThreadState* __tstate = wxPyBeginAllowThreads();

11473

(arg1)->Copy((wxRichTextParagraphLayoutBox const &)*arg2);

11474

wxPyEndAllowThreads(__tstate);

11475

if (PyErr_Occurred()) SWIG_fail;

11476

}

11477

resultobj = SWIG_Py_Void();

11478

return resultobj;

11479

fail:

11480

return NULL;

11481

}

11482

11483

11484

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_UpdateRanges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11485

PyObject *resultobj = 0;

11486

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11487

void *argp1 = 0 ;

11488

int res1 = 0 ;

11489

PyObject *swig_obj[1] ;

11490

11491

if (!args) SWIG_fail;

11492

swig_obj[0] = args;

11493

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11494

if (!SWIG_IsOK(res1)) {

11495

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_UpdateRanges" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11496

}

11497

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11498

{

11499

PyThreadState* __tstate = wxPyBeginAllowThreads();

11500

(arg1)->UpdateRanges();

11501

wxPyEndAllowThreads(__tstate);

11502

if (PyErr_Occurred()) SWIG_fail;

11503

}

11504

resultobj = SWIG_Py_Void();

11505

return resultobj;

11506

fail:

11507

return NULL;

11508

}

11509

11510

11511

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11512

PyObject *resultobj = 0;

11513

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11514

wxString result;

11515

void *argp1 = 0 ;

11516

int res1 = 0 ;

11517

PyObject *swig_obj[1] ;

11518

11519

if (!args) SWIG_fail;

11520

swig_obj[0] = args;

11521

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11522

if (!SWIG_IsOK(res1)) {

11523

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetText" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11524

}

11525

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11526

{

11527

PyThreadState* __tstate = wxPyBeginAllowThreads();

11528

result = ((wxRichTextParagraphLayoutBox const *)arg1)->GetText();

11529

wxPyEndAllowThreads(__tstate);

11530

if (PyErr_Occurred()) SWIG_fail;

11531

}

11532

{

11533

#if wxUSE_UNICODE

11534

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

11535

#else

11536

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

11537

#endif

11538

}

11539

return resultobj;

11540

fail:

11541

return NULL;

11542

}

11543

11544

11545

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_SetDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11546

PyObject *resultobj = 0;

11547

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11548

wxTextAttrEx *arg2 = 0 ;

11549

bool result;

11550

void *argp1 = 0 ;

11551

int res1 = 0 ;

11552

void *argp2 = 0 ;

11553

int res2 = 0 ;

11554

PyObject * obj0 = 0 ;

11555

PyObject * obj1 = 0 ;

11556

char * kwnames[] = {

11557

(char *) "self",(char *) "style", NULL

11558

};

11559

11560

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_SetDefaultStyle",kwnames,&obj0,&obj1)) SWIG_fail;

11561

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11562

if (!SWIG_IsOK(res1)) {

11563

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_SetDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11564

}

11565

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11566

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

11567

if (!SWIG_IsOK(res2)) {

11568

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_SetDefaultStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

11569

}

11570

if (!argp2) {

11571

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_SetDefaultStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

11572

}

11573

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

11574

{

11575

PyThreadState* __tstate = wxPyBeginAllowThreads();

11576

result = (bool)(arg1)->SetDefaultStyle((wxTextAttrEx const &)*arg2);

11577

wxPyEndAllowThreads(__tstate);

11578

if (PyErr_Occurred()) SWIG_fail;

11579

}

11580

{

11581

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

11582

}

11583

return resultobj;

11584

fail:

11585

return NULL;

11586

}

11587

11588

11589

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11590

PyObject *resultobj = 0;

11591

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11592

wxTextAttrEx *result = 0 ;

11593

void *argp1 = 0 ;

11594

int res1 = 0 ;

11595

PyObject *swig_obj[1] ;

11596

11597

if (!args) SWIG_fail;

11598

swig_obj[0] = args;

11599

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11600

if (!SWIG_IsOK(res1)) {

11601

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11602

}

11603

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11604

{

11605

PyThreadState* __tstate = wxPyBeginAllowThreads();

11606

{

11607

wxTextAttrEx const &_result_ref = ((wxRichTextParagraphLayoutBox const *)arg1)->GetDefaultStyle();

11608

result = (wxTextAttrEx *) &_result_ref;

11609

}

11610

wxPyEndAllowThreads(__tstate);

11611

if (PyErr_Occurred()) SWIG_fail;

11612

}

11613

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

11614

return resultobj;

11615

fail:

11616

return NULL;

11617

}

11618

11619

11620

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_SetBasicStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11621

PyObject *resultobj = 0;

11622

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11623

wxTextAttrEx *arg2 = 0 ;

11624

void *argp1 = 0 ;

11625

int res1 = 0 ;

11626

void *argp2 = 0 ;

11627

int res2 = 0 ;

11628

PyObject * obj0 = 0 ;

11629

PyObject * obj1 = 0 ;

11630

char * kwnames[] = {

11631

(char *) "self",(char *) "style", NULL

11632

};

11633

11634

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraphLayoutBox_SetBasicStyle",kwnames,&obj0,&obj1)) SWIG_fail;

11635

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11636

if (!SWIG_IsOK(res1)) {

11637

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_SetBasicStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11638

}

11639

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11640

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

11641

if (!SWIG_IsOK(res2)) {

11642

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraphLayoutBox_SetBasicStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

11643

}

11644

if (!argp2) {

11645

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraphLayoutBox_SetBasicStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

11646

}

11647

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

11648

{

11649

PyThreadState* __tstate = wxPyBeginAllowThreads();

11650

(arg1)->SetBasicStyle((wxTextAttrEx const &)*arg2);

11651

wxPyEndAllowThreads(__tstate);

11652

if (PyErr_Occurred()) SWIG_fail;

11653

}

11654

resultobj = SWIG_Py_Void();

11655

return resultobj;

11656

fail:

11657

return NULL;

11658

}

11659

11660

11661

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetBasicStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11662

PyObject *resultobj = 0;

11663

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11664

wxTextAttrEx *result = 0 ;

11665

void *argp1 = 0 ;

11666

int res1 = 0 ;

11667

PyObject *swig_obj[1] ;

11668

11669

if (!args) SWIG_fail;

11670

swig_obj[0] = args;

11671

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11672

if (!SWIG_IsOK(res1)) {

11673

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetBasicStyle" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11674

}

11675

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11676

{

11677

PyThreadState* __tstate = wxPyBeginAllowThreads();

11678

{

11679

wxTextAttrEx const &_result_ref = ((wxRichTextParagraphLayoutBox const *)arg1)->GetBasicStyle();

11680

result = (wxTextAttrEx *) &_result_ref;

11681

}

11682

wxPyEndAllowThreads(__tstate);

11683

if (PyErr_Occurred()) SWIG_fail;

11684

}

11685

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

11686

return resultobj;

11687

fail:

11688

return NULL;

11689

}

11690

11691

11692

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_Invalidate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11693

PyObject *resultobj = 0;

11694

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11695

wxRichTextRange const &arg2_defvalue = wxRICHTEXT_ALL ;

11696

wxRichTextRange *arg2 = (wxRichTextRange *) &arg2_defvalue ;

11697

void *argp1 = 0 ;

11698

int res1 = 0 ;

11699

wxRichTextRange temp2 ;

11700

PyObject * obj0 = 0 ;

11701

PyObject * obj1 = 0 ;

11702

char * kwnames[] = {

11703

(char *) "self",(char *) "invalidRange", NULL

11704

};

11705

11706

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextParagraphLayoutBox_Invalidate",kwnames,&obj0,&obj1)) SWIG_fail;

11707

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11708

if (!SWIG_IsOK(res1)) {

11709

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_Invalidate" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox *""'");

11710

}

11711

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11712

if (obj1) {

11713

{

11714

arg2 = &temp2;

11715

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

11716

}

11717

}

11718

{

11719

PyThreadState* __tstate = wxPyBeginAllowThreads();

11720

(arg1)->Invalidate((wxRichTextRange const &)*arg2);

11721

wxPyEndAllowThreads(__tstate);

11722

if (PyErr_Occurred()) SWIG_fail;

11723

}

11724

resultobj = SWIG_Py_Void();

11725

return resultobj;

11726

fail:

11727

return NULL;

11728

}

11729

11730

11731

SWIGINTERN PyObject *_wrap_RichTextParagraphLayoutBox_GetInvalidRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11732

PyObject *resultobj = 0;

11733

wxRichTextParagraphLayoutBox *arg1 = (wxRichTextParagraphLayoutBox *) 0 ;

11734

bool arg2 = (bool) false ;

11735

wxRichTextRange result;

11736

void *argp1 = 0 ;

11737

int res1 = 0 ;

11738

bool val2 ;

11739

int ecode2 = 0 ;

11740

PyObject * obj0 = 0 ;

11741

PyObject * obj1 = 0 ;

11742

char * kwnames[] = {

11743

(char *) "self",(char *) "wholeParagraphs", NULL

11744

};

11745

11746

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextParagraphLayoutBox_GetInvalidRange",kwnames,&obj0,&obj1)) SWIG_fail;

11747

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0 );

11748

if (!SWIG_IsOK(res1)) {

11749

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraphLayoutBox_GetInvalidRange" "', expected argument " "1"" of type '" "wxRichTextParagraphLayoutBox const *""'");

11750

}

11751

arg1 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp1);

11752

if (obj1) {

11753

ecode2 = SWIG_AsVal_bool(obj1, &val2);

11754

if (!SWIG_IsOK(ecode2)) {

11755

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraphLayoutBox_GetInvalidRange" "', expected argument " "2"" of type '" "bool""'");

11756

}

11757

arg2 = static_cast< bool >(val2);

11758

}

11759

{

11760

PyThreadState* __tstate = wxPyBeginAllowThreads();

11761

result = ((wxRichTextParagraphLayoutBox const *)arg1)->GetInvalidRange(arg2);

11762

wxPyEndAllowThreads(__tstate);

11763

if (PyErr_Occurred()) SWIG_fail;

11764

}

11765

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

11766

return resultobj;

11767

fail:

11768

return NULL;

11769

}

11770

11771

11772

SWIGINTERN PyObject *RichTextParagraphLayoutBox_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11773

PyObject *obj;

11774

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

11775

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextParagraphLayoutBox, SWIG_NewClientData(obj));

11776

return SWIG_Py_Void();

11777

}

11778

11779

SWIGINTERN PyObject *RichTextParagraphLayoutBox_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11780

return SWIG_Python_InitShadowInstance(args);

11781

}

11782

11783

SWIGINTERN PyObject *_wrap_new_RichTextLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11784

PyObject *resultobj = 0;

11785

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

11786

wxRichTextLine *result = 0 ;

11787

void *argp1 = 0 ;

11788

int res1 = 0 ;

11789

PyObject * obj0 = 0 ;

11790

char * kwnames[] = {

11791

(char *) "parent", NULL

11792

};

11793

11794

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RichTextLine",kwnames,&obj0)) SWIG_fail;

11795

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

11796

if (!SWIG_IsOK(res1)) {

11797

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RichTextLine" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

11798

}

11799

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

11800

{

11801

PyThreadState* __tstate = wxPyBeginAllowThreads();

11802

result = (wxRichTextLine *)new wxRichTextLine(arg1);

11803

wxPyEndAllowThreads(__tstate);

11804

if (PyErr_Occurred()) SWIG_fail;

11805

}

11806

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, SWIG_POINTER_NEW | 0 );

11807

return resultobj;

11808

fail:

11809

return NULL;

11810

}

11811

11812

11813

SWIGINTERN PyObject *_wrap_delete_RichTextLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11814

PyObject *resultobj = 0;

11815

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11816

void *argp1 = 0 ;

11817

int res1 = 0 ;

11818

PyObject *swig_obj[1] ;

11819

11820

if (!args) SWIG_fail;

11821

swig_obj[0] = args;

11822

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, SWIG_POINTER_DISOWN | 0 );

11823

if (!SWIG_IsOK(res1)) {

11824

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextLine" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

11825

}

11826

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

11827

{

11828

PyThreadState* __tstate = wxPyBeginAllowThreads();

11829

delete arg1;

11830

11831

wxPyEndAllowThreads(__tstate);

11832

if (PyErr_Occurred()) SWIG_fail;

11833

}

11834

resultobj = SWIG_Py_Void();

11835

return resultobj;

11836

fail:

11837

return NULL;

11838

}

11839

11840

11841

SWIGINTERN PyObject *_wrap_RichTextLine_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11842

PyObject *resultobj = 0;

11843

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11844

wxRichTextRange *arg2 = 0 ;

11845

void *argp1 = 0 ;

11846

int res1 = 0 ;

11847

wxRichTextRange temp2 ;

11848

PyObject * obj0 = 0 ;

11849

PyObject * obj1 = 0 ;

11850

char * kwnames[] = {

11851

(char *) "self",(char *) "range", NULL

11852

};

11853

11854

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextLine_SetRange",kwnames,&obj0,&obj1)) SWIG_fail;

11855

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

11856

if (!SWIG_IsOK(res1)) {

11857

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_SetRange" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

11858

}

11859

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

11860

{

11861

arg2 = &temp2;

11862

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

11863

}

11864

{

11865

PyThreadState* __tstate = wxPyBeginAllowThreads();

11866

(arg1)->SetRange((wxRichTextRange const &)*arg2);

11867

wxPyEndAllowThreads(__tstate);

11868

if (PyErr_Occurred()) SWIG_fail;

11869

}

11870

resultobj = SWIG_Py_Void();

11871

return resultobj;

11872

fail:

11873

return NULL;

11874

}

11875

11876

11877

SWIGINTERN PyObject *_wrap_RichTextLine_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11878

PyObject *resultobj = 0;

11879

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11880

wxRichTextParagraph *result = 0 ;

11881

void *argp1 = 0 ;

11882

int res1 = 0 ;

11883

PyObject *swig_obj[1] ;

11884

11885

if (!args) SWIG_fail;

11886

swig_obj[0] = args;

11887

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

11888

if (!SWIG_IsOK(res1)) {

11889

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetParent" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

11890

}

11891

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

11892

{

11893

PyThreadState* __tstate = wxPyBeginAllowThreads();

11894

result = (wxRichTextParagraph *)(arg1)->GetParent();

11895

wxPyEndAllowThreads(__tstate);

11896

if (PyErr_Occurred()) SWIG_fail;

11897

}

11898

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

11899

return resultobj;

11900

fail:

11901

return NULL;

11902

}

11903

11904

11905

SWIGINTERN PyObject *_wrap_RichTextLine_GetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11906

PyObject *resultobj = 0;

11907

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11908

wxRichTextRange result;

11909

void *argp1 = 0 ;

11910

int res1 = 0 ;

11911

PyObject *swig_obj[1] ;

11912

11913

if (!args) SWIG_fail;

11914

swig_obj[0] = args;

11915

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

11916

if (!SWIG_IsOK(res1)) {

11917

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetRange" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

11918

}

11919

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

11920

{

11921

PyThreadState* __tstate = wxPyBeginAllowThreads();

11922

result = (arg1)->GetRange();

11923

wxPyEndAllowThreads(__tstate);

11924

if (PyErr_Occurred()) SWIG_fail;

11925

}

11926

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

11927

return resultobj;

11928

fail:

11929

return NULL;

11930

}

11931

11932

11933

SWIGINTERN PyObject *_wrap_RichTextLine_GetAbsoluteRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11934

PyObject *resultobj = 0;

11935

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11936

wxRichTextRange result;

11937

void *argp1 = 0 ;

11938

int res1 = 0 ;

11939

PyObject *swig_obj[1] ;

11940

11941

if (!args) SWIG_fail;

11942

swig_obj[0] = args;

11943

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

11944

if (!SWIG_IsOK(res1)) {

11945

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetAbsoluteRange" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

11946

}

11947

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

11948

{

11949

PyThreadState* __tstate = wxPyBeginAllowThreads();

11950

result = ((wxRichTextLine const *)arg1)->GetAbsoluteRange();

11951

wxPyEndAllowThreads(__tstate);

11952

if (PyErr_Occurred()) SWIG_fail;

11953

}

11954

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

11955

return resultobj;

11956

fail:

11957

return NULL;

11958

}

11959

11960

11961

SWIGINTERN PyObject *_wrap_RichTextLine_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

11962

PyObject *resultobj = 0;

11963

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11964

wxSize result;

11965

void *argp1 = 0 ;

11966

int res1 = 0 ;

11967

PyObject *swig_obj[1] ;

11968

11969

if (!args) SWIG_fail;

11970

swig_obj[0] = args;

11971

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

11972

if (!SWIG_IsOK(res1)) {

11973

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetSize" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

11974

}

11975

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

11976

{

11977

PyThreadState* __tstate = wxPyBeginAllowThreads();

11978

result = ((wxRichTextLine const *)arg1)->GetSize();

11979

wxPyEndAllowThreads(__tstate);

11980

if (PyErr_Occurred()) SWIG_fail;

11981

}

11982

resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );

11983

return resultobj;

11984

fail:

11985

return NULL;

11986

}

11987

11988

11989

SWIGINTERN PyObject *_wrap_RichTextLine_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

11990

PyObject *resultobj = 0;

11991

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

11992

wxSize *arg2 = 0 ;

11993

void *argp1 = 0 ;

11994

int res1 = 0 ;

11995

wxSize temp2 ;

11996

PyObject * obj0 = 0 ;

11997

PyObject * obj1 = 0 ;

11998

char * kwnames[] = {

11999

(char *) "self",(char *) "sz", NULL

12000

};

12001

12002

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextLine_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;

12003

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12004

if (!SWIG_IsOK(res1)) {

12005

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_SetSize" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

12006

}

12007

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12008

{

12009

arg2 = &temp2;

12010

if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;

12011

}

12012

{

12013

PyThreadState* __tstate = wxPyBeginAllowThreads();

12014

(arg1)->SetSize((wxSize const &)*arg2);

12015

wxPyEndAllowThreads(__tstate);

12016

if (PyErr_Occurred()) SWIG_fail;

12017

}

12018

resultobj = SWIG_Py_Void();

12019

return resultobj;

12020

fail:

12021

return NULL;

12022

}

12023

12024

12025

SWIGINTERN PyObject *_wrap_RichTextLine_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12026

PyObject *resultobj = 0;

12027

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12028

wxPoint result;

12029

void *argp1 = 0 ;

12030

int res1 = 0 ;

12031

PyObject *swig_obj[1] ;

12032

12033

if (!args) SWIG_fail;

12034

swig_obj[0] = args;

12035

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12036

if (!SWIG_IsOK(res1)) {

12037

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetPosition" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

12038

}

12039

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12040

{

12041

PyThreadState* __tstate = wxPyBeginAllowThreads();

12042

result = ((wxRichTextLine const *)arg1)->GetPosition();

12043

wxPyEndAllowThreads(__tstate);

12044

if (PyErr_Occurred()) SWIG_fail;

12045

}

12046

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

12047

return resultobj;

12048

fail:

12049

return NULL;

12050

}

12051

12052

12053

SWIGINTERN PyObject *_wrap_RichTextLine_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12054

PyObject *resultobj = 0;

12055

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12056

wxPoint *arg2 = 0 ;

12057

void *argp1 = 0 ;

12058

int res1 = 0 ;

12059

wxPoint temp2 ;

12060

PyObject * obj0 = 0 ;

12061

PyObject * obj1 = 0 ;

12062

char * kwnames[] = {

12063

(char *) "self",(char *) "pos", NULL

12064

};

12065

12066

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextLine_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;

12067

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12068

if (!SWIG_IsOK(res1)) {

12069

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_SetPosition" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

12070

}

12071

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12072

{

12073

arg2 = &temp2;

12074

if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;

12075

}

12076

{

12077

PyThreadState* __tstate = wxPyBeginAllowThreads();

12078

(arg1)->SetPosition((wxPoint const &)*arg2);

12079

wxPyEndAllowThreads(__tstate);

12080

if (PyErr_Occurred()) SWIG_fail;

12081

}

12082

resultobj = SWIG_Py_Void();

12083

return resultobj;

12084

fail:

12085

return NULL;

12086

}

12087

12088

12089

SWIGINTERN PyObject *_wrap_RichTextLine_GetAbsolutePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12090

PyObject *resultobj = 0;

12091

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12092

wxPoint result;

12093

void *argp1 = 0 ;

12094

int res1 = 0 ;

12095

PyObject *swig_obj[1] ;

12096

12097

if (!args) SWIG_fail;

12098

swig_obj[0] = args;

12099

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12100

if (!SWIG_IsOK(res1)) {

12101

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetAbsolutePosition" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

12102

}

12103

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12104

{

12105

PyThreadState* __tstate = wxPyBeginAllowThreads();

12106

result = ((wxRichTextLine const *)arg1)->GetAbsolutePosition();

12107

wxPyEndAllowThreads(__tstate);

12108

if (PyErr_Occurred()) SWIG_fail;

12109

}

12110

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

12111

return resultobj;

12112

fail:

12113

return NULL;

12114

}

12115

12116

12117

SWIGINTERN PyObject *_wrap_RichTextLine_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12118

PyObject *resultobj = 0;

12119

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12120

wxRect result;

12121

void *argp1 = 0 ;

12122

int res1 = 0 ;

12123

PyObject *swig_obj[1] ;

12124

12125

if (!args) SWIG_fail;

12126

swig_obj[0] = args;

12127

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12128

if (!SWIG_IsOK(res1)) {

12129

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetRect" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

12130

}

12131

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12132

{

12133

PyThreadState* __tstate = wxPyBeginAllowThreads();

12134

result = ((wxRichTextLine const *)arg1)->GetRect();

12135

wxPyEndAllowThreads(__tstate);

12136

if (PyErr_Occurred()) SWIG_fail;

12137

}

12138

resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );

12139

return resultobj;

12140

fail:

12141

return NULL;

12142

}

12143

12144

12145

SWIGINTERN PyObject *_wrap_RichTextLine_SetDescent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12146

PyObject *resultobj = 0;

12147

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12148

int arg2 ;

12149

void *argp1 = 0 ;

12150

int res1 = 0 ;

12151

int val2 ;

12152

int ecode2 = 0 ;

12153

PyObject * obj0 = 0 ;

12154

PyObject * obj1 = 0 ;

12155

char * kwnames[] = {

12156

(char *) "self",(char *) "descent", NULL

12157

};

12158

12159

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextLine_SetDescent",kwnames,&obj0,&obj1)) SWIG_fail;

12160

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12161

if (!SWIG_IsOK(res1)) {

12162

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_SetDescent" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

12163

}

12164

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12165

ecode2 = SWIG_AsVal_int(obj1, &val2);

12166

if (!SWIG_IsOK(ecode2)) {

12167

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextLine_SetDescent" "', expected argument " "2"" of type '" "int""'");

12168

}

12169

arg2 = static_cast< int >(val2);

12170

{

12171

PyThreadState* __tstate = wxPyBeginAllowThreads();

12172

(arg1)->SetDescent(arg2);

12173

wxPyEndAllowThreads(__tstate);

12174

if (PyErr_Occurred()) SWIG_fail;

12175

}

12176

resultobj = SWIG_Py_Void();

12177

return resultobj;

12178

fail:

12179

return NULL;

12180

}

12181

12182

12183

SWIGINTERN PyObject *_wrap_RichTextLine_GetDescent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12184

PyObject *resultobj = 0;

12185

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12186

int result;

12187

void *argp1 = 0 ;

12188

int res1 = 0 ;

12189

PyObject *swig_obj[1] ;

12190

12191

if (!args) SWIG_fail;

12192

swig_obj[0] = args;

12193

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12194

if (!SWIG_IsOK(res1)) {

12195

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_GetDescent" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

12196

}

12197

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12198

{

12199

PyThreadState* __tstate = wxPyBeginAllowThreads();

12200

result = (int)((wxRichTextLine const *)arg1)->GetDescent();

12201

wxPyEndAllowThreads(__tstate);

12202

if (PyErr_Occurred()) SWIG_fail;

12203

}

12204

resultobj = SWIG_From_int(static_cast< int >(result));

12205

return resultobj;

12206

fail:

12207

return NULL;

12208

}

12209

12210

12211

SWIGINTERN PyObject *_wrap_RichTextLine_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12212

PyObject *resultobj = 0;

12213

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12214

wxRichTextParagraph *arg2 = (wxRichTextParagraph *) 0 ;

12215

void *argp1 = 0 ;

12216

int res1 = 0 ;

12217

void *argp2 = 0 ;

12218

int res2 = 0 ;

12219

PyObject * obj0 = 0 ;

12220

PyObject * obj1 = 0 ;

12221

char * kwnames[] = {

12222

(char *) "self",(char *) "parent", NULL

12223

};

12224

12225

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextLine_Init",kwnames,&obj0,&obj1)) SWIG_fail;

12226

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12227

if (!SWIG_IsOK(res1)) {

12228

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_Init" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

12229

}

12230

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12231

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12232

if (!SWIG_IsOK(res2)) {

12233

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextLine_Init" "', expected argument " "2"" of type '" "wxRichTextParagraph *""'");

12234

}

12235

arg2 = reinterpret_cast< wxRichTextParagraph * >(argp2);

12236

{

12237

PyThreadState* __tstate = wxPyBeginAllowThreads();

12238

(arg1)->Init(arg2);

12239

wxPyEndAllowThreads(__tstate);

12240

if (PyErr_Occurred()) SWIG_fail;

12241

}

12242

resultobj = SWIG_Py_Void();

12243

return resultobj;

12244

fail:

12245

return NULL;

12246

}

12247

12248

12249

SWIGINTERN PyObject *_wrap_RichTextLine_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12250

PyObject *resultobj = 0;

12251

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12252

wxRichTextLine *arg2 = 0 ;

12253

void *argp1 = 0 ;

12254

int res1 = 0 ;

12255

void *argp2 = 0 ;

12256

int res2 = 0 ;

12257

PyObject * obj0 = 0 ;

12258

PyObject * obj1 = 0 ;

12259

char * kwnames[] = {

12260

(char *) "self",(char *) "obj", NULL

12261

};

12262

12263

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextLine_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

12264

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12265

if (!SWIG_IsOK(res1)) {

12266

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_Copy" "', expected argument " "1"" of type '" "wxRichTextLine *""'");

12267

}

12268

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12269

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextLine, 0 | 0);

12270

if (!SWIG_IsOK(res2)) {

12271

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextLine_Copy" "', expected argument " "2"" of type '" "wxRichTextLine const &""'");

12272

}

12273

if (!argp2) {

12274

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextLine_Copy" "', expected argument " "2"" of type '" "wxRichTextLine const &""'");

12275

}

12276

arg2 = reinterpret_cast< wxRichTextLine * >(argp2);

12277

{

12278

PyThreadState* __tstate = wxPyBeginAllowThreads();

12279

(arg1)->Copy((wxRichTextLine const &)*arg2);

12280

wxPyEndAllowThreads(__tstate);

12281

if (PyErr_Occurred()) SWIG_fail;

12282

}

12283

resultobj = SWIG_Py_Void();

12284

return resultobj;

12285

fail:

12286

return NULL;

12287

}

12288

12289

12290

SWIGINTERN PyObject *_wrap_RichTextLine_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12291

PyObject *resultobj = 0;

12292

wxRichTextLine *arg1 = (wxRichTextLine *) 0 ;

12293

wxRichTextLine *result = 0 ;

12294

void *argp1 = 0 ;

12295

int res1 = 0 ;

12296

PyObject *swig_obj[1] ;

12297

12298

if (!args) SWIG_fail;

12299

swig_obj[0] = args;

12300

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12301

if (!SWIG_IsOK(res1)) {

12302

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextLine_Clone" "', expected argument " "1"" of type '" "wxRichTextLine const *""'");

12303

}

12304

arg1 = reinterpret_cast< wxRichTextLine * >(argp1);

12305

{

12306

PyThreadState* __tstate = wxPyBeginAllowThreads();

12307

result = (wxRichTextLine *)((wxRichTextLine const *)arg1)->Clone();

12308

wxPyEndAllowThreads(__tstate);

12309

if (PyErr_Occurred()) SWIG_fail;

12310

}

12311

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, 0 | 0 );

12312

return resultobj;

12313

fail:

12314

return NULL;

12315

}

12316

12317

12318

SWIGINTERN PyObject *RichTextLine_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12319

PyObject *obj;

12320

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

12321

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextLine, SWIG_NewClientData(obj));

12322

return SWIG_Py_Void();

12323

}

12324

12325

SWIGINTERN PyObject *RichTextLine_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12326

return SWIG_Python_InitShadowInstance(args);

12327

}

12328

12329

SWIGINTERN PyObject *_wrap_new_RichTextParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12330

PyObject *resultobj = 0;

12331

wxString *arg1 = 0 ;

12332

wxRichTextObject *arg2 = (wxRichTextObject *) NULL ;

12333

wxTextAttrEx *arg3 = (wxTextAttrEx *) NULL ;

12334

wxTextAttrEx *arg4 = (wxTextAttrEx *) NULL ;

12335

wxRichTextParagraph *result = 0 ;

12336

bool temp1 = false ;

12337

void *argp2 = 0 ;

12338

int res2 = 0 ;

12339

void *argp3 = 0 ;

12340

int res3 = 0 ;

12341

void *argp4 = 0 ;

12342

int res4 = 0 ;

12343

PyObject * obj0 = 0 ;

12344

PyObject * obj1 = 0 ;

12345

PyObject * obj2 = 0 ;

12346

PyObject * obj3 = 0 ;

12347

char * kwnames[] = {

12348

(char *) "text",(char *) "parent",(char *) "paraStyle",(char *) "charStyle", NULL

12349

};

12350

12351

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_RichTextParagraph",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

12352

{

12353

arg1 = wxString_in_helper(obj0);

12354

if (arg1 == NULL) SWIG_fail;

12355

temp1 = true;

12356

}

12357

if (obj1) {

12358

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

12359

if (!SWIG_IsOK(res2)) {

12360

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RichTextParagraph" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

12361

}

12362

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

12363

}

12364

if (obj2) {

12365

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

12366

if (!SWIG_IsOK(res3)) {

12367

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RichTextParagraph" "', expected argument " "3"" of type '" "wxTextAttrEx *""'");

12368

}

12369

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

12370

}

12371

if (obj3) {

12372

res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

12373

if (!SWIG_IsOK(res4)) {

12374

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RichTextParagraph" "', expected argument " "4"" of type '" "wxTextAttrEx *""'");

12375

}

12376

arg4 = reinterpret_cast< wxTextAttrEx * >(argp4);

12377

}

12378

{

12379

PyThreadState* __tstate = wxPyBeginAllowThreads();

12380

result = (wxRichTextParagraph *)new wxRichTextParagraph((wxString const &)*arg1,arg2,arg3,arg4);

12381

wxPyEndAllowThreads(__tstate);

12382

if (PyErr_Occurred()) SWIG_fail;

12383

}

12384

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextParagraph, SWIG_POINTER_NEW | 0 );

12385

{

12386

if (temp1)

12387

delete arg1;

12388

}

12389

return resultobj;

12390

fail:

12391

{

12392

if (temp1)

12393

delete arg1;

12394

}

12395

return NULL;

12396

}

12397

12398

12399

SWIGINTERN PyObject *_wrap_delete_RichTextParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12400

PyObject *resultobj = 0;

12401

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12402

void *argp1 = 0 ;

12403

int res1 = 0 ;

12404

PyObject *swig_obj[1] ;

12405

12406

if (!args) SWIG_fail;

12407

swig_obj[0] = args;

12408

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraph, SWIG_POINTER_DISOWN | 0 );

12409

if (!SWIG_IsOK(res1)) {

12410

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextParagraph" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12411

}

12412

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12413

{

12414

PyThreadState* __tstate = wxPyBeginAllowThreads();

12415

delete arg1;

12416

12417

wxPyEndAllowThreads(__tstate);

12418

if (PyErr_Occurred()) SWIG_fail;

12419

}

12420

resultobj = SWIG_Py_Void();

12421

return resultobj;

12422

fail:

12423

return NULL;

12424

}

12425

12426

12427

SWIGINTERN PyObject *_wrap_RichTextParagraph_GetLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12428

PyObject *resultobj = 0;

12429

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12430

wxRichTextLineList *result = 0 ;

12431

void *argp1 = 0 ;

12432

int res1 = 0 ;

12433

PyObject *swig_obj[1] ;

12434

12435

if (!args) SWIG_fail;

12436

swig_obj[0] = args;

12437

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12438

if (!SWIG_IsOK(res1)) {

12439

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_GetLines" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12440

}

12441

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12442

{

12443

PyThreadState* __tstate = wxPyBeginAllowThreads();

12444

{

12445

wxRichTextLineList &_result_ref = (arg1)->GetLines();

12446

result = (wxRichTextLineList *) &_result_ref;

12447

}

12448

wxPyEndAllowThreads(__tstate);

12449

if (PyErr_Occurred()) SWIG_fail;

12450

}

12451

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLineList, 0 | 0 );

12452

return resultobj;

12453

fail:

12454

return NULL;

12455

}

12456

12457

12458

SWIGINTERN PyObject *_wrap_RichTextParagraph_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12459

PyObject *resultobj = 0;

12460

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12461

wxRichTextParagraph *arg2 = 0 ;

12462

void *argp1 = 0 ;

12463

int res1 = 0 ;

12464

void *argp2 = 0 ;

12465

int res2 = 0 ;

12466

PyObject * obj0 = 0 ;

12467

PyObject * obj1 = 0 ;

12468

char * kwnames[] = {

12469

(char *) "self",(char *) "obj", NULL

12470

};

12471

12472

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraph_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

12473

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12474

if (!SWIG_IsOK(res1)) {

12475

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_Copy" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12476

}

12477

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12478

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextParagraph, 0 | 0);

12479

if (!SWIG_IsOK(res2)) {

12480

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraph_Copy" "', expected argument " "2"" of type '" "wxRichTextParagraph const &""'");

12481

}

12482

if (!argp2) {

12483

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraph_Copy" "', expected argument " "2"" of type '" "wxRichTextParagraph const &""'");

12484

}

12485

arg2 = reinterpret_cast< wxRichTextParagraph * >(argp2);

12486

{

12487

PyThreadState* __tstate = wxPyBeginAllowThreads();

12488

(arg1)->Copy((wxRichTextParagraph const &)*arg2);

12489

wxPyEndAllowThreads(__tstate);

12490

if (PyErr_Occurred()) SWIG_fail;

12491

}

12492

resultobj = SWIG_Py_Void();

12493

return resultobj;

12494

fail:

12495

return NULL;

12496

}

12497

12498

12499

SWIGINTERN PyObject *_wrap_RichTextParagraph_ClearLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12500

PyObject *resultobj = 0;

12501

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12502

void *argp1 = 0 ;

12503

int res1 = 0 ;

12504

PyObject *swig_obj[1] ;

12505

12506

if (!args) SWIG_fail;

12507

swig_obj[0] = args;

12508

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12509

if (!SWIG_IsOK(res1)) {

12510

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_ClearLines" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12511

}

12512

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12513

{

12514

PyThreadState* __tstate = wxPyBeginAllowThreads();

12515

(arg1)->ClearLines();

12516

wxPyEndAllowThreads(__tstate);

12517

if (PyErr_Occurred()) SWIG_fail;

12518

}

12519

resultobj = SWIG_Py_Void();

12520

return resultobj;

12521

fail:

12522

return NULL;

12523

}

12524

12525

12526

SWIGINTERN PyObject *_wrap_RichTextParagraph_ApplyParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12527

PyObject *resultobj = 0;

12528

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12529

wxTextAttrEx *arg2 = 0 ;

12530

wxRect *arg3 = 0 ;

12531

void *argp1 = 0 ;

12532

int res1 = 0 ;

12533

void *argp2 = 0 ;

12534

int res2 = 0 ;

12535

wxRect temp3 ;

12536

PyObject * obj0 = 0 ;

12537

PyObject * obj1 = 0 ;

12538

PyObject * obj2 = 0 ;

12539

char * kwnames[] = {

12540

(char *) "self",(char *) "attr",(char *) "rect", NULL

12541

};

12542

12543

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraph_ApplyParagraphStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12544

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12545

if (!SWIG_IsOK(res1)) {

12546

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_ApplyParagraphStyle" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12547

}

12548

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12549

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

12550

if (!SWIG_IsOK(res2)) {

12551

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraph_ApplyParagraphStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

12552

}

12553

if (!argp2) {

12554

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraph_ApplyParagraphStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

12555

}

12556

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

12557

{

12558

arg3 = &temp3;

12559

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

12560

}

12561

{

12562

PyThreadState* __tstate = wxPyBeginAllowThreads();

12563

(arg1)->ApplyParagraphStyle((wxTextAttrEx const &)*arg2,(wxRect const &)*arg3);

12564

wxPyEndAllowThreads(__tstate);

12565

if (PyErr_Occurred()) SWIG_fail;

12566

}

12567

resultobj = SWIG_Py_Void();

12568

return resultobj;

12569

fail:

12570

return NULL;

12571

}

12572

12573

12574

SWIGINTERN PyObject *_wrap_RichTextParagraph_InsertText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12575

PyObject *resultobj = 0;

12576

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12577

long arg2 ;

12578

wxString *arg3 = 0 ;

12579

bool result;

12580

void *argp1 = 0 ;

12581

int res1 = 0 ;

12582

long val2 ;

12583

int ecode2 = 0 ;

12584

bool temp3 = false ;

12585

PyObject * obj0 = 0 ;

12586

PyObject * obj1 = 0 ;

12587

PyObject * obj2 = 0 ;

12588

char * kwnames[] = {

12589

(char *) "self",(char *) "pos",(char *) "text", NULL

12590

};

12591

12592

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraph_InsertText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12593

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12594

if (!SWIG_IsOK(res1)) {

12595

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_InsertText" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12596

}

12597

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12598

ecode2 = SWIG_AsVal_long(obj1, &val2);

12599

if (!SWIG_IsOK(ecode2)) {

12600

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraph_InsertText" "', expected argument " "2"" of type '" "long""'");

12601

}

12602

arg2 = static_cast< long >(val2);

12603

{

12604

arg3 = wxString_in_helper(obj2);

12605

if (arg3 == NULL) SWIG_fail;

12606

temp3 = true;

12607

}

12608

{

12609

PyThreadState* __tstate = wxPyBeginAllowThreads();

12610

result = (bool)(arg1)->InsertText(arg2,(wxString const &)*arg3);

12611

wxPyEndAllowThreads(__tstate);

12612

if (PyErr_Occurred()) SWIG_fail;

12613

}

12614

{

12615

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

12616

}

12617

{

12618

if (temp3)

12619

delete arg3;

12620

}

12621

return resultobj;

12622

fail:

12623

{

12624

if (temp3)

12625

delete arg3;

12626

}

12627

return NULL;

12628

}

12629

12630

12631

SWIGINTERN PyObject *_wrap_RichTextParagraph_SplitAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12632

PyObject *resultobj = 0;

12633

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12634

long arg2 ;

12635

wxRichTextObject **arg3 = (wxRichTextObject **) NULL ;

12636

wxRichTextObject *result = 0 ;

12637

void *argp1 = 0 ;

12638

int res1 = 0 ;

12639

long val2 ;

12640

int ecode2 = 0 ;

12641

void *argp3 = 0 ;

12642

int res3 = 0 ;

12643

PyObject * obj0 = 0 ;

12644

PyObject * obj1 = 0 ;

12645

PyObject * obj2 = 0 ;

12646

char * kwnames[] = {

12647

(char *) "self",(char *) "pos",(char *) "previousObject", NULL

12648

};

12649

12650

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextParagraph_SplitAt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12651

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12652

if (!SWIG_IsOK(res1)) {

12653

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_SplitAt" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12654

}

12655

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12656

ecode2 = SWIG_AsVal_long(obj1, &val2);

12657

if (!SWIG_IsOK(ecode2)) {

12658

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraph_SplitAt" "', expected argument " "2"" of type '" "long""'");

12659

}

12660

arg2 = static_cast< long >(val2);

12661

if (obj2) {

12662

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_wxRichTextObject, 0 | 0 );

12663

if (!SWIG_IsOK(res3)) {

12664

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraph_SplitAt" "', expected argument " "3"" of type '" "wxRichTextObject **""'");

12665

}

12666

arg3 = reinterpret_cast< wxRichTextObject ** >(argp3);

12667

}

12668

{

12669

PyThreadState* __tstate = wxPyBeginAllowThreads();

12670

result = (wxRichTextObject *)(arg1)->SplitAt(arg2,arg3);

12671

wxPyEndAllowThreads(__tstate);

12672

if (PyErr_Occurred()) SWIG_fail;

12673

}

12674

{

12675

resultobj = wxPyMake_wxObject(result, (bool)0);

12676

}

12677

return resultobj;

12678

fail:

12679

return NULL;

12680

}

12681

12682

12683

SWIGINTERN PyObject *_wrap_RichTextParagraph_MoveToList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12684

PyObject *resultobj = 0;

12685

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12686

wxRichTextObject *arg2 = (wxRichTextObject *) 0 ;

12687

wxList *arg3 = 0 ;

12688

void *argp1 = 0 ;

12689

int res1 = 0 ;

12690

void *argp2 = 0 ;

12691

int res2 = 0 ;

12692

void *argp3 = 0 ;

12693

int res3 = 0 ;

12694

PyObject * obj0 = 0 ;

12695

PyObject * obj1 = 0 ;

12696

PyObject * obj2 = 0 ;

12697

char * kwnames[] = {

12698

(char *) "self",(char *) "obj",(char *) "list", NULL

12699

};

12700

12701

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextParagraph_MoveToList",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

12702

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12703

if (!SWIG_IsOK(res1)) {

12704

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_MoveToList" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12705

}

12706

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12707

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

12708

if (!SWIG_IsOK(res2)) {

12709

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraph_MoveToList" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

12710

}

12711

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

12712

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxList, 0 );

12713

if (!SWIG_IsOK(res3)) {

12714

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraph_MoveToList" "', expected argument " "3"" of type '" "wxList &""'");

12715

}

12716

if (!argp3) {

12717

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraph_MoveToList" "', expected argument " "3"" of type '" "wxList &""'");

12718

}

12719

arg3 = reinterpret_cast< wxList * >(argp3);

12720

{

12721

PyThreadState* __tstate = wxPyBeginAllowThreads();

12722

(arg1)->MoveToList(arg2,*arg3);

12723

wxPyEndAllowThreads(__tstate);

12724

if (PyErr_Occurred()) SWIG_fail;

12725

}

12726

resultobj = SWIG_Py_Void();

12727

return resultobj;

12728

fail:

12729

return NULL;

12730

}

12731

12732

12733

SWIGINTERN PyObject *_wrap_RichTextParagraph_MoveFromList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12734

PyObject *resultobj = 0;

12735

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12736

wxList *arg2 = 0 ;

12737

void *argp1 = 0 ;

12738

int res1 = 0 ;

12739

void *argp2 = 0 ;

12740

int res2 = 0 ;

12741

PyObject * obj0 = 0 ;

12742

PyObject * obj1 = 0 ;

12743

char * kwnames[] = {

12744

(char *) "self",(char *) "list", NULL

12745

};

12746

12747

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraph_MoveFromList",kwnames,&obj0,&obj1)) SWIG_fail;

12748

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12749

if (!SWIG_IsOK(res1)) {

12750

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_MoveFromList" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12751

}

12752

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12753

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxList, 0 );

12754

if (!SWIG_IsOK(res2)) {

12755

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraph_MoveFromList" "', expected argument " "2"" of type '" "wxList &""'");

12756

}

12757

if (!argp2) {

12758

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraph_MoveFromList" "', expected argument " "2"" of type '" "wxList &""'");

12759

}

12760

arg2 = reinterpret_cast< wxList * >(argp2);

12761

{

12762

PyThreadState* __tstate = wxPyBeginAllowThreads();

12763

(arg1)->MoveFromList(*arg2);

12764

wxPyEndAllowThreads(__tstate);

12765

if (PyErr_Occurred()) SWIG_fail;

12766

}

12767

resultobj = SWIG_Py_Void();

12768

return resultobj;

12769

fail:

12770

return NULL;

12771

}

12772

12773

12774

SWIGINTERN PyObject *_wrap_RichTextParagraph_GetContiguousPlainText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12775

PyObject *resultobj = 0;

12776

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12777

wxString *arg2 = 0 ;

12778

wxRichTextRange *arg3 = 0 ;

12779

bool arg4 = (bool) true ;

12780

bool result;

12781

void *argp1 = 0 ;

12782

int res1 = 0 ;

12783

bool temp2 = false ;

12784

wxRichTextRange temp3 ;

12785

bool val4 ;

12786

int ecode4 = 0 ;

12787

PyObject * obj0 = 0 ;

12788

PyObject * obj1 = 0 ;

12789

PyObject * obj2 = 0 ;

12790

PyObject * obj3 = 0 ;

12791

char * kwnames[] = {

12792

(char *) "self",(char *) "text",(char *) "range",(char *) "fromStart", NULL

12793

};

12794

12795

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:RichTextParagraph_GetContiguousPlainText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

12796

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12797

if (!SWIG_IsOK(res1)) {

12798

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_GetContiguousPlainText" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12799

}

12800

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12801

{

12802

arg2 = wxString_in_helper(obj1);

12803

if (arg2 == NULL) SWIG_fail;

12804

temp2 = true;

12805

}

12806

{

12807

arg3 = &temp3;

12808

if ( ! wxRichTextRange_helper(obj2, &arg3)) SWIG_fail;

12809

}

12810

if (obj3) {

12811

ecode4 = SWIG_AsVal_bool(obj3, &val4);

12812

if (!SWIG_IsOK(ecode4)) {

12813

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraph_GetContiguousPlainText" "', expected argument " "4"" of type '" "bool""'");

12814

}

12815

arg4 = static_cast< bool >(val4);

12816

}

12817

{

12818

PyThreadState* __tstate = wxPyBeginAllowThreads();

12819

result = (bool)(arg1)->GetContiguousPlainText(*arg2,(wxRichTextRange const &)*arg3,arg4);

12820

wxPyEndAllowThreads(__tstate);

12821

if (PyErr_Occurred()) SWIG_fail;

12822

}

12823

{

12824

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

12825

}

12826

{

12827

if (temp2)

12828

delete arg2;

12829

}

12830

return resultobj;

12831

fail:

12832

{

12833

if (temp2)

12834

delete arg2;

12835

}

12836

return NULL;

12837

}

12838

12839

12840

SWIGINTERN PyObject *_wrap_RichTextParagraph_FindWrapPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12841

PyObject *resultobj = 0;

12842

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12843

wxRichTextRange *arg2 = 0 ;

12844

wxDC *arg3 = 0 ;

12845

int arg4 ;

12846

long *arg5 = 0 ;

12847

bool result;

12848

void *argp1 = 0 ;

12849

int res1 = 0 ;

12850

wxRichTextRange temp2 ;

12851

void *argp3 = 0 ;

12852

int res3 = 0 ;

12853

int val4 ;

12854

int ecode4 = 0 ;

12855

void *argp5 = 0 ;

12856

int res5 = 0 ;

12857

PyObject * obj0 = 0 ;

12858

PyObject * obj1 = 0 ;

12859

PyObject * obj2 = 0 ;

12860

PyObject * obj3 = 0 ;

12861

PyObject * obj4 = 0 ;

12862

char * kwnames[] = {

12863

(char *) "self",(char *) "range",(char *) "dc",(char *) "availableSpace",(char *) "wrapPosition", NULL

12864

};

12865

12866

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:RichTextParagraph_FindWrapPosition",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

12867

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12868

if (!SWIG_IsOK(res1)) {

12869

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_FindWrapPosition" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12870

}

12871

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12872

{

12873

arg2 = &temp2;

12874

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

12875

}

12876

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );

12877

if (!SWIG_IsOK(res3)) {

12878

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextParagraph_FindWrapPosition" "', expected argument " "3"" of type '" "wxDC &""'");

12879

}

12880

if (!argp3) {

12881

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraph_FindWrapPosition" "', expected argument " "3"" of type '" "wxDC &""'");

12882

}

12883

arg3 = reinterpret_cast< wxDC * >(argp3);

12884

ecode4 = SWIG_AsVal_int(obj3, &val4);

12885

if (!SWIG_IsOK(ecode4)) {

12886

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextParagraph_FindWrapPosition" "', expected argument " "4"" of type '" "int""'");

12887

}

12888

arg4 = static_cast< int >(val4);

12889

res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_long, 0 );

12890

if (!SWIG_IsOK(res5)) {

12891

SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RichTextParagraph_FindWrapPosition" "', expected argument " "5"" of type '" "long &""'");

12892

}

12893

if (!argp5) {

12894

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextParagraph_FindWrapPosition" "', expected argument " "5"" of type '" "long &""'");

12895

}

12896

arg5 = reinterpret_cast< long * >(argp5);

12897

{

12898

PyThreadState* __tstate = wxPyBeginAllowThreads();

12899

result = (bool)(arg1)->FindWrapPosition((wxRichTextRange const &)*arg2,*arg3,arg4,*arg5);

12900

wxPyEndAllowThreads(__tstate);

12901

if (PyErr_Occurred()) SWIG_fail;

12902

}

12903

{

12904

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

12905

}

12906

return resultobj;

12907

fail:

12908

return NULL;

12909

}

12910

12911

12912

SWIGINTERN PyObject *_wrap_RichTextParagraph_FindObjectAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12913

PyObject *resultobj = 0;

12914

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12915

long arg2 ;

12916

wxRichTextObject *result = 0 ;

12917

void *argp1 = 0 ;

12918

int res1 = 0 ;

12919

long val2 ;

12920

int ecode2 = 0 ;

12921

PyObject * obj0 = 0 ;

12922

PyObject * obj1 = 0 ;

12923

char * kwnames[] = {

12924

(char *) "self",(char *) "position", NULL

12925

};

12926

12927

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraph_FindObjectAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;

12928

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12929

if (!SWIG_IsOK(res1)) {

12930

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_FindObjectAtPosition" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12931

}

12932

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12933

ecode2 = SWIG_AsVal_long(obj1, &val2);

12934

if (!SWIG_IsOK(ecode2)) {

12935

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraph_FindObjectAtPosition" "', expected argument " "2"" of type '" "long""'");

12936

}

12937

arg2 = static_cast< long >(val2);

12938

{

12939

PyThreadState* __tstate = wxPyBeginAllowThreads();

12940

result = (wxRichTextObject *)(arg1)->FindObjectAtPosition(arg2);

12941

wxPyEndAllowThreads(__tstate);

12942

if (PyErr_Occurred()) SWIG_fail;

12943

}

12944

{

12945

resultobj = wxPyMake_wxObject(result, (bool)0);

12946

}

12947

return resultobj;

12948

fail:

12949

return NULL;

12950

}

12951

12952

12953

SWIGINTERN PyObject *_wrap_RichTextParagraph_GetBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

12954

PyObject *resultobj = 0;

12955

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12956

wxString result;

12957

void *argp1 = 0 ;

12958

int res1 = 0 ;

12959

PyObject *swig_obj[1] ;

12960

12961

if (!args) SWIG_fail;

12962

swig_obj[0] = args;

12963

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

12964

if (!SWIG_IsOK(res1)) {

12965

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_GetBulletText" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

12966

}

12967

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

12968

{

12969

PyThreadState* __tstate = wxPyBeginAllowThreads();

12970

result = (arg1)->GetBulletText();

12971

wxPyEndAllowThreads(__tstate);

12972

if (PyErr_Occurred()) SWIG_fail;

12973

}

12974

{

12975

#if wxUSE_UNICODE

12976

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

12977

#else

12978

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

12979

#endif

12980

}

12981

return resultobj;

12982

fail:

12983

return NULL;

12984

}

12985

12986

12987

SWIGINTERN PyObject *_wrap_RichTextParagraph_AllocateLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

12988

PyObject *resultobj = 0;

12989

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

12990

int arg2 ;

12991

wxRichTextLine *result = 0 ;

12992

void *argp1 = 0 ;

12993

int res1 = 0 ;

12994

int val2 ;

12995

int ecode2 = 0 ;

12996

PyObject * obj0 = 0 ;

12997

PyObject * obj1 = 0 ;

12998

char * kwnames[] = {

12999

(char *) "self",(char *) "pos", NULL

13000

};

13001

13002

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraph_AllocateLine",kwnames,&obj0,&obj1)) SWIG_fail;

13003

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

13004

if (!SWIG_IsOK(res1)) {

13005

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_AllocateLine" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

13006

}

13007

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

13008

ecode2 = SWIG_AsVal_int(obj1, &val2);

13009

if (!SWIG_IsOK(ecode2)) {

13010

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraph_AllocateLine" "', expected argument " "2"" of type '" "int""'");

13011

}

13012

arg2 = static_cast< int >(val2);

13013

{

13014

PyThreadState* __tstate = wxPyBeginAllowThreads();

13015

result = (wxRichTextLine *)(arg1)->AllocateLine(arg2);

13016

wxPyEndAllowThreads(__tstate);

13017

if (PyErr_Occurred()) SWIG_fail;

13018

}

13019

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, 0 | 0 );

13020

return resultobj;

13021

fail:

13022

return NULL;

13023

}

13024

13025

13026

SWIGINTERN PyObject *_wrap_RichTextParagraph_ClearUnusedLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13027

PyObject *resultobj = 0;

13028

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

13029

int arg2 ;

13030

bool result;

13031

void *argp1 = 0 ;

13032

int res1 = 0 ;

13033

int val2 ;

13034

int ecode2 = 0 ;

13035

PyObject * obj0 = 0 ;

13036

PyObject * obj1 = 0 ;

13037

char * kwnames[] = {

13038

(char *) "self",(char *) "lineCount", NULL

13039

};

13040

13041

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraph_ClearUnusedLines",kwnames,&obj0,&obj1)) SWIG_fail;

13042

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

13043

if (!SWIG_IsOK(res1)) {

13044

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_ClearUnusedLines" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

13045

}

13046

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

13047

ecode2 = SWIG_AsVal_int(obj1, &val2);

13048

if (!SWIG_IsOK(ecode2)) {

13049

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraph_ClearUnusedLines" "', expected argument " "2"" of type '" "int""'");

13050

}

13051

arg2 = static_cast< int >(val2);

13052

{

13053

PyThreadState* __tstate = wxPyBeginAllowThreads();

13054

result = (bool)(arg1)->ClearUnusedLines(arg2);

13055

wxPyEndAllowThreads(__tstate);

13056

if (PyErr_Occurred()) SWIG_fail;

13057

}

13058

{

13059

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

13060

}

13061

return resultobj;

13062

fail:

13063

return NULL;

13064

}

13065

13066

13067

SWIGINTERN PyObject *_wrap_RichTextParagraph_GetCombinedAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13068

PyObject *resultobj = 0;

13069

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

13070

wxTextAttrEx *arg2 = (wxTextAttrEx *) NULL ;

13071

wxTextAttrEx result;

13072

void *argp1 = 0 ;

13073

int res1 = 0 ;

13074

void *argp2 = 0 ;

13075

int res2 = 0 ;

13076

PyObject * obj0 = 0 ;

13077

PyObject * obj1 = 0 ;

13078

char * kwnames[] = {

13079

(char *) "self",(char *) "contentStyle", NULL

13080

};

13081

13082

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextParagraph_GetCombinedAttributes",kwnames,&obj0,&obj1)) SWIG_fail;

13083

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

13084

if (!SWIG_IsOK(res1)) {

13085

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_GetCombinedAttributes" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

13086

}

13087

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

13088

if (obj1) {

13089

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

13090

if (!SWIG_IsOK(res2)) {

13091

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextParagraph_GetCombinedAttributes" "', expected argument " "2"" of type '" "wxTextAttrEx *""'");

13092

}

13093

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

13094

}

13095

{

13096

PyThreadState* __tstate = wxPyBeginAllowThreads();

13097

result = wxRichTextParagraph_GetCombinedAttributes(arg1,arg2);

13098

wxPyEndAllowThreads(__tstate);

13099

if (PyErr_Occurred()) SWIG_fail;

13100

}

13101

resultobj = SWIG_NewPointerObj((new wxTextAttrEx(static_cast< const wxTextAttrEx& >(result))), SWIGTYPE_p_wxTextAttrEx, SWIG_POINTER_OWN | 0 );

13102

return resultobj;

13103

fail:

13104

return NULL;

13105

}

13106

13107

13108

SWIGINTERN PyObject *_wrap_RichTextParagraph_GetFirstLineBreakPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13109

PyObject *resultobj = 0;

13110

wxRichTextParagraph *arg1 = (wxRichTextParagraph *) 0 ;

13111

long arg2 ;

13112

long result;

13113

void *argp1 = 0 ;

13114

int res1 = 0 ;

13115

long val2 ;

13116

int ecode2 = 0 ;

13117

PyObject * obj0 = 0 ;

13118

PyObject * obj1 = 0 ;

13119

char * kwnames[] = {

13120

(char *) "self",(char *) "pos", NULL

13121

};

13122

13123

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextParagraph_GetFirstLineBreakPosition",kwnames,&obj0,&obj1)) SWIG_fail;

13124

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

13125

if (!SWIG_IsOK(res1)) {

13126

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextParagraph_GetFirstLineBreakPosition" "', expected argument " "1"" of type '" "wxRichTextParagraph *""'");

13127

}

13128

arg1 = reinterpret_cast< wxRichTextParagraph * >(argp1);

13129

ecode2 = SWIG_AsVal_long(obj1, &val2);

13130

if (!SWIG_IsOK(ecode2)) {

13131

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextParagraph_GetFirstLineBreakPosition" "', expected argument " "2"" of type '" "long""'");

13132

}

13133

arg2 = static_cast< long >(val2);

13134

{

13135

PyThreadState* __tstate = wxPyBeginAllowThreads();

13136

result = (long)(arg1)->GetFirstLineBreakPosition(arg2);

13137

wxPyEndAllowThreads(__tstate);

13138

if (PyErr_Occurred()) SWIG_fail;

13139

}

13140

resultobj = SWIG_From_long(static_cast< long >(result));

13141

return resultobj;

13142

fail:

13143

return NULL;

13144

}

13145

13146

13147

SWIGINTERN PyObject *_wrap_RichTextParagraph_InitDefaultTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13148

PyObject *resultobj = 0;

13149

13150

if (!SWIG_Python_UnpackTuple(args,"RichTextParagraph_InitDefaultTabs",0,0,0)) SWIG_fail;

13151

{

13152

PyThreadState* __tstate = wxPyBeginAllowThreads();

13153

wxRichTextParagraph::InitDefaultTabs();

13154

wxPyEndAllowThreads(__tstate);

13155

if (PyErr_Occurred()) SWIG_fail;

13156

}

13157

resultobj = SWIG_Py_Void();

13158

return resultobj;

13159

fail:

13160

return NULL;

13161

}

13162

13163

13164

SWIGINTERN PyObject *_wrap_RichTextParagraph_ClearDefaultTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13165

PyObject *resultobj = 0;

13166

13167

if (!SWIG_Python_UnpackTuple(args,"RichTextParagraph_ClearDefaultTabs",0,0,0)) SWIG_fail;

13168

{

13169

PyThreadState* __tstate = wxPyBeginAllowThreads();

13170

wxRichTextParagraph::ClearDefaultTabs();

13171

wxPyEndAllowThreads(__tstate);

13172

if (PyErr_Occurred()) SWIG_fail;

13173

}

13174

resultobj = SWIG_Py_Void();

13175

return resultobj;

13176

fail:

13177

return NULL;

13178

}

13179

13180

13181

SWIGINTERN PyObject *_wrap_RichTextParagraph_GetDefaultTabs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13182

PyObject *resultobj = 0;

13183

wxArrayInt *result = 0 ;

13184

13185

if (!SWIG_Python_UnpackTuple(args,"RichTextParagraph_GetDefaultTabs",0,0,0)) SWIG_fail;

13186

{

13187

PyThreadState* __tstate = wxPyBeginAllowThreads();

13188

{

13189

wxArrayInt const &_result_ref = wxRichTextParagraph::GetDefaultTabs();

13190

result = (wxArrayInt *) &_result_ref;

13191

}

13192

wxPyEndAllowThreads(__tstate);

13193

if (PyErr_Occurred()) SWIG_fail;

13194

}

13195

{

13196

resultobj = wxArrayInt2PyList_helper(*result);

13197

}

13198

return resultobj;

13199

fail:

13200

return NULL;

13201

}

13202

13203

13204

SWIGINTERN PyObject *RichTextParagraph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13205

PyObject *obj;

13206

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

13207

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextParagraph, SWIG_NewClientData(obj));

13208

return SWIG_Py_Void();

13209

}

13210

13211

SWIGINTERN PyObject *RichTextParagraph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13212

return SWIG_Python_InitShadowInstance(args);

13213

}

13214

13215

SWIGINTERN PyObject *_wrap_new_RichTextPlainText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13216

PyObject *resultobj = 0;

13217

wxString const &arg1_defvalue = wxEmptyString ;

13218

wxString *arg1 = (wxString *) &arg1_defvalue ;

13219

wxRichTextObject *arg2 = (wxRichTextObject *) NULL ;

13220

wxTextAttrEx *arg3 = (wxTextAttrEx *) NULL ;

13221

wxRichTextPlainText *result = 0 ;

13222

bool temp1 = false ;

13223

void *argp2 = 0 ;

13224

int res2 = 0 ;

13225

void *argp3 = 0 ;

13226

int res3 = 0 ;

13227

PyObject * obj0 = 0 ;

13228

PyObject * obj1 = 0 ;

13229

PyObject * obj2 = 0 ;

13230

char * kwnames[] = {

13231

(char *) "text",(char *) "parent",(char *) "style", NULL

13232

};

13233

13234

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_RichTextPlainText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

13235

if (obj0) {

13236

{

13237

arg1 = wxString_in_helper(obj0);

13238

if (arg1 == NULL) SWIG_fail;

13239

temp1 = true;

13240

}

13241

}

13242

if (obj1) {

13243

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

13244

if (!SWIG_IsOK(res2)) {

13245

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RichTextPlainText" "', expected argument " "2"" of type '" "wxRichTextObject *""'");

13246

}

13247

arg2 = reinterpret_cast< wxRichTextObject * >(argp2);

13248

}

13249

if (obj2) {

13250

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextAttrEx, 0 | 0 );

13251

if (!SWIG_IsOK(res3)) {

13252

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RichTextPlainText" "', expected argument " "3"" of type '" "wxTextAttrEx *""'");

13253

}

13254

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

13255

}

13256

{

13257

PyThreadState* __tstate = wxPyBeginAllowThreads();

13258

result = (wxRichTextPlainText *)new wxRichTextPlainText((wxString const &)*arg1,arg2,arg3);

13259

wxPyEndAllowThreads(__tstate);

13260

if (PyErr_Occurred()) SWIG_fail;

13261

}

13262

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextPlainText, SWIG_POINTER_NEW | 0 );

13263

{

13264

if (temp1)

13265

delete arg1;

13266

}

13267

return resultobj;

13268

fail:

13269

{

13270

if (temp1)

13271

delete arg1;

13272

}

13273

return NULL;

13274

}

13275

13276

13277

SWIGINTERN PyObject *_wrap_RichTextPlainText_GetFirstLineBreakPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13278

PyObject *resultobj = 0;

13279

wxRichTextPlainText *arg1 = (wxRichTextPlainText *) 0 ;

13280

long arg2 ;

13281

long result;

13282

void *argp1 = 0 ;

13283

int res1 = 0 ;

13284

long val2 ;

13285

int ecode2 = 0 ;

13286

PyObject * obj0 = 0 ;

13287

PyObject * obj1 = 0 ;

13288

char * kwnames[] = {

13289

(char *) "self",(char *) "pos", NULL

13290

};

13291

13292

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPlainText_GetFirstLineBreakPosition",kwnames,&obj0,&obj1)) SWIG_fail;

13293

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPlainText, 0 | 0 );

13294

if (!SWIG_IsOK(res1)) {

13295

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPlainText_GetFirstLineBreakPosition" "', expected argument " "1"" of type '" "wxRichTextPlainText *""'");

13296

}

13297

arg1 = reinterpret_cast< wxRichTextPlainText * >(argp1);

13298

ecode2 = SWIG_AsVal_long(obj1, &val2);

13299

if (!SWIG_IsOK(ecode2)) {

13300

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextPlainText_GetFirstLineBreakPosition" "', expected argument " "2"" of type '" "long""'");

13301

}

13302

arg2 = static_cast< long >(val2);

13303

{

13304

PyThreadState* __tstate = wxPyBeginAllowThreads();

13305

result = (long)(arg1)->GetFirstLineBreakPosition(arg2);

13306

wxPyEndAllowThreads(__tstate);

13307

if (PyErr_Occurred()) SWIG_fail;

13308

}

13309

resultobj = SWIG_From_long(static_cast< long >(result));

13310

return resultobj;

13311

fail:

13312

return NULL;

13313

}

13314

13315

13316

SWIGINTERN PyObject *_wrap_RichTextPlainText_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13317

PyObject *resultobj = 0;

13318

wxRichTextPlainText *arg1 = (wxRichTextPlainText *) 0 ;

13319

wxString *result = 0 ;

13320

void *argp1 = 0 ;

13321

int res1 = 0 ;

13322

PyObject *swig_obj[1] ;

13323

13324

if (!args) SWIG_fail;

13325

swig_obj[0] = args;

13326

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPlainText, 0 | 0 );

13327

if (!SWIG_IsOK(res1)) {

13328

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPlainText_GetText" "', expected argument " "1"" of type '" "wxRichTextPlainText const *""'");

13329

}

13330

arg1 = reinterpret_cast< wxRichTextPlainText * >(argp1);

13331

{

13332

PyThreadState* __tstate = wxPyBeginAllowThreads();

13333

{

13334

wxString const &_result_ref = ((wxRichTextPlainText const *)arg1)->GetText();

13335

result = (wxString *) &_result_ref;

13336

}

13337

wxPyEndAllowThreads(__tstate);

13338

if (PyErr_Occurred()) SWIG_fail;

13339

}

13340

{

13341

#if wxUSE_UNICODE

13342

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

13343

#else

13344

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

13345

#endif

13346

}

13347

return resultobj;

13348

fail:

13349

return NULL;

13350

}

13351

13352

13353

SWIGINTERN PyObject *_wrap_RichTextPlainText_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13354

PyObject *resultobj = 0;

13355

wxRichTextPlainText *arg1 = (wxRichTextPlainText *) 0 ;

13356

wxString *arg2 = 0 ;

13357

void *argp1 = 0 ;

13358

int res1 = 0 ;

13359

bool temp2 = false ;

13360

PyObject * obj0 = 0 ;

13361

PyObject * obj1 = 0 ;

13362

char * kwnames[] = {

13363

(char *) "self",(char *) "text", NULL

13364

};

13365

13366

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPlainText_SetText",kwnames,&obj0,&obj1)) SWIG_fail;

13367

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPlainText, 0 | 0 );

13368

if (!SWIG_IsOK(res1)) {

13369

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPlainText_SetText" "', expected argument " "1"" of type '" "wxRichTextPlainText *""'");

13370

}

13371

arg1 = reinterpret_cast< wxRichTextPlainText * >(argp1);

13372

{

13373

arg2 = wxString_in_helper(obj1);

13374

if (arg2 == NULL) SWIG_fail;

13375

temp2 = true;

13376

}

13377

{

13378

PyThreadState* __tstate = wxPyBeginAllowThreads();

13379

(arg1)->SetText((wxString const &)*arg2);

13380

wxPyEndAllowThreads(__tstate);

13381

if (PyErr_Occurred()) SWIG_fail;

13382

}

13383

resultobj = SWIG_Py_Void();

13384

{

13385

if (temp2)

13386

delete arg2;

13387

}

13388

return resultobj;

13389

fail:

13390

{

13391

if (temp2)

13392

delete arg2;

13393

}

13394

return NULL;

13395

}

13396

13397

13398

SWIGINTERN PyObject *_wrap_RichTextPlainText_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13399

PyObject *resultobj = 0;

13400

wxRichTextPlainText *arg1 = (wxRichTextPlainText *) 0 ;

13401

wxRichTextPlainText *arg2 = 0 ;

13402

void *argp1 = 0 ;

13403

int res1 = 0 ;

13404

void *argp2 = 0 ;

13405

int res2 = 0 ;

13406

PyObject * obj0 = 0 ;

13407

PyObject * obj1 = 0 ;

13408

char * kwnames[] = {

13409

(char *) "self",(char *) "obj", NULL

13410

};

13411

13412

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPlainText_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

13413

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPlainText, 0 | 0 );

13414

if (!SWIG_IsOK(res1)) {

13415

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPlainText_Copy" "', expected argument " "1"" of type '" "wxRichTextPlainText *""'");

13416

}

13417

arg1 = reinterpret_cast< wxRichTextPlainText * >(argp1);

13418

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextPlainText, 0 | 0);

13419

if (!SWIG_IsOK(res2)) {

13420

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPlainText_Copy" "', expected argument " "2"" of type '" "wxRichTextPlainText const &""'");

13421

}

13422

if (!argp2) {

13423

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPlainText_Copy" "', expected argument " "2"" of type '" "wxRichTextPlainText const &""'");

13424

}

13425

arg2 = reinterpret_cast< wxRichTextPlainText * >(argp2);

13426

{

13427

PyThreadState* __tstate = wxPyBeginAllowThreads();

13428

(arg1)->Copy((wxRichTextPlainText const &)*arg2);

13429

wxPyEndAllowThreads(__tstate);

13430

if (PyErr_Occurred()) SWIG_fail;

13431

}

13432

resultobj = SWIG_Py_Void();

13433

return resultobj;

13434

fail:

13435

return NULL;

13436

}

13437

13438

13439

SWIGINTERN PyObject *RichTextPlainText_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13440

PyObject *obj;

13441

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

13442

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextPlainText, SWIG_NewClientData(obj));

13443

return SWIG_Py_Void();

13444

}

13445

13446

SWIGINTERN PyObject *RichTextPlainText_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13447

return SWIG_Python_InitShadowInstance(args);

13448

}

13449

13450

SWIGINTERN PyObject *_wrap_new_RichTextImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13451

PyObject *resultobj = 0;

13452

wxRichTextObject *arg1 = (wxRichTextObject *) NULL ;

13453

wxRichTextImage *result = 0 ;

13454

void *argp1 = 0 ;

13455

int res1 = 0 ;

13456

PyObject * obj0 = 0 ;

13457

char * kwnames[] = {

13458

(char *) "parent", NULL

13459

};

13460

13461

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_RichTextImage",kwnames,&obj0)) SWIG_fail;

13462

if (obj0) {

13463

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextObject, 0 | 0 );

13464

if (!SWIG_IsOK(res1)) {

13465

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RichTextImage" "', expected argument " "1"" of type '" "wxRichTextObject *""'");

13466

}

13467

arg1 = reinterpret_cast< wxRichTextObject * >(argp1);

13468

}

13469

{

13470

PyThreadState* __tstate = wxPyBeginAllowThreads();

13471

result = (wxRichTextImage *)new wxRichTextImage(arg1);

13472

wxPyEndAllowThreads(__tstate);

13473

if (PyErr_Occurred()) SWIG_fail;

13474

}

13475

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextImage, SWIG_POINTER_NEW | 0 );

13476

return resultobj;

13477

fail:

13478

return NULL;

13479

}

13480

13481

13482

SWIGINTERN PyObject *_wrap_RichTextImage_GetImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13483

PyObject *resultobj = 0;

13484

wxRichTextImage *arg1 = (wxRichTextImage *) 0 ;

13485

wxImage *result = 0 ;

13486

void *argp1 = 0 ;

13487

int res1 = 0 ;

13488

PyObject *swig_obj[1] ;

13489

13490

if (!args) SWIG_fail;

13491

swig_obj[0] = args;

13492

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextImage, 0 | 0 );

13493

if (!SWIG_IsOK(res1)) {

13494

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextImage_GetImage" "', expected argument " "1"" of type '" "wxRichTextImage const *""'");

13495

}

13496

arg1 = reinterpret_cast< wxRichTextImage * >(argp1);

13497

{

13498

PyThreadState* __tstate = wxPyBeginAllowThreads();

13499

{

13500

wxImage const &_result_ref = ((wxRichTextImage const *)arg1)->GetImage();

13501

result = (wxImage *) &_result_ref;

13502

}

13503

wxPyEndAllowThreads(__tstate);

13504

if (PyErr_Occurred()) SWIG_fail;

13505

}

13506

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );

13507

return resultobj;

13508

fail:

13509

return NULL;

13510

}

13511

13512

13513

SWIGINTERN PyObject *_wrap_RichTextImage_SetImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13514

PyObject *resultobj = 0;

13515

wxRichTextImage *arg1 = (wxRichTextImage *) 0 ;

13516

wxImage *arg2 = 0 ;

13517

void *argp1 = 0 ;

13518

int res1 = 0 ;

13519

void *argp2 = 0 ;

13520

int res2 = 0 ;

13521

PyObject * obj0 = 0 ;

13522

PyObject * obj1 = 0 ;

13523

char * kwnames[] = {

13524

(char *) "self",(char *) "image", NULL

13525

};

13526

13527

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextImage_SetImage",kwnames,&obj0,&obj1)) SWIG_fail;

13528

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextImage, 0 | 0 );

13529

if (!SWIG_IsOK(res1)) {

13530

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextImage_SetImage" "', expected argument " "1"" of type '" "wxRichTextImage *""'");

13531

}

13532

arg1 = reinterpret_cast< wxRichTextImage * >(argp1);

13533

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);

13534

if (!SWIG_IsOK(res2)) {

13535

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextImage_SetImage" "', expected argument " "2"" of type '" "wxImage const &""'");

13536

}

13537

if (!argp2) {

13538

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextImage_SetImage" "', expected argument " "2"" of type '" "wxImage const &""'");

13539

}

13540

arg2 = reinterpret_cast< wxImage * >(argp2);

13541

{

13542

PyThreadState* __tstate = wxPyBeginAllowThreads();

13543

(arg1)->SetImage((wxImage const &)*arg2);

13544

wxPyEndAllowThreads(__tstate);

13545

if (PyErr_Occurred()) SWIG_fail;

13546

}

13547

resultobj = SWIG_Py_Void();

13548

return resultobj;

13549

fail:

13550

return NULL;

13551

}

13552

13553

13554

SWIGINTERN PyObject *_wrap_RichTextImage_GetImageBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13555

PyObject *resultobj = 0;

13556

wxRichTextImage *arg1 = (wxRichTextImage *) 0 ;

13557

wxRichTextImageBlock *result = 0 ;

13558

void *argp1 = 0 ;

13559

int res1 = 0 ;

13560

PyObject *swig_obj[1] ;

13561

13562

if (!args) SWIG_fail;

13563

swig_obj[0] = args;

13564

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextImage, 0 | 0 );

13565

if (!SWIG_IsOK(res1)) {

13566

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextImage_GetImageBlock" "', expected argument " "1"" of type '" "wxRichTextImage *""'");

13567

}

13568

arg1 = reinterpret_cast< wxRichTextImage * >(argp1);

13569

{

13570

PyThreadState* __tstate = wxPyBeginAllowThreads();

13571

{

13572

wxRichTextImageBlock &_result_ref = (arg1)->GetImageBlock();

13573

result = (wxRichTextImageBlock *) &_result_ref;

13574

}

13575

wxPyEndAllowThreads(__tstate);

13576

if (PyErr_Occurred()) SWIG_fail;

13577

}

13578

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextImageBlock, 0 | 0 );

13579

return resultobj;

13580

fail:

13581

return NULL;

13582

}

13583

13584

13585

SWIGINTERN PyObject *_wrap_RichTextImage_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13586

PyObject *resultobj = 0;

13587

wxRichTextImage *arg1 = (wxRichTextImage *) 0 ;

13588

wxRichTextImage *arg2 = 0 ;

13589

void *argp1 = 0 ;

13590

int res1 = 0 ;

13591

void *argp2 = 0 ;

13592

int res2 = 0 ;

13593

PyObject * obj0 = 0 ;

13594

PyObject * obj1 = 0 ;

13595

char * kwnames[] = {

13596

(char *) "self",(char *) "obj", NULL

13597

};

13598

13599

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextImage_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

13600

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextImage, 0 | 0 );

13601

if (!SWIG_IsOK(res1)) {

13602

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextImage_Copy" "', expected argument " "1"" of type '" "wxRichTextImage *""'");

13603

}

13604

arg1 = reinterpret_cast< wxRichTextImage * >(argp1);

13605

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextImage, 0 | 0);

13606

if (!SWIG_IsOK(res2)) {

13607

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextImage_Copy" "', expected argument " "2"" of type '" "wxRichTextImage const &""'");

13608

}

13609

if (!argp2) {

13610

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextImage_Copy" "', expected argument " "2"" of type '" "wxRichTextImage const &""'");

13611

}

13612

arg2 = reinterpret_cast< wxRichTextImage * >(argp2);

13613

{

13614

PyThreadState* __tstate = wxPyBeginAllowThreads();

13615

(arg1)->Copy((wxRichTextImage const &)*arg2);

13616

wxPyEndAllowThreads(__tstate);

13617

if (PyErr_Occurred()) SWIG_fail;

13618

}

13619

resultobj = SWIG_Py_Void();

13620

return resultobj;

13621

fail:

13622

return NULL;

13623

}

13624

13625

13626

SWIGINTERN PyObject *_wrap_RichTextImage_LoadFromBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13627

PyObject *resultobj = 0;

13628

wxRichTextImage *arg1 = (wxRichTextImage *) 0 ;

13629

bool result;

13630

void *argp1 = 0 ;

13631

int res1 = 0 ;

13632

PyObject *swig_obj[1] ;

13633

13634

if (!args) SWIG_fail;

13635

swig_obj[0] = args;

13636

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextImage, 0 | 0 );

13637

if (!SWIG_IsOK(res1)) {

13638

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextImage_LoadFromBlock" "', expected argument " "1"" of type '" "wxRichTextImage *""'");

13639

}

13640

arg1 = reinterpret_cast< wxRichTextImage * >(argp1);

13641

{

13642

PyThreadState* __tstate = wxPyBeginAllowThreads();

13643

result = (bool)(arg1)->LoadFromBlock();

13644

wxPyEndAllowThreads(__tstate);

13645

if (PyErr_Occurred()) SWIG_fail;

13646

}

13647

{

13648

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

13649

}

13650

return resultobj;

13651

fail:

13652

return NULL;

13653

}

13654

13655

13656

SWIGINTERN PyObject *_wrap_RichTextImage_MakeBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13657

PyObject *resultobj = 0;

13658

wxRichTextImage *arg1 = (wxRichTextImage *) 0 ;

13659

bool result;

13660

void *argp1 = 0 ;

13661

int res1 = 0 ;

13662

PyObject *swig_obj[1] ;

13663

13664

if (!args) SWIG_fail;

13665

swig_obj[0] = args;

13666

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextImage, 0 | 0 );

13667

if (!SWIG_IsOK(res1)) {

13668

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextImage_MakeBlock" "', expected argument " "1"" of type '" "wxRichTextImage *""'");

13669

}

13670

arg1 = reinterpret_cast< wxRichTextImage * >(argp1);

13671

{

13672

PyThreadState* __tstate = wxPyBeginAllowThreads();

13673

result = (bool)(arg1)->MakeBlock();

13674

wxPyEndAllowThreads(__tstate);

13675

if (PyErr_Occurred()) SWIG_fail;

13676

}

13677

{

13678

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

13679

}

13680

return resultobj;

13681

fail:

13682

return NULL;

13683

}

13684

13685

13686

SWIGINTERN PyObject *RichTextImage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13687

PyObject *obj;

13688

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

13689

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextImage, SWIG_NewClientData(obj));

13690

return SWIG_Py_Void();

13691

}

13692

13693

SWIGINTERN PyObject *RichTextImage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13694

return SWIG_Python_InitShadowInstance(args);

13695

}

13696

13697

SWIGINTERN PyObject *_wrap_delete_RichTextFileHandlerList_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13698

PyObject *resultobj = 0;

13699

wxRichTextFileHandlerList_iterator *arg1 = (wxRichTextFileHandlerList_iterator *) 0 ;

13700

void *argp1 = 0 ;

13701

int res1 = 0 ;

13702

PyObject *swig_obj[1] ;

13703

13704

if (!args) SWIG_fail;

13705

swig_obj[0] = args;

13706

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandlerList_iterator, SWIG_POINTER_DISOWN | 0 );

13707

if (!SWIG_IsOK(res1)) {

13708

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextFileHandlerList_iterator" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList_iterator *""'");

13709

}

13710

arg1 = reinterpret_cast< wxRichTextFileHandlerList_iterator * >(argp1);

13711

{

13712

PyThreadState* __tstate = wxPyBeginAllowThreads();

13713

delete arg1;

13714

13715

wxPyEndAllowThreads(__tstate);

13716

if (PyErr_Occurred()) SWIG_fail;

13717

}

13718

resultobj = SWIG_Py_Void();

13719

return resultobj;

13720

fail:

13721

return NULL;

13722

}

13723

13724

13725

SWIGINTERN PyObject *_wrap_RichTextFileHandlerList_iterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13726

PyObject *resultobj = 0;

13727

wxRichTextFileHandlerList_iterator *arg1 = (wxRichTextFileHandlerList_iterator *) 0 ;

13728

wxRichTextFileHandler *result = 0 ;

13729

void *argp1 = 0 ;

13730

int res1 = 0 ;

13731

PyObject *swig_obj[1] ;

13732

13733

if (!args) SWIG_fail;

13734

swig_obj[0] = args;

13735

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandlerList_iterator, 0 | 0 );

13736

if (!SWIG_IsOK(res1)) {

13737

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandlerList_iterator_next" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList_iterator *""'");

13738

}

13739

arg1 = reinterpret_cast< wxRichTextFileHandlerList_iterator * >(argp1);

13740

{

13741

result = (wxRichTextFileHandler *)(arg1)->next();

13742

if (PyErr_Occurred()) SWIG_fail;

13743

}

13744

{

13745

resultobj = wxPyMake_wxObject(result, (bool)0);

13746

}

13747

return resultobj;

13748

fail:

13749

return NULL;

13750

}

13751

13752

13753

SWIGINTERN PyObject *RichTextFileHandlerList_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13754

PyObject *obj;

13755

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

13756

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextFileHandlerList_iterator, SWIG_NewClientData(obj));

13757

return SWIG_Py_Void();

13758

}

13759

13760

SWIGINTERN PyObject *_wrap_delete_RichTextFileHandlerList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13761

PyObject *resultobj = 0;

13762

wxRichTextFileHandlerList *arg1 = (wxRichTextFileHandlerList *) 0 ;

13763

void *argp1 = 0 ;

13764

int res1 = 0 ;

13765

PyObject *swig_obj[1] ;

13766

13767

if (!args) SWIG_fail;

13768

swig_obj[0] = args;

13769

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandlerList, SWIG_POINTER_DISOWN | 0 );

13770

if (!SWIG_IsOK(res1)) {

13771

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextFileHandlerList" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList *""'");

13772

}

13773

arg1 = reinterpret_cast< wxRichTextFileHandlerList * >(argp1);

13774

{

13775

PyThreadState* __tstate = wxPyBeginAllowThreads();

13776

delete arg1;

13777

13778

wxPyEndAllowThreads(__tstate);

13779

if (PyErr_Occurred()) SWIG_fail;

13780

}

13781

resultobj = SWIG_Py_Void();

13782

return resultobj;

13783

fail:

13784

return NULL;

13785

}

13786

13787

13788

SWIGINTERN PyObject *_wrap_RichTextFileHandlerList___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13789

PyObject *resultobj = 0;

13790

wxRichTextFileHandlerList *arg1 = (wxRichTextFileHandlerList *) 0 ;

13791

size_t result;

13792

void *argp1 = 0 ;

13793

int res1 = 0 ;

13794

PyObject *swig_obj[1] ;

13795

13796

if (!args) SWIG_fail;

13797

swig_obj[0] = args;

13798

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandlerList, 0 | 0 );

13799

if (!SWIG_IsOK(res1)) {

13800

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandlerList___len__" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList *""'");

13801

}

13802

arg1 = reinterpret_cast< wxRichTextFileHandlerList * >(argp1);

13803

{

13804

result = (size_t)wxRichTextFileHandlerList___len__(arg1);

13805

if (PyErr_Occurred()) SWIG_fail;

13806

}

13807

resultobj = SWIG_From_size_t(static_cast< size_t >(result));

13808

return resultobj;

13809

fail:

13810

return NULL;

13811

}

13812

13813

13814

SWIGINTERN PyObject *_wrap_RichTextFileHandlerList___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13815

PyObject *resultobj = 0;

13816

wxRichTextFileHandlerList *arg1 = (wxRichTextFileHandlerList *) 0 ;

13817

size_t arg2 ;

13818

wxRichTextFileHandler *result = 0 ;

13819

void *argp1 = 0 ;

13820

int res1 = 0 ;

13821

size_t val2 ;

13822

int ecode2 = 0 ;

13823

PyObject * obj0 = 0 ;

13824

PyObject * obj1 = 0 ;

13825

char * kwnames[] = {

13826

(char *) "self",(char *) "index", NULL

13827

};

13828

13829

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandlerList___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;

13830

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandlerList, 0 | 0 );

13831

if (!SWIG_IsOK(res1)) {

13832

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandlerList___getitem__" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList *""'");

13833

}

13834

arg1 = reinterpret_cast< wxRichTextFileHandlerList * >(argp1);

13835

ecode2 = SWIG_AsVal_size_t(obj1, &val2);

13836

if (!SWIG_IsOK(ecode2)) {

13837

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextFileHandlerList___getitem__" "', expected argument " "2"" of type '" "size_t""'");

13838

}

13839

arg2 = static_cast< size_t >(val2);

13840

{

13841

result = (wxRichTextFileHandler *)wxRichTextFileHandlerList___getitem__(arg1,arg2);

13842

if (PyErr_Occurred()) SWIG_fail;

13843

}

13844

{

13845

resultobj = wxPyMake_wxObject(result, (bool)0);

13846

}

13847

return resultobj;

13848

fail:

13849

return NULL;

13850

}

13851

13852

13853

SWIGINTERN PyObject *_wrap_RichTextFileHandlerList___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

13854

PyObject *resultobj = 0;

13855

wxRichTextFileHandlerList *arg1 = (wxRichTextFileHandlerList *) 0 ;

13856

wxRichTextFileHandler *arg2 = (wxRichTextFileHandler *) 0 ;

13857

bool result;

13858

void *argp1 = 0 ;

13859

int res1 = 0 ;

13860

void *argp2 = 0 ;

13861

int res2 = 0 ;

13862

PyObject * obj0 = 0 ;

13863

PyObject * obj1 = 0 ;

13864

char * kwnames[] = {

13865

(char *) "self",(char *) "obj", NULL

13866

};

13867

13868

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandlerList___contains__",kwnames,&obj0,&obj1)) SWIG_fail;

13869

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandlerList, 0 | 0 );

13870

if (!SWIG_IsOK(res1)) {

13871

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandlerList___contains__" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList *""'");

13872

}

13873

arg1 = reinterpret_cast< wxRichTextFileHandlerList * >(argp1);

13874

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

13875

if (!SWIG_IsOK(res2)) {

13876

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextFileHandlerList___contains__" "', expected argument " "2"" of type '" "wxRichTextFileHandler const *""'");

13877

}

13878

arg2 = reinterpret_cast< wxRichTextFileHandler * >(argp2);

13879

{

13880

result = (bool)wxRichTextFileHandlerList___contains__(arg1,(wxRichTextFileHandler const *)arg2);

13881

if (PyErr_Occurred()) SWIG_fail;

13882

}

13883

{

13884

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

13885

}

13886

return resultobj;

13887

fail:

13888

return NULL;

13889

}

13890

13891

13892

SWIGINTERN PyObject *_wrap_RichTextFileHandlerList___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13893

PyObject *resultobj = 0;

13894

wxRichTextFileHandlerList *arg1 = (wxRichTextFileHandlerList *) 0 ;

13895

wxRichTextFileHandlerList_iterator *result = 0 ;

13896

void *argp1 = 0 ;

13897

int res1 = 0 ;

13898

PyObject *swig_obj[1] ;

13899

13900

if (!args) SWIG_fail;

13901

swig_obj[0] = args;

13902

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandlerList, 0 | 0 );

13903

if (!SWIG_IsOK(res1)) {

13904

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandlerList___iter__" "', expected argument " "1"" of type '" "wxRichTextFileHandlerList *""'");

13905

}

13906

arg1 = reinterpret_cast< wxRichTextFileHandlerList * >(argp1);

13907

{

13908

result = (wxRichTextFileHandlerList_iterator *)wxRichTextFileHandlerList___iter__(arg1);

13909

if (PyErr_Occurred()) SWIG_fail;

13910

}

13911

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextFileHandlerList_iterator, SWIG_POINTER_OWN | 0 );

13912

return resultobj;

13913

fail:

13914

return NULL;

13915

}

13916

13917

13918

SWIGINTERN PyObject *RichTextFileHandlerList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13919

PyObject *obj;

13920

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

13921

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextFileHandlerList, SWIG_NewClientData(obj));

13922

return SWIG_Py_Void();

13923

}

13924

13925

SWIGINTERN PyObject *_wrap_new_RichTextBuffer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {

13926

PyObject *resultobj = 0;

13927

wxRichTextBuffer *result = 0 ;

13928

13929

if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;

13930

{

13931

PyThreadState* __tstate = wxPyBeginAllowThreads();

13932

result = (wxRichTextBuffer *)new wxRichTextBuffer();

13933

wxPyEndAllowThreads(__tstate);

13934

if (PyErr_Occurred()) SWIG_fail;

13935

}

13936

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, SWIG_POINTER_NEW | 0 );

13937

return resultobj;

13938

fail:

13939

return NULL;

13940

}

13941

13942

13943

SWIGINTERN PyObject *_wrap_new_RichTextBuffer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {

13944

PyObject *resultobj = 0;

13945

wxRichTextBuffer *arg1 = 0 ;

13946

wxRichTextBuffer *result = 0 ;

13947

void *argp1 = 0 ;

13948

int res1 = 0 ;

13949

13950

if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;

13951

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_wxRichTextBuffer, 0 | 0);

13952

if (!SWIG_IsOK(res1)) {

13953

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RichTextBuffer" "', expected argument " "1"" of type '" "wxRichTextBuffer const &""'");

13954

}

13955

if (!argp1) {

13956

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RichTextBuffer" "', expected argument " "1"" of type '" "wxRichTextBuffer const &""'");

13957

}

13958

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

13959

{

13960

PyThreadState* __tstate = wxPyBeginAllowThreads();

13961

result = (wxRichTextBuffer *)new wxRichTextBuffer((wxRichTextBuffer const &)*arg1);

13962

wxPyEndAllowThreads(__tstate);

13963

if (PyErr_Occurred()) SWIG_fail;

13964

}

13965

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, SWIG_POINTER_NEW | 0 );

13966

return resultobj;

13967

fail:

13968

return NULL;

13969

}

13970

13971

13972

SWIGINTERN PyObject *_wrap_new_RichTextBuffer(PyObject *self, PyObject *args) {

13973

int argc;

13974

PyObject *argv[2];

13975

13976

if (!(argc = SWIG_Python_UnpackTuple(args,"new_RichTextBuffer",0,1,argv))) SWIG_fail;

13977

--argc;

13978

if (argc == 0) {

13979

return _wrap_new_RichTextBuffer__SWIG_0(self, argc, argv);

13980

}

13981

if (argc == 1) {

13982

return _wrap_new_RichTextBuffer__SWIG_1(self, argc, argv);

13983

}

13984

13985

fail:

13986

SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'new_RichTextBuffer'");

13987

return NULL;

13988

}

13989

13990

13991

SWIGINTERN PyObject *_wrap_delete_RichTextBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

13992

PyObject *resultobj = 0;

13993

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

13994

void *argp1 = 0 ;

13995

int res1 = 0 ;

13996

PyObject *swig_obj[1] ;

13997

13998

if (!args) SWIG_fail;

13999

swig_obj[0] = args;

14000

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, SWIG_POINTER_DISOWN | 0 );

14001

if (!SWIG_IsOK(res1)) {

14002

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextBuffer" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14003

}

14004

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14005

{

14006

PyThreadState* __tstate = wxPyBeginAllowThreads();

14007

delete arg1;

14008

14009

wxPyEndAllowThreads(__tstate);

14010

if (PyErr_Occurred()) SWIG_fail;

14011

}

14012

resultobj = SWIG_Py_Void();

14013

return resultobj;

14014

fail:

14015

return NULL;

14016

}

14017

14018

14019

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetCommandProcessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14020

PyObject *resultobj = 0;

14021

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14022

wxCommandProcessor *result = 0 ;

14023

void *argp1 = 0 ;

14024

int res1 = 0 ;

14025

PyObject *swig_obj[1] ;

14026

14027

if (!args) SWIG_fail;

14028

swig_obj[0] = args;

14029

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14030

if (!SWIG_IsOK(res1)) {

14031

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_GetCommandProcessor" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

14032

}

14033

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14034

{

14035

PyThreadState* __tstate = wxPyBeginAllowThreads();

14036

result = (wxCommandProcessor *)((wxRichTextBuffer const *)arg1)->GetCommandProcessor();

14037

wxPyEndAllowThreads(__tstate);

14038

if (PyErr_Occurred()) SWIG_fail;

14039

}

14040

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandProcessor, 0 | 0 );

14041

return resultobj;

14042

fail:

14043

return NULL;

14044

}

14045

14046

14047

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14048

PyObject *resultobj = 0;

14049

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14050

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

14051

void *argp1 = 0 ;

14052

int res1 = 0 ;

14053

void *argp2 = 0 ;

14054

int res2 = 0 ;

14055

PyObject * obj0 = 0 ;

14056

PyObject * obj1 = 0 ;

14057

char * kwnames[] = {

14058

(char *) "self",(char *) "styleSheet", NULL

14059

};

14060

14061

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_SetStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

14062

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14063

if (!SWIG_IsOK(res1)) {

14064

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SetStyleSheet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14065

}

14066

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14067

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

14068

if (!SWIG_IsOK(res2)) {

14069

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_SetStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

14070

}

14071

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

14072

{

14073

PyThreadState* __tstate = wxPyBeginAllowThreads();

14074

(arg1)->SetStyleSheet(arg2);

14075

wxPyEndAllowThreads(__tstate);

14076

if (PyErr_Occurred()) SWIG_fail;

14077

}

14078

resultobj = SWIG_Py_Void();

14079

return resultobj;

14080

fail:

14081

return NULL;

14082

}

14083

14084

14085

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetStyleSheetAndNotify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14086

PyObject *resultobj = 0;

14087

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14088

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

14089

bool result;

14090

void *argp1 = 0 ;

14091

int res1 = 0 ;

14092

void *argp2 = 0 ;

14093

int res2 = 0 ;

14094

PyObject * obj0 = 0 ;

14095

PyObject * obj1 = 0 ;

14096

char * kwnames[] = {

14097

(char *) "self",(char *) "sheet", NULL

14098

};

14099

14100

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_SetStyleSheetAndNotify",kwnames,&obj0,&obj1)) SWIG_fail;

14101

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14102

if (!SWIG_IsOK(res1)) {

14103

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SetStyleSheetAndNotify" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14104

}

14105

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14106

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

14107

if (!SWIG_IsOK(res2)) {

14108

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_SetStyleSheetAndNotify" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

14109

}

14110

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

14111

{

14112

PyThreadState* __tstate = wxPyBeginAllowThreads();

14113

result = (bool)(arg1)->SetStyleSheetAndNotify(arg2);

14114

wxPyEndAllowThreads(__tstate);

14115

if (PyErr_Occurred()) SWIG_fail;

14116

}

14117

{

14118

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14119

}

14120

return resultobj;

14121

fail:

14122

return NULL;

14123

}

14124

14125

14126

SWIGINTERN PyObject *_wrap_RichTextBuffer_PushStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14127

PyObject *resultobj = 0;

14128

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14129

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

14130

bool result;

14131

void *argp1 = 0 ;

14132

int res1 = 0 ;

14133

void *argp2 = 0 ;

14134

int res2 = 0 ;

14135

PyObject * obj0 = 0 ;

14136

PyObject * obj1 = 0 ;

14137

char * kwnames[] = {

14138

(char *) "self",(char *) "styleSheet", NULL

14139

};

14140

14141

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_PushStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

14142

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14143

if (!SWIG_IsOK(res1)) {

14144

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_PushStyleSheet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14145

}

14146

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14147

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

14148

if (!SWIG_IsOK(res2)) {

14149

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_PushStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

14150

}

14151

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

14152

{

14153

PyThreadState* __tstate = wxPyBeginAllowThreads();

14154

result = (bool)(arg1)->PushStyleSheet(arg2);

14155

wxPyEndAllowThreads(__tstate);

14156

if (PyErr_Occurred()) SWIG_fail;

14157

}

14158

{

14159

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14160

}

14161

return resultobj;

14162

fail:

14163

return NULL;

14164

}

14165

14166

14167

SWIGINTERN PyObject *_wrap_RichTextBuffer_PopStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14168

PyObject *resultobj = 0;

14169

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14170

wxRichTextStyleSheet *result = 0 ;

14171

void *argp1 = 0 ;

14172

int res1 = 0 ;

14173

PyObject *swig_obj[1] ;

14174

14175

if (!args) SWIG_fail;

14176

swig_obj[0] = args;

14177

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14178

if (!SWIG_IsOK(res1)) {

14179

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_PopStyleSheet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14180

}

14181

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14182

{

14183

PyThreadState* __tstate = wxPyBeginAllowThreads();

14184

result = (wxRichTextStyleSheet *)(arg1)->PopStyleSheet();

14185

wxPyEndAllowThreads(__tstate);

14186

if (PyErr_Occurred()) SWIG_fail;

14187

}

14188

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

14189

return resultobj;

14190

fail:

14191

return NULL;

14192

}

14193

14194

14195

SWIGINTERN PyObject *_wrap_RichTextBuffer_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14196

PyObject *resultobj = 0;

14197

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14198

void *argp1 = 0 ;

14199

int res1 = 0 ;

14200

PyObject *swig_obj[1] ;

14201

14202

if (!args) SWIG_fail;

14203

swig_obj[0] = args;

14204

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14205

if (!SWIG_IsOK(res1)) {

14206

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_Init" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14207

}

14208

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14209

{

14210

PyThreadState* __tstate = wxPyBeginAllowThreads();

14211

(arg1)->Init();

14212

wxPyEndAllowThreads(__tstate);

14213

if (PyErr_Occurred()) SWIG_fail;

14214

}

14215

resultobj = SWIG_Py_Void();

14216

return resultobj;

14217

fail:

14218

return NULL;

14219

}

14220

14221

14222

SWIGINTERN PyObject *_wrap_RichTextBuffer_ResetAndClearCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14223

PyObject *resultobj = 0;

14224

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14225

void *argp1 = 0 ;

14226

int res1 = 0 ;

14227

PyObject *swig_obj[1] ;

14228

14229

if (!args) SWIG_fail;

14230

swig_obj[0] = args;

14231

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14232

if (!SWIG_IsOK(res1)) {

14233

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_ResetAndClearCommands" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14234

}

14235

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14236

{

14237

PyThreadState* __tstate = wxPyBeginAllowThreads();

14238

(arg1)->ResetAndClearCommands();

14239

wxPyEndAllowThreads(__tstate);

14240

if (PyErr_Occurred()) SWIG_fail;

14241

}

14242

resultobj = SWIG_Py_Void();

14243

return resultobj;

14244

fail:

14245

return NULL;

14246

}

14247

14248

14249

SWIGINTERN PyObject *_wrap_RichTextBuffer_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14250

PyObject *resultobj = 0;

14251

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14252

wxString *arg2 = 0 ;

14253

int arg3 = (int) wxRICHTEXT_TYPE_ANY ;

14254

bool result;

14255

void *argp1 = 0 ;

14256

int res1 = 0 ;

14257

bool temp2 = false ;

14258

int val3 ;

14259

int ecode3 = 0 ;

14260

PyObject * obj0 = 0 ;

14261

PyObject * obj1 = 0 ;

14262

PyObject * obj2 = 0 ;

14263

char * kwnames[] = {

14264

(char *) "self",(char *) "filename",(char *) "type", NULL

14265

};

14266

14267

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

14268

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14269

if (!SWIG_IsOK(res1)) {

14270

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_LoadFile" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14271

}

14272

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14273

{

14274

arg2 = wxString_in_helper(obj1);

14275

if (arg2 == NULL) SWIG_fail;

14276

temp2 = true;

14277

}

14278

if (obj2) {

14279

ecode3 = SWIG_AsVal_int(obj2, &val3);

14280

if (!SWIG_IsOK(ecode3)) {

14281

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_LoadFile" "', expected argument " "3"" of type '" "int""'");

14282

}

14283

arg3 = static_cast< int >(val3);

14284

}

14285

{

14286

PyThreadState* __tstate = wxPyBeginAllowThreads();

14287

result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);

14288

wxPyEndAllowThreads(__tstate);

14289

if (PyErr_Occurred()) SWIG_fail;

14290

}

14291

{

14292

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14293

}

14294

{

14295

if (temp2)

14296

delete arg2;

14297

}

14298

return resultobj;

14299

fail:

14300

{

14301

if (temp2)

14302

delete arg2;

14303

}

14304

return NULL;

14305

}

14306

14307

14308

SWIGINTERN PyObject *_wrap_RichTextBuffer_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14309

PyObject *resultobj = 0;

14310

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14311

wxString *arg2 = 0 ;

14312

int arg3 = (int) wxRICHTEXT_TYPE_ANY ;

14313

bool result;

14314

void *argp1 = 0 ;

14315

int res1 = 0 ;

14316

bool temp2 = false ;

14317

int val3 ;

14318

int ecode3 = 0 ;

14319

PyObject * obj0 = 0 ;

14320

PyObject * obj1 = 0 ;

14321

PyObject * obj2 = 0 ;

14322

char * kwnames[] = {

14323

(char *) "self",(char *) "filename",(char *) "type", NULL

14324

};

14325

14326

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

14327

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14328

if (!SWIG_IsOK(res1)) {

14329

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SaveFile" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14330

}

14331

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14332

{

14333

arg2 = wxString_in_helper(obj1);

14334

if (arg2 == NULL) SWIG_fail;

14335

temp2 = true;

14336

}

14337

if (obj2) {

14338

ecode3 = SWIG_AsVal_int(obj2, &val3);

14339

if (!SWIG_IsOK(ecode3)) {

14340

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_SaveFile" "', expected argument " "3"" of type '" "int""'");

14341

}

14342

arg3 = static_cast< int >(val3);

14343

}

14344

{

14345

PyThreadState* __tstate = wxPyBeginAllowThreads();

14346

result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);

14347

wxPyEndAllowThreads(__tstate);

14348

if (PyErr_Occurred()) SWIG_fail;

14349

}

14350

{

14351

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14352

}

14353

{

14354

if (temp2)

14355

delete arg2;

14356

}

14357

return resultobj;

14358

fail:

14359

{

14360

if (temp2)

14361

delete arg2;

14362

}

14363

return NULL;

14364

}

14365

14366

14367

SWIGINTERN PyObject *_wrap_RichTextBuffer_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14368

PyObject *resultobj = 0;

14369

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14370

wxInputStream *arg2 = 0 ;

14371

int arg3 = (int) wxRICHTEXT_TYPE_ANY ;

14372

bool result;

14373

void *argp1 = 0 ;

14374

int res1 = 0 ;

14375

wxPyInputStream *temp2 ;

14376

bool created2 ;

14377

int val3 ;

14378

int ecode3 = 0 ;

14379

PyObject * obj0 = 0 ;

14380

PyObject * obj1 = 0 ;

14381

PyObject * obj2 = 0 ;

14382

char * kwnames[] = {

14383

(char *) "self",(char *) "stream",(char *) "type", NULL

14384

};

14385

14386

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_LoadStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

14387

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14388

if (!SWIG_IsOK(res1)) {

14389

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_LoadStream" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14390

}

14391

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14392

{

14393

if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {

14394

arg2 = temp2->m_wxis;

14395

created2 = false;

14396

} else {

14397

PyErr_Clear(); // clear the failure of the wxPyConvert above

14398

arg2 = wxPyCBInputStream_create(obj1, false);

14399

if (arg2 == NULL) {

14400

PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");

14401

SWIG_fail;

14402

}

14403

created2 = true;

14404

}

14405

}

14406

if (obj2) {

14407

ecode3 = SWIG_AsVal_int(obj2, &val3);

14408

if (!SWIG_IsOK(ecode3)) {

14409

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_LoadStream" "', expected argument " "3"" of type '" "int""'");

14410

}

14411

arg3 = static_cast< int >(val3);

14412

}

14413

{

14414

PyThreadState* __tstate = wxPyBeginAllowThreads();

14415

result = (bool)(arg1)->LoadFile(*arg2,arg3);

14416

wxPyEndAllowThreads(__tstate);

14417

if (PyErr_Occurred()) SWIG_fail;

14418

}

14419

{

14420

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14421

}

14422

{

14423

if (created2) delete arg2;

14424

}

14425

return resultobj;

14426

fail:

14427

{

14428

if (created2) delete arg2;

14429

}

14430

return NULL;

14431

}

14432

14433

14434

SWIGINTERN PyObject *_wrap_RichTextBuffer_SaveStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14435

PyObject *resultobj = 0;

14436

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14437

wxOutputStream *arg2 = 0 ;

14438

int arg3 = (int) wxRICHTEXT_TYPE_ANY ;

14439

bool result;

14440

void *argp1 = 0 ;

14441

int res1 = 0 ;

14442

wxPyOutputStream *temp2 ;

14443

bool created2 ;

14444

int val3 ;

14445

int ecode3 = 0 ;

14446

PyObject * obj0 = 0 ;

14447

PyObject * obj1 = 0 ;

14448

PyObject * obj2 = 0 ;

14449

char * kwnames[] = {

14450

(char *) "self",(char *) "stream",(char *) "type", NULL

14451

};

14452

14453

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_SaveStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

14454

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14455

if (!SWIG_IsOK(res1)) {

14456

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SaveStream" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14457

}

14458

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14459

{

14460

if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyOutputStream"))) {

14461

arg2 = temp2->m_wxos;

14462

created2 = false;

14463

} else {

14464

PyErr_Clear(); // clear the failure of the wxPyConvert above

14465

arg2 = wxPyCBOutputStream_create(obj1, false);

14466

if (arg2 == NULL) {

14467

PyErr_SetString(PyExc_TypeError, "Expected wx.OutputStream or Python file-like object.");

14468

SWIG_fail;

14469

}

14470

created2 = true;

14471

}

14472

}

14473

if (obj2) {

14474

ecode3 = SWIG_AsVal_int(obj2, &val3);

14475

if (!SWIG_IsOK(ecode3)) {

14476

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_SaveStream" "', expected argument " "3"" of type '" "int""'");

14477

}

14478

arg3 = static_cast< int >(val3);

14479

}

14480

{

14481

PyThreadState* __tstate = wxPyBeginAllowThreads();

14482

result = (bool)(arg1)->SaveFile(*arg2,arg3);

14483

wxPyEndAllowThreads(__tstate);

14484

if (PyErr_Occurred()) SWIG_fail;

14485

}

14486

{

14487

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14488

}

14489

{

14490

if (created2) delete arg2;

14491

}

14492

return resultobj;

14493

fail:

14494

{

14495

if (created2) delete arg2;

14496

}

14497

return NULL;

14498

}

14499

14500

14501

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetHandlerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14502

PyObject *resultobj = 0;

14503

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14504

int arg2 ;

14505

void *argp1 = 0 ;

14506

int res1 = 0 ;

14507

int val2 ;

14508

int ecode2 = 0 ;

14509

PyObject * obj0 = 0 ;

14510

PyObject * obj1 = 0 ;

14511

char * kwnames[] = {

14512

(char *) "self",(char *) "flags", NULL

14513

};

14514

14515

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_SetHandlerFlags",kwnames,&obj0,&obj1)) SWIG_fail;

14516

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14517

if (!SWIG_IsOK(res1)) {

14518

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SetHandlerFlags" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14519

}

14520

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14521

ecode2 = SWIG_AsVal_int(obj1, &val2);

14522

if (!SWIG_IsOK(ecode2)) {

14523

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_SetHandlerFlags" "', expected argument " "2"" of type '" "int""'");

14524

}

14525

arg2 = static_cast< int >(val2);

14526

{

14527

PyThreadState* __tstate = wxPyBeginAllowThreads();

14528

(arg1)->SetHandlerFlags(arg2);

14529

wxPyEndAllowThreads(__tstate);

14530

if (PyErr_Occurred()) SWIG_fail;

14531

}

14532

resultobj = SWIG_Py_Void();

14533

return resultobj;

14534

fail:

14535

return NULL;

14536

}

14537

14538

14539

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetHandlerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14540

PyObject *resultobj = 0;

14541

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14542

int result;

14543

void *argp1 = 0 ;

14544

int res1 = 0 ;

14545

PyObject *swig_obj[1] ;

14546

14547

if (!args) SWIG_fail;

14548

swig_obj[0] = args;

14549

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14550

if (!SWIG_IsOK(res1)) {

14551

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_GetHandlerFlags" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

14552

}

14553

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14554

{

14555

PyThreadState* __tstate = wxPyBeginAllowThreads();

14556

result = (int)((wxRichTextBuffer const *)arg1)->GetHandlerFlags();

14557

wxPyEndAllowThreads(__tstate);

14558

if (PyErr_Occurred()) SWIG_fail;

14559

}

14560

resultobj = SWIG_From_int(static_cast< int >(result));

14561

return resultobj;

14562

fail:

14563

return NULL;

14564

}

14565

14566

14567

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginBatchUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14568

PyObject *resultobj = 0;

14569

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14570

wxString *arg2 = 0 ;

14571

bool result;

14572

void *argp1 = 0 ;

14573

int res1 = 0 ;

14574

bool temp2 = false ;

14575

PyObject * obj0 = 0 ;

14576

PyObject * obj1 = 0 ;

14577

char * kwnames[] = {

14578

(char *) "self",(char *) "cmdName", NULL

14579

};

14580

14581

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginBatchUndo",kwnames,&obj0,&obj1)) SWIG_fail;

14582

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14583

if (!SWIG_IsOK(res1)) {

14584

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginBatchUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14585

}

14586

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14587

{

14588

arg2 = wxString_in_helper(obj1);

14589

if (arg2 == NULL) SWIG_fail;

14590

temp2 = true;

14591

}

14592

{

14593

PyThreadState* __tstate = wxPyBeginAllowThreads();

14594

result = (bool)(arg1)->BeginBatchUndo((wxString const &)*arg2);

14595

wxPyEndAllowThreads(__tstate);

14596

if (PyErr_Occurred()) SWIG_fail;

14597

}

14598

{

14599

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14600

}

14601

{

14602

if (temp2)

14603

delete arg2;

14604

}

14605

return resultobj;

14606

fail:

14607

{

14608

if (temp2)

14609

delete arg2;

14610

}

14611

return NULL;

14612

}

14613

14614

14615

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndBatchUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14616

PyObject *resultobj = 0;

14617

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14618

bool result;

14619

void *argp1 = 0 ;

14620

int res1 = 0 ;

14621

PyObject *swig_obj[1] ;

14622

14623

if (!args) SWIG_fail;

14624

swig_obj[0] = args;

14625

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14626

if (!SWIG_IsOK(res1)) {

14627

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndBatchUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14628

}

14629

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14630

{

14631

PyThreadState* __tstate = wxPyBeginAllowThreads();

14632

result = (bool)(arg1)->EndBatchUndo();

14633

wxPyEndAllowThreads(__tstate);

14634

if (PyErr_Occurred()) SWIG_fail;

14635

}

14636

{

14637

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14638

}

14639

return resultobj;

14640

fail:

14641

return NULL;

14642

}

14643

14644

14645

SWIGINTERN PyObject *_wrap_RichTextBuffer_BatchingUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14646

PyObject *resultobj = 0;

14647

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14648

bool result;

14649

void *argp1 = 0 ;

14650

int res1 = 0 ;

14651

PyObject *swig_obj[1] ;

14652

14653

if (!args) SWIG_fail;

14654

swig_obj[0] = args;

14655

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14656

if (!SWIG_IsOK(res1)) {

14657

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BatchingUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

14658

}

14659

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14660

{

14661

PyThreadState* __tstate = wxPyBeginAllowThreads();

14662

result = (bool)((wxRichTextBuffer const *)arg1)->BatchingUndo();

14663

wxPyEndAllowThreads(__tstate);

14664

if (PyErr_Occurred()) SWIG_fail;

14665

}

14666

{

14667

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14668

}

14669

return resultobj;

14670

fail:

14671

return NULL;

14672

}

14673

14674

14675

SWIGINTERN PyObject *_wrap_RichTextBuffer_SubmitAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14676

PyObject *resultobj = 0;

14677

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14678

wxRichTextAction *arg2 = (wxRichTextAction *) 0 ;

14679

bool result;

14680

void *argp1 = 0 ;

14681

int res1 = 0 ;

14682

void *argp2 = 0 ;

14683

int res2 = 0 ;

14684

PyObject * obj0 = 0 ;

14685

PyObject * obj1 = 0 ;

14686

char * kwnames[] = {

14687

(char *) "self",(char *) "action", NULL

14688

};

14689

14690

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_SubmitAction",kwnames,&obj0,&obj1)) SWIG_fail;

14691

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14692

if (!SWIG_IsOK(res1)) {

14693

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SubmitAction" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14694

}

14695

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14696

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextAction, 0 | 0 );

14697

if (!SWIG_IsOK(res2)) {

14698

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_SubmitAction" "', expected argument " "2"" of type '" "wxRichTextAction *""'");

14699

}

14700

arg2 = reinterpret_cast< wxRichTextAction * >(argp2);

14701

{

14702

PyThreadState* __tstate = wxPyBeginAllowThreads();

14703

result = (bool)(arg1)->SubmitAction(arg2);

14704

wxPyEndAllowThreads(__tstate);

14705

if (PyErr_Occurred()) SWIG_fail;

14706

}

14707

{

14708

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14709

}

14710

return resultobj;

14711

fail:

14712

return NULL;

14713

}

14714

14715

14716

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetBatchedCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14717

PyObject *resultobj = 0;

14718

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14719

wxRichTextCommand *result = 0 ;

14720

void *argp1 = 0 ;

14721

int res1 = 0 ;

14722

PyObject *swig_obj[1] ;

14723

14724

if (!args) SWIG_fail;

14725

swig_obj[0] = args;

14726

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14727

if (!SWIG_IsOK(res1)) {

14728

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_GetBatchedCommand" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

14729

}

14730

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14731

{

14732

PyThreadState* __tstate = wxPyBeginAllowThreads();

14733

result = (wxRichTextCommand *)((wxRichTextBuffer const *)arg1)->GetBatchedCommand();

14734

wxPyEndAllowThreads(__tstate);

14735

if (PyErr_Occurred()) SWIG_fail;

14736

}

14737

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextCommand, 0 | 0 );

14738

return resultobj;

14739

fail:

14740

return NULL;

14741

}

14742

14743

14744

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginSuppressUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14745

PyObject *resultobj = 0;

14746

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14747

bool result;

14748

void *argp1 = 0 ;

14749

int res1 = 0 ;

14750

PyObject *swig_obj[1] ;

14751

14752

if (!args) SWIG_fail;

14753

swig_obj[0] = args;

14754

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14755

if (!SWIG_IsOK(res1)) {

14756

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginSuppressUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14757

}

14758

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14759

{

14760

PyThreadState* __tstate = wxPyBeginAllowThreads();

14761

result = (bool)(arg1)->BeginSuppressUndo();

14762

wxPyEndAllowThreads(__tstate);

14763

if (PyErr_Occurred()) SWIG_fail;

14764

}

14765

{

14766

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14767

}

14768

return resultobj;

14769

fail:

14770

return NULL;

14771

}

14772

14773

14774

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndSuppressUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14775

PyObject *resultobj = 0;

14776

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14777

bool result;

14778

void *argp1 = 0 ;

14779

int res1 = 0 ;

14780

PyObject *swig_obj[1] ;

14781

14782

if (!args) SWIG_fail;

14783

swig_obj[0] = args;

14784

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14785

if (!SWIG_IsOK(res1)) {

14786

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndSuppressUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14787

}

14788

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14789

{

14790

PyThreadState* __tstate = wxPyBeginAllowThreads();

14791

result = (bool)(arg1)->EndSuppressUndo();

14792

wxPyEndAllowThreads(__tstate);

14793

if (PyErr_Occurred()) SWIG_fail;

14794

}

14795

{

14796

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14797

}

14798

return resultobj;

14799

fail:

14800

return NULL;

14801

}

14802

14803

14804

SWIGINTERN PyObject *_wrap_RichTextBuffer_SuppressingUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14805

PyObject *resultobj = 0;

14806

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14807

bool result;

14808

void *argp1 = 0 ;

14809

int res1 = 0 ;

14810

PyObject *swig_obj[1] ;

14811

14812

if (!args) SWIG_fail;

14813

swig_obj[0] = args;

14814

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14815

if (!SWIG_IsOK(res1)) {

14816

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SuppressingUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

14817

}

14818

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14819

{

14820

PyThreadState* __tstate = wxPyBeginAllowThreads();

14821

result = (bool)((wxRichTextBuffer const *)arg1)->SuppressingUndo();

14822

wxPyEndAllowThreads(__tstate);

14823

if (PyErr_Occurred()) SWIG_fail;

14824

}

14825

{

14826

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14827

}

14828

return resultobj;

14829

fail:

14830

return NULL;

14831

}

14832

14833

14834

SWIGINTERN PyObject *_wrap_RichTextBuffer_CopyToClipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14835

PyObject *resultobj = 0;

14836

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14837

wxRichTextRange *arg2 = 0 ;

14838

bool result;

14839

void *argp1 = 0 ;

14840

int res1 = 0 ;

14841

wxRichTextRange temp2 ;

14842

PyObject * obj0 = 0 ;

14843

PyObject * obj1 = 0 ;

14844

char * kwnames[] = {

14845

(char *) "self",(char *) "range", NULL

14846

};

14847

14848

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_CopyToClipboard",kwnames,&obj0,&obj1)) SWIG_fail;

14849

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14850

if (!SWIG_IsOK(res1)) {

14851

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_CopyToClipboard" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14852

}

14853

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14854

{

14855

arg2 = &temp2;

14856

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

14857

}

14858

{

14859

PyThreadState* __tstate = wxPyBeginAllowThreads();

14860

result = (bool)(arg1)->CopyToClipboard((wxRichTextRange const &)*arg2);

14861

wxPyEndAllowThreads(__tstate);

14862

if (PyErr_Occurred()) SWIG_fail;

14863

}

14864

{

14865

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14866

}

14867

return resultobj;

14868

fail:

14869

return NULL;

14870

}

14871

14872

14873

SWIGINTERN PyObject *_wrap_RichTextBuffer_PasteFromClipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14874

PyObject *resultobj = 0;

14875

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14876

long arg2 ;

14877

bool result;

14878

void *argp1 = 0 ;

14879

int res1 = 0 ;

14880

long val2 ;

14881

int ecode2 = 0 ;

14882

PyObject * obj0 = 0 ;

14883

PyObject * obj1 = 0 ;

14884

char * kwnames[] = {

14885

(char *) "self",(char *) "position", NULL

14886

};

14887

14888

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_PasteFromClipboard",kwnames,&obj0,&obj1)) SWIG_fail;

14889

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14890

if (!SWIG_IsOK(res1)) {

14891

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_PasteFromClipboard" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14892

}

14893

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14894

ecode2 = SWIG_AsVal_long(obj1, &val2);

14895

if (!SWIG_IsOK(ecode2)) {

14896

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_PasteFromClipboard" "', expected argument " "2"" of type '" "long""'");

14897

}

14898

arg2 = static_cast< long >(val2);

14899

{

14900

PyThreadState* __tstate = wxPyBeginAllowThreads();

14901

result = (bool)(arg1)->PasteFromClipboard(arg2);

14902

wxPyEndAllowThreads(__tstate);

14903

if (PyErr_Occurred()) SWIG_fail;

14904

}

14905

{

14906

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14907

}

14908

return resultobj;

14909

fail:

14910

return NULL;

14911

}

14912

14913

14914

SWIGINTERN PyObject *_wrap_RichTextBuffer_CanPasteFromClipboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14915

PyObject *resultobj = 0;

14916

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14917

bool result;

14918

void *argp1 = 0 ;

14919

int res1 = 0 ;

14920

PyObject *swig_obj[1] ;

14921

14922

if (!args) SWIG_fail;

14923

swig_obj[0] = args;

14924

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14925

if (!SWIG_IsOK(res1)) {

14926

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_CanPasteFromClipboard" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

14927

}

14928

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14929

{

14930

PyThreadState* __tstate = wxPyBeginAllowThreads();

14931

result = (bool)((wxRichTextBuffer const *)arg1)->CanPasteFromClipboard();

14932

wxPyEndAllowThreads(__tstate);

14933

if (PyErr_Occurred()) SWIG_fail;

14934

}

14935

{

14936

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14937

}

14938

return resultobj;

14939

fail:

14940

return NULL;

14941

}

14942

14943

14944

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

14945

PyObject *resultobj = 0;

14946

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14947

wxTextAttrEx *arg2 = 0 ;

14948

bool result;

14949

void *argp1 = 0 ;

14950

int res1 = 0 ;

14951

void *argp2 = 0 ;

14952

int res2 = 0 ;

14953

PyObject * obj0 = 0 ;

14954

PyObject * obj1 = 0 ;

14955

char * kwnames[] = {

14956

(char *) "self",(char *) "style", NULL

14957

};

14958

14959

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginStyle",kwnames,&obj0,&obj1)) SWIG_fail;

14960

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14961

if (!SWIG_IsOK(res1)) {

14962

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

14963

}

14964

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

14965

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

14966

if (!SWIG_IsOK(res2)) {

14967

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_BeginStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

14968

}

14969

if (!argp2) {

14970

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBuffer_BeginStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

14971

}

14972

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

14973

{

14974

PyThreadState* __tstate = wxPyBeginAllowThreads();

14975

result = (bool)(arg1)->BeginStyle((wxTextAttrEx const &)*arg2);

14976

wxPyEndAllowThreads(__tstate);

14977

if (PyErr_Occurred()) SWIG_fail;

14978

}

14979

{

14980

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

14981

}

14982

return resultobj;

14983

fail:

14984

return NULL;

14985

}

14986

14987

14988

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

14989

PyObject *resultobj = 0;

14990

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

14991

bool result;

14992

void *argp1 = 0 ;

14993

int res1 = 0 ;

14994

PyObject *swig_obj[1] ;

14995

14996

if (!args) SWIG_fail;

14997

swig_obj[0] = args;

14998

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

14999

if (!SWIG_IsOK(res1)) {

15000

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15001

}

15002

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15003

{

15004

PyThreadState* __tstate = wxPyBeginAllowThreads();

15005

result = (bool)(arg1)->EndStyle();

15006

wxPyEndAllowThreads(__tstate);

15007

if (PyErr_Occurred()) SWIG_fail;

15008

}

15009

{

15010

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15011

}

15012

return resultobj;

15013

fail:

15014

return NULL;

15015

}

15016

15017

15018

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndAllStyles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15019

PyObject *resultobj = 0;

15020

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15021

bool result;

15022

void *argp1 = 0 ;

15023

int res1 = 0 ;

15024

PyObject *swig_obj[1] ;

15025

15026

if (!args) SWIG_fail;

15027

swig_obj[0] = args;

15028

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15029

if (!SWIG_IsOK(res1)) {

15030

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndAllStyles" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15031

}

15032

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15033

{

15034

PyThreadState* __tstate = wxPyBeginAllowThreads();

15035

result = (bool)(arg1)->EndAllStyles();

15036

wxPyEndAllowThreads(__tstate);

15037

if (PyErr_Occurred()) SWIG_fail;

15038

}

15039

{

15040

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15041

}

15042

return resultobj;

15043

fail:

15044

return NULL;

15045

}

15046

15047

15048

SWIGINTERN PyObject *_wrap_RichTextBuffer_ClearStyleStack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15049

PyObject *resultobj = 0;

15050

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15051

void *argp1 = 0 ;

15052

int res1 = 0 ;

15053

PyObject *swig_obj[1] ;

15054

15055

if (!args) SWIG_fail;

15056

swig_obj[0] = args;

15057

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15058

if (!SWIG_IsOK(res1)) {

15059

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_ClearStyleStack" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15060

}

15061

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15062

{

15063

PyThreadState* __tstate = wxPyBeginAllowThreads();

15064

(arg1)->ClearStyleStack();

15065

wxPyEndAllowThreads(__tstate);

15066

if (PyErr_Occurred()) SWIG_fail;

15067

}

15068

resultobj = SWIG_Py_Void();

15069

return resultobj;

15070

fail:

15071

return NULL;

15072

}

15073

15074

15075

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetStyleStackSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15076

PyObject *resultobj = 0;

15077

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15078

size_t result;

15079

void *argp1 = 0 ;

15080

int res1 = 0 ;

15081

PyObject *swig_obj[1] ;

15082

15083

if (!args) SWIG_fail;

15084

swig_obj[0] = args;

15085

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15086

if (!SWIG_IsOK(res1)) {

15087

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_GetStyleStackSize" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

15088

}

15089

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15090

{

15091

PyThreadState* __tstate = wxPyBeginAllowThreads();

15092

result = (size_t)((wxRichTextBuffer const *)arg1)->GetStyleStackSize();

15093

wxPyEndAllowThreads(__tstate);

15094

if (PyErr_Occurred()) SWIG_fail;

15095

}

15096

resultobj = SWIG_From_size_t(static_cast< size_t >(result));

15097

return resultobj;

15098

fail:

15099

return NULL;

15100

}

15101

15102

15103

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15104

PyObject *resultobj = 0;

15105

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15106

bool result;

15107

void *argp1 = 0 ;

15108

int res1 = 0 ;

15109

PyObject *swig_obj[1] ;

15110

15111

if (!args) SWIG_fail;

15112

swig_obj[0] = args;

15113

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15114

if (!SWIG_IsOK(res1)) {

15115

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginBold" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15116

}

15117

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15118

{

15119

PyThreadState* __tstate = wxPyBeginAllowThreads();

15120

result = (bool)(arg1)->BeginBold();

15121

wxPyEndAllowThreads(__tstate);

15122

if (PyErr_Occurred()) SWIG_fail;

15123

}

15124

{

15125

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15126

}

15127

return resultobj;

15128

fail:

15129

return NULL;

15130

}

15131

15132

15133

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15134

PyObject *resultobj = 0;

15135

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15136

bool result;

15137

void *argp1 = 0 ;

15138

int res1 = 0 ;

15139

PyObject *swig_obj[1] ;

15140

15141

if (!args) SWIG_fail;

15142

swig_obj[0] = args;

15143

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15144

if (!SWIG_IsOK(res1)) {

15145

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndBold" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15146

}

15147

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15148

{

15149

PyThreadState* __tstate = wxPyBeginAllowThreads();

15150

result = (bool)(arg1)->EndBold();

15151

wxPyEndAllowThreads(__tstate);

15152

if (PyErr_Occurred()) SWIG_fail;

15153

}

15154

{

15155

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15156

}

15157

return resultobj;

15158

fail:

15159

return NULL;

15160

}

15161

15162

15163

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginItalic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15164

PyObject *resultobj = 0;

15165

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15166

bool result;

15167

void *argp1 = 0 ;

15168

int res1 = 0 ;

15169

PyObject *swig_obj[1] ;

15170

15171

if (!args) SWIG_fail;

15172

swig_obj[0] = args;

15173

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15174

if (!SWIG_IsOK(res1)) {

15175

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginItalic" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15176

}

15177

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15178

{

15179

PyThreadState* __tstate = wxPyBeginAllowThreads();

15180

result = (bool)(arg1)->BeginItalic();

15181

wxPyEndAllowThreads(__tstate);

15182

if (PyErr_Occurred()) SWIG_fail;

15183

}

15184

{

15185

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15186

}

15187

return resultobj;

15188

fail:

15189

return NULL;

15190

}

15191

15192

15193

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndItalic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15194

PyObject *resultobj = 0;

15195

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15196

bool result;

15197

void *argp1 = 0 ;

15198

int res1 = 0 ;

15199

PyObject *swig_obj[1] ;

15200

15201

if (!args) SWIG_fail;

15202

swig_obj[0] = args;

15203

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15204

if (!SWIG_IsOK(res1)) {

15205

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndItalic" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15206

}

15207

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15208

{

15209

PyThreadState* __tstate = wxPyBeginAllowThreads();

15210

result = (bool)(arg1)->EndItalic();

15211

wxPyEndAllowThreads(__tstate);

15212

if (PyErr_Occurred()) SWIG_fail;

15213

}

15214

{

15215

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15216

}

15217

return resultobj;

15218

fail:

15219

return NULL;

15220

}

15221

15222

15223

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginUnderline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15224

PyObject *resultobj = 0;

15225

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15226

bool result;

15227

void *argp1 = 0 ;

15228

int res1 = 0 ;

15229

PyObject *swig_obj[1] ;

15230

15231

if (!args) SWIG_fail;

15232

swig_obj[0] = args;

15233

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15234

if (!SWIG_IsOK(res1)) {

15235

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginUnderline" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15236

}

15237

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15238

{

15239

PyThreadState* __tstate = wxPyBeginAllowThreads();

15240

result = (bool)(arg1)->BeginUnderline();

15241

wxPyEndAllowThreads(__tstate);

15242

if (PyErr_Occurred()) SWIG_fail;

15243

}

15244

{

15245

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15246

}

15247

return resultobj;

15248

fail:

15249

return NULL;

15250

}

15251

15252

15253

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndUnderline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15254

PyObject *resultobj = 0;

15255

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15256

bool result;

15257

void *argp1 = 0 ;

15258

int res1 = 0 ;

15259

PyObject *swig_obj[1] ;

15260

15261

if (!args) SWIG_fail;

15262

swig_obj[0] = args;

15263

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15264

if (!SWIG_IsOK(res1)) {

15265

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndUnderline" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15266

}

15267

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15268

{

15269

PyThreadState* __tstate = wxPyBeginAllowThreads();

15270

result = (bool)(arg1)->EndUnderline();

15271

wxPyEndAllowThreads(__tstate);

15272

if (PyErr_Occurred()) SWIG_fail;

15273

}

15274

{

15275

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15276

}

15277

return resultobj;

15278

fail:

15279

return NULL;

15280

}

15281

15282

15283

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15284

PyObject *resultobj = 0;

15285

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15286

int arg2 ;

15287

bool result;

15288

void *argp1 = 0 ;

15289

int res1 = 0 ;

15290

int val2 ;

15291

int ecode2 = 0 ;

15292

PyObject * obj0 = 0 ;

15293

PyObject * obj1 = 0 ;

15294

char * kwnames[] = {

15295

(char *) "self",(char *) "pointSize", NULL

15296

};

15297

15298

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginFontSize",kwnames,&obj0,&obj1)) SWIG_fail;

15299

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15300

if (!SWIG_IsOK(res1)) {

15301

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginFontSize" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15302

}

15303

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15304

ecode2 = SWIG_AsVal_int(obj1, &val2);

15305

if (!SWIG_IsOK(ecode2)) {

15306

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginFontSize" "', expected argument " "2"" of type '" "int""'");

15307

}

15308

arg2 = static_cast< int >(val2);

15309

{

15310

PyThreadState* __tstate = wxPyBeginAllowThreads();

15311

result = (bool)(arg1)->BeginFontSize(arg2);

15312

wxPyEndAllowThreads(__tstate);

15313

if (PyErr_Occurred()) SWIG_fail;

15314

}

15315

{

15316

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15317

}

15318

return resultobj;

15319

fail:

15320

return NULL;

15321

}

15322

15323

15324

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15325

PyObject *resultobj = 0;

15326

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15327

bool result;

15328

void *argp1 = 0 ;

15329

int res1 = 0 ;

15330

PyObject *swig_obj[1] ;

15331

15332

if (!args) SWIG_fail;

15333

swig_obj[0] = args;

15334

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15335

if (!SWIG_IsOK(res1)) {

15336

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndFontSize" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15337

}

15338

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15339

{

15340

PyThreadState* __tstate = wxPyBeginAllowThreads();

15341

result = (bool)(arg1)->EndFontSize();

15342

wxPyEndAllowThreads(__tstate);

15343

if (PyErr_Occurred()) SWIG_fail;

15344

}

15345

{

15346

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15347

}

15348

return resultobj;

15349

fail:

15350

return NULL;

15351

}

15352

15353

15354

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15355

PyObject *resultobj = 0;

15356

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15357

wxFont *arg2 = 0 ;

15358

bool result;

15359

void *argp1 = 0 ;

15360

int res1 = 0 ;

15361

void *argp2 = 0 ;

15362

int res2 = 0 ;

15363

PyObject * obj0 = 0 ;

15364

PyObject * obj1 = 0 ;

15365

char * kwnames[] = {

15366

(char *) "self",(char *) "font", NULL

15367

};

15368

15369

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginFont",kwnames,&obj0,&obj1)) SWIG_fail;

15370

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15371

if (!SWIG_IsOK(res1)) {

15372

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginFont" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15373

}

15374

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15375

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);

15376

if (!SWIG_IsOK(res2)) {

15377

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_BeginFont" "', expected argument " "2"" of type '" "wxFont const &""'");

15378

}

15379

if (!argp2) {

15380

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBuffer_BeginFont" "', expected argument " "2"" of type '" "wxFont const &""'");

15381

}

15382

arg2 = reinterpret_cast< wxFont * >(argp2);

15383

{

15384

PyThreadState* __tstate = wxPyBeginAllowThreads();

15385

result = (bool)(arg1)->BeginFont((wxFont const &)*arg2);

15386

wxPyEndAllowThreads(__tstate);

15387

if (PyErr_Occurred()) SWIG_fail;

15388

}

15389

{

15390

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15391

}

15392

return resultobj;

15393

fail:

15394

return NULL;

15395

}

15396

15397

15398

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15399

PyObject *resultobj = 0;

15400

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15401

bool result;

15402

void *argp1 = 0 ;

15403

int res1 = 0 ;

15404

PyObject *swig_obj[1] ;

15405

15406

if (!args) SWIG_fail;

15407

swig_obj[0] = args;

15408

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15409

if (!SWIG_IsOK(res1)) {

15410

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndFont" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15411

}

15412

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15413

{

15414

PyThreadState* __tstate = wxPyBeginAllowThreads();

15415

result = (bool)(arg1)->EndFont();

15416

wxPyEndAllowThreads(__tstate);

15417

if (PyErr_Occurred()) SWIG_fail;

15418

}

15419

{

15420

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15421

}

15422

return resultobj;

15423

fail:

15424

return NULL;

15425

}

15426

15427

15428

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15429

PyObject *resultobj = 0;

15430

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15431

wxColour *arg2 = 0 ;

15432

bool result;

15433

void *argp1 = 0 ;

15434

int res1 = 0 ;

15435

wxColour temp2 ;

15436

PyObject * obj0 = 0 ;

15437

PyObject * obj1 = 0 ;

15438

char * kwnames[] = {

15439

(char *) "self",(char *) "colour", NULL

15440

};

15441

15442

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginTextColour",kwnames,&obj0,&obj1)) SWIG_fail;

15443

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15444

if (!SWIG_IsOK(res1)) {

15445

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginTextColour" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15446

}

15447

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15448

{

15449

arg2 = &temp2;

15450

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

15451

}

15452

{

15453

PyThreadState* __tstate = wxPyBeginAllowThreads();

15454

result = (bool)(arg1)->BeginTextColour((wxColour const &)*arg2);

15455

wxPyEndAllowThreads(__tstate);

15456

if (PyErr_Occurred()) SWIG_fail;

15457

}

15458

{

15459

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15460

}

15461

return resultobj;

15462

fail:

15463

return NULL;

15464

}

15465

15466

15467

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15468

PyObject *resultobj = 0;

15469

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15470

bool result;

15471

void *argp1 = 0 ;

15472

int res1 = 0 ;

15473

PyObject *swig_obj[1] ;

15474

15475

if (!args) SWIG_fail;

15476

swig_obj[0] = args;

15477

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15478

if (!SWIG_IsOK(res1)) {

15479

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndTextColour" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15480

}

15481

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15482

{

15483

PyThreadState* __tstate = wxPyBeginAllowThreads();

15484

result = (bool)(arg1)->EndTextColour();

15485

wxPyEndAllowThreads(__tstate);

15486

if (PyErr_Occurred()) SWIG_fail;

15487

}

15488

{

15489

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15490

}

15491

return resultobj;

15492

fail:

15493

return NULL;

15494

}

15495

15496

15497

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15498

PyObject *resultobj = 0;

15499

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15500

wxTextAttrAlignment arg2 ;

15501

bool result;

15502

void *argp1 = 0 ;

15503

int res1 = 0 ;

15504

int val2 ;

15505

int ecode2 = 0 ;

15506

PyObject * obj0 = 0 ;

15507

PyObject * obj1 = 0 ;

15508

char * kwnames[] = {

15509

(char *) "self",(char *) "alignment", NULL

15510

};

15511

15512

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginAlignment",kwnames,&obj0,&obj1)) SWIG_fail;

15513

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15514

if (!SWIG_IsOK(res1)) {

15515

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginAlignment" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15516

}

15517

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15518

ecode2 = SWIG_AsVal_int(obj1, &val2);

15519

if (!SWIG_IsOK(ecode2)) {

15520

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginAlignment" "', expected argument " "2"" of type '" "wxTextAttrAlignment""'");

15521

}

15522

arg2 = static_cast< wxTextAttrAlignment >(val2);

15523

{

15524

PyThreadState* __tstate = wxPyBeginAllowThreads();

15525

result = (bool)(arg1)->BeginAlignment(arg2);

15526

wxPyEndAllowThreads(__tstate);

15527

if (PyErr_Occurred()) SWIG_fail;

15528

}

15529

{

15530

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15531

}

15532

return resultobj;

15533

fail:

15534

return NULL;

15535

}

15536

15537

15538

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15539

PyObject *resultobj = 0;

15540

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15541

bool result;

15542

void *argp1 = 0 ;

15543

int res1 = 0 ;

15544

PyObject *swig_obj[1] ;

15545

15546

if (!args) SWIG_fail;

15547

swig_obj[0] = args;

15548

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15549

if (!SWIG_IsOK(res1)) {

15550

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndAlignment" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15551

}

15552

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15553

{

15554

PyThreadState* __tstate = wxPyBeginAllowThreads();

15555

result = (bool)(arg1)->EndAlignment();

15556

wxPyEndAllowThreads(__tstate);

15557

if (PyErr_Occurred()) SWIG_fail;

15558

}

15559

{

15560

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15561

}

15562

return resultobj;

15563

fail:

15564

return NULL;

15565

}

15566

15567

15568

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15569

PyObject *resultobj = 0;

15570

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15571

int arg2 ;

15572

int arg3 = (int) 0 ;

15573

bool result;

15574

void *argp1 = 0 ;

15575

int res1 = 0 ;

15576

int val2 ;

15577

int ecode2 = 0 ;

15578

int val3 ;

15579

int ecode3 = 0 ;

15580

PyObject * obj0 = 0 ;

15581

PyObject * obj1 = 0 ;

15582

PyObject * obj2 = 0 ;

15583

char * kwnames[] = {

15584

(char *) "self",(char *) "leftIndent",(char *) "leftSubIndent", NULL

15585

};

15586

15587

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_BeginLeftIndent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

15588

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15589

if (!SWIG_IsOK(res1)) {

15590

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginLeftIndent" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15591

}

15592

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15593

ecode2 = SWIG_AsVal_int(obj1, &val2);

15594

if (!SWIG_IsOK(ecode2)) {

15595

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginLeftIndent" "', expected argument " "2"" of type '" "int""'");

15596

}

15597

arg2 = static_cast< int >(val2);

15598

if (obj2) {

15599

ecode3 = SWIG_AsVal_int(obj2, &val3);

15600

if (!SWIG_IsOK(ecode3)) {

15601

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_BeginLeftIndent" "', expected argument " "3"" of type '" "int""'");

15602

}

15603

arg3 = static_cast< int >(val3);

15604

}

15605

{

15606

PyThreadState* __tstate = wxPyBeginAllowThreads();

15607

result = (bool)(arg1)->BeginLeftIndent(arg2,arg3);

15608

wxPyEndAllowThreads(__tstate);

15609

if (PyErr_Occurred()) SWIG_fail;

15610

}

15611

{

15612

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15613

}

15614

return resultobj;

15615

fail:

15616

return NULL;

15617

}

15618

15619

15620

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15621

PyObject *resultobj = 0;

15622

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15623

bool result;

15624

void *argp1 = 0 ;

15625

int res1 = 0 ;

15626

PyObject *swig_obj[1] ;

15627

15628

if (!args) SWIG_fail;

15629

swig_obj[0] = args;

15630

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15631

if (!SWIG_IsOK(res1)) {

15632

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndLeftIndent" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15633

}

15634

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15635

{

15636

PyThreadState* __tstate = wxPyBeginAllowThreads();

15637

result = (bool)(arg1)->EndLeftIndent();

15638

wxPyEndAllowThreads(__tstate);

15639

if (PyErr_Occurred()) SWIG_fail;

15640

}

15641

{

15642

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15643

}

15644

return resultobj;

15645

fail:

15646

return NULL;

15647

}

15648

15649

15650

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15651

PyObject *resultobj = 0;

15652

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15653

int arg2 ;

15654

bool result;

15655

void *argp1 = 0 ;

15656

int res1 = 0 ;

15657

int val2 ;

15658

int ecode2 = 0 ;

15659

PyObject * obj0 = 0 ;

15660

PyObject * obj1 = 0 ;

15661

char * kwnames[] = {

15662

(char *) "self",(char *) "rightIndent", NULL

15663

};

15664

15665

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginRightIndent",kwnames,&obj0,&obj1)) SWIG_fail;

15666

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15667

if (!SWIG_IsOK(res1)) {

15668

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginRightIndent" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15669

}

15670

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15671

ecode2 = SWIG_AsVal_int(obj1, &val2);

15672

if (!SWIG_IsOK(ecode2)) {

15673

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginRightIndent" "', expected argument " "2"" of type '" "int""'");

15674

}

15675

arg2 = static_cast< int >(val2);

15676

{

15677

PyThreadState* __tstate = wxPyBeginAllowThreads();

15678

result = (bool)(arg1)->BeginRightIndent(arg2);

15679

wxPyEndAllowThreads(__tstate);

15680

if (PyErr_Occurred()) SWIG_fail;

15681

}

15682

{

15683

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15684

}

15685

return resultobj;

15686

fail:

15687

return NULL;

15688

}

15689

15690

15691

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15692

PyObject *resultobj = 0;

15693

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15694

bool result;

15695

void *argp1 = 0 ;

15696

int res1 = 0 ;

15697

PyObject *swig_obj[1] ;

15698

15699

if (!args) SWIG_fail;

15700

swig_obj[0] = args;

15701

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15702

if (!SWIG_IsOK(res1)) {

15703

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndRightIndent" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15704

}

15705

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15706

{

15707

PyThreadState* __tstate = wxPyBeginAllowThreads();

15708

result = (bool)(arg1)->EndRightIndent();

15709

wxPyEndAllowThreads(__tstate);

15710

if (PyErr_Occurred()) SWIG_fail;

15711

}

15712

{

15713

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15714

}

15715

return resultobj;

15716

fail:

15717

return NULL;

15718

}

15719

15720

15721

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginParagraphSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15722

PyObject *resultobj = 0;

15723

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15724

int arg2 ;

15725

int arg3 ;

15726

bool result;

15727

void *argp1 = 0 ;

15728

int res1 = 0 ;

15729

int val2 ;

15730

int ecode2 = 0 ;

15731

int val3 ;

15732

int ecode3 = 0 ;

15733

PyObject * obj0 = 0 ;

15734

PyObject * obj1 = 0 ;

15735

PyObject * obj2 = 0 ;

15736

char * kwnames[] = {

15737

(char *) "self",(char *) "before",(char *) "after", NULL

15738

};

15739

15740

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextBuffer_BeginParagraphSpacing",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

15741

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15742

if (!SWIG_IsOK(res1)) {

15743

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginParagraphSpacing" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15744

}

15745

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15746

ecode2 = SWIG_AsVal_int(obj1, &val2);

15747

if (!SWIG_IsOK(ecode2)) {

15748

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginParagraphSpacing" "', expected argument " "2"" of type '" "int""'");

15749

}

15750

arg2 = static_cast< int >(val2);

15751

ecode3 = SWIG_AsVal_int(obj2, &val3);

15752

if (!SWIG_IsOK(ecode3)) {

15753

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_BeginParagraphSpacing" "', expected argument " "3"" of type '" "int""'");

15754

}

15755

arg3 = static_cast< int >(val3);

15756

{

15757

PyThreadState* __tstate = wxPyBeginAllowThreads();

15758

result = (bool)(arg1)->BeginParagraphSpacing(arg2,arg3);

15759

wxPyEndAllowThreads(__tstate);

15760

if (PyErr_Occurred()) SWIG_fail;

15761

}

15762

{

15763

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15764

}

15765

return resultobj;

15766

fail:

15767

return NULL;

15768

}

15769

15770

15771

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndParagraphSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15772

PyObject *resultobj = 0;

15773

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15774

bool result;

15775

void *argp1 = 0 ;

15776

int res1 = 0 ;

15777

PyObject *swig_obj[1] ;

15778

15779

if (!args) SWIG_fail;

15780

swig_obj[0] = args;

15781

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15782

if (!SWIG_IsOK(res1)) {

15783

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndParagraphSpacing" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15784

}

15785

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15786

{

15787

PyThreadState* __tstate = wxPyBeginAllowThreads();

15788

result = (bool)(arg1)->EndParagraphSpacing();

15789

wxPyEndAllowThreads(__tstate);

15790

if (PyErr_Occurred()) SWIG_fail;

15791

}

15792

{

15793

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15794

}

15795

return resultobj;

15796

fail:

15797

return NULL;

15798

}

15799

15800

15801

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15802

PyObject *resultobj = 0;

15803

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15804

int arg2 ;

15805

bool result;

15806

void *argp1 = 0 ;

15807

int res1 = 0 ;

15808

int val2 ;

15809

int ecode2 = 0 ;

15810

PyObject * obj0 = 0 ;

15811

PyObject * obj1 = 0 ;

15812

char * kwnames[] = {

15813

(char *) "self",(char *) "lineSpacing", NULL

15814

};

15815

15816

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginLineSpacing",kwnames,&obj0,&obj1)) SWIG_fail;

15817

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15818

if (!SWIG_IsOK(res1)) {

15819

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginLineSpacing" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15820

}

15821

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15822

ecode2 = SWIG_AsVal_int(obj1, &val2);

15823

if (!SWIG_IsOK(ecode2)) {

15824

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginLineSpacing" "', expected argument " "2"" of type '" "int""'");

15825

}

15826

arg2 = static_cast< int >(val2);

15827

{

15828

PyThreadState* __tstate = wxPyBeginAllowThreads();

15829

result = (bool)(arg1)->BeginLineSpacing(arg2);

15830

wxPyEndAllowThreads(__tstate);

15831

if (PyErr_Occurred()) SWIG_fail;

15832

}

15833

{

15834

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15835

}

15836

return resultobj;

15837

fail:

15838

return NULL;

15839

}

15840

15841

15842

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15843

PyObject *resultobj = 0;

15844

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15845

bool result;

15846

void *argp1 = 0 ;

15847

int res1 = 0 ;

15848

PyObject *swig_obj[1] ;

15849

15850

if (!args) SWIG_fail;

15851

swig_obj[0] = args;

15852

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15853

if (!SWIG_IsOK(res1)) {

15854

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndLineSpacing" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15855

}

15856

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15857

{

15858

PyThreadState* __tstate = wxPyBeginAllowThreads();

15859

result = (bool)(arg1)->EndLineSpacing();

15860

wxPyEndAllowThreads(__tstate);

15861

if (PyErr_Occurred()) SWIG_fail;

15862

}

15863

{

15864

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15865

}

15866

return resultobj;

15867

fail:

15868

return NULL;

15869

}

15870

15871

15872

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginNumberedBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15873

PyObject *resultobj = 0;

15874

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15875

int arg2 ;

15876

int arg3 ;

15877

int arg4 ;

15878

int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD ;

15879

bool result;

15880

void *argp1 = 0 ;

15881

int res1 = 0 ;

15882

int val2 ;

15883

int ecode2 = 0 ;

15884

int val3 ;

15885

int ecode3 = 0 ;

15886

int val4 ;

15887

int ecode4 = 0 ;

15888

int val5 ;

15889

int ecode5 = 0 ;

15890

PyObject * obj0 = 0 ;

15891

PyObject * obj1 = 0 ;

15892

PyObject * obj2 = 0 ;

15893

PyObject * obj3 = 0 ;

15894

PyObject * obj4 = 0 ;

15895

char * kwnames[] = {

15896

(char *) "self",(char *) "bulletNumber",(char *) "leftIndent",(char *) "leftSubIndent",(char *) "bulletStyle", NULL

15897

};

15898

15899

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextBuffer_BeginNumberedBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

15900

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15901

if (!SWIG_IsOK(res1)) {

15902

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginNumberedBullet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15903

}

15904

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15905

ecode2 = SWIG_AsVal_int(obj1, &val2);

15906

if (!SWIG_IsOK(ecode2)) {

15907

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_BeginNumberedBullet" "', expected argument " "2"" of type '" "int""'");

15908

}

15909

arg2 = static_cast< int >(val2);

15910

ecode3 = SWIG_AsVal_int(obj2, &val3);

15911

if (!SWIG_IsOK(ecode3)) {

15912

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_BeginNumberedBullet" "', expected argument " "3"" of type '" "int""'");

15913

}

15914

arg3 = static_cast< int >(val3);

15915

ecode4 = SWIG_AsVal_int(obj3, &val4);

15916

if (!SWIG_IsOK(ecode4)) {

15917

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextBuffer_BeginNumberedBullet" "', expected argument " "4"" of type '" "int""'");

15918

}

15919

arg4 = static_cast< int >(val4);

15920

if (obj4) {

15921

ecode5 = SWIG_AsVal_int(obj4, &val5);

15922

if (!SWIG_IsOK(ecode5)) {

15923

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextBuffer_BeginNumberedBullet" "', expected argument " "5"" of type '" "int""'");

15924

}

15925

arg5 = static_cast< int >(val5);

15926

}

15927

{

15928

PyThreadState* __tstate = wxPyBeginAllowThreads();

15929

result = (bool)(arg1)->BeginNumberedBullet(arg2,arg3,arg4,arg5);

15930

wxPyEndAllowThreads(__tstate);

15931

if (PyErr_Occurred()) SWIG_fail;

15932

}

15933

{

15934

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15935

}

15936

return resultobj;

15937

fail:

15938

return NULL;

15939

}

15940

15941

15942

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndNumberedBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

15943

PyObject *resultobj = 0;

15944

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15945

bool result;

15946

void *argp1 = 0 ;

15947

int res1 = 0 ;

15948

PyObject *swig_obj[1] ;

15949

15950

if (!args) SWIG_fail;

15951

swig_obj[0] = args;

15952

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

15953

if (!SWIG_IsOK(res1)) {

15954

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndNumberedBullet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

15955

}

15956

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

15957

{

15958

PyThreadState* __tstate = wxPyBeginAllowThreads();

15959

result = (bool)(arg1)->EndNumberedBullet();

15960

wxPyEndAllowThreads(__tstate);

15961

if (PyErr_Occurred()) SWIG_fail;

15962

}

15963

{

15964

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

15965

}

15966

return resultobj;

15967

fail:

15968

return NULL;

15969

}

15970

15971

15972

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginSymbolBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

15973

PyObject *resultobj = 0;

15974

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

15975

wxString *arg2 = 0 ;

15976

int arg3 ;

15977

int arg4 ;

15978

int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_SYMBOL ;

15979

bool result;

15980

void *argp1 = 0 ;

15981

int res1 = 0 ;

15982

bool temp2 = false ;

15983

int val3 ;

15984

int ecode3 = 0 ;

15985

int val4 ;

15986

int ecode4 = 0 ;

15987

int val5 ;

15988

int ecode5 = 0 ;

15989

PyObject * obj0 = 0 ;

15990

PyObject * obj1 = 0 ;

15991

PyObject * obj2 = 0 ;

15992

PyObject * obj3 = 0 ;

15993

PyObject * obj4 = 0 ;

15994

char * kwnames[] = {

15995

(char *) "self",(char *) "symbol",(char *) "leftIndent",(char *) "leftSubIndent",(char *) "bulletStyle", NULL

15996

};

15997

15998

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextBuffer_BeginSymbolBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

15999

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16000

if (!SWIG_IsOK(res1)) {

16001

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginSymbolBullet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16002

}

16003

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16004

{

16005

arg2 = wxString_in_helper(obj1);

16006

if (arg2 == NULL) SWIG_fail;

16007

temp2 = true;

16008

}

16009

ecode3 = SWIG_AsVal_int(obj2, &val3);

16010

if (!SWIG_IsOK(ecode3)) {

16011

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_BeginSymbolBullet" "', expected argument " "3"" of type '" "int""'");

16012

}

16013

arg3 = static_cast< int >(val3);

16014

ecode4 = SWIG_AsVal_int(obj3, &val4);

16015

if (!SWIG_IsOK(ecode4)) {

16016

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextBuffer_BeginSymbolBullet" "', expected argument " "4"" of type '" "int""'");

16017

}

16018

arg4 = static_cast< int >(val4);

16019

if (obj4) {

16020

ecode5 = SWIG_AsVal_int(obj4, &val5);

16021

if (!SWIG_IsOK(ecode5)) {

16022

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextBuffer_BeginSymbolBullet" "', expected argument " "5"" of type '" "int""'");

16023

}

16024

arg5 = static_cast< int >(val5);

16025

}

16026

{

16027

PyThreadState* __tstate = wxPyBeginAllowThreads();

16028

result = (bool)(arg1)->BeginSymbolBullet((wxString const &)*arg2,arg3,arg4,arg5);

16029

wxPyEndAllowThreads(__tstate);

16030

if (PyErr_Occurred()) SWIG_fail;

16031

}

16032

{

16033

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16034

}

16035

{

16036

if (temp2)

16037

delete arg2;

16038

}

16039

return resultobj;

16040

fail:

16041

{

16042

if (temp2)

16043

delete arg2;

16044

}

16045

return NULL;

16046

}

16047

16048

16049

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndSymbolBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16050

PyObject *resultobj = 0;

16051

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16052

bool result;

16053

void *argp1 = 0 ;

16054

int res1 = 0 ;

16055

PyObject *swig_obj[1] ;

16056

16057

if (!args) SWIG_fail;

16058

swig_obj[0] = args;

16059

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16060

if (!SWIG_IsOK(res1)) {

16061

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndSymbolBullet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16062

}

16063

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16064

{

16065

PyThreadState* __tstate = wxPyBeginAllowThreads();

16066

result = (bool)(arg1)->EndSymbolBullet();

16067

wxPyEndAllowThreads(__tstate);

16068

if (PyErr_Occurred()) SWIG_fail;

16069

}

16070

{

16071

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16072

}

16073

return resultobj;

16074

fail:

16075

return NULL;

16076

}

16077

16078

16079

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginStandardBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16080

PyObject *resultobj = 0;

16081

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16082

wxString *arg2 = 0 ;

16083

int arg3 ;

16084

int arg4 ;

16085

int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_STANDARD ;

16086

bool result;

16087

void *argp1 = 0 ;

16088

int res1 = 0 ;

16089

bool temp2 = false ;

16090

int val3 ;

16091

int ecode3 = 0 ;

16092

int val4 ;

16093

int ecode4 = 0 ;

16094

int val5 ;

16095

int ecode5 = 0 ;

16096

PyObject * obj0 = 0 ;

16097

PyObject * obj1 = 0 ;

16098

PyObject * obj2 = 0 ;

16099

PyObject * obj3 = 0 ;

16100

PyObject * obj4 = 0 ;

16101

char * kwnames[] = {

16102

(char *) "self",(char *) "bulletName",(char *) "leftIndent",(char *) "leftSubIndent",(char *) "bulletStyle", NULL

16103

};

16104

16105

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextBuffer_BeginStandardBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

16106

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16107

if (!SWIG_IsOK(res1)) {

16108

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginStandardBullet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16109

}

16110

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16111

{

16112

arg2 = wxString_in_helper(obj1);

16113

if (arg2 == NULL) SWIG_fail;

16114

temp2 = true;

16115

}

16116

ecode3 = SWIG_AsVal_int(obj2, &val3);

16117

if (!SWIG_IsOK(ecode3)) {

16118

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_BeginStandardBullet" "', expected argument " "3"" of type '" "int""'");

16119

}

16120

arg3 = static_cast< int >(val3);

16121

ecode4 = SWIG_AsVal_int(obj3, &val4);

16122

if (!SWIG_IsOK(ecode4)) {

16123

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextBuffer_BeginStandardBullet" "', expected argument " "4"" of type '" "int""'");

16124

}

16125

arg4 = static_cast< int >(val4);

16126

if (obj4) {

16127

ecode5 = SWIG_AsVal_int(obj4, &val5);

16128

if (!SWIG_IsOK(ecode5)) {

16129

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextBuffer_BeginStandardBullet" "', expected argument " "5"" of type '" "int""'");

16130

}

16131

arg5 = static_cast< int >(val5);

16132

}

16133

{

16134

PyThreadState* __tstate = wxPyBeginAllowThreads();

16135

result = (bool)(arg1)->BeginStandardBullet((wxString const &)*arg2,arg3,arg4,arg5);

16136

wxPyEndAllowThreads(__tstate);

16137

if (PyErr_Occurred()) SWIG_fail;

16138

}

16139

{

16140

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16141

}

16142

{

16143

if (temp2)

16144

delete arg2;

16145

}

16146

return resultobj;

16147

fail:

16148

{

16149

if (temp2)

16150

delete arg2;

16151

}

16152

return NULL;

16153

}

16154

16155

16156

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndStandardBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16157

PyObject *resultobj = 0;

16158

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16159

bool result;

16160

void *argp1 = 0 ;

16161

int res1 = 0 ;

16162

PyObject *swig_obj[1] ;

16163

16164

if (!args) SWIG_fail;

16165

swig_obj[0] = args;

16166

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16167

if (!SWIG_IsOK(res1)) {

16168

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndStandardBullet" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16169

}

16170

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16171

{

16172

PyThreadState* __tstate = wxPyBeginAllowThreads();

16173

result = (bool)(arg1)->EndStandardBullet();

16174

wxPyEndAllowThreads(__tstate);

16175

if (PyErr_Occurred()) SWIG_fail;

16176

}

16177

{

16178

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16179

}

16180

return resultobj;

16181

fail:

16182

return NULL;

16183

}

16184

16185

16186

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginCharacterStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16187

PyObject *resultobj = 0;

16188

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16189

wxString *arg2 = 0 ;

16190

bool result;

16191

void *argp1 = 0 ;

16192

int res1 = 0 ;

16193

bool temp2 = false ;

16194

PyObject * obj0 = 0 ;

16195

PyObject * obj1 = 0 ;

16196

char * kwnames[] = {

16197

(char *) "self",(char *) "characterStyle", NULL

16198

};

16199

16200

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginCharacterStyle",kwnames,&obj0,&obj1)) SWIG_fail;

16201

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16202

if (!SWIG_IsOK(res1)) {

16203

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginCharacterStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16204

}

16205

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16206

{

16207

arg2 = wxString_in_helper(obj1);

16208

if (arg2 == NULL) SWIG_fail;

16209

temp2 = true;

16210

}

16211

{

16212

PyThreadState* __tstate = wxPyBeginAllowThreads();

16213

result = (bool)(arg1)->BeginCharacterStyle((wxString const &)*arg2);

16214

wxPyEndAllowThreads(__tstate);

16215

if (PyErr_Occurred()) SWIG_fail;

16216

}

16217

{

16218

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16219

}

16220

{

16221

if (temp2)

16222

delete arg2;

16223

}

16224

return resultobj;

16225

fail:

16226

{

16227

if (temp2)

16228

delete arg2;

16229

}

16230

return NULL;

16231

}

16232

16233

16234

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndCharacterStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16235

PyObject *resultobj = 0;

16236

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16237

bool result;

16238

void *argp1 = 0 ;

16239

int res1 = 0 ;

16240

PyObject *swig_obj[1] ;

16241

16242

if (!args) SWIG_fail;

16243

swig_obj[0] = args;

16244

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16245

if (!SWIG_IsOK(res1)) {

16246

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndCharacterStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16247

}

16248

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16249

{

16250

PyThreadState* __tstate = wxPyBeginAllowThreads();

16251

result = (bool)(arg1)->EndCharacterStyle();

16252

wxPyEndAllowThreads(__tstate);

16253

if (PyErr_Occurred()) SWIG_fail;

16254

}

16255

{

16256

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16257

}

16258

return resultobj;

16259

fail:

16260

return NULL;

16261

}

16262

16263

16264

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16265

PyObject *resultobj = 0;

16266

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16267

wxString *arg2 = 0 ;

16268

bool result;

16269

void *argp1 = 0 ;

16270

int res1 = 0 ;

16271

bool temp2 = false ;

16272

PyObject * obj0 = 0 ;

16273

PyObject * obj1 = 0 ;

16274

char * kwnames[] = {

16275

(char *) "self",(char *) "paragraphStyle", NULL

16276

};

16277

16278

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_BeginParagraphStyle",kwnames,&obj0,&obj1)) SWIG_fail;

16279

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16280

if (!SWIG_IsOK(res1)) {

16281

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginParagraphStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16282

}

16283

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16284

{

16285

arg2 = wxString_in_helper(obj1);

16286

if (arg2 == NULL) SWIG_fail;

16287

temp2 = true;

16288

}

16289

{

16290

PyThreadState* __tstate = wxPyBeginAllowThreads();

16291

result = (bool)(arg1)->BeginParagraphStyle((wxString const &)*arg2);

16292

wxPyEndAllowThreads(__tstate);

16293

if (PyErr_Occurred()) SWIG_fail;

16294

}

16295

{

16296

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16297

}

16298

{

16299

if (temp2)

16300

delete arg2;

16301

}

16302

return resultobj;

16303

fail:

16304

{

16305

if (temp2)

16306

delete arg2;

16307

}

16308

return NULL;

16309

}

16310

16311

16312

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16313

PyObject *resultobj = 0;

16314

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16315

bool result;

16316

void *argp1 = 0 ;

16317

int res1 = 0 ;

16318

PyObject *swig_obj[1] ;

16319

16320

if (!args) SWIG_fail;

16321

swig_obj[0] = args;

16322

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16323

if (!SWIG_IsOK(res1)) {

16324

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndParagraphStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16325

}

16326

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16327

{

16328

PyThreadState* __tstate = wxPyBeginAllowThreads();

16329

result = (bool)(arg1)->EndParagraphStyle();

16330

wxPyEndAllowThreads(__tstate);

16331

if (PyErr_Occurred()) SWIG_fail;

16332

}

16333

{

16334

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16335

}

16336

return resultobj;

16337

fail:

16338

return NULL;

16339

}

16340

16341

16342

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16343

PyObject *resultobj = 0;

16344

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16345

wxString *arg2 = 0 ;

16346

int arg3 = (int) 1 ;

16347

int arg4 = (int) 1 ;

16348

bool result;

16349

void *argp1 = 0 ;

16350

int res1 = 0 ;

16351

bool temp2 = false ;

16352

int val3 ;

16353

int ecode3 = 0 ;

16354

int val4 ;

16355

int ecode4 = 0 ;

16356

PyObject * obj0 = 0 ;

16357

PyObject * obj1 = 0 ;

16358

PyObject * obj2 = 0 ;

16359

PyObject * obj3 = 0 ;

16360

char * kwnames[] = {

16361

(char *) "self",(char *) "listStyle",(char *) "level",(char *) "number", NULL

16362

};

16363

16364

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextBuffer_BeginListStyle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

16365

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16366

if (!SWIG_IsOK(res1)) {

16367

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginListStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16368

}

16369

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16370

{

16371

arg2 = wxString_in_helper(obj1);

16372

if (arg2 == NULL) SWIG_fail;

16373

temp2 = true;

16374

}

16375

if (obj2) {

16376

ecode3 = SWIG_AsVal_int(obj2, &val3);

16377

if (!SWIG_IsOK(ecode3)) {

16378

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_BeginListStyle" "', expected argument " "3"" of type '" "int""'");

16379

}

16380

arg3 = static_cast< int >(val3);

16381

}

16382

if (obj3) {

16383

ecode4 = SWIG_AsVal_int(obj3, &val4);

16384

if (!SWIG_IsOK(ecode4)) {

16385

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextBuffer_BeginListStyle" "', expected argument " "4"" of type '" "int""'");

16386

}

16387

arg4 = static_cast< int >(val4);

16388

}

16389

{

16390

PyThreadState* __tstate = wxPyBeginAllowThreads();

16391

result = (bool)(arg1)->BeginListStyle((wxString const &)*arg2,arg3,arg4);

16392

wxPyEndAllowThreads(__tstate);

16393

if (PyErr_Occurred()) SWIG_fail;

16394

}

16395

{

16396

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16397

}

16398

{

16399

if (temp2)

16400

delete arg2;

16401

}

16402

return resultobj;

16403

fail:

16404

{

16405

if (temp2)

16406

delete arg2;

16407

}

16408

return NULL;

16409

}

16410

16411

16412

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16413

PyObject *resultobj = 0;

16414

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16415

bool result;

16416

void *argp1 = 0 ;

16417

int res1 = 0 ;

16418

PyObject *swig_obj[1] ;

16419

16420

if (!args) SWIG_fail;

16421

swig_obj[0] = args;

16422

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16423

if (!SWIG_IsOK(res1)) {

16424

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndListStyle" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16425

}

16426

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16427

{

16428

PyThreadState* __tstate = wxPyBeginAllowThreads();

16429

result = (bool)(arg1)->EndListStyle();

16430

wxPyEndAllowThreads(__tstate);

16431

if (PyErr_Occurred()) SWIG_fail;

16432

}

16433

{

16434

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16435

}

16436

return resultobj;

16437

fail:

16438

return NULL;

16439

}

16440

16441

16442

SWIGINTERN PyObject *_wrap_RichTextBuffer_BeginURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16443

PyObject *resultobj = 0;

16444

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16445

wxString *arg2 = 0 ;

16446

wxString const &arg3_defvalue = wxEmptyString ;

16447

wxString *arg3 = (wxString *) &arg3_defvalue ;

16448

bool result;

16449

void *argp1 = 0 ;

16450

int res1 = 0 ;

16451

bool temp2 = false ;

16452

bool temp3 = false ;

16453

PyObject * obj0 = 0 ;

16454

PyObject * obj1 = 0 ;

16455

PyObject * obj2 = 0 ;

16456

char * kwnames[] = {

16457

(char *) "self",(char *) "url",(char *) "characterStyle", NULL

16458

};

16459

16460

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_BeginURL",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16461

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16462

if (!SWIG_IsOK(res1)) {

16463

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_BeginURL" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16464

}

16465

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16466

{

16467

arg2 = wxString_in_helper(obj1);

16468

if (arg2 == NULL) SWIG_fail;

16469

temp2 = true;

16470

}

16471

if (obj2) {

16472

{

16473

arg3 = wxString_in_helper(obj2);

16474

if (arg3 == NULL) SWIG_fail;

16475

temp3 = true;

16476

}

16477

}

16478

{

16479

PyThreadState* __tstate = wxPyBeginAllowThreads();

16480

result = (bool)(arg1)->BeginURL((wxString const &)*arg2,(wxString const &)*arg3);

16481

wxPyEndAllowThreads(__tstate);

16482

if (PyErr_Occurred()) SWIG_fail;

16483

}

16484

{

16485

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16486

}

16487

{

16488

if (temp2)

16489

delete arg2;

16490

}

16491

{

16492

if (temp3)

16493

delete arg3;

16494

}

16495

return resultobj;

16496

fail:

16497

{

16498

if (temp2)

16499

delete arg2;

16500

}

16501

{

16502

if (temp3)

16503

delete arg3;

16504

}

16505

return NULL;

16506

}

16507

16508

16509

SWIGINTERN PyObject *_wrap_RichTextBuffer_EndURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16510

PyObject *resultobj = 0;

16511

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16512

bool result;

16513

void *argp1 = 0 ;

16514

int res1 = 0 ;

16515

PyObject *swig_obj[1] ;

16516

16517

if (!args) SWIG_fail;

16518

swig_obj[0] = args;

16519

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16520

if (!SWIG_IsOK(res1)) {

16521

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_EndURL" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16522

}

16523

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16524

{

16525

PyThreadState* __tstate = wxPyBeginAllowThreads();

16526

result = (bool)(arg1)->EndURL();

16527

wxPyEndAllowThreads(__tstate);

16528

if (PyErr_Occurred()) SWIG_fail;

16529

}

16530

{

16531

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16532

}

16533

return resultobj;

16534

fail:

16535

return NULL;

16536

}

16537

16538

16539

SWIGINTERN PyObject *_wrap_RichTextBuffer_AddEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16540

PyObject *resultobj = 0;

16541

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16542

wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;

16543

bool result;

16544

void *argp1 = 0 ;

16545

int res1 = 0 ;

16546

void *argp2 = 0 ;

16547

int res2 = 0 ;

16548

PyObject * obj0 = 0 ;

16549

PyObject * obj1 = 0 ;

16550

char * kwnames[] = {

16551

(char *) "self",(char *) "handler", NULL

16552

};

16553

16554

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_AddEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;

16555

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16556

if (!SWIG_IsOK(res1)) {

16557

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_AddEventHandler" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16558

}

16559

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16560

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );

16561

if (!SWIG_IsOK(res2)) {

16562

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_AddEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");

16563

}

16564

arg2 = reinterpret_cast< wxEvtHandler * >(argp2);

16565

{

16566

PyThreadState* __tstate = wxPyBeginAllowThreads();

16567

result = (bool)(arg1)->AddEventHandler(arg2);

16568

wxPyEndAllowThreads(__tstate);

16569

if (PyErr_Occurred()) SWIG_fail;

16570

}

16571

{

16572

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16573

}

16574

return resultobj;

16575

fail:

16576

return NULL;

16577

}

16578

16579

16580

SWIGINTERN PyObject *_wrap_RichTextBuffer_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16581

PyObject *resultobj = 0;

16582

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16583

wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;

16584

bool arg3 = (bool) false ;

16585

bool result;

16586

void *argp1 = 0 ;

16587

int res1 = 0 ;

16588

void *argp2 = 0 ;

16589

int res2 = 0 ;

16590

bool val3 ;

16591

int ecode3 = 0 ;

16592

PyObject * obj0 = 0 ;

16593

PyObject * obj1 = 0 ;

16594

PyObject * obj2 = 0 ;

16595

char * kwnames[] = {

16596

(char *) "self",(char *) "handler",(char *) "deleteHandler", NULL

16597

};

16598

16599

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_RemoveEventHandler",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16600

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16601

if (!SWIG_IsOK(res1)) {

16602

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_RemoveEventHandler" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16603

}

16604

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16605

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );

16606

if (!SWIG_IsOK(res2)) {

16607

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");

16608

}

16609

arg2 = reinterpret_cast< wxEvtHandler * >(argp2);

16610

if (obj2) {

16611

ecode3 = SWIG_AsVal_bool(obj2, &val3);

16612

if (!SWIG_IsOK(ecode3)) {

16613

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_RemoveEventHandler" "', expected argument " "3"" of type '" "bool""'");

16614

}

16615

arg3 = static_cast< bool >(val3);

16616

}

16617

{

16618

PyThreadState* __tstate = wxPyBeginAllowThreads();

16619

result = (bool)(arg1)->RemoveEventHandler(arg2,arg3);

16620

wxPyEndAllowThreads(__tstate);

16621

if (PyErr_Occurred()) SWIG_fail;

16622

}

16623

{

16624

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16625

}

16626

return resultobj;

16627

fail:

16628

return NULL;

16629

}

16630

16631

16632

SWIGINTERN PyObject *_wrap_RichTextBuffer_ClearEventHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

16633

PyObject *resultobj = 0;

16634

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16635

void *argp1 = 0 ;

16636

int res1 = 0 ;

16637

PyObject *swig_obj[1] ;

16638

16639

if (!args) SWIG_fail;

16640

swig_obj[0] = args;

16641

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16642

if (!SWIG_IsOK(res1)) {

16643

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_ClearEventHandlers" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16644

}

16645

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16646

{

16647

PyThreadState* __tstate = wxPyBeginAllowThreads();

16648

(arg1)->ClearEventHandlers();

16649

wxPyEndAllowThreads(__tstate);

16650

if (PyErr_Occurred()) SWIG_fail;

16651

}

16652

resultobj = SWIG_Py_Void();

16653

return resultobj;

16654

fail:

16655

return NULL;

16656

}

16657

16658

16659

SWIGINTERN PyObject *_wrap_RichTextBuffer_SendEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16660

PyObject *resultobj = 0;

16661

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16662

wxEvent *arg2 = 0 ;

16663

bool arg3 = (bool) true ;

16664

bool result;

16665

void *argp1 = 0 ;

16666

int res1 = 0 ;

16667

void *argp2 = 0 ;

16668

int res2 = 0 ;

16669

bool val3 ;

16670

int ecode3 = 0 ;

16671

PyObject * obj0 = 0 ;

16672

PyObject * obj1 = 0 ;

16673

PyObject * obj2 = 0 ;

16674

char * kwnames[] = {

16675

(char *) "self",(char *) "event",(char *) "sendToAll", NULL

16676

};

16677

16678

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextBuffer_SendEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

16679

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16680

if (!SWIG_IsOK(res1)) {

16681

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SendEvent" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16682

}

16683

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16684

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );

16685

if (!SWIG_IsOK(res2)) {

16686

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_SendEvent" "', expected argument " "2"" of type '" "wxEvent &""'");

16687

}

16688

if (!argp2) {

16689

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBuffer_SendEvent" "', expected argument " "2"" of type '" "wxEvent &""'");

16690

}

16691

arg2 = reinterpret_cast< wxEvent * >(argp2);

16692

if (obj2) {

16693

ecode3 = SWIG_AsVal_bool(obj2, &val3);

16694

if (!SWIG_IsOK(ecode3)) {

16695

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_SendEvent" "', expected argument " "3"" of type '" "bool""'");

16696

}

16697

arg3 = static_cast< bool >(val3);

16698

}

16699

{

16700

PyThreadState* __tstate = wxPyBeginAllowThreads();

16701

result = (bool)(arg1)->SendEvent(*arg2,arg3);

16702

wxPyEndAllowThreads(__tstate);

16703

if (PyErr_Occurred()) SWIG_fail;

16704

}

16705

{

16706

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16707

}

16708

return resultobj;

16709

fail:

16710

return NULL;

16711

}

16712

16713

16714

SWIGINTERN PyObject *_wrap_RichTextBuffer_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16715

PyObject *resultobj = 0;

16716

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16717

wxRichTextBuffer *arg2 = 0 ;

16718

void *argp1 = 0 ;

16719

int res1 = 0 ;

16720

void *argp2 = 0 ;

16721

int res2 = 0 ;

16722

PyObject * obj0 = 0 ;

16723

PyObject * obj1 = 0 ;

16724

char * kwnames[] = {

16725

(char *) "self",(char *) "obj", NULL

16726

};

16727

16728

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_Copy",kwnames,&obj0,&obj1)) SWIG_fail;

16729

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16730

if (!SWIG_IsOK(res1)) {

16731

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_Copy" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16732

}

16733

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16734

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextBuffer, 0 | 0);

16735

if (!SWIG_IsOK(res2)) {

16736

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextBuffer_Copy" "', expected argument " "2"" of type '" "wxRichTextBuffer const &""'");

16737

}

16738

if (!argp2) {

16739

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBuffer_Copy" "', expected argument " "2"" of type '" "wxRichTextBuffer const &""'");

16740

}

16741

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

16742

{

16743

PyThreadState* __tstate = wxPyBeginAllowThreads();

16744

(arg1)->Copy((wxRichTextBuffer const &)*arg2);

16745

wxPyEndAllowThreads(__tstate);

16746

if (PyErr_Occurred()) SWIG_fail;

16747

}

16748

resultobj = SWIG_Py_Void();

16749

return resultobj;

16750

fail:

16751

return NULL;

16752

}

16753

16754

16755

SWIGINTERN PyObject *_wrap_RichTextBuffer_InsertParagraphsWithUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16756

PyObject *resultobj = 0;

16757

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16758

long arg2 ;

16759

wxRichTextParagraphLayoutBox *arg3 = 0 ;

16760

wxRichTextCtrl *arg4 = (wxRichTextCtrl *) 0 ;

16761

int arg5 = (int) 0 ;

16762

bool result;

16763

void *argp1 = 0 ;

16764

int res1 = 0 ;

16765

long val2 ;

16766

int ecode2 = 0 ;

16767

void *argp3 = 0 ;

16768

int res3 = 0 ;

16769

void *argp4 = 0 ;

16770

int res4 = 0 ;

16771

int val5 ;

16772

int ecode5 = 0 ;

16773

PyObject * obj0 = 0 ;

16774

PyObject * obj1 = 0 ;

16775

PyObject * obj2 = 0 ;

16776

PyObject * obj3 = 0 ;

16777

PyObject * obj4 = 0 ;

16778

char * kwnames[] = {

16779

(char *) "self",(char *) "pos",(char *) "paragraphs",(char *) "ctrl",(char *) "flags", NULL

16780

};

16781

16782

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextBuffer_InsertParagraphsWithUndo",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

16783

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16784

if (!SWIG_IsOK(res1)) {

16785

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_InsertParagraphsWithUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16786

}

16787

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16788

ecode2 = SWIG_AsVal_long(obj1, &val2);

16789

if (!SWIG_IsOK(ecode2)) {

16790

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_InsertParagraphsWithUndo" "', expected argument " "2"" of type '" "long""'");

16791

}

16792

arg2 = static_cast< long >(val2);

16793

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRichTextParagraphLayoutBox, 0 | 0);

16794

if (!SWIG_IsOK(res3)) {

16795

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextBuffer_InsertParagraphsWithUndo" "', expected argument " "3"" of type '" "wxRichTextParagraphLayoutBox const &""'");

16796

}

16797

if (!argp3) {

16798

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBuffer_InsertParagraphsWithUndo" "', expected argument " "3"" of type '" "wxRichTextParagraphLayoutBox const &""'");

16799

}

16800

arg3 = reinterpret_cast< wxRichTextParagraphLayoutBox * >(argp3);

16801

res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

16802

if (!SWIG_IsOK(res4)) {

16803

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextBuffer_InsertParagraphsWithUndo" "', expected argument " "4"" of type '" "wxRichTextCtrl *""'");

16804

}

16805

arg4 = reinterpret_cast< wxRichTextCtrl * >(argp4);

16806

if (obj4) {

16807

ecode5 = SWIG_AsVal_int(obj4, &val5);

16808

if (!SWIG_IsOK(ecode5)) {

16809

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextBuffer_InsertParagraphsWithUndo" "', expected argument " "5"" of type '" "int""'");

16810

}

16811

arg5 = static_cast< int >(val5);

16812

}

16813

{

16814

PyThreadState* __tstate = wxPyBeginAllowThreads();

16815

result = (bool)(arg1)->InsertParagraphsWithUndo(arg2,(wxRichTextParagraphLayoutBox const &)*arg3,arg4,arg5);

16816

wxPyEndAllowThreads(__tstate);

16817

if (PyErr_Occurred()) SWIG_fail;

16818

}

16819

{

16820

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16821

}

16822

return resultobj;

16823

fail:

16824

return NULL;

16825

}

16826

16827

16828

SWIGINTERN PyObject *_wrap_RichTextBuffer_InsertTextWithUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16829

PyObject *resultobj = 0;

16830

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16831

long arg2 ;

16832

wxString *arg3 = 0 ;

16833

wxRichTextCtrl *arg4 = (wxRichTextCtrl *) 0 ;

16834

int arg5 = (int) 0 ;

16835

bool result;

16836

void *argp1 = 0 ;

16837

int res1 = 0 ;

16838

long val2 ;

16839

int ecode2 = 0 ;

16840

bool temp3 = false ;

16841

void *argp4 = 0 ;

16842

int res4 = 0 ;

16843

int val5 ;

16844

int ecode5 = 0 ;

16845

PyObject * obj0 = 0 ;

16846

PyObject * obj1 = 0 ;

16847

PyObject * obj2 = 0 ;

16848

PyObject * obj3 = 0 ;

16849

PyObject * obj4 = 0 ;

16850

char * kwnames[] = {

16851

(char *) "self",(char *) "pos",(char *) "text",(char *) "ctrl",(char *) "flags", NULL

16852

};

16853

16854

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextBuffer_InsertTextWithUndo",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

16855

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16856

if (!SWIG_IsOK(res1)) {

16857

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_InsertTextWithUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16858

}

16859

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16860

ecode2 = SWIG_AsVal_long(obj1, &val2);

16861

if (!SWIG_IsOK(ecode2)) {

16862

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_InsertTextWithUndo" "', expected argument " "2"" of type '" "long""'");

16863

}

16864

arg2 = static_cast< long >(val2);

16865

{

16866

arg3 = wxString_in_helper(obj2);

16867

if (arg3 == NULL) SWIG_fail;

16868

temp3 = true;

16869

}

16870

res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

16871

if (!SWIG_IsOK(res4)) {

16872

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextBuffer_InsertTextWithUndo" "', expected argument " "4"" of type '" "wxRichTextCtrl *""'");

16873

}

16874

arg4 = reinterpret_cast< wxRichTextCtrl * >(argp4);

16875

if (obj4) {

16876

ecode5 = SWIG_AsVal_int(obj4, &val5);

16877

if (!SWIG_IsOK(ecode5)) {

16878

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextBuffer_InsertTextWithUndo" "', expected argument " "5"" of type '" "int""'");

16879

}

16880

arg5 = static_cast< int >(val5);

16881

}

16882

{

16883

PyThreadState* __tstate = wxPyBeginAllowThreads();

16884

result = (bool)(arg1)->InsertTextWithUndo(arg2,(wxString const &)*arg3,arg4,arg5);

16885

wxPyEndAllowThreads(__tstate);

16886

if (PyErr_Occurred()) SWIG_fail;

16887

}

16888

{

16889

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16890

}

16891

{

16892

if (temp3)

16893

delete arg3;

16894

}

16895

return resultobj;

16896

fail:

16897

{

16898

if (temp3)

16899

delete arg3;

16900

}

16901

return NULL;

16902

}

16903

16904

16905

SWIGINTERN PyObject *_wrap_RichTextBuffer_InsertNewlineWithUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16906

PyObject *resultobj = 0;

16907

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16908

long arg2 ;

16909

wxRichTextCtrl *arg3 = (wxRichTextCtrl *) 0 ;

16910

int arg4 = (int) 0 ;

16911

bool result;

16912

void *argp1 = 0 ;

16913

int res1 = 0 ;

16914

long val2 ;

16915

int ecode2 = 0 ;

16916

void *argp3 = 0 ;

16917

int res3 = 0 ;

16918

int val4 ;

16919

int ecode4 = 0 ;

16920

PyObject * obj0 = 0 ;

16921

PyObject * obj1 = 0 ;

16922

PyObject * obj2 = 0 ;

16923

PyObject * obj3 = 0 ;

16924

char * kwnames[] = {

16925

(char *) "self",(char *) "pos",(char *) "ctrl",(char *) "flags", NULL

16926

};

16927

16928

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:RichTextBuffer_InsertNewlineWithUndo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

16929

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16930

if (!SWIG_IsOK(res1)) {

16931

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_InsertNewlineWithUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16932

}

16933

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16934

ecode2 = SWIG_AsVal_long(obj1, &val2);

16935

if (!SWIG_IsOK(ecode2)) {

16936

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_InsertNewlineWithUndo" "', expected argument " "2"" of type '" "long""'");

16937

}

16938

arg2 = static_cast< long >(val2);

16939

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

16940

if (!SWIG_IsOK(res3)) {

16941

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextBuffer_InsertNewlineWithUndo" "', expected argument " "3"" of type '" "wxRichTextCtrl *""'");

16942

}

16943

arg3 = reinterpret_cast< wxRichTextCtrl * >(argp3);

16944

if (obj3) {

16945

ecode4 = SWIG_AsVal_int(obj3, &val4);

16946

if (!SWIG_IsOK(ecode4)) {

16947

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextBuffer_InsertNewlineWithUndo" "', expected argument " "4"" of type '" "int""'");

16948

}

16949

arg4 = static_cast< int >(val4);

16950

}

16951

{

16952

PyThreadState* __tstate = wxPyBeginAllowThreads();

16953

result = (bool)(arg1)->InsertNewlineWithUndo(arg2,arg3,arg4);

16954

wxPyEndAllowThreads(__tstate);

16955

if (PyErr_Occurred()) SWIG_fail;

16956

}

16957

{

16958

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

16959

}

16960

return resultobj;

16961

fail:

16962

return NULL;

16963

}

16964

16965

16966

SWIGINTERN PyObject *_wrap_RichTextBuffer_InsertImageWithUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

16967

PyObject *resultobj = 0;

16968

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

16969

long arg2 ;

16970

wxRichTextImageBlock *arg3 = 0 ;

16971

wxRichTextCtrl *arg4 = (wxRichTextCtrl *) 0 ;

16972

int arg5 = (int) 0 ;

16973

bool result;

16974

void *argp1 = 0 ;

16975

int res1 = 0 ;

16976

long val2 ;

16977

int ecode2 = 0 ;

16978

void *argp3 = 0 ;

16979

int res3 = 0 ;

16980

void *argp4 = 0 ;

16981

int res4 = 0 ;

16982

int val5 ;

16983

int ecode5 = 0 ;

16984

PyObject * obj0 = 0 ;

16985

PyObject * obj1 = 0 ;

16986

PyObject * obj2 = 0 ;

16987

PyObject * obj3 = 0 ;

16988

PyObject * obj4 = 0 ;

16989

char * kwnames[] = {

16990

(char *) "self",(char *) "pos",(char *) "imageBlock",(char *) "ctrl",(char *) "flags", NULL

16991

};

16992

16993

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextBuffer_InsertImageWithUndo",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

16994

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

16995

if (!SWIG_IsOK(res1)) {

16996

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_InsertImageWithUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

16997

}

16998

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

16999

ecode2 = SWIG_AsVal_long(obj1, &val2);

17000

if (!SWIG_IsOK(ecode2)) {

17001

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_InsertImageWithUndo" "', expected argument " "2"" of type '" "long""'");

17002

}

17003

arg2 = static_cast< long >(val2);

17004

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxRichTextImageBlock, 0 | 0);

17005

if (!SWIG_IsOK(res3)) {

17006

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextBuffer_InsertImageWithUndo" "', expected argument " "3"" of type '" "wxRichTextImageBlock const &""'");

17007

}

17008

if (!argp3) {

17009

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextBuffer_InsertImageWithUndo" "', expected argument " "3"" of type '" "wxRichTextImageBlock const &""'");

17010

}

17011

arg3 = reinterpret_cast< wxRichTextImageBlock * >(argp3);

17012

res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

17013

if (!SWIG_IsOK(res4)) {

17014

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextBuffer_InsertImageWithUndo" "', expected argument " "4"" of type '" "wxRichTextCtrl *""'");

17015

}

17016

arg4 = reinterpret_cast< wxRichTextCtrl * >(argp4);

17017

if (obj4) {

17018

ecode5 = SWIG_AsVal_int(obj4, &val5);

17019

if (!SWIG_IsOK(ecode5)) {

17020

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextBuffer_InsertImageWithUndo" "', expected argument " "5"" of type '" "int""'");

17021

}

17022

arg5 = static_cast< int >(val5);

17023

}

17024

{

17025

PyThreadState* __tstate = wxPyBeginAllowThreads();

17026

result = (bool)(arg1)->InsertImageWithUndo(arg2,(wxRichTextImageBlock const &)*arg3,arg4,arg5);

17027

wxPyEndAllowThreads(__tstate);

17028

if (PyErr_Occurred()) SWIG_fail;

17029

}

17030

{

17031

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17032

}

17033

return resultobj;

17034

fail:

17035

return NULL;

17036

}

17037

17038

17039

SWIGINTERN PyObject *_wrap_RichTextBuffer_DeleteRangeWithUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17040

PyObject *resultobj = 0;

17041

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

17042

wxRichTextRange *arg2 = 0 ;

17043

wxRichTextCtrl *arg3 = (wxRichTextCtrl *) 0 ;

17044

bool result;

17045

void *argp1 = 0 ;

17046

int res1 = 0 ;

17047

wxRichTextRange temp2 ;

17048

void *argp3 = 0 ;

17049

int res3 = 0 ;

17050

PyObject * obj0 = 0 ;

17051

PyObject * obj1 = 0 ;

17052

PyObject * obj2 = 0 ;

17053

char * kwnames[] = {

17054

(char *) "self",(char *) "range",(char *) "ctrl", NULL

17055

};

17056

17057

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextBuffer_DeleteRangeWithUndo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17058

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17059

if (!SWIG_IsOK(res1)) {

17060

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_DeleteRangeWithUndo" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

17061

}

17062

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

17063

{

17064

arg2 = &temp2;

17065

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

17066

}

17067

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

17068

if (!SWIG_IsOK(res3)) {

17069

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextBuffer_DeleteRangeWithUndo" "', expected argument " "3"" of type '" "wxRichTextCtrl *""'");

17070

}

17071

arg3 = reinterpret_cast< wxRichTextCtrl * >(argp3);

17072

{

17073

PyThreadState* __tstate = wxPyBeginAllowThreads();

17074

result = (bool)(arg1)->DeleteRangeWithUndo((wxRichTextRange const &)*arg2,arg3);

17075

wxPyEndAllowThreads(__tstate);

17076

if (PyErr_Occurred()) SWIG_fail;

17077

}

17078

{

17079

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17080

}

17081

return resultobj;

17082

fail:

17083

return NULL;

17084

}

17085

17086

17087

SWIGINTERN PyObject *_wrap_RichTextBuffer_Modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17088

PyObject *resultobj = 0;

17089

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

17090

bool arg2 = (bool) true ;

17091

void *argp1 = 0 ;

17092

int res1 = 0 ;

17093

bool val2 ;

17094

int ecode2 = 0 ;

17095

PyObject * obj0 = 0 ;

17096

PyObject * obj1 = 0 ;

17097

char * kwnames[] = {

17098

(char *) "self",(char *) "modify", NULL

17099

};

17100

17101

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextBuffer_Modify",kwnames,&obj0,&obj1)) SWIG_fail;

17102

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17103

if (!SWIG_IsOK(res1)) {

17104

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_Modify" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

17105

}

17106

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

17107

if (obj1) {

17108

ecode2 = SWIG_AsVal_bool(obj1, &val2);

17109

if (!SWIG_IsOK(ecode2)) {

17110

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_Modify" "', expected argument " "2"" of type '" "bool""'");

17111

}

17112

arg2 = static_cast< bool >(val2);

17113

}

17114

{

17115

PyThreadState* __tstate = wxPyBeginAllowThreads();

17116

(arg1)->Modify(arg2);

17117

wxPyEndAllowThreads(__tstate);

17118

if (PyErr_Occurred()) SWIG_fail;

17119

}

17120

resultobj = SWIG_Py_Void();

17121

return resultobj;

17122

fail:

17123

return NULL;

17124

}

17125

17126

17127

SWIGINTERN PyObject *_wrap_RichTextBuffer_IsModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17128

PyObject *resultobj = 0;

17129

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

17130

bool result;

17131

void *argp1 = 0 ;

17132

int res1 = 0 ;

17133

PyObject *swig_obj[1] ;

17134

17135

if (!args) SWIG_fail;

17136

swig_obj[0] = args;

17137

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17138

if (!SWIG_IsOK(res1)) {

17139

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_IsModified" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

17140

}

17141

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

17142

{

17143

PyThreadState* __tstate = wxPyBeginAllowThreads();

17144

result = (bool)((wxRichTextBuffer const *)arg1)->IsModified();

17145

wxPyEndAllowThreads(__tstate);

17146

if (PyErr_Occurred()) SWIG_fail;

17147

}

17148

{

17149

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17150

}

17151

return resultobj;

17152

fail:

17153

return NULL;

17154

}

17155

17156

17157

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetStyleForNewParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17158

PyObject *resultobj = 0;

17159

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

17160

long arg2 ;

17161

bool arg3 = (bool) false ;

17162

bool arg4 = (bool) false ;

17163

wxTextAttrEx result;

17164

void *argp1 = 0 ;

17165

int res1 = 0 ;

17166

long val2 ;

17167

int ecode2 = 0 ;

17168

bool val3 ;

17169

int ecode3 = 0 ;

17170

bool val4 ;

17171

int ecode4 = 0 ;

17172

PyObject * obj0 = 0 ;

17173

PyObject * obj1 = 0 ;

17174

PyObject * obj2 = 0 ;

17175

PyObject * obj3 = 0 ;

17176

char * kwnames[] = {

17177

(char *) "self",(char *) "pos",(char *) "caretPosition",(char *) "lookUpNewParaStyle", NULL

17178

};

17179

17180

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextBuffer_GetStyleForNewParagraph",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

17181

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17182

if (!SWIG_IsOK(res1)) {

17183

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_GetStyleForNewParagraph" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

17184

}

17185

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

17186

ecode2 = SWIG_AsVal_long(obj1, &val2);

17187

if (!SWIG_IsOK(ecode2)) {

17188

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_GetStyleForNewParagraph" "', expected argument " "2"" of type '" "long""'");

17189

}

17190

arg2 = static_cast< long >(val2);

17191

if (obj2) {

17192

ecode3 = SWIG_AsVal_bool(obj2, &val3);

17193

if (!SWIG_IsOK(ecode3)) {

17194

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextBuffer_GetStyleForNewParagraph" "', expected argument " "3"" of type '" "bool""'");

17195

}

17196

arg3 = static_cast< bool >(val3);

17197

}

17198

if (obj3) {

17199

ecode4 = SWIG_AsVal_bool(obj3, &val4);

17200

if (!SWIG_IsOK(ecode4)) {

17201

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextBuffer_GetStyleForNewParagraph" "', expected argument " "4"" of type '" "bool""'");

17202

}

17203

arg4 = static_cast< bool >(val4);

17204

}

17205

{

17206

PyThreadState* __tstate = wxPyBeginAllowThreads();

17207

result = ((wxRichTextBuffer const *)arg1)->GetStyleForNewParagraph(arg2,arg3,arg4);

17208

wxPyEndAllowThreads(__tstate);

17209

if (PyErr_Occurred()) SWIG_fail;

17210

}

17211

resultobj = SWIG_NewPointerObj((new wxTextAttrEx(static_cast< const wxTextAttrEx& >(result))), SWIGTYPE_p_wxTextAttrEx, SWIG_POINTER_OWN | 0 );

17212

return resultobj;

17213

fail:

17214

return NULL;

17215

}

17216

17217

17218

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17219

PyObject *resultobj = 0;

17220

wxRichTextFileHandlerList_t *result = 0 ;

17221

17222

if (!SWIG_Python_UnpackTuple(args,"RichTextBuffer_GetHandlers",0,0,0)) SWIG_fail;

17223

{

17224

PyThreadState* __tstate = wxPyBeginAllowThreads();

17225

{

17226

wxRichTextFileHandlerList_t &_result_ref = wxRichTextBuffer::GetHandlers();

17227

result = (wxRichTextFileHandlerList_t *) &_result_ref;

17228

}

17229

wxPyEndAllowThreads(__tstate);

17230

if (PyErr_Occurred()) SWIG_fail;

17231

}

17232

{

17233

wxRichTextFileHandlerList* mylist = new wxRichTextFileHandlerList(result);

17234

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(mylist), SWIGTYPE_p_wxRichTextFileHandlerList, SWIG_POINTER_OWN );

17235

}

17236

return resultobj;

17237

fail:

17238

return NULL;

17239

}

17240

17241

17242

SWIGINTERN PyObject *_wrap_RichTextBuffer_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17243

PyObject *resultobj = 0;

17244

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

17245

int res1 = 0 ;

17246

PyObject * obj0 = 0 ;

17247

char * kwnames[] = {

17248

(char *) "handler", NULL

17249

};

17250

17251

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_AddHandler",kwnames,&obj0)) SWIG_fail;

17252

res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxRichTextFileHandler, SWIG_POINTER_DISOWN | 0 );

17253

if (!SWIG_IsOK(res1)) {

17254

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_AddHandler" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

17255

}

17256

{

17257

PyThreadState* __tstate = wxPyBeginAllowThreads();

17258

wxRichTextBuffer::AddHandler(arg1);

17259

wxPyEndAllowThreads(__tstate);

17260

if (PyErr_Occurred()) SWIG_fail;

17261

}

17262

resultobj = SWIG_Py_Void();

17263

return resultobj;

17264

fail:

17265

return NULL;

17266

}

17267

17268

17269

SWIGINTERN PyObject *_wrap_RichTextBuffer_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17270

PyObject *resultobj = 0;

17271

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

17272

int res1 = 0 ;

17273

PyObject * obj0 = 0 ;

17274

char * kwnames[] = {

17275

(char *) "handler", NULL

17276

};

17277

17278

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_InsertHandler",kwnames,&obj0)) SWIG_fail;

17279

res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxRichTextFileHandler, SWIG_POINTER_DISOWN | 0 );

17280

if (!SWIG_IsOK(res1)) {

17281

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_InsertHandler" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

17282

}

17283

{

17284

PyThreadState* __tstate = wxPyBeginAllowThreads();

17285

wxRichTextBuffer::InsertHandler(arg1);

17286

wxPyEndAllowThreads(__tstate);

17287

if (PyErr_Occurred()) SWIG_fail;

17288

}

17289

resultobj = SWIG_Py_Void();

17290

return resultobj;

17291

fail:

17292

return NULL;

17293

}

17294

17295

17296

SWIGINTERN PyObject *_wrap_RichTextBuffer_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17297

PyObject *resultobj = 0;

17298

wxString *arg1 = 0 ;

17299

bool result;

17300

bool temp1 = false ;

17301

PyObject * obj0 = 0 ;

17302

char * kwnames[] = {

17303

(char *) "name", NULL

17304

};

17305

17306

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_RemoveHandler",kwnames,&obj0)) SWIG_fail;

17307

{

17308

arg1 = wxString_in_helper(obj0);

17309

if (arg1 == NULL) SWIG_fail;

17310

temp1 = true;

17311

}

17312

{

17313

PyThreadState* __tstate = wxPyBeginAllowThreads();

17314

result = (bool)wxRichTextBuffer::RemoveHandler((wxString const &)*arg1);

17315

wxPyEndAllowThreads(__tstate);

17316

if (PyErr_Occurred()) SWIG_fail;

17317

}

17318

{

17319

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17320

}

17321

{

17322

if (temp1)

17323

delete arg1;

17324

}

17325

return resultobj;

17326

fail:

17327

{

17328

if (temp1)

17329

delete arg1;

17330

}

17331

return NULL;

17332

}

17333

17334

17335

SWIGINTERN PyObject *_wrap_RichTextBuffer_FindHandlerByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17336

PyObject *resultobj = 0;

17337

wxString *arg1 = 0 ;

17338

wxRichTextFileHandler *result = 0 ;

17339

bool temp1 = false ;

17340

PyObject * obj0 = 0 ;

17341

char * kwnames[] = {

17342

(char *) "name", NULL

17343

};

17344

17345

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_FindHandlerByName",kwnames,&obj0)) SWIG_fail;

17346

{

17347

arg1 = wxString_in_helper(obj0);

17348

if (arg1 == NULL) SWIG_fail;

17349

temp1 = true;

17350

}

17351

{

17352

PyThreadState* __tstate = wxPyBeginAllowThreads();

17353

result = (wxRichTextFileHandler *)wxRichTextBuffer::FindHandler((wxString const &)*arg1);

17354

wxPyEndAllowThreads(__tstate);

17355

if (PyErr_Occurred()) SWIG_fail;

17356

}

17357

{

17358

resultobj = wxPyMake_wxObject(result, (bool)0);

17359

}

17360

{

17361

if (temp1)

17362

delete arg1;

17363

}

17364

return resultobj;

17365

fail:

17366

{

17367

if (temp1)

17368

delete arg1;

17369

}

17370

return NULL;

17371

}

17372

17373

17374

SWIGINTERN PyObject *_wrap_RichTextBuffer_FindHandlerByExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17375

PyObject *resultobj = 0;

17376

wxString *arg1 = 0 ;

17377

int arg2 ;

17378

wxRichTextFileHandler *result = 0 ;

17379

bool temp1 = false ;

17380

int val2 ;

17381

int ecode2 = 0 ;

17382

PyObject * obj0 = 0 ;

17383

PyObject * obj1 = 0 ;

17384

char * kwnames[] = {

17385

(char *) "extension",(char *) "imageType", NULL

17386

};

17387

17388

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_FindHandlerByExtension",kwnames,&obj0,&obj1)) SWIG_fail;

17389

{

17390

arg1 = wxString_in_helper(obj0);

17391

if (arg1 == NULL) SWIG_fail;

17392

temp1 = true;

17393

}

17394

ecode2 = SWIG_AsVal_int(obj1, &val2);

17395

if (!SWIG_IsOK(ecode2)) {

17396

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_FindHandlerByExtension" "', expected argument " "2"" of type '" "int""'");

17397

}

17398

arg2 = static_cast< int >(val2);

17399

{

17400

PyThreadState* __tstate = wxPyBeginAllowThreads();

17401

result = (wxRichTextFileHandler *)wxRichTextBuffer::FindHandler((wxString const &)*arg1,arg2);

17402

wxPyEndAllowThreads(__tstate);

17403

if (PyErr_Occurred()) SWIG_fail;

17404

}

17405

{

17406

resultobj = wxPyMake_wxObject(result, (bool)0);

17407

}

17408

{

17409

if (temp1)

17410

delete arg1;

17411

}

17412

return resultobj;

17413

fail:

17414

{

17415

if (temp1)

17416

delete arg1;

17417

}

17418

return NULL;

17419

}

17420

17421

17422

SWIGINTERN PyObject *_wrap_RichTextBuffer_FindHandlerByFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17423

PyObject *resultobj = 0;

17424

wxString *arg1 = 0 ;

17425

int arg2 ;

17426

wxRichTextFileHandler *result = 0 ;

17427

bool temp1 = false ;

17428

int val2 ;

17429

int ecode2 = 0 ;

17430

PyObject * obj0 = 0 ;

17431

PyObject * obj1 = 0 ;

17432

char * kwnames[] = {

17433

(char *) "filename",(char *) "imageType", NULL

17434

};

17435

17436

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_FindHandlerByFilename",kwnames,&obj0,&obj1)) SWIG_fail;

17437

{

17438

arg1 = wxString_in_helper(obj0);

17439

if (arg1 == NULL) SWIG_fail;

17440

temp1 = true;

17441

}

17442

ecode2 = SWIG_AsVal_int(obj1, &val2);

17443

if (!SWIG_IsOK(ecode2)) {

17444

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_FindHandlerByFilename" "', expected argument " "2"" of type '" "int""'");

17445

}

17446

arg2 = static_cast< int >(val2);

17447

{

17448

PyThreadState* __tstate = wxPyBeginAllowThreads();

17449

result = (wxRichTextFileHandler *)wxRichTextBuffer::FindHandlerFilenameOrType((wxString const &)*arg1,arg2);

17450

wxPyEndAllowThreads(__tstate);

17451

if (PyErr_Occurred()) SWIG_fail;

17452

}

17453

{

17454

resultobj = wxPyMake_wxObject(result, (bool)0);

17455

}

17456

{

17457

if (temp1)

17458

delete arg1;

17459

}

17460

return resultobj;

17461

fail:

17462

{

17463

if (temp1)

17464

delete arg1;

17465

}

17466

return NULL;

17467

}

17468

17469

17470

SWIGINTERN PyObject *_wrap_RichTextBuffer_FindHandlerByType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17471

PyObject *resultobj = 0;

17472

int arg1 ;

17473

wxRichTextFileHandler *result = 0 ;

17474

int val1 ;

17475

int ecode1 = 0 ;

17476

PyObject * obj0 = 0 ;

17477

char * kwnames[] = {

17478

(char *) "imageType", NULL

17479

};

17480

17481

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_FindHandlerByType",kwnames,&obj0)) SWIG_fail;

17482

ecode1 = SWIG_AsVal_int(obj0, &val1);

17483

if (!SWIG_IsOK(ecode1)) {

17484

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RichTextBuffer_FindHandlerByType" "', expected argument " "1"" of type '" "int""'");

17485

}

17486

arg1 = static_cast< int >(val1);

17487

{

17488

PyThreadState* __tstate = wxPyBeginAllowThreads();

17489

result = (wxRichTextFileHandler *)wxRichTextBuffer::FindHandler(arg1);

17490

wxPyEndAllowThreads(__tstate);

17491

if (PyErr_Occurred()) SWIG_fail;

17492

}

17493

{

17494

resultobj = wxPyMake_wxObject(result, (bool)0);

17495

}

17496

return resultobj;

17497

fail:

17498

return NULL;

17499

}

17500

17501

17502

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17503

PyObject *resultobj = 0;

17504

bool arg1 = (bool) false ;

17505

bool arg2 = (bool) false ;

17506

PyObject *result = 0 ;

17507

bool val1 ;

17508

int ecode1 = 0 ;

17509

bool val2 ;

17510

int ecode2 = 0 ;

17511

PyObject * obj0 = 0 ;

17512

PyObject * obj1 = 0 ;

17513

char * kwnames[] = {

17514

(char *) "combine",(char *) "save", NULL

17515

};

17516

17517

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:RichTextBuffer_GetExtWildcard",kwnames,&obj0,&obj1)) SWIG_fail;

17518

if (obj0) {

17519

ecode1 = SWIG_AsVal_bool(obj0, &val1);

17520

if (!SWIG_IsOK(ecode1)) {

17521

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RichTextBuffer_GetExtWildcard" "', expected argument " "1"" of type '" "bool""'");

17522

}

17523

arg1 = static_cast< bool >(val1);

17524

}

17525

if (obj1) {

17526

ecode2 = SWIG_AsVal_bool(obj1, &val2);

17527

if (!SWIG_IsOK(ecode2)) {

17528

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_GetExtWildcard" "', expected argument " "2"" of type '" "bool""'");

17529

}

17530

arg2 = static_cast< bool >(val2);

17531

}

17532

{

17533

result = (PyObject *)wxRichTextBuffer_GetExtWildcard(arg1,arg2);

17534

if (PyErr_Occurred()) SWIG_fail;

17535

}

17536

resultobj = result;

17537

return resultobj;

17538

fail:

17539

return NULL;

17540

}

17541

17542

17543

SWIGINTERN PyObject *_wrap_RichTextBuffer_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17544

PyObject *resultobj = 0;

17545

17546

if (!SWIG_Python_UnpackTuple(args,"RichTextBuffer_CleanUpHandlers",0,0,0)) SWIG_fail;

17547

{

17548

PyThreadState* __tstate = wxPyBeginAllowThreads();

17549

wxRichTextBuffer::CleanUpHandlers();

17550

wxPyEndAllowThreads(__tstate);

17551

if (PyErr_Occurred()) SWIG_fail;

17552

}

17553

resultobj = SWIG_Py_Void();

17554

return resultobj;

17555

fail:

17556

return NULL;

17557

}

17558

17559

17560

SWIGINTERN PyObject *_wrap_RichTextBuffer_InitStandardHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17561

PyObject *resultobj = 0;

17562

17563

if (!SWIG_Python_UnpackTuple(args,"RichTextBuffer_InitStandardHandlers",0,0,0)) SWIG_fail;

17564

{

17565

PyThreadState* __tstate = wxPyBeginAllowThreads();

17566

wxRichTextBuffer::InitStandardHandlers();

17567

wxPyEndAllowThreads(__tstate);

17568

if (PyErr_Occurred()) SWIG_fail;

17569

}

17570

resultobj = SWIG_Py_Void();

17571

return resultobj;

17572

fail:

17573

return NULL;

17574

}

17575

17576

17577

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17578

PyObject *resultobj = 0;

17579

wxRichTextRenderer *result = 0 ;

17580

17581

if (!SWIG_Python_UnpackTuple(args,"RichTextBuffer_GetRenderer",0,0,0)) SWIG_fail;

17582

{

17583

PyThreadState* __tstate = wxPyBeginAllowThreads();

17584

result = (wxRichTextRenderer *)wxRichTextBuffer::GetRenderer();

17585

wxPyEndAllowThreads(__tstate);

17586

if (PyErr_Occurred()) SWIG_fail;

17587

}

17588

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextRenderer, 0 | 0 );

17589

return resultobj;

17590

fail:

17591

return NULL;

17592

}

17593

17594

17595

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17596

PyObject *resultobj = 0;

17597

wxRichTextRenderer *arg1 = (wxRichTextRenderer *) 0 ;

17598

void *argp1 = 0 ;

17599

int res1 = 0 ;

17600

PyObject * obj0 = 0 ;

17601

char * kwnames[] = {

17602

(char *) "renderer", NULL

17603

};

17604

17605

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_SetRenderer",kwnames,&obj0)) SWIG_fail;

17606

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextRenderer, 0 | 0 );

17607

if (!SWIG_IsOK(res1)) {

17608

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SetRenderer" "', expected argument " "1"" of type '" "wxRichTextRenderer *""'");

17609

}

17610

arg1 = reinterpret_cast< wxRichTextRenderer * >(argp1);

17611

{

17612

PyThreadState* __tstate = wxPyBeginAllowThreads();

17613

wxRichTextBuffer::SetRenderer(arg1);

17614

wxPyEndAllowThreads(__tstate);

17615

if (PyErr_Occurred()) SWIG_fail;

17616

}

17617

resultobj = SWIG_Py_Void();

17618

return resultobj;

17619

fail:

17620

return NULL;

17621

}

17622

17623

17624

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetBulletRightMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17625

PyObject *resultobj = 0;

17626

int result;

17627

17628

if (!SWIG_Python_UnpackTuple(args,"RichTextBuffer_GetBulletRightMargin",0,0,0)) SWIG_fail;

17629

{

17630

PyThreadState* __tstate = wxPyBeginAllowThreads();

17631

result = (int)wxRichTextBuffer::GetBulletRightMargin();

17632

wxPyEndAllowThreads(__tstate);

17633

if (PyErr_Occurred()) SWIG_fail;

17634

}

17635

resultobj = SWIG_From_int(static_cast< int >(result));

17636

return resultobj;

17637

fail:

17638

return NULL;

17639

}

17640

17641

17642

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetBulletRightMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17643

PyObject *resultobj = 0;

17644

int arg1 ;

17645

int val1 ;

17646

int ecode1 = 0 ;

17647

PyObject * obj0 = 0 ;

17648

char * kwnames[] = {

17649

(char *) "margin", NULL

17650

};

17651

17652

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_SetBulletRightMargin",kwnames,&obj0)) SWIG_fail;

17653

ecode1 = SWIG_AsVal_int(obj0, &val1);

17654

if (!SWIG_IsOK(ecode1)) {

17655

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RichTextBuffer_SetBulletRightMargin" "', expected argument " "1"" of type '" "int""'");

17656

}

17657

arg1 = static_cast< int >(val1);

17658

{

17659

PyThreadState* __tstate = wxPyBeginAllowThreads();

17660

wxRichTextBuffer::SetBulletRightMargin(arg1);

17661

wxPyEndAllowThreads(__tstate);

17662

if (PyErr_Occurred()) SWIG_fail;

17663

}

17664

resultobj = SWIG_Py_Void();

17665

return resultobj;

17666

fail:

17667

return NULL;

17668

}

17669

17670

17671

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetBulletProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17672

PyObject *resultobj = 0;

17673

float result;

17674

17675

if (!SWIG_Python_UnpackTuple(args,"RichTextBuffer_GetBulletProportion",0,0,0)) SWIG_fail;

17676

{

17677

PyThreadState* __tstate = wxPyBeginAllowThreads();

17678

result = (float)wxRichTextBuffer::GetBulletProportion();

17679

wxPyEndAllowThreads(__tstate);

17680

if (PyErr_Occurred()) SWIG_fail;

17681

}

17682

resultobj = SWIG_From_float(static_cast< float >(result));

17683

return resultobj;

17684

fail:

17685

return NULL;

17686

}

17687

17688

17689

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetBulletProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17690

PyObject *resultobj = 0;

17691

float arg1 ;

17692

float val1 ;

17693

int ecode1 = 0 ;

17694

PyObject * obj0 = 0 ;

17695

char * kwnames[] = {

17696

(char *) "prop", NULL

17697

};

17698

17699

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextBuffer_SetBulletProportion",kwnames,&obj0)) SWIG_fail;

17700

ecode1 = SWIG_AsVal_float(obj0, &val1);

17701

if (!SWIG_IsOK(ecode1)) {

17702

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RichTextBuffer_SetBulletProportion" "', expected argument " "1"" of type '" "float""'");

17703

}

17704

arg1 = static_cast< float >(val1);

17705

{

17706

PyThreadState* __tstate = wxPyBeginAllowThreads();

17707

wxRichTextBuffer::SetBulletProportion(arg1);

17708

wxPyEndAllowThreads(__tstate);

17709

if (PyErr_Occurred()) SWIG_fail;

17710

}

17711

resultobj = SWIG_Py_Void();

17712

return resultobj;

17713

fail:

17714

return NULL;

17715

}

17716

17717

17718

SWIGINTERN PyObject *_wrap_RichTextBuffer_GetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17719

PyObject *resultobj = 0;

17720

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

17721

double result;

17722

void *argp1 = 0 ;

17723

int res1 = 0 ;

17724

PyObject *swig_obj[1] ;

17725

17726

if (!args) SWIG_fail;

17727

swig_obj[0] = args;

17728

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17729

if (!SWIG_IsOK(res1)) {

17730

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_GetScale" "', expected argument " "1"" of type '" "wxRichTextBuffer const *""'");

17731

}

17732

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

17733

{

17734

PyThreadState* __tstate = wxPyBeginAllowThreads();

17735

result = (double)((wxRichTextBuffer const *)arg1)->GetScale();

17736

wxPyEndAllowThreads(__tstate);

17737

if (PyErr_Occurred()) SWIG_fail;

17738

}

17739

resultobj = SWIG_From_double(static_cast< double >(result));

17740

return resultobj;

17741

fail:

17742

return NULL;

17743

}

17744

17745

17746

SWIGINTERN PyObject *_wrap_RichTextBuffer_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17747

PyObject *resultobj = 0;

17748

wxRichTextBuffer *arg1 = (wxRichTextBuffer *) 0 ;

17749

double arg2 ;

17750

void *argp1 = 0 ;

17751

int res1 = 0 ;

17752

double val2 ;

17753

int ecode2 = 0 ;

17754

PyObject * obj0 = 0 ;

17755

PyObject * obj1 = 0 ;

17756

char * kwnames[] = {

17757

(char *) "self",(char *) "scale", NULL

17758

};

17759

17760

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextBuffer_SetScale",kwnames,&obj0,&obj1)) SWIG_fail;

17761

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17762

if (!SWIG_IsOK(res1)) {

17763

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextBuffer_SetScale" "', expected argument " "1"" of type '" "wxRichTextBuffer *""'");

17764

}

17765

arg1 = reinterpret_cast< wxRichTextBuffer * >(argp1);

17766

ecode2 = SWIG_AsVal_double(obj1, &val2);

17767

if (!SWIG_IsOK(ecode2)) {

17768

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextBuffer_SetScale" "', expected argument " "2"" of type '" "double""'");

17769

}

17770

arg2 = static_cast< double >(val2);

17771

{

17772

PyThreadState* __tstate = wxPyBeginAllowThreads();

17773

(arg1)->SetScale(arg2);

17774

wxPyEndAllowThreads(__tstate);

17775

if (PyErr_Occurred()) SWIG_fail;

17776

}

17777

resultobj = SWIG_Py_Void();

17778

return resultobj;

17779

fail:

17780

return NULL;

17781

}

17782

17783

17784

SWIGINTERN PyObject *RichTextBuffer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17785

PyObject *obj;

17786

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

17787

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextBuffer, SWIG_NewClientData(obj));

17788

return SWIG_Py_Void();

17789

}

17790

17791

SWIGINTERN PyObject *RichTextBuffer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17792

return SWIG_Python_InitShadowInstance(args);

17793

}

17794

17795

SWIGINTERN PyObject *_wrap_delete_RichTextFileHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

17796

PyObject *resultobj = 0;

17797

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

17798

void *argp1 = 0 ;

17799

int res1 = 0 ;

17800

PyObject *swig_obj[1] ;

17801

17802

if (!args) SWIG_fail;

17803

swig_obj[0] = args;

17804

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, SWIG_POINTER_DISOWN | 0 );

17805

if (!SWIG_IsOK(res1)) {

17806

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextFileHandler" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

17807

}

17808

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

17809

{

17810

PyThreadState* __tstate = wxPyBeginAllowThreads();

17811

delete arg1;

17812

17813

wxPyEndAllowThreads(__tstate);

17814

if (PyErr_Occurred()) SWIG_fail;

17815

}

17816

resultobj = SWIG_Py_Void();

17817

return resultobj;

17818

fail:

17819

return NULL;

17820

}

17821

17822

17823

SWIGINTERN PyObject *_wrap_RichTextFileHandler_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17824

PyObject *resultobj = 0;

17825

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

17826

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

17827

wxInputStream *arg3 = 0 ;

17828

bool result;

17829

void *argp1 = 0 ;

17830

int res1 = 0 ;

17831

void *argp2 = 0 ;

17832

int res2 = 0 ;

17833

wxPyInputStream *temp3 ;

17834

bool created3 ;

17835

PyObject * obj0 = 0 ;

17836

PyObject * obj1 = 0 ;

17837

PyObject * obj2 = 0 ;

17838

char * kwnames[] = {

17839

(char *) "self",(char *) "buffer",(char *) "stream", NULL

17840

};

17841

17842

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextFileHandler_LoadStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17843

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

17844

if (!SWIG_IsOK(res1)) {

17845

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_LoadStream" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

17846

}

17847

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

17848

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17849

if (!SWIG_IsOK(res2)) {

17850

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextFileHandler_LoadStream" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

17851

}

17852

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

17853

{

17854

if (wxPyConvertSwigPtr(obj2, (void **)&temp3, wxT("wxPyInputStream"))) {

17855

arg3 = temp3->m_wxis;

17856

created3 = false;

17857

} else {

17858

PyErr_Clear(); // clear the failure of the wxPyConvert above

17859

arg3 = wxPyCBInputStream_create(obj2, false);

17860

if (arg3 == NULL) {

17861

PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");

17862

SWIG_fail;

17863

}

17864

created3 = true;

17865

}

17866

}

17867

{

17868

PyThreadState* __tstate = wxPyBeginAllowThreads();

17869

result = (bool)(arg1)->LoadFile(arg2,*arg3);

17870

wxPyEndAllowThreads(__tstate);

17871

if (PyErr_Occurred()) SWIG_fail;

17872

}

17873

{

17874

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17875

}

17876

{

17877

if (created3) delete arg3;

17878

}

17879

return resultobj;

17880

fail:

17881

{

17882

if (created3) delete arg3;

17883

}

17884

return NULL;

17885

}

17886

17887

17888

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SaveStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17889

PyObject *resultobj = 0;

17890

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

17891

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

17892

wxOutputStream *arg3 = 0 ;

17893

bool result;

17894

void *argp1 = 0 ;

17895

int res1 = 0 ;

17896

void *argp2 = 0 ;

17897

int res2 = 0 ;

17898

wxPyOutputStream *temp3 ;

17899

bool created3 ;

17900

PyObject * obj0 = 0 ;

17901

PyObject * obj1 = 0 ;

17902

PyObject * obj2 = 0 ;

17903

char * kwnames[] = {

17904

(char *) "self",(char *) "buffer",(char *) "stream", NULL

17905

};

17906

17907

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextFileHandler_SaveStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17908

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

17909

if (!SWIG_IsOK(res1)) {

17910

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SaveStream" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

17911

}

17912

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

17913

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17914

if (!SWIG_IsOK(res2)) {

17915

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextFileHandler_SaveStream" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

17916

}

17917

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

17918

{

17919

if (wxPyConvertSwigPtr(obj2, (void **)&temp3, wxT("wxPyOutputStream"))) {

17920

arg3 = temp3->m_wxos;

17921

created3 = false;

17922

} else {

17923

PyErr_Clear(); // clear the failure of the wxPyConvert above

17924

arg3 = wxPyCBOutputStream_create(obj2, false);

17925

if (arg3 == NULL) {

17926

PyErr_SetString(PyExc_TypeError, "Expected wx.OutputStream or Python file-like object.");

17927

SWIG_fail;

17928

}

17929

created3 = true;

17930

}

17931

}

17932

{

17933

PyThreadState* __tstate = wxPyBeginAllowThreads();

17934

result = (bool)(arg1)->SaveFile(arg2,*arg3);

17935

wxPyEndAllowThreads(__tstate);

17936

if (PyErr_Occurred()) SWIG_fail;

17937

}

17938

{

17939

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17940

}

17941

{

17942

if (created3) delete arg3;

17943

}

17944

return resultobj;

17945

fail:

17946

{

17947

if (created3) delete arg3;

17948

}

17949

return NULL;

17950

}

17951

17952

17953

SWIGINTERN PyObject *_wrap_RichTextFileHandler_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

17954

PyObject *resultobj = 0;

17955

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

17956

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

17957

wxString *arg3 = 0 ;

17958

bool result;

17959

void *argp1 = 0 ;

17960

int res1 = 0 ;

17961

void *argp2 = 0 ;

17962

int res2 = 0 ;

17963

bool temp3 = false ;

17964

PyObject * obj0 = 0 ;

17965

PyObject * obj1 = 0 ;

17966

PyObject * obj2 = 0 ;

17967

char * kwnames[] = {

17968

(char *) "self",(char *) "buffer",(char *) "filename", NULL

17969

};

17970

17971

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextFileHandler_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

17972

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

17973

if (!SWIG_IsOK(res1)) {

17974

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_LoadFile" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

17975

}

17976

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

17977

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

17978

if (!SWIG_IsOK(res2)) {

17979

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextFileHandler_LoadFile" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

17980

}

17981

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

17982

{

17983

arg3 = wxString_in_helper(obj2);

17984

if (arg3 == NULL) SWIG_fail;

17985

temp3 = true;

17986

}

17987

{

17988

PyThreadState* __tstate = wxPyBeginAllowThreads();

17989

result = (bool)(arg1)->LoadFile(arg2,(wxString const &)*arg3);

17990

wxPyEndAllowThreads(__tstate);

17991

if (PyErr_Occurred()) SWIG_fail;

17992

}

17993

{

17994

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

17995

}

17996

{

17997

if (temp3)

17998

delete arg3;

17999

}

18000

return resultobj;

18001

fail:

18002

{

18003

if (temp3)

18004

delete arg3;

18005

}

18006

return NULL;

18007

}

18008

18009

18010

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18011

PyObject *resultobj = 0;

18012

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18013

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

18014

wxString *arg3 = 0 ;

18015

bool result;

18016

void *argp1 = 0 ;

18017

int res1 = 0 ;

18018

void *argp2 = 0 ;

18019

int res2 = 0 ;

18020

bool temp3 = false ;

18021

PyObject * obj0 = 0 ;

18022

PyObject * obj1 = 0 ;

18023

PyObject * obj2 = 0 ;

18024

char * kwnames[] = {

18025

(char *) "self",(char *) "buffer",(char *) "filename", NULL

18026

};

18027

18028

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextFileHandler_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18029

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18030

if (!SWIG_IsOK(res1)) {

18031

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SaveFile" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18032

}

18033

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18034

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

18035

if (!SWIG_IsOK(res2)) {

18036

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextFileHandler_SaveFile" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

18037

}

18038

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

18039

{

18040

arg3 = wxString_in_helper(obj2);

18041

if (arg3 == NULL) SWIG_fail;

18042

temp3 = true;

18043

}

18044

{

18045

PyThreadState* __tstate = wxPyBeginAllowThreads();

18046

result = (bool)(arg1)->SaveFile(arg2,(wxString const &)*arg3);

18047

wxPyEndAllowThreads(__tstate);

18048

if (PyErr_Occurred()) SWIG_fail;

18049

}

18050

{

18051

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18052

}

18053

{

18054

if (temp3)

18055

delete arg3;

18056

}

18057

return resultobj;

18058

fail:

18059

{

18060

if (temp3)

18061

delete arg3;

18062

}

18063

return NULL;

18064

}

18065

18066

18067

SWIGINTERN PyObject *_wrap_RichTextFileHandler_CanHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18068

PyObject *resultobj = 0;

18069

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18070

wxString *arg2 = 0 ;

18071

bool result;

18072

void *argp1 = 0 ;

18073

int res1 = 0 ;

18074

bool temp2 = false ;

18075

PyObject * obj0 = 0 ;

18076

PyObject * obj1 = 0 ;

18077

char * kwnames[] = {

18078

(char *) "self",(char *) "filename", NULL

18079

};

18080

18081

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_CanHandle",kwnames,&obj0,&obj1)) SWIG_fail;

18082

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18083

if (!SWIG_IsOK(res1)) {

18084

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_CanHandle" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18085

}

18086

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18087

{

18088

arg2 = wxString_in_helper(obj1);

18089

if (arg2 == NULL) SWIG_fail;

18090

temp2 = true;

18091

}

18092

{

18093

PyThreadState* __tstate = wxPyBeginAllowThreads();

18094

result = (bool)((wxRichTextFileHandler const *)arg1)->CanHandle((wxString const &)*arg2);

18095

wxPyEndAllowThreads(__tstate);

18096

if (PyErr_Occurred()) SWIG_fail;

18097

}

18098

{

18099

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18100

}

18101

{

18102

if (temp2)

18103

delete arg2;

18104

}

18105

return resultobj;

18106

fail:

18107

{

18108

if (temp2)

18109

delete arg2;

18110

}

18111

return NULL;

18112

}

18113

18114

18115

SWIGINTERN PyObject *_wrap_RichTextFileHandler_CanSave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18116

PyObject *resultobj = 0;

18117

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18118

bool result;

18119

void *argp1 = 0 ;

18120

int res1 = 0 ;

18121

PyObject *swig_obj[1] ;

18122

18123

if (!args) SWIG_fail;

18124

swig_obj[0] = args;

18125

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18126

if (!SWIG_IsOK(res1)) {

18127

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_CanSave" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18128

}

18129

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18130

{

18131

PyThreadState* __tstate = wxPyBeginAllowThreads();

18132

result = (bool)((wxRichTextFileHandler const *)arg1)->CanSave();

18133

wxPyEndAllowThreads(__tstate);

18134

if (PyErr_Occurred()) SWIG_fail;

18135

}

18136

{

18137

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18138

}

18139

return resultobj;

18140

fail:

18141

return NULL;

18142

}

18143

18144

18145

SWIGINTERN PyObject *_wrap_RichTextFileHandler_CanLoad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18146

PyObject *resultobj = 0;

18147

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18148

bool result;

18149

void *argp1 = 0 ;

18150

int res1 = 0 ;

18151

PyObject *swig_obj[1] ;

18152

18153

if (!args) SWIG_fail;

18154

swig_obj[0] = args;

18155

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18156

if (!SWIG_IsOK(res1)) {

18157

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_CanLoad" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18158

}

18159

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18160

{

18161

PyThreadState* __tstate = wxPyBeginAllowThreads();

18162

result = (bool)((wxRichTextFileHandler const *)arg1)->CanLoad();

18163

wxPyEndAllowThreads(__tstate);

18164

if (PyErr_Occurred()) SWIG_fail;

18165

}

18166

{

18167

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18168

}

18169

return resultobj;

18170

fail:

18171

return NULL;

18172

}

18173

18174

18175

SWIGINTERN PyObject *_wrap_RichTextFileHandler_IsVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18176

PyObject *resultobj = 0;

18177

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18178

bool result;

18179

void *argp1 = 0 ;

18180

int res1 = 0 ;

18181

PyObject *swig_obj[1] ;

18182

18183

if (!args) SWIG_fail;

18184

swig_obj[0] = args;

18185

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18186

if (!SWIG_IsOK(res1)) {

18187

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_IsVisible" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18188

}

18189

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18190

{

18191

PyThreadState* __tstate = wxPyBeginAllowThreads();

18192

result = (bool)((wxRichTextFileHandler const *)arg1)->IsVisible();

18193

wxPyEndAllowThreads(__tstate);

18194

if (PyErr_Occurred()) SWIG_fail;

18195

}

18196

{

18197

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18198

}

18199

return resultobj;

18200

fail:

18201

return NULL;

18202

}

18203

18204

18205

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SetVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18206

PyObject *resultobj = 0;

18207

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18208

bool arg2 ;

18209

void *argp1 = 0 ;

18210

int res1 = 0 ;

18211

bool val2 ;

18212

int ecode2 = 0 ;

18213

PyObject * obj0 = 0 ;

18214

PyObject * obj1 = 0 ;

18215

char * kwnames[] = {

18216

(char *) "self",(char *) "visible", NULL

18217

};

18218

18219

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_SetVisible",kwnames,&obj0,&obj1)) SWIG_fail;

18220

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18221

if (!SWIG_IsOK(res1)) {

18222

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SetVisible" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18223

}

18224

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18225

ecode2 = SWIG_AsVal_bool(obj1, &val2);

18226

if (!SWIG_IsOK(ecode2)) {

18227

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextFileHandler_SetVisible" "', expected argument " "2"" of type '" "bool""'");

18228

}

18229

arg2 = static_cast< bool >(val2);

18230

{

18231

PyThreadState* __tstate = wxPyBeginAllowThreads();

18232

(arg1)->SetVisible(arg2);

18233

wxPyEndAllowThreads(__tstate);

18234

if (PyErr_Occurred()) SWIG_fail;

18235

}

18236

resultobj = SWIG_Py_Void();

18237

return resultobj;

18238

fail:

18239

return NULL;

18240

}

18241

18242

18243

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18244

PyObject *resultobj = 0;

18245

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18246

wxString *arg2 = 0 ;

18247

void *argp1 = 0 ;

18248

int res1 = 0 ;

18249

bool temp2 = false ;

18250

PyObject * obj0 = 0 ;

18251

PyObject * obj1 = 0 ;

18252

char * kwnames[] = {

18253

(char *) "self",(char *) "name", NULL

18254

};

18255

18256

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;

18257

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18258

if (!SWIG_IsOK(res1)) {

18259

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SetName" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18260

}

18261

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18262

{

18263

arg2 = wxString_in_helper(obj1);

18264

if (arg2 == NULL) SWIG_fail;

18265

temp2 = true;

18266

}

18267

{

18268

PyThreadState* __tstate = wxPyBeginAllowThreads();

18269

(arg1)->SetName((wxString const &)*arg2);

18270

wxPyEndAllowThreads(__tstate);

18271

if (PyErr_Occurred()) SWIG_fail;

18272

}

18273

resultobj = SWIG_Py_Void();

18274

{

18275

if (temp2)

18276

delete arg2;

18277

}

18278

return resultobj;

18279

fail:

18280

{

18281

if (temp2)

18282

delete arg2;

18283

}

18284

return NULL;

18285

}

18286

18287

18288

SWIGINTERN PyObject *_wrap_RichTextFileHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18289

PyObject *resultobj = 0;

18290

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18291

wxString result;

18292

void *argp1 = 0 ;

18293

int res1 = 0 ;

18294

PyObject *swig_obj[1] ;

18295

18296

if (!args) SWIG_fail;

18297

swig_obj[0] = args;

18298

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18299

if (!SWIG_IsOK(res1)) {

18300

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_GetName" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18301

}

18302

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18303

{

18304

PyThreadState* __tstate = wxPyBeginAllowThreads();

18305

result = ((wxRichTextFileHandler const *)arg1)->GetName();

18306

wxPyEndAllowThreads(__tstate);

18307

if (PyErr_Occurred()) SWIG_fail;

18308

}

18309

{

18310

#if wxUSE_UNICODE

18311

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

18312

#else

18313

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

18314

#endif

18315

}

18316

return resultobj;

18317

fail:

18318

return NULL;

18319

}

18320

18321

18322

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18323

PyObject *resultobj = 0;

18324

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18325

wxString *arg2 = 0 ;

18326

void *argp1 = 0 ;

18327

int res1 = 0 ;

18328

bool temp2 = false ;

18329

PyObject * obj0 = 0 ;

18330

PyObject * obj1 = 0 ;

18331

char * kwnames[] = {

18332

(char *) "self",(char *) "ext", NULL

18333

};

18334

18335

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;

18336

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18337

if (!SWIG_IsOK(res1)) {

18338

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SetExtension" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18339

}

18340

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18341

{

18342

arg2 = wxString_in_helper(obj1);

18343

if (arg2 == NULL) SWIG_fail;

18344

temp2 = true;

18345

}

18346

{

18347

PyThreadState* __tstate = wxPyBeginAllowThreads();

18348

(arg1)->SetExtension((wxString const &)*arg2);

18349

wxPyEndAllowThreads(__tstate);

18350

if (PyErr_Occurred()) SWIG_fail;

18351

}

18352

resultobj = SWIG_Py_Void();

18353

{

18354

if (temp2)

18355

delete arg2;

18356

}

18357

return resultobj;

18358

fail:

18359

{

18360

if (temp2)

18361

delete arg2;

18362

}

18363

return NULL;

18364

}

18365

18366

18367

SWIGINTERN PyObject *_wrap_RichTextFileHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18368

PyObject *resultobj = 0;

18369

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18370

wxString result;

18371

void *argp1 = 0 ;

18372

int res1 = 0 ;

18373

PyObject *swig_obj[1] ;

18374

18375

if (!args) SWIG_fail;

18376

swig_obj[0] = args;

18377

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18378

if (!SWIG_IsOK(res1)) {

18379

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_GetExtension" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18380

}

18381

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18382

{

18383

PyThreadState* __tstate = wxPyBeginAllowThreads();

18384

result = ((wxRichTextFileHandler const *)arg1)->GetExtension();

18385

wxPyEndAllowThreads(__tstate);

18386

if (PyErr_Occurred()) SWIG_fail;

18387

}

18388

{

18389

#if wxUSE_UNICODE

18390

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

18391

#else

18392

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

18393

#endif

18394

}

18395

return resultobj;

18396

fail:

18397

return NULL;

18398

}

18399

18400

18401

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18402

PyObject *resultobj = 0;

18403

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18404

int arg2 ;

18405

void *argp1 = 0 ;

18406

int res1 = 0 ;

18407

int val2 ;

18408

int ecode2 = 0 ;

18409

PyObject * obj0 = 0 ;

18410

PyObject * obj1 = 0 ;

18411

char * kwnames[] = {

18412

(char *) "self",(char *) "type", NULL

18413

};

18414

18415

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;

18416

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18417

if (!SWIG_IsOK(res1)) {

18418

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SetType" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18419

}

18420

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18421

ecode2 = SWIG_AsVal_int(obj1, &val2);

18422

if (!SWIG_IsOK(ecode2)) {

18423

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextFileHandler_SetType" "', expected argument " "2"" of type '" "int""'");

18424

}

18425

arg2 = static_cast< int >(val2);

18426

{

18427

PyThreadState* __tstate = wxPyBeginAllowThreads();

18428

(arg1)->SetType(arg2);

18429

wxPyEndAllowThreads(__tstate);

18430

if (PyErr_Occurred()) SWIG_fail;

18431

}

18432

resultobj = SWIG_Py_Void();

18433

return resultobj;

18434

fail:

18435

return NULL;

18436

}

18437

18438

18439

SWIGINTERN PyObject *_wrap_RichTextFileHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18440

PyObject *resultobj = 0;

18441

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18442

int result;

18443

void *argp1 = 0 ;

18444

int res1 = 0 ;

18445

PyObject *swig_obj[1] ;

18446

18447

if (!args) SWIG_fail;

18448

swig_obj[0] = args;

18449

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18450

if (!SWIG_IsOK(res1)) {

18451

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_GetType" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18452

}

18453

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18454

{

18455

PyThreadState* __tstate = wxPyBeginAllowThreads();

18456

result = (int)((wxRichTextFileHandler const *)arg1)->GetType();

18457

wxPyEndAllowThreads(__tstate);

18458

if (PyErr_Occurred()) SWIG_fail;

18459

}

18460

resultobj = SWIG_From_int(static_cast< int >(result));

18461

return resultobj;

18462

fail:

18463

return NULL;

18464

}

18465

18466

18467

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18468

PyObject *resultobj = 0;

18469

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18470

int arg2 ;

18471

void *argp1 = 0 ;

18472

int res1 = 0 ;

18473

int val2 ;

18474

int ecode2 = 0 ;

18475

PyObject * obj0 = 0 ;

18476

PyObject * obj1 = 0 ;

18477

char * kwnames[] = {

18478

(char *) "self",(char *) "flags", NULL

18479

};

18480

18481

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;

18482

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18483

if (!SWIG_IsOK(res1)) {

18484

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SetFlags" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18485

}

18486

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18487

ecode2 = SWIG_AsVal_int(obj1, &val2);

18488

if (!SWIG_IsOK(ecode2)) {

18489

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextFileHandler_SetFlags" "', expected argument " "2"" of type '" "int""'");

18490

}

18491

arg2 = static_cast< int >(val2);

18492

{

18493

PyThreadState* __tstate = wxPyBeginAllowThreads();

18494

(arg1)->SetFlags(arg2);

18495

wxPyEndAllowThreads(__tstate);

18496

if (PyErr_Occurred()) SWIG_fail;

18497

}

18498

resultobj = SWIG_Py_Void();

18499

return resultobj;

18500

fail:

18501

return NULL;

18502

}

18503

18504

18505

SWIGINTERN PyObject *_wrap_RichTextFileHandler_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18506

PyObject *resultobj = 0;

18507

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18508

int result;

18509

void *argp1 = 0 ;

18510

int res1 = 0 ;

18511

PyObject *swig_obj[1] ;

18512

18513

if (!args) SWIG_fail;

18514

swig_obj[0] = args;

18515

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18516

if (!SWIG_IsOK(res1)) {

18517

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_GetFlags" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18518

}

18519

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18520

{

18521

PyThreadState* __tstate = wxPyBeginAllowThreads();

18522

result = (int)((wxRichTextFileHandler const *)arg1)->GetFlags();

18523

wxPyEndAllowThreads(__tstate);

18524

if (PyErr_Occurred()) SWIG_fail;

18525

}

18526

resultobj = SWIG_From_int(static_cast< int >(result));

18527

return resultobj;

18528

fail:

18529

return NULL;

18530

}

18531

18532

18533

SWIGINTERN PyObject *_wrap_RichTextFileHandler_SetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18534

PyObject *resultobj = 0;

18535

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18536

wxString *arg2 = 0 ;

18537

void *argp1 = 0 ;

18538

int res1 = 0 ;

18539

bool temp2 = false ;

18540

PyObject * obj0 = 0 ;

18541

PyObject * obj1 = 0 ;

18542

char * kwnames[] = {

18543

(char *) "self",(char *) "encoding", NULL

18544

};

18545

18546

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextFileHandler_SetEncoding",kwnames,&obj0,&obj1)) SWIG_fail;

18547

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18548

if (!SWIG_IsOK(res1)) {

18549

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_SetEncoding" "', expected argument " "1"" of type '" "wxRichTextFileHandler *""'");

18550

}

18551

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18552

{

18553

arg2 = wxString_in_helper(obj1);

18554

if (arg2 == NULL) SWIG_fail;

18555

temp2 = true;

18556

}

18557

{

18558

PyThreadState* __tstate = wxPyBeginAllowThreads();

18559

(arg1)->SetEncoding((wxString const &)*arg2);

18560

wxPyEndAllowThreads(__tstate);

18561

if (PyErr_Occurred()) SWIG_fail;

18562

}

18563

resultobj = SWIG_Py_Void();

18564

{

18565

if (temp2)

18566

delete arg2;

18567

}

18568

return resultobj;

18569

fail:

18570

{

18571

if (temp2)

18572

delete arg2;

18573

}

18574

return NULL;

18575

}

18576

18577

18578

SWIGINTERN PyObject *_wrap_RichTextFileHandler_GetEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18579

PyObject *resultobj = 0;

18580

wxRichTextFileHandler *arg1 = (wxRichTextFileHandler *) 0 ;

18581

wxString *result = 0 ;

18582

void *argp1 = 0 ;

18583

int res1 = 0 ;

18584

PyObject *swig_obj[1] ;

18585

18586

if (!args) SWIG_fail;

18587

swig_obj[0] = args;

18588

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextFileHandler, 0 | 0 );

18589

if (!SWIG_IsOK(res1)) {

18590

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextFileHandler_GetEncoding" "', expected argument " "1"" of type '" "wxRichTextFileHandler const *""'");

18591

}

18592

arg1 = reinterpret_cast< wxRichTextFileHandler * >(argp1);

18593

{

18594

PyThreadState* __tstate = wxPyBeginAllowThreads();

18595

{

18596

wxString const &_result_ref = ((wxRichTextFileHandler const *)arg1)->GetEncoding();

18597

result = (wxString *) &_result_ref;

18598

}

18599

wxPyEndAllowThreads(__tstate);

18600

if (PyErr_Occurred()) SWIG_fail;

18601

}

18602

{

18603

#if wxUSE_UNICODE

18604

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

18605

#else

18606

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

18607

#endif

18608

}

18609

return resultobj;

18610

fail:

18611

return NULL;

18612

}

18613

18614

18615

SWIGINTERN PyObject *RichTextFileHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18616

PyObject *obj;

18617

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

18618

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextFileHandler, SWIG_NewClientData(obj));

18619

return SWIG_Py_Void();

18620

}

18621

18622

SWIGINTERN int TextName_set(PyObject *) {

18623

SWIG_Error(SWIG_AttributeError,"Variable TextName is read-only.");

18624

return 1;

18625

}

18626

18627

18628

SWIGINTERN PyObject *TextName_get(void) {

18629

PyObject *pyobj = 0;

18630

18631

{

18632

#if wxUSE_UNICODE

18633

pyobj = PyUnicode_FromWideChar((&wxPyTextName)->c_str(), (&wxPyTextName)->Len());

18634

#else

18635

pyobj = PyString_FromStringAndSize((&wxPyTextName)->c_str(), (&wxPyTextName)->Len());

18636

#endif

18637

}

18638

return pyobj;

18639

}

18640

18641

18642

SWIGINTERN int TextExt_set(PyObject *) {

18643

SWIG_Error(SWIG_AttributeError,"Variable TextExt is read-only.");

18644

return 1;

18645

}

18646

18647

18648

SWIGINTERN PyObject *TextExt_get(void) {

18649

PyObject *pyobj = 0;

18650

18651

{

18652

#if wxUSE_UNICODE

18653

pyobj = PyUnicode_FromWideChar((&wxPyTextExt)->c_str(), (&wxPyTextExt)->Len());

18654

#else

18655

pyobj = PyString_FromStringAndSize((&wxPyTextExt)->c_str(), (&wxPyTextExt)->Len());

18656

#endif

18657

}

18658

return pyobj;

18659

}

18660

18661

18662

SWIGINTERN PyObject *_wrap_new_RichTextPlainTextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18663

PyObject *resultobj = 0;

18664

wxString const &arg1_defvalue = wxPyTextName ;

18665

wxString *arg1 = (wxString *) &arg1_defvalue ;

18666

wxString const &arg2_defvalue = wxPyTextExt ;

18667

wxString *arg2 = (wxString *) &arg2_defvalue ;

18668

int arg3 = (int) wxRICHTEXT_TYPE_TEXT ;

18669

wxRichTextPlainTextHandler *result = 0 ;

18670

bool temp1 = false ;

18671

bool temp2 = false ;

18672

int val3 ;

18673

int ecode3 = 0 ;

18674

PyObject * obj0 = 0 ;

18675

PyObject * obj1 = 0 ;

18676

PyObject * obj2 = 0 ;

18677

char * kwnames[] = {

18678

(char *) "name",(char *) "ext",(char *) "type", NULL

18679

};

18680

18681

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_RichTextPlainTextHandler",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

18682

if (obj0) {

18683

{

18684

arg1 = wxString_in_helper(obj0);

18685

if (arg1 == NULL) SWIG_fail;

18686

temp1 = true;

18687

}

18688

}

18689

if (obj1) {

18690

{

18691

arg2 = wxString_in_helper(obj1);

18692

if (arg2 == NULL) SWIG_fail;

18693

temp2 = true;

18694

}

18695

}

18696

if (obj2) {

18697

ecode3 = SWIG_AsVal_int(obj2, &val3);

18698

if (!SWIG_IsOK(ecode3)) {

18699

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RichTextPlainTextHandler" "', expected argument " "3"" of type '" "int""'");

18700

}

18701

arg3 = static_cast< int >(val3);

18702

}

18703

{

18704

PyThreadState* __tstate = wxPyBeginAllowThreads();

18705

result = (wxRichTextPlainTextHandler *)new wxRichTextPlainTextHandler((wxString const &)*arg1,(wxString const &)*arg2,arg3);

18706

wxPyEndAllowThreads(__tstate);

18707

if (PyErr_Occurred()) SWIG_fail;

18708

}

18709

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextPlainTextHandler, SWIG_POINTER_NEW | 0 );

18710

{

18711

if (temp1)

18712

delete arg1;

18713

}

18714

{

18715

if (temp2)

18716

delete arg2;

18717

}

18718

return resultobj;

18719

fail:

18720

{

18721

if (temp1)

18722

delete arg1;

18723

}

18724

{

18725

if (temp2)

18726

delete arg2;

18727

}

18728

return NULL;

18729

}

18730

18731

18732

SWIGINTERN PyObject *RichTextPlainTextHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18733

PyObject *obj;

18734

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

18735

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextPlainTextHandler, SWIG_NewClientData(obj));

18736

return SWIG_Py_Void();

18737

}

18738

18739

SWIGINTERN PyObject *RichTextPlainTextHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18740

return SWIG_Python_InitShadowInstance(args);

18741

}

18742

18743

SWIGINTERN PyObject *_wrap_delete_RichTextRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

18744

PyObject *resultobj = 0;

18745

wxRichTextRenderer *arg1 = (wxRichTextRenderer *) 0 ;

18746

void *argp1 = 0 ;

18747

int res1 = 0 ;

18748

PyObject *swig_obj[1] ;

18749

18750

if (!args) SWIG_fail;

18751

swig_obj[0] = args;

18752

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextRenderer, SWIG_POINTER_DISOWN | 0 );

18753

if (!SWIG_IsOK(res1)) {

18754

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextRenderer" "', expected argument " "1"" of type '" "wxRichTextRenderer *""'");

18755

}

18756

arg1 = reinterpret_cast< wxRichTextRenderer * >(argp1);

18757

{

18758

PyThreadState* __tstate = wxPyBeginAllowThreads();

18759

delete arg1;

18760

18761

wxPyEndAllowThreads(__tstate);

18762

if (PyErr_Occurred()) SWIG_fail;

18763

}

18764

resultobj = SWIG_Py_Void();

18765

return resultobj;

18766

fail:

18767

return NULL;

18768

}

18769

18770

18771

SWIGINTERN PyObject *_wrap_RichTextRenderer_DrawStandardBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18772

PyObject *resultobj = 0;

18773

wxRichTextRenderer *arg1 = (wxRichTextRenderer *) 0 ;

18774

wxRichTextParagraph *arg2 = (wxRichTextParagraph *) 0 ;

18775

wxDC *arg3 = 0 ;

18776

wxTextAttrEx *arg4 = 0 ;

18777

wxRect *arg5 = 0 ;

18778

bool result;

18779

void *argp1 = 0 ;

18780

int res1 = 0 ;

18781

void *argp2 = 0 ;

18782

int res2 = 0 ;

18783

void *argp3 = 0 ;

18784

int res3 = 0 ;

18785

void *argp4 = 0 ;

18786

int res4 = 0 ;

18787

wxRect temp5 ;

18788

PyObject * obj0 = 0 ;

18789

PyObject * obj1 = 0 ;

18790

PyObject * obj2 = 0 ;

18791

PyObject * obj3 = 0 ;

18792

PyObject * obj4 = 0 ;

18793

char * kwnames[] = {

18794

(char *) "self",(char *) "paragraph",(char *) "dc",(char *) "attr",(char *) "rect", NULL

18795

};

18796

18797

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:RichTextRenderer_DrawStandardBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

18798

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextRenderer, 0 | 0 );

18799

if (!SWIG_IsOK(res1)) {

18800

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextRenderer_DrawStandardBullet" "', expected argument " "1"" of type '" "wxRichTextRenderer *""'");

18801

}

18802

arg1 = reinterpret_cast< wxRichTextRenderer * >(argp1);

18803

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

18804

if (!SWIG_IsOK(res2)) {

18805

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextRenderer_DrawStandardBullet" "', expected argument " "2"" of type '" "wxRichTextParagraph *""'");

18806

}

18807

arg2 = reinterpret_cast< wxRichTextParagraph * >(argp2);

18808

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );

18809

if (!SWIG_IsOK(res3)) {

18810

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextRenderer_DrawStandardBullet" "', expected argument " "3"" of type '" "wxDC &""'");

18811

}

18812

if (!argp3) {

18813

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextRenderer_DrawStandardBullet" "', expected argument " "3"" of type '" "wxDC &""'");

18814

}

18815

arg3 = reinterpret_cast< wxDC * >(argp3);

18816

res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

18817

if (!SWIG_IsOK(res4)) {

18818

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextRenderer_DrawStandardBullet" "', expected argument " "4"" of type '" "wxTextAttrEx const &""'");

18819

}

18820

if (!argp4) {

18821

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextRenderer_DrawStandardBullet" "', expected argument " "4"" of type '" "wxTextAttrEx const &""'");

18822

}

18823

arg4 = reinterpret_cast< wxTextAttrEx * >(argp4);

18824

{

18825

arg5 = &temp5;

18826

if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;

18827

}

18828

{

18829

PyThreadState* __tstate = wxPyBeginAllowThreads();

18830

result = (bool)(arg1)->DrawStandardBullet(arg2,*arg3,(wxTextAttrEx const &)*arg4,(wxRect const &)*arg5);

18831

wxPyEndAllowThreads(__tstate);

18832

if (PyErr_Occurred()) SWIG_fail;

18833

}

18834

{

18835

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18836

}

18837

return resultobj;

18838

fail:

18839

return NULL;

18840

}

18841

18842

18843

SWIGINTERN PyObject *_wrap_RichTextRenderer_DrawTextBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18844

PyObject *resultobj = 0;

18845

wxRichTextRenderer *arg1 = (wxRichTextRenderer *) 0 ;

18846

wxRichTextParagraph *arg2 = (wxRichTextParagraph *) 0 ;

18847

wxDC *arg3 = 0 ;

18848

wxTextAttrEx *arg4 = 0 ;

18849

wxRect *arg5 = 0 ;

18850

wxString *arg6 = 0 ;

18851

bool result;

18852

void *argp1 = 0 ;

18853

int res1 = 0 ;

18854

void *argp2 = 0 ;

18855

int res2 = 0 ;

18856

void *argp3 = 0 ;

18857

int res3 = 0 ;

18858

void *argp4 = 0 ;

18859

int res4 = 0 ;

18860

wxRect temp5 ;

18861

bool temp6 = false ;

18862

PyObject * obj0 = 0 ;

18863

PyObject * obj1 = 0 ;

18864

PyObject * obj2 = 0 ;

18865

PyObject * obj3 = 0 ;

18866

PyObject * obj4 = 0 ;

18867

PyObject * obj5 = 0 ;

18868

char * kwnames[] = {

18869

(char *) "self",(char *) "paragraph",(char *) "dc",(char *) "attr",(char *) "rect",(char *) "text", NULL

18870

};

18871

18872

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:RichTextRenderer_DrawTextBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

18873

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextRenderer, 0 | 0 );

18874

if (!SWIG_IsOK(res1)) {

18875

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextRenderer_DrawTextBullet" "', expected argument " "1"" of type '" "wxRichTextRenderer *""'");

18876

}

18877

arg1 = reinterpret_cast< wxRichTextRenderer * >(argp1);

18878

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

18879

if (!SWIG_IsOK(res2)) {

18880

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextRenderer_DrawTextBullet" "', expected argument " "2"" of type '" "wxRichTextParagraph *""'");

18881

}

18882

arg2 = reinterpret_cast< wxRichTextParagraph * >(argp2);

18883

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );

18884

if (!SWIG_IsOK(res3)) {

18885

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextRenderer_DrawTextBullet" "', expected argument " "3"" of type '" "wxDC &""'");

18886

}

18887

if (!argp3) {

18888

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextRenderer_DrawTextBullet" "', expected argument " "3"" of type '" "wxDC &""'");

18889

}

18890

arg3 = reinterpret_cast< wxDC * >(argp3);

18891

res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

18892

if (!SWIG_IsOK(res4)) {

18893

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextRenderer_DrawTextBullet" "', expected argument " "4"" of type '" "wxTextAttrEx const &""'");

18894

}

18895

if (!argp4) {

18896

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextRenderer_DrawTextBullet" "', expected argument " "4"" of type '" "wxTextAttrEx const &""'");

18897

}

18898

arg4 = reinterpret_cast< wxTextAttrEx * >(argp4);

18899

{

18900

arg5 = &temp5;

18901

if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;

18902

}

18903

{

18904

arg6 = wxString_in_helper(obj5);

18905

if (arg6 == NULL) SWIG_fail;

18906

temp6 = true;

18907

}

18908

{

18909

PyThreadState* __tstate = wxPyBeginAllowThreads();

18910

result = (bool)(arg1)->DrawTextBullet(arg2,*arg3,(wxTextAttrEx const &)*arg4,(wxRect const &)*arg5,(wxString const &)*arg6);

18911

wxPyEndAllowThreads(__tstate);

18912

if (PyErr_Occurred()) SWIG_fail;

18913

}

18914

{

18915

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18916

}

18917

{

18918

if (temp6)

18919

delete arg6;

18920

}

18921

return resultobj;

18922

fail:

18923

{

18924

if (temp6)

18925

delete arg6;

18926

}

18927

return NULL;

18928

}

18929

18930

18931

SWIGINTERN PyObject *_wrap_RichTextRenderer_DrawBitmapBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

18932

PyObject *resultobj = 0;

18933

wxRichTextRenderer *arg1 = (wxRichTextRenderer *) 0 ;

18934

wxRichTextParagraph *arg2 = (wxRichTextParagraph *) 0 ;

18935

wxDC *arg3 = 0 ;

18936

wxTextAttrEx *arg4 = 0 ;

18937

wxRect *arg5 = 0 ;

18938

bool result;

18939

void *argp1 = 0 ;

18940

int res1 = 0 ;

18941

void *argp2 = 0 ;

18942

int res2 = 0 ;

18943

void *argp3 = 0 ;

18944

int res3 = 0 ;

18945

void *argp4 = 0 ;

18946

int res4 = 0 ;

18947

wxRect temp5 ;

18948

PyObject * obj0 = 0 ;

18949

PyObject * obj1 = 0 ;

18950

PyObject * obj2 = 0 ;

18951

PyObject * obj3 = 0 ;

18952

PyObject * obj4 = 0 ;

18953

char * kwnames[] = {

18954

(char *) "self",(char *) "paragraph",(char *) "dc",(char *) "attr",(char *) "rect", NULL

18955

};

18956

18957

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:RichTextRenderer_DrawBitmapBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

18958

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextRenderer, 0 | 0 );

18959

if (!SWIG_IsOK(res1)) {

18960

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextRenderer_DrawBitmapBullet" "', expected argument " "1"" of type '" "wxRichTextRenderer *""'");

18961

}

18962

arg1 = reinterpret_cast< wxRichTextRenderer * >(argp1);

18963

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextParagraph, 0 | 0 );

18964

if (!SWIG_IsOK(res2)) {

18965

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextRenderer_DrawBitmapBullet" "', expected argument " "2"" of type '" "wxRichTextParagraph *""'");

18966

}

18967

arg2 = reinterpret_cast< wxRichTextParagraph * >(argp2);

18968

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDC, 0 );

18969

if (!SWIG_IsOK(res3)) {

18970

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextRenderer_DrawBitmapBullet" "', expected argument " "3"" of type '" "wxDC &""'");

18971

}

18972

if (!argp3) {

18973

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextRenderer_DrawBitmapBullet" "', expected argument " "3"" of type '" "wxDC &""'");

18974

}

18975

arg3 = reinterpret_cast< wxDC * >(argp3);

18976

res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

18977

if (!SWIG_IsOK(res4)) {

18978

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextRenderer_DrawBitmapBullet" "', expected argument " "4"" of type '" "wxTextAttrEx const &""'");

18979

}

18980

if (!argp4) {

18981

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextRenderer_DrawBitmapBullet" "', expected argument " "4"" of type '" "wxTextAttrEx const &""'");

18982

}

18983

arg4 = reinterpret_cast< wxTextAttrEx * >(argp4);

18984

{

18985

arg5 = &temp5;

18986

if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;

18987

}

18988

{

18989

PyThreadState* __tstate = wxPyBeginAllowThreads();

18990

result = (bool)(arg1)->DrawBitmapBullet(arg2,*arg3,(wxTextAttrEx const &)*arg4,(wxRect const &)*arg5);

18991

wxPyEndAllowThreads(__tstate);

18992

if (PyErr_Occurred()) SWIG_fail;

18993

}

18994

{

18995

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

18996

}

18997

return resultobj;

18998

fail:

18999

return NULL;

19000

}

19001

19002

19003

SWIGINTERN PyObject *_wrap_RichTextRenderer_EnumerateStandardBulletNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19004

PyObject *resultobj = 0;

19005

wxRichTextRenderer *arg1 = (wxRichTextRenderer *) 0 ;

19006

wxArrayString *arg2 = 0 ;

19007

bool result;

19008

void *argp1 = 0 ;

19009

int res1 = 0 ;

19010

bool temp2 = false ;

19011

PyObject * obj0 = 0 ;

19012

PyObject * obj1 = 0 ;

19013

char * kwnames[] = {

19014

(char *) "self",(char *) "bulletNames", NULL

19015

};

19016

19017

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextRenderer_EnumerateStandardBulletNames",kwnames,&obj0,&obj1)) SWIG_fail;

19018

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextRenderer, 0 | 0 );

19019

if (!SWIG_IsOK(res1)) {

19020

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextRenderer_EnumerateStandardBulletNames" "', expected argument " "1"" of type '" "wxRichTextRenderer *""'");

19021

}

19022

arg1 = reinterpret_cast< wxRichTextRenderer * >(argp1);

19023

{

19024

if (! PySequence_Check(obj1)) {

19025

PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");

19026

SWIG_fail;

19027

}

19028

arg2 = new wxArrayString;

19029

temp2 = true;

19030

int i, len=PySequence_Length(obj1);

19031

for (i=0; i<len; i++) {

19032

PyObject* item = PySequence_GetItem(obj1, i);

19033

wxString* s = wxString_in_helper(item);

19034

if (PyErr_Occurred()) SWIG_fail;

19035

arg2->Add(*s);

19036

delete s;

19037

Py_DECREF(item);

19038

}

19039

}

19040

{

19041

PyThreadState* __tstate = wxPyBeginAllowThreads();

19042

result = (bool)(arg1)->EnumerateStandardBulletNames(*arg2);

19043

wxPyEndAllowThreads(__tstate);

19044

if (PyErr_Occurred()) SWIG_fail;

19045

}

19046

{

19047

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19048

}

19049

{

19050

if (temp2) delete arg2;

19051

}

19052

return resultobj;

19053

fail:

19054

{

19055

if (temp2) delete arg2;

19056

}

19057

return NULL;

19058

}

19059

19060

19061

SWIGINTERN PyObject *RichTextRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19062

PyObject *obj;

19063

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

19064

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextRenderer, SWIG_NewClientData(obj));

19065

return SWIG_Py_Void();

19066

}

19067

19068

SWIGINTERN PyObject *_wrap_new_RichTextStdRenderer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19069

PyObject *resultobj = 0;

19070

wxRichTextStdRenderer *result = 0 ;

19071

19072

if (!SWIG_Python_UnpackTuple(args,"new_RichTextStdRenderer",0,0,0)) SWIG_fail;

19073

{

19074

PyThreadState* __tstate = wxPyBeginAllowThreads();

19075

result = (wxRichTextStdRenderer *)new wxRichTextStdRenderer();

19076

wxPyEndAllowThreads(__tstate);

19077

if (PyErr_Occurred()) SWIG_fail;

19078

}

19079

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStdRenderer, SWIG_POINTER_NEW | 0 );

19080

return resultobj;

19081

fail:

19082

return NULL;

19083

}

19084

19085

19086

SWIGINTERN PyObject *RichTextStdRenderer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19087

PyObject *obj;

19088

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

19089

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextStdRenderer, SWIG_NewClientData(obj));

19090

return SWIG_Py_Void();

19091

}

19092

19093

SWIGINTERN PyObject *RichTextStdRenderer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19094

return SWIG_Python_InitShadowInstance(args);

19095

}

19096

19097

SWIGINTERN int RichTextCtrlNameStr_set(PyObject *) {

19098

SWIG_Error(SWIG_AttributeError,"Variable RichTextCtrlNameStr is read-only.");

19099

return 1;

19100

}

19101

19102

19103

SWIGINTERN PyObject *RichTextCtrlNameStr_get(void) {

19104

PyObject *pyobj = 0;

19105

19106

{

19107

#if wxUSE_UNICODE

19108

pyobj = PyUnicode_FromWideChar((&wxPyRichTextCtrlNameStr)->c_str(), (&wxPyRichTextCtrlNameStr)->Len());

19109

#else

19110

pyobj = PyString_FromStringAndSize((&wxPyRichTextCtrlNameStr)->c_str(), (&wxPyRichTextCtrlNameStr)->Len());

19111

#endif

19112

}

19113

return pyobj;

19114

}

19115

19116

19117

SWIGINTERN PyObject *_wrap_new_RichTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19118

PyObject *resultobj = 0;

19119

wxWindow *arg1 = (wxWindow *) 0 ;

19120

int arg2 = (int) -1 ;

19121

wxString const &arg3_defvalue = wxPyEmptyString ;

19122

wxString *arg3 = (wxString *) &arg3_defvalue ;

19123

wxPoint const &arg4_defvalue = wxDefaultPosition ;

19124

wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;

19125

wxSize const &arg5_defvalue = wxDefaultSize ;

19126

wxSize *arg5 = (wxSize *) &arg5_defvalue ;

19127

long arg6 = (long) wxRE_MULTILINE ;

19128

wxValidator const &arg7_defvalue = wxDefaultValidator ;

19129

wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;

19130

wxString const &arg8_defvalue = wxPyRichTextCtrlNameStr ;

19131

wxString *arg8 = (wxString *) &arg8_defvalue ;

19132

wxRichTextCtrl *result = 0 ;

19133

void *argp1 = 0 ;

19134

int res1 = 0 ;

19135

int val2 ;

19136

int ecode2 = 0 ;

19137

bool temp3 = false ;

19138

wxPoint temp4 ;

19139

wxSize temp5 ;

19140

long val6 ;

19141

int ecode6 = 0 ;

19142

void *argp7 = 0 ;

19143

int res7 = 0 ;

19144

bool temp8 = false ;

19145

PyObject * obj0 = 0 ;

19146

PyObject * obj1 = 0 ;

19147

PyObject * obj2 = 0 ;

19148

PyObject * obj3 = 0 ;

19149

PyObject * obj4 = 0 ;

19150

PyObject * obj5 = 0 ;

19151

PyObject * obj6 = 0 ;

19152

PyObject * obj7 = 0 ;

19153

char * kwnames[] = {

19154

(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL

19155

};

19156

19157

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOOO:new_RichTextCtrl",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;

19158

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );

19159

if (!SWIG_IsOK(res1)) {

19160

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RichTextCtrl" "', expected argument " "1"" of type '" "wxWindow *""'");

19161

}

19162

arg1 = reinterpret_cast< wxWindow * >(argp1);

19163

if (obj1) {

19164

ecode2 = SWIG_AsVal_int(obj1, &val2);

19165

if (!SWIG_IsOK(ecode2)) {

19166

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RichTextCtrl" "', expected argument " "2"" of type '" "int""'");

19167

}

19168

arg2 = static_cast< int >(val2);

19169

}

19170

if (obj2) {

19171

{

19172

arg3 = wxString_in_helper(obj2);

19173

if (arg3 == NULL) SWIG_fail;

19174

temp3 = true;

19175

}

19176

}

19177

if (obj3) {

19178

{

19179

arg4 = &temp4;

19180

if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;

19181

}

19182

}

19183

if (obj4) {

19184

{

19185

arg5 = &temp5;

19186

if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;

19187

}

19188

}

19189

if (obj5) {

19190

ecode6 = SWIG_AsVal_long(obj5, &val6);

19191

if (!SWIG_IsOK(ecode6)) {

19192

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RichTextCtrl" "', expected argument " "6"" of type '" "long""'");

19193

}

19194

arg6 = static_cast< long >(val6);

19195

}

19196

if (obj6) {

19197

res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);

19198

if (!SWIG_IsOK(res7)) {

19199

SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_RichTextCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'");

19200

}

19201

if (!argp7) {

19202

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RichTextCtrl" "', expected argument " "7"" of type '" "wxValidator const &""'");

19203

}

19204

arg7 = reinterpret_cast< wxValidator * >(argp7);

19205

}

19206

if (obj7) {

19207

{

19208

arg8 = wxString_in_helper(obj7);

19209

if (arg8 == NULL) SWIG_fail;

19210

temp8 = true;

19211

}

19212

}

19213

{

19214

if (!wxPyCheckForApp()) SWIG_fail;

19215

PyThreadState* __tstate = wxPyBeginAllowThreads();

19216

result = (wxRichTextCtrl *)new wxRichTextCtrl(arg1,arg2,(wxString const &)*arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);

19217

wxPyEndAllowThreads(__tstate);

19218

if (PyErr_Occurred()) SWIG_fail;

19219

}

19220

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextCtrl, SWIG_POINTER_NEW | 0 );

19221

{

19222

if (temp3)

19223

delete arg3;

19224

}

19225

{

19226

if (temp8)

19227

delete arg8;

19228

}

19229

return resultobj;

19230

fail:

19231

{

19232

if (temp3)

19233

delete arg3;

19234

}

19235

{

19236

if (temp8)

19237

delete arg8;

19238

}

19239

return NULL;

19240

}

19241

19242

19243

SWIGINTERN PyObject *_wrap_new_PreRichTextCtrl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19244

PyObject *resultobj = 0;

19245

wxRichTextCtrl *result = 0 ;

19246

19247

if (!SWIG_Python_UnpackTuple(args,"new_PreRichTextCtrl",0,0,0)) SWIG_fail;

19248

{

19249

if (!wxPyCheckForApp()) SWIG_fail;

19250

PyThreadState* __tstate = wxPyBeginAllowThreads();

19251

result = (wxRichTextCtrl *)new wxRichTextCtrl();

19252

wxPyEndAllowThreads(__tstate);

19253

if (PyErr_Occurred()) SWIG_fail;

19254

}

19255

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextCtrl, SWIG_POINTER_OWN | 0 );

19256

return resultobj;

19257

fail:

19258

return NULL;

19259

}

19260

19261

19262

SWIGINTERN PyObject *_wrap_RichTextCtrl_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19263

PyObject *resultobj = 0;

19264

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19265

wxWindow *arg2 = (wxWindow *) 0 ;

19266

int arg3 = (int) -1 ;

19267

wxString const &arg4_defvalue = wxPyEmptyString ;

19268

wxString *arg4 = (wxString *) &arg4_defvalue ;

19269

wxPoint const &arg5_defvalue = wxDefaultPosition ;

19270

wxPoint *arg5 = (wxPoint *) &arg5_defvalue ;

19271

wxSize const &arg6_defvalue = wxDefaultSize ;

19272

wxSize *arg6 = (wxSize *) &arg6_defvalue ;

19273

long arg7 = (long) wxRE_MULTILINE ;

19274

wxValidator const &arg8_defvalue = wxDefaultValidator ;

19275

wxValidator *arg8 = (wxValidator *) &arg8_defvalue ;

19276

wxString const &arg9_defvalue = wxPyRichTextCtrlNameStr ;

19277

wxString *arg9 = (wxString *) &arg9_defvalue ;

19278

bool result;

19279

void *argp1 = 0 ;

19280

int res1 = 0 ;

19281

void *argp2 = 0 ;

19282

int res2 = 0 ;

19283

int val3 ;

19284

int ecode3 = 0 ;

19285

bool temp4 = false ;

19286

wxPoint temp5 ;

19287

wxSize temp6 ;

19288

long val7 ;

19289

int ecode7 = 0 ;

19290

void *argp8 = 0 ;

19291

int res8 = 0 ;

19292

bool temp9 = false ;

19293

PyObject * obj0 = 0 ;

19294

PyObject * obj1 = 0 ;

19295

PyObject * obj2 = 0 ;

19296

PyObject * obj3 = 0 ;

19297

PyObject * obj4 = 0 ;

19298

PyObject * obj5 = 0 ;

19299

PyObject * obj6 = 0 ;

19300

PyObject * obj7 = 0 ;

19301

PyObject * obj8 = 0 ;

19302

char * kwnames[] = {

19303

(char *) "self",(char *) "parent",(char *) "id",(char *) "value",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL

19304

};

19305

19306

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOOO:RichTextCtrl_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;

19307

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19308

if (!SWIG_IsOK(res1)) {

19309

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Create" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

19310

}

19311

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19312

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

19313

if (!SWIG_IsOK(res2)) {

19314

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_Create" "', expected argument " "2"" of type '" "wxWindow *""'");

19315

}

19316

arg2 = reinterpret_cast< wxWindow * >(argp2);

19317

if (obj2) {

19318

ecode3 = SWIG_AsVal_int(obj2, &val3);

19319

if (!SWIG_IsOK(ecode3)) {

19320

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_Create" "', expected argument " "3"" of type '" "int""'");

19321

}

19322

arg3 = static_cast< int >(val3);

19323

}

19324

if (obj3) {

19325

{

19326

arg4 = wxString_in_helper(obj3);

19327

if (arg4 == NULL) SWIG_fail;

19328

temp4 = true;

19329

}

19330

}

19331

if (obj4) {

19332

{

19333

arg5 = &temp5;

19334

if ( ! wxPoint_helper(obj4, &arg5)) SWIG_fail;

19335

}

19336

}

19337

if (obj5) {

19338

{

19339

arg6 = &temp6;

19340

if ( ! wxSize_helper(obj5, &arg6)) SWIG_fail;

19341

}

19342

}

19343

if (obj6) {

19344

ecode7 = SWIG_AsVal_long(obj6, &val7);

19345

if (!SWIG_IsOK(ecode7)) {

19346

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RichTextCtrl_Create" "', expected argument " "7"" of type '" "long""'");

19347

}

19348

arg7 = static_cast< long >(val7);

19349

}

19350

if (obj7) {

19351

res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_wxValidator, 0 | 0);

19352

if (!SWIG_IsOK(res8)) {

19353

SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "RichTextCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'");

19354

}

19355

if (!argp8) {

19356

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_Create" "', expected argument " "8"" of type '" "wxValidator const &""'");

19357

}

19358

arg8 = reinterpret_cast< wxValidator * >(argp8);

19359

}

19360

if (obj8) {

19361

{

19362

arg9 = wxString_in_helper(obj8);

19363

if (arg9 == NULL) SWIG_fail;

19364

temp9 = true;

19365

}

19366

}

19367

{

19368

PyThreadState* __tstate = wxPyBeginAllowThreads();

19369

result = (bool)(arg1)->Create(arg2,arg3,(wxString const &)*arg4,(wxPoint const &)*arg5,(wxSize const &)*arg6,arg7,(wxValidator const &)*arg8,(wxString const &)*arg9);

19370

wxPyEndAllowThreads(__tstate);

19371

if (PyErr_Occurred()) SWIG_fail;

19372

}

19373

{

19374

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19375

}

19376

{

19377

if (temp4)

19378

delete arg4;

19379

}

19380

{

19381

if (temp9)

19382

delete arg9;

19383

}

19384

return resultobj;

19385

fail:

19386

{

19387

if (temp4)

19388

delete arg4;

19389

}

19390

{

19391

if (temp9)

19392

delete arg9;

19393

}

19394

return NULL;

19395

}

19396

19397

19398

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19399

PyObject *resultobj = 0;

19400

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19401

wxString result;

19402

void *argp1 = 0 ;

19403

int res1 = 0 ;

19404

PyObject *swig_obj[1] ;

19405

19406

if (!args) SWIG_fail;

19407

swig_obj[0] = args;

19408

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19409

if (!SWIG_IsOK(res1)) {

19410

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetValue" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19411

}

19412

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19413

{

19414

PyThreadState* __tstate = wxPyBeginAllowThreads();

19415

result = ((wxRichTextCtrl const *)arg1)->GetValue();

19416

wxPyEndAllowThreads(__tstate);

19417

if (PyErr_Occurred()) SWIG_fail;

19418

}

19419

{

19420

#if wxUSE_UNICODE

19421

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

19422

#else

19423

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

19424

#endif

19425

}

19426

return resultobj;

19427

fail:

19428

return NULL;

19429

}

19430

19431

19432

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19433

PyObject *resultobj = 0;

19434

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19435

wxString *arg2 = 0 ;

19436

void *argp1 = 0 ;

19437

int res1 = 0 ;

19438

bool temp2 = false ;

19439

PyObject * obj0 = 0 ;

19440

PyObject * obj1 = 0 ;

19441

char * kwnames[] = {

19442

(char *) "self",(char *) "value", NULL

19443

};

19444

19445

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;

19446

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19447

if (!SWIG_IsOK(res1)) {

19448

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetValue" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

19449

}

19450

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19451

{

19452

arg2 = wxString_in_helper(obj1);

19453

if (arg2 == NULL) SWIG_fail;

19454

temp2 = true;

19455

}

19456

{

19457

PyThreadState* __tstate = wxPyBeginAllowThreads();

19458

(arg1)->SetValue((wxString const &)*arg2);

19459

wxPyEndAllowThreads(__tstate);

19460

if (PyErr_Occurred()) SWIG_fail;

19461

}

19462

resultobj = SWIG_Py_Void();

19463

{

19464

if (temp2)

19465

delete arg2;

19466

}

19467

return resultobj;

19468

fail:

19469

{

19470

if (temp2)

19471

delete arg2;

19472

}

19473

return NULL;

19474

}

19475

19476

19477

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19478

PyObject *resultobj = 0;

19479

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19480

long arg2 ;

19481

long arg3 ;

19482

wxString result;

19483

void *argp1 = 0 ;

19484

int res1 = 0 ;

19485

long val2 ;

19486

int ecode2 = 0 ;

19487

long val3 ;

19488

int ecode3 = 0 ;

19489

PyObject * obj0 = 0 ;

19490

PyObject * obj1 = 0 ;

19491

PyObject * obj2 = 0 ;

19492

char * kwnames[] = {

19493

(char *) "self",(char *) "from",(char *) "to", NULL

19494

};

19495

19496

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_GetRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

19497

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19498

if (!SWIG_IsOK(res1)) {

19499

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetRange" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19500

}

19501

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19502

ecode2 = SWIG_AsVal_long(obj1, &val2);

19503

if (!SWIG_IsOK(ecode2)) {

19504

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetRange" "', expected argument " "2"" of type '" "long""'");

19505

}

19506

arg2 = static_cast< long >(val2);

19507

ecode3 = SWIG_AsVal_long(obj2, &val3);

19508

if (!SWIG_IsOK(ecode3)) {

19509

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_GetRange" "', expected argument " "3"" of type '" "long""'");

19510

}

19511

arg3 = static_cast< long >(val3);

19512

{

19513

PyThreadState* __tstate = wxPyBeginAllowThreads();

19514

result = ((wxRichTextCtrl const *)arg1)->GetRange(arg2,arg3);

19515

wxPyEndAllowThreads(__tstate);

19516

if (PyErr_Occurred()) SWIG_fail;

19517

}

19518

{

19519

#if wxUSE_UNICODE

19520

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

19521

#else

19522

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

19523

#endif

19524

}

19525

return resultobj;

19526

fail:

19527

return NULL;

19528

}

19529

19530

19531

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetLineLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19532

PyObject *resultobj = 0;

19533

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19534

long arg2 ;

19535

int result;

19536

void *argp1 = 0 ;

19537

int res1 = 0 ;

19538

long val2 ;

19539

int ecode2 = 0 ;

19540

PyObject * obj0 = 0 ;

19541

PyObject * obj1 = 0 ;

19542

char * kwnames[] = {

19543

(char *) "self",(char *) "lineNo", NULL

19544

};

19545

19546

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetLineLength",kwnames,&obj0,&obj1)) SWIG_fail;

19547

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19548

if (!SWIG_IsOK(res1)) {

19549

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetLineLength" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19550

}

19551

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19552

ecode2 = SWIG_AsVal_long(obj1, &val2);

19553

if (!SWIG_IsOK(ecode2)) {

19554

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetLineLength" "', expected argument " "2"" of type '" "long""'");

19555

}

19556

arg2 = static_cast< long >(val2);

19557

{

19558

PyThreadState* __tstate = wxPyBeginAllowThreads();

19559

result = (int)((wxRichTextCtrl const *)arg1)->GetLineLength(arg2);

19560

wxPyEndAllowThreads(__tstate);

19561

if (PyErr_Occurred()) SWIG_fail;

19562

}

19563

resultobj = SWIG_From_int(static_cast< int >(result));

19564

return resultobj;

19565

fail:

19566

return NULL;

19567

}

19568

19569

19570

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetLineText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19571

PyObject *resultobj = 0;

19572

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19573

long arg2 ;

19574

wxString result;

19575

void *argp1 = 0 ;

19576

int res1 = 0 ;

19577

long val2 ;

19578

int ecode2 = 0 ;

19579

PyObject * obj0 = 0 ;

19580

PyObject * obj1 = 0 ;

19581

char * kwnames[] = {

19582

(char *) "self",(char *) "lineNo", NULL

19583

};

19584

19585

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetLineText",kwnames,&obj0,&obj1)) SWIG_fail;

19586

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19587

if (!SWIG_IsOK(res1)) {

19588

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetLineText" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19589

}

19590

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19591

ecode2 = SWIG_AsVal_long(obj1, &val2);

19592

if (!SWIG_IsOK(ecode2)) {

19593

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetLineText" "', expected argument " "2"" of type '" "long""'");

19594

}

19595

arg2 = static_cast< long >(val2);

19596

{

19597

PyThreadState* __tstate = wxPyBeginAllowThreads();

19598

result = ((wxRichTextCtrl const *)arg1)->GetLineText(arg2);

19599

wxPyEndAllowThreads(__tstate);

19600

if (PyErr_Occurred()) SWIG_fail;

19601

}

19602

{

19603

#if wxUSE_UNICODE

19604

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

19605

#else

19606

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

19607

#endif

19608

}

19609

return resultobj;

19610

fail:

19611

return NULL;

19612

}

19613

19614

19615

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetNumberOfLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19616

PyObject *resultobj = 0;

19617

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19618

int result;

19619

void *argp1 = 0 ;

19620

int res1 = 0 ;

19621

PyObject *swig_obj[1] ;

19622

19623

if (!args) SWIG_fail;

19624

swig_obj[0] = args;

19625

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19626

if (!SWIG_IsOK(res1)) {

19627

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetNumberOfLines" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19628

}

19629

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19630

{

19631

PyThreadState* __tstate = wxPyBeginAllowThreads();

19632

result = (int)((wxRichTextCtrl const *)arg1)->GetNumberOfLines();

19633

wxPyEndAllowThreads(__tstate);

19634

if (PyErr_Occurred()) SWIG_fail;

19635

}

19636

resultobj = SWIG_From_int(static_cast< int >(result));

19637

return resultobj;

19638

fail:

19639

return NULL;

19640

}

19641

19642

19643

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19644

PyObject *resultobj = 0;

19645

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19646

bool result;

19647

void *argp1 = 0 ;

19648

int res1 = 0 ;

19649

PyObject *swig_obj[1] ;

19650

19651

if (!args) SWIG_fail;

19652

swig_obj[0] = args;

19653

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19654

if (!SWIG_IsOK(res1)) {

19655

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsModified" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19656

}

19657

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19658

{

19659

PyThreadState* __tstate = wxPyBeginAllowThreads();

19660

result = (bool)((wxRichTextCtrl const *)arg1)->IsModified();

19661

wxPyEndAllowThreads(__tstate);

19662

if (PyErr_Occurred()) SWIG_fail;

19663

}

19664

{

19665

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19666

}

19667

return resultobj;

19668

fail:

19669

return NULL;

19670

}

19671

19672

19673

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19674

PyObject *resultobj = 0;

19675

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19676

bool result;

19677

void *argp1 = 0 ;

19678

int res1 = 0 ;

19679

PyObject *swig_obj[1] ;

19680

19681

if (!args) SWIG_fail;

19682

swig_obj[0] = args;

19683

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19684

if (!SWIG_IsOK(res1)) {

19685

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsEditable" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19686

}

19687

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19688

{

19689

PyThreadState* __tstate = wxPyBeginAllowThreads();

19690

result = (bool)((wxRichTextCtrl const *)arg1)->IsEditable();

19691

wxPyEndAllowThreads(__tstate);

19692

if (PyErr_Occurred()) SWIG_fail;

19693

}

19694

{

19695

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19696

}

19697

return resultobj;

19698

fail:

19699

return NULL;

19700

}

19701

19702

19703

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsSingleLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19704

PyObject *resultobj = 0;

19705

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19706

bool result;

19707

void *argp1 = 0 ;

19708

int res1 = 0 ;

19709

PyObject *swig_obj[1] ;

19710

19711

if (!args) SWIG_fail;

19712

swig_obj[0] = args;

19713

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19714

if (!SWIG_IsOK(res1)) {

19715

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsSingleLine" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19716

}

19717

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19718

{

19719

PyThreadState* __tstate = wxPyBeginAllowThreads();

19720

result = (bool)((wxRichTextCtrl const *)arg1)->IsSingleLine();

19721

wxPyEndAllowThreads(__tstate);

19722

if (PyErr_Occurred()) SWIG_fail;

19723

}

19724

{

19725

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19726

}

19727

return resultobj;

19728

fail:

19729

return NULL;

19730

}

19731

19732

19733

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsMultiLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19734

PyObject *resultobj = 0;

19735

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19736

bool result;

19737

void *argp1 = 0 ;

19738

int res1 = 0 ;

19739

PyObject *swig_obj[1] ;

19740

19741

if (!args) SWIG_fail;

19742

swig_obj[0] = args;

19743

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19744

if (!SWIG_IsOK(res1)) {

19745

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsMultiLine" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19746

}

19747

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19748

{

19749

PyThreadState* __tstate = wxPyBeginAllowThreads();

19750

result = (bool)((wxRichTextCtrl const *)arg1)->IsMultiLine();

19751

wxPyEndAllowThreads(__tstate);

19752

if (PyErr_Occurred()) SWIG_fail;

19753

}

19754

{

19755

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

19756

}

19757

return resultobj;

19758

fail:

19759

return NULL;

19760

}

19761

19762

19763

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19764

PyObject *resultobj = 0;

19765

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19766

long *arg2 = (long *) 0 ;

19767

long *arg3 = (long *) 0 ;

19768

void *argp1 = 0 ;

19769

int res1 = 0 ;

19770

long temp2 ;

19771

int res2 = SWIG_TMPOBJ ;

19772

long temp3 ;

19773

int res3 = SWIG_TMPOBJ ;

19774

PyObject *swig_obj[1] ;

19775

19776

arg2 = &temp2;

19777

arg3 = &temp3;

19778

if (!args) SWIG_fail;

19779

swig_obj[0] = args;

19780

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19781

if (!SWIG_IsOK(res1)) {

19782

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19783

}

19784

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19785

{

19786

PyThreadState* __tstate = wxPyBeginAllowThreads();

19787

((wxRichTextCtrl const *)arg1)->GetSelection(arg2,arg3);

19788

wxPyEndAllowThreads(__tstate);

19789

if (PyErr_Occurred()) SWIG_fail;

19790

}

19791

resultobj = SWIG_Py_Void();

19792

if (SWIG_IsTmpObj(res2)) {

19793

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));

19794

} else {

19795

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

19796

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));

19797

}

19798

if (SWIG_IsTmpObj(res3)) {

19799

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));

19800

} else {

19801

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

19802

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));

19803

}

19804

return resultobj;

19805

fail:

19806

return NULL;

19807

}

19808

19809

19810

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19811

PyObject *resultobj = 0;

19812

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19813

wxString result;

19814

void *argp1 = 0 ;

19815

int res1 = 0 ;

19816

PyObject *swig_obj[1] ;

19817

19818

if (!args) SWIG_fail;

19819

swig_obj[0] = args;

19820

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19821

if (!SWIG_IsOK(res1)) {

19822

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetStringSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19823

}

19824

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19825

{

19826

PyThreadState* __tstate = wxPyBeginAllowThreads();

19827

result = ((wxRichTextCtrl const *)arg1)->GetStringSelection();

19828

wxPyEndAllowThreads(__tstate);

19829

if (PyErr_Occurred()) SWIG_fail;

19830

}

19831

{

19832

#if wxUSE_UNICODE

19833

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

19834

#else

19835

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

19836

#endif

19837

}

19838

return resultobj;

19839

fail:

19840

return NULL;

19841

}

19842

19843

19844

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19845

PyObject *resultobj = 0;

19846

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19847

wxString result;

19848

void *argp1 = 0 ;

19849

int res1 = 0 ;

19850

PyObject *swig_obj[1] ;

19851

19852

if (!args) SWIG_fail;

19853

swig_obj[0] = args;

19854

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19855

if (!SWIG_IsOK(res1)) {

19856

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetFilename" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19857

}

19858

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19859

{

19860

PyThreadState* __tstate = wxPyBeginAllowThreads();

19861

result = ((wxRichTextCtrl const *)arg1)->GetFilename();

19862

wxPyEndAllowThreads(__tstate);

19863

if (PyErr_Occurred()) SWIG_fail;

19864

}

19865

{

19866

#if wxUSE_UNICODE

19867

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

19868

#else

19869

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

19870

#endif

19871

}

19872

return resultobj;

19873

fail:

19874

return NULL;

19875

}

19876

19877

19878

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19879

PyObject *resultobj = 0;

19880

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19881

wxString *arg2 = 0 ;

19882

void *argp1 = 0 ;

19883

int res1 = 0 ;

19884

bool temp2 = false ;

19885

PyObject * obj0 = 0 ;

19886

PyObject * obj1 = 0 ;

19887

char * kwnames[] = {

19888

(char *) "self",(char *) "filename", NULL

19889

};

19890

19891

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetFilename",kwnames,&obj0,&obj1)) SWIG_fail;

19892

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19893

if (!SWIG_IsOK(res1)) {

19894

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetFilename" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

19895

}

19896

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19897

{

19898

arg2 = wxString_in_helper(obj1);

19899

if (arg2 == NULL) SWIG_fail;

19900

temp2 = true;

19901

}

19902

{

19903

PyThreadState* __tstate = wxPyBeginAllowThreads();

19904

(arg1)->SetFilename((wxString const &)*arg2);

19905

wxPyEndAllowThreads(__tstate);

19906

if (PyErr_Occurred()) SWIG_fail;

19907

}

19908

resultobj = SWIG_Py_Void();

19909

{

19910

if (temp2)

19911

delete arg2;

19912

}

19913

return resultobj;

19914

fail:

19915

{

19916

if (temp2)

19917

delete arg2;

19918

}

19919

return NULL;

19920

}

19921

19922

19923

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetDelayedLayoutThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19924

PyObject *resultobj = 0;

19925

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19926

long arg2 ;

19927

void *argp1 = 0 ;

19928

int res1 = 0 ;

19929

long val2 ;

19930

int ecode2 = 0 ;

19931

PyObject * obj0 = 0 ;

19932

PyObject * obj1 = 0 ;

19933

char * kwnames[] = {

19934

(char *) "self",(char *) "threshold", NULL

19935

};

19936

19937

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetDelayedLayoutThreshold",kwnames,&obj0,&obj1)) SWIG_fail;

19938

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19939

if (!SWIG_IsOK(res1)) {

19940

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetDelayedLayoutThreshold" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

19941

}

19942

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19943

ecode2 = SWIG_AsVal_long(obj1, &val2);

19944

if (!SWIG_IsOK(ecode2)) {

19945

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetDelayedLayoutThreshold" "', expected argument " "2"" of type '" "long""'");

19946

}

19947

arg2 = static_cast< long >(val2);

19948

{

19949

PyThreadState* __tstate = wxPyBeginAllowThreads();

19950

(arg1)->SetDelayedLayoutThreshold(arg2);

19951

wxPyEndAllowThreads(__tstate);

19952

if (PyErr_Occurred()) SWIG_fail;

19953

}

19954

resultobj = SWIG_Py_Void();

19955

return resultobj;

19956

fail:

19957

return NULL;

19958

}

19959

19960

19961

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetDelayedLayoutThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

19962

PyObject *resultobj = 0;

19963

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19964

long result;

19965

void *argp1 = 0 ;

19966

int res1 = 0 ;

19967

PyObject *swig_obj[1] ;

19968

19969

if (!args) SWIG_fail;

19970

swig_obj[0] = args;

19971

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

19972

if (!SWIG_IsOK(res1)) {

19973

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetDelayedLayoutThreshold" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

19974

}

19975

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

19976

{

19977

PyThreadState* __tstate = wxPyBeginAllowThreads();

19978

result = (long)((wxRichTextCtrl const *)arg1)->GetDelayedLayoutThreshold();

19979

wxPyEndAllowThreads(__tstate);

19980

if (PyErr_Occurred()) SWIG_fail;

19981

}

19982

resultobj = SWIG_From_long(static_cast< long >(result));

19983

return resultobj;

19984

fail:

19985

return NULL;

19986

}

19987

19988

19989

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetTextCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

19990

PyObject *resultobj = 0;

19991

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

19992

wxCursor *arg2 = 0 ;

19993

void *argp1 = 0 ;

19994

int res1 = 0 ;

19995

void *argp2 = 0 ;

19996

int res2 = 0 ;

19997

PyObject * obj0 = 0 ;

19998

PyObject * obj1 = 0 ;

19999

char * kwnames[] = {

20000

(char *) "self",(char *) "cursor", NULL

20001

};

20002

20003

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetTextCursor",kwnames,&obj0,&obj1)) SWIG_fail;

20004

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20005

if (!SWIG_IsOK(res1)) {

20006

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetTextCursor" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20007

}

20008

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20009

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);

20010

if (!SWIG_IsOK(res2)) {

20011

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetTextCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");

20012

}

20013

if (!argp2) {

20014

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetTextCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");

20015

}

20016

arg2 = reinterpret_cast< wxCursor * >(argp2);

20017

{

20018

PyThreadState* __tstate = wxPyBeginAllowThreads();

20019

(arg1)->SetTextCursor((wxCursor const &)*arg2);

20020

wxPyEndAllowThreads(__tstate);

20021

if (PyErr_Occurred()) SWIG_fail;

20022

}

20023

resultobj = SWIG_Py_Void();

20024

return resultobj;

20025

fail:

20026

return NULL;

20027

}

20028

20029

20030

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetTextCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20031

PyObject *resultobj = 0;

20032

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20033

wxCursor result;

20034

void *argp1 = 0 ;

20035

int res1 = 0 ;

20036

PyObject *swig_obj[1] ;

20037

20038

if (!args) SWIG_fail;

20039

swig_obj[0] = args;

20040

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20041

if (!SWIG_IsOK(res1)) {

20042

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetTextCursor" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

20043

}

20044

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20045

{

20046

PyThreadState* __tstate = wxPyBeginAllowThreads();

20047

result = ((wxRichTextCtrl const *)arg1)->GetTextCursor();

20048

wxPyEndAllowThreads(__tstate);

20049

if (PyErr_Occurred()) SWIG_fail;

20050

}

20051

resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );

20052

return resultobj;

20053

fail:

20054

return NULL;

20055

}

20056

20057

20058

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetURLCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20059

PyObject *resultobj = 0;

20060

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20061

wxCursor *arg2 = 0 ;

20062

void *argp1 = 0 ;

20063

int res1 = 0 ;

20064

void *argp2 = 0 ;

20065

int res2 = 0 ;

20066

PyObject * obj0 = 0 ;

20067

PyObject * obj1 = 0 ;

20068

char * kwnames[] = {

20069

(char *) "self",(char *) "cursor", NULL

20070

};

20071

20072

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetURLCursor",kwnames,&obj0,&obj1)) SWIG_fail;

20073

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20074

if (!SWIG_IsOK(res1)) {

20075

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetURLCursor" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20076

}

20077

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20078

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);

20079

if (!SWIG_IsOK(res2)) {

20080

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetURLCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");

20081

}

20082

if (!argp2) {

20083

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetURLCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");

20084

}

20085

arg2 = reinterpret_cast< wxCursor * >(argp2);

20086

{

20087

PyThreadState* __tstate = wxPyBeginAllowThreads();

20088

(arg1)->SetURLCursor((wxCursor const &)*arg2);

20089

wxPyEndAllowThreads(__tstate);

20090

if (PyErr_Occurred()) SWIG_fail;

20091

}

20092

resultobj = SWIG_Py_Void();

20093

return resultobj;

20094

fail:

20095

return NULL;

20096

}

20097

20098

20099

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetURLCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20100

PyObject *resultobj = 0;

20101

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20102

wxCursor result;

20103

void *argp1 = 0 ;

20104

int res1 = 0 ;

20105

PyObject *swig_obj[1] ;

20106

20107

if (!args) SWIG_fail;

20108

swig_obj[0] = args;

20109

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20110

if (!SWIG_IsOK(res1)) {

20111

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetURLCursor" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

20112

}

20113

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20114

{

20115

PyThreadState* __tstate = wxPyBeginAllowThreads();

20116

result = ((wxRichTextCtrl const *)arg1)->GetURLCursor();

20117

wxPyEndAllowThreads(__tstate);

20118

if (PyErr_Occurred()) SWIG_fail;

20119

}

20120

resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );

20121

return resultobj;

20122

fail:

20123

return NULL;

20124

}

20125

20126

20127

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetContextMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20128

PyObject *resultobj = 0;

20129

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20130

wxMenu *result = 0 ;

20131

void *argp1 = 0 ;

20132

int res1 = 0 ;

20133

PyObject *swig_obj[1] ;

20134

20135

if (!args) SWIG_fail;

20136

swig_obj[0] = args;

20137

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20138

if (!SWIG_IsOK(res1)) {

20139

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetContextMenu" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

20140

}

20141

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20142

{

20143

PyThreadState* __tstate = wxPyBeginAllowThreads();

20144

result = (wxMenu *)((wxRichTextCtrl const *)arg1)->GetContextMenu();

20145

wxPyEndAllowThreads(__tstate);

20146

if (PyErr_Occurred()) SWIG_fail;

20147

}

20148

{

20149

resultobj = wxPyMake_wxObject(result, 0);

20150

}

20151

return resultobj;

20152

fail:

20153

return NULL;

20154

}

20155

20156

20157

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetContextMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20158

PyObject *resultobj = 0;

20159

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20160

wxMenu *arg2 = (wxMenu *) 0 ;

20161

void *argp1 = 0 ;

20162

int res1 = 0 ;

20163

void *argp2 = 0 ;

20164

int res2 = 0 ;

20165

PyObject * obj0 = 0 ;

20166

PyObject * obj1 = 0 ;

20167

char * kwnames[] = {

20168

(char *) "self",(char *) "menu", NULL

20169

};

20170

20171

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetContextMenu",kwnames,&obj0,&obj1)) SWIG_fail;

20172

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20173

if (!SWIG_IsOK(res1)) {

20174

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetContextMenu" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20175

}

20176

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20177

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );

20178

if (!SWIG_IsOK(res2)) {

20179

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetContextMenu" "', expected argument " "2"" of type '" "wxMenu *""'");

20180

}

20181

arg2 = reinterpret_cast< wxMenu * >(argp2);

20182

{

20183

PyThreadState* __tstate = wxPyBeginAllowThreads();

20184

(arg1)->SetContextMenu(arg2);

20185

wxPyEndAllowThreads(__tstate);

20186

if (PyErr_Occurred()) SWIG_fail;

20187

}

20188

resultobj = SWIG_Py_Void();

20189

return resultobj;

20190

fail:

20191

return NULL;

20192

}

20193

20194

20195

SWIGINTERN PyObject *_wrap_RichTextCtrl_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20196

PyObject *resultobj = 0;

20197

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20198

void *argp1 = 0 ;

20199

int res1 = 0 ;

20200

PyObject *swig_obj[1] ;

20201

20202

if (!args) SWIG_fail;

20203

swig_obj[0] = args;

20204

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20205

if (!SWIG_IsOK(res1)) {

20206

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Clear" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20207

}

20208

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20209

{

20210

PyThreadState* __tstate = wxPyBeginAllowThreads();

20211

(arg1)->Clear();

20212

wxPyEndAllowThreads(__tstate);

20213

if (PyErr_Occurred()) SWIG_fail;

20214

}

20215

resultobj = SWIG_Py_Void();

20216

return resultobj;

20217

fail:

20218

return NULL;

20219

}

20220

20221

20222

SWIGINTERN PyObject *_wrap_RichTextCtrl_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20223

PyObject *resultobj = 0;

20224

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20225

long arg2 ;

20226

long arg3 ;

20227

wxString *arg4 = 0 ;

20228

void *argp1 = 0 ;

20229

int res1 = 0 ;

20230

long val2 ;

20231

int ecode2 = 0 ;

20232

long val3 ;

20233

int ecode3 = 0 ;

20234

bool temp4 = false ;

20235

PyObject * obj0 = 0 ;

20236

PyObject * obj1 = 0 ;

20237

PyObject * obj2 = 0 ;

20238

PyObject * obj3 = 0 ;

20239

char * kwnames[] = {

20240

(char *) "self",(char *) "from",(char *) "to",(char *) "value", NULL

20241

};

20242

20243

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RichTextCtrl_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

20244

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20245

if (!SWIG_IsOK(res1)) {

20246

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Replace" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20247

}

20248

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20249

ecode2 = SWIG_AsVal_long(obj1, &val2);

20250

if (!SWIG_IsOK(ecode2)) {

20251

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_Replace" "', expected argument " "2"" of type '" "long""'");

20252

}

20253

arg2 = static_cast< long >(val2);

20254

ecode3 = SWIG_AsVal_long(obj2, &val3);

20255

if (!SWIG_IsOK(ecode3)) {

20256

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_Replace" "', expected argument " "3"" of type '" "long""'");

20257

}

20258

arg3 = static_cast< long >(val3);

20259

{

20260

arg4 = wxString_in_helper(obj3);

20261

if (arg4 == NULL) SWIG_fail;

20262

temp4 = true;

20263

}

20264

{

20265

PyThreadState* __tstate = wxPyBeginAllowThreads();

20266

(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);

20267

wxPyEndAllowThreads(__tstate);

20268

if (PyErr_Occurred()) SWIG_fail;

20269

}

20270

resultobj = SWIG_Py_Void();

20271

{

20272

if (temp4)

20273

delete arg4;

20274

}

20275

return resultobj;

20276

fail:

20277

{

20278

if (temp4)

20279

delete arg4;

20280

}

20281

return NULL;

20282

}

20283

20284

20285

SWIGINTERN PyObject *_wrap_RichTextCtrl_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20286

PyObject *resultobj = 0;

20287

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20288

long arg2 ;

20289

long arg3 ;

20290

void *argp1 = 0 ;

20291

int res1 = 0 ;

20292

long val2 ;

20293

int ecode2 = 0 ;

20294

long val3 ;

20295

int ecode3 = 0 ;

20296

PyObject * obj0 = 0 ;

20297

PyObject * obj1 = 0 ;

20298

PyObject * obj2 = 0 ;

20299

char * kwnames[] = {

20300

(char *) "self",(char *) "from",(char *) "to", NULL

20301

};

20302

20303

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_Remove",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20304

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20305

if (!SWIG_IsOK(res1)) {

20306

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Remove" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20307

}

20308

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20309

ecode2 = SWIG_AsVal_long(obj1, &val2);

20310

if (!SWIG_IsOK(ecode2)) {

20311

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_Remove" "', expected argument " "2"" of type '" "long""'");

20312

}

20313

arg2 = static_cast< long >(val2);

20314

ecode3 = SWIG_AsVal_long(obj2, &val3);

20315

if (!SWIG_IsOK(ecode3)) {

20316

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_Remove" "', expected argument " "3"" of type '" "long""'");

20317

}

20318

arg3 = static_cast< long >(val3);

20319

{

20320

PyThreadState* __tstate = wxPyBeginAllowThreads();

20321

(arg1)->Remove(arg2,arg3);

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_RichTextCtrl_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20333

PyObject *resultobj = 0;

20334

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20335

wxString *arg2 = 0 ;

20336

int arg3 = (int) wxRICHTEXT_TYPE_ANY ;

20337

bool result;

20338

void *argp1 = 0 ;

20339

int res1 = 0 ;

20340

bool temp2 = false ;

20341

int val3 ;

20342

int ecode3 = 0 ;

20343

PyObject * obj0 = 0 ;

20344

PyObject * obj1 = 0 ;

20345

PyObject * obj2 = 0 ;

20346

char * kwnames[] = {

20347

(char *) "self",(char *) "file",(char *) "type", NULL

20348

};

20349

20350

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_LoadFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20351

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20352

if (!SWIG_IsOK(res1)) {

20353

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_LoadFile" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20354

}

20355

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20356

{

20357

arg2 = wxString_in_helper(obj1);

20358

if (arg2 == NULL) SWIG_fail;

20359

temp2 = true;

20360

}

20361

if (obj2) {

20362

ecode3 = SWIG_AsVal_int(obj2, &val3);

20363

if (!SWIG_IsOK(ecode3)) {

20364

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_LoadFile" "', expected argument " "3"" of type '" "int""'");

20365

}

20366

arg3 = static_cast< int >(val3);

20367

}

20368

{

20369

PyThreadState* __tstate = wxPyBeginAllowThreads();

20370

result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3);

20371

wxPyEndAllowThreads(__tstate);

20372

if (PyErr_Occurred()) SWIG_fail;

20373

}

20374

{

20375

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20376

}

20377

{

20378

if (temp2)

20379

delete arg2;

20380

}

20381

return resultobj;

20382

fail:

20383

{

20384

if (temp2)

20385

delete arg2;

20386

}

20387

return NULL;

20388

}

20389

20390

20391

SWIGINTERN PyObject *_wrap_RichTextCtrl_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20392

PyObject *resultobj = 0;

20393

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20394

wxString const &arg2_defvalue = wxPyEmptyString ;

20395

wxString *arg2 = (wxString *) &arg2_defvalue ;

20396

int arg3 = (int) wxRICHTEXT_TYPE_ANY ;

20397

bool result;

20398

void *argp1 = 0 ;

20399

int res1 = 0 ;

20400

bool temp2 = false ;

20401

int val3 ;

20402

int ecode3 = 0 ;

20403

PyObject * obj0 = 0 ;

20404

PyObject * obj1 = 0 ;

20405

PyObject * obj2 = 0 ;

20406

char * kwnames[] = {

20407

(char *) "self",(char *) "file",(char *) "type", NULL

20408

};

20409

20410

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20411

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20412

if (!SWIG_IsOK(res1)) {

20413

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SaveFile" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20414

}

20415

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20416

if (obj1) {

20417

{

20418

arg2 = wxString_in_helper(obj1);

20419

if (arg2 == NULL) SWIG_fail;

20420

temp2 = true;

20421

}

20422

}

20423

if (obj2) {

20424

ecode3 = SWIG_AsVal_int(obj2, &val3);

20425

if (!SWIG_IsOK(ecode3)) {

20426

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SaveFile" "', expected argument " "3"" of type '" "int""'");

20427

}

20428

arg3 = static_cast< int >(val3);

20429

}

20430

{

20431

PyThreadState* __tstate = wxPyBeginAllowThreads();

20432

result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);

20433

wxPyEndAllowThreads(__tstate);

20434

if (PyErr_Occurred()) SWIG_fail;

20435

}

20436

{

20437

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20438

}

20439

{

20440

if (temp2)

20441

delete arg2;

20442

}

20443

return resultobj;

20444

fail:

20445

{

20446

if (temp2)

20447

delete arg2;

20448

}

20449

return NULL;

20450

}

20451

20452

20453

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetHandlerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20454

PyObject *resultobj = 0;

20455

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20456

int arg2 ;

20457

void *argp1 = 0 ;

20458

int res1 = 0 ;

20459

int val2 ;

20460

int ecode2 = 0 ;

20461

PyObject * obj0 = 0 ;

20462

PyObject * obj1 = 0 ;

20463

char * kwnames[] = {

20464

(char *) "self",(char *) "flags", NULL

20465

};

20466

20467

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetHandlerFlags",kwnames,&obj0,&obj1)) SWIG_fail;

20468

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20469

if (!SWIG_IsOK(res1)) {

20470

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetHandlerFlags" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20471

}

20472

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20473

ecode2 = SWIG_AsVal_int(obj1, &val2);

20474

if (!SWIG_IsOK(ecode2)) {

20475

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetHandlerFlags" "', expected argument " "2"" of type '" "int""'");

20476

}

20477

arg2 = static_cast< int >(val2);

20478

{

20479

PyThreadState* __tstate = wxPyBeginAllowThreads();

20480

(arg1)->SetHandlerFlags(arg2);

20481

wxPyEndAllowThreads(__tstate);

20482

if (PyErr_Occurred()) SWIG_fail;

20483

}

20484

resultobj = SWIG_Py_Void();

20485

return resultobj;

20486

fail:

20487

return NULL;

20488

}

20489

20490

20491

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetHandlerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20492

PyObject *resultobj = 0;

20493

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20494

int result;

20495

void *argp1 = 0 ;

20496

int res1 = 0 ;

20497

PyObject *swig_obj[1] ;

20498

20499

if (!args) SWIG_fail;

20500

swig_obj[0] = args;

20501

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20502

if (!SWIG_IsOK(res1)) {

20503

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetHandlerFlags" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

20504

}

20505

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20506

{

20507

PyThreadState* __tstate = wxPyBeginAllowThreads();

20508

result = (int)((wxRichTextCtrl const *)arg1)->GetHandlerFlags();

20509

wxPyEndAllowThreads(__tstate);

20510

if (PyErr_Occurred()) SWIG_fail;

20511

}

20512

resultobj = SWIG_From_int(static_cast< int >(result));

20513

return resultobj;

20514

fail:

20515

return NULL;

20516

}

20517

20518

20519

SWIGINTERN PyObject *_wrap_RichTextCtrl_MarkDirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20520

PyObject *resultobj = 0;

20521

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20522

void *argp1 = 0 ;

20523

int res1 = 0 ;

20524

PyObject *swig_obj[1] ;

20525

20526

if (!args) SWIG_fail;

20527

swig_obj[0] = args;

20528

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20529

if (!SWIG_IsOK(res1)) {

20530

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MarkDirty" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20531

}

20532

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20533

{

20534

PyThreadState* __tstate = wxPyBeginAllowThreads();

20535

(arg1)->MarkDirty();

20536

wxPyEndAllowThreads(__tstate);

20537

if (PyErr_Occurred()) SWIG_fail;

20538

}

20539

resultobj = SWIG_Py_Void();

20540

return resultobj;

20541

fail:

20542

return NULL;

20543

}

20544

20545

20546

SWIGINTERN PyObject *_wrap_RichTextCtrl_DiscardEdits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

20547

PyObject *resultobj = 0;

20548

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20549

void *argp1 = 0 ;

20550

int res1 = 0 ;

20551

PyObject *swig_obj[1] ;

20552

20553

if (!args) SWIG_fail;

20554

swig_obj[0] = args;

20555

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20556

if (!SWIG_IsOK(res1)) {

20557

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_DiscardEdits" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20558

}

20559

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20560

{

20561

PyThreadState* __tstate = wxPyBeginAllowThreads();

20562

(arg1)->DiscardEdits();

20563

wxPyEndAllowThreads(__tstate);

20564

if (PyErr_Occurred()) SWIG_fail;

20565

}

20566

resultobj = SWIG_Py_Void();

20567

return resultobj;

20568

fail:

20569

return NULL;

20570

}

20571

20572

20573

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetMaxLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20574

PyObject *resultobj = 0;

20575

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20576

unsigned long arg2 ;

20577

void *argp1 = 0 ;

20578

int res1 = 0 ;

20579

unsigned long val2 ;

20580

int ecode2 = 0 ;

20581

PyObject * obj0 = 0 ;

20582

PyObject * obj1 = 0 ;

20583

char * kwnames[] = {

20584

(char *) "self",(char *) "len", NULL

20585

};

20586

20587

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetMaxLength",kwnames,&obj0,&obj1)) SWIG_fail;

20588

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20589

if (!SWIG_IsOK(res1)) {

20590

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetMaxLength" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20591

}

20592

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20593

ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);

20594

if (!SWIG_IsOK(ecode2)) {

20595

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetMaxLength" "', expected argument " "2"" of type '" "unsigned long""'");

20596

}

20597

arg2 = static_cast< unsigned long >(val2);

20598

{

20599

PyThreadState* __tstate = wxPyBeginAllowThreads();

20600

(arg1)->SetMaxLength(arg2);

20601

wxPyEndAllowThreads(__tstate);

20602

if (PyErr_Occurred()) SWIG_fail;

20603

}

20604

resultobj = SWIG_Py_Void();

20605

return resultobj;

20606

fail:

20607

return NULL;

20608

}

20609

20610

20611

SWIGINTERN PyObject *_wrap_RichTextCtrl_WriteText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20612

PyObject *resultobj = 0;

20613

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20614

wxString *arg2 = 0 ;

20615

void *argp1 = 0 ;

20616

int res1 = 0 ;

20617

bool temp2 = false ;

20618

PyObject * obj0 = 0 ;

20619

PyObject * obj1 = 0 ;

20620

char * kwnames[] = {

20621

(char *) "self",(char *) "text", NULL

20622

};

20623

20624

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_WriteText",kwnames,&obj0,&obj1)) SWIG_fail;

20625

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20626

if (!SWIG_IsOK(res1)) {

20627

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WriteText" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20628

}

20629

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20630

{

20631

arg2 = wxString_in_helper(obj1);

20632

if (arg2 == NULL) SWIG_fail;

20633

temp2 = true;

20634

}

20635

{

20636

PyThreadState* __tstate = wxPyBeginAllowThreads();

20637

(arg1)->WriteText((wxString const &)*arg2);

20638

wxPyEndAllowThreads(__tstate);

20639

if (PyErr_Occurred()) SWIG_fail;

20640

}

20641

resultobj = SWIG_Py_Void();

20642

{

20643

if (temp2)

20644

delete arg2;

20645

}

20646

return resultobj;

20647

fail:

20648

{

20649

if (temp2)

20650

delete arg2;

20651

}

20652

return NULL;

20653

}

20654

20655

20656

SWIGINTERN PyObject *_wrap_RichTextCtrl_AppendText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20657

PyObject *resultobj = 0;

20658

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20659

wxString *arg2 = 0 ;

20660

void *argp1 = 0 ;

20661

int res1 = 0 ;

20662

bool temp2 = false ;

20663

PyObject * obj0 = 0 ;

20664

PyObject * obj1 = 0 ;

20665

char * kwnames[] = {

20666

(char *) "self",(char *) "text", NULL

20667

};

20668

20669

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_AppendText",kwnames,&obj0,&obj1)) SWIG_fail;

20670

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20671

if (!SWIG_IsOK(res1)) {

20672

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_AppendText" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20673

}

20674

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20675

{

20676

arg2 = wxString_in_helper(obj1);

20677

if (arg2 == NULL) SWIG_fail;

20678

temp2 = true;

20679

}

20680

{

20681

PyThreadState* __tstate = wxPyBeginAllowThreads();

20682

(arg1)->AppendText((wxString const &)*arg2);

20683

wxPyEndAllowThreads(__tstate);

20684

if (PyErr_Occurred()) SWIG_fail;

20685

}

20686

resultobj = SWIG_Py_Void();

20687

{

20688

if (temp2)

20689

delete arg2;

20690

}

20691

return resultobj;

20692

fail:

20693

{

20694

if (temp2)

20695

delete arg2;

20696

}

20697

return NULL;

20698

}

20699

20700

20701

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20702

PyObject *resultobj = 0;

20703

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20704

wxRichTextRange *arg2 = 0 ;

20705

wxTextAttrEx *arg3 = 0 ;

20706

bool result;

20707

void *argp1 = 0 ;

20708

int res1 = 0 ;

20709

wxRichTextRange temp2 ;

20710

void *argp3 = 0 ;

20711

int res3 = 0 ;

20712

PyObject * obj0 = 0 ;

20713

PyObject * obj1 = 0 ;

20714

PyObject * obj2 = 0 ;

20715

char * kwnames[] = {

20716

(char *) "self",(char *) "range",(char *) "style", NULL

20717

};

20718

20719

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_SetStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20720

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20721

if (!SWIG_IsOK(res1)) {

20722

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20723

}

20724

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20725

{

20726

arg2 = &temp2;

20727

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

20728

}

20729

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

20730

if (!SWIG_IsOK(res3)) {

20731

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_SetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

20732

}

20733

if (!argp3) {

20734

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

20735

}

20736

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

20737

{

20738

PyThreadState* __tstate = wxPyBeginAllowThreads();

20739

result = (bool)(arg1)->SetStyle((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3);

20740

wxPyEndAllowThreads(__tstate);

20741

if (PyErr_Occurred()) SWIG_fail;

20742

}

20743

{

20744

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20745

}

20746

return resultobj;

20747

fail:

20748

return NULL;

20749

}

20750

20751

20752

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20753

PyObject *resultobj = 0;

20754

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20755

long arg2 ;

20756

wxTextAttrEx *arg3 = 0 ;

20757

bool result;

20758

void *argp1 = 0 ;

20759

int res1 = 0 ;

20760

long val2 ;

20761

int ecode2 = 0 ;

20762

void *argp3 = 0 ;

20763

int res3 = 0 ;

20764

PyObject * obj0 = 0 ;

20765

PyObject * obj1 = 0 ;

20766

PyObject * obj2 = 0 ;

20767

char * kwnames[] = {

20768

(char *) "self",(char *) "position",(char *) "style", NULL

20769

};

20770

20771

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_GetStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20772

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20773

if (!SWIG_IsOK(res1)) {

20774

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20775

}

20776

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20777

ecode2 = SWIG_AsVal_long(obj1, &val2);

20778

if (!SWIG_IsOK(ecode2)) {

20779

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetStyle" "', expected argument " "2"" of type '" "long""'");

20780

}

20781

arg2 = static_cast< long >(val2);

20782

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

20783

if (!SWIG_IsOK(res3)) {

20784

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_GetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

20785

}

20786

if (!argp3) {

20787

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_GetStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

20788

}

20789

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

20790

{

20791

PyThreadState* __tstate = wxPyBeginAllowThreads();

20792

result = (bool)(arg1)->GetStyle(arg2,*arg3);

20793

wxPyEndAllowThreads(__tstate);

20794

if (PyErr_Occurred()) SWIG_fail;

20795

}

20796

{

20797

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20798

}

20799

return resultobj;

20800

fail:

20801

return NULL;

20802

}

20803

20804

20805

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetStyleForRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20806

PyObject *resultobj = 0;

20807

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20808

wxRichTextRange *arg2 = 0 ;

20809

wxTextAttrEx *arg3 = 0 ;

20810

bool result;

20811

void *argp1 = 0 ;

20812

int res1 = 0 ;

20813

wxRichTextRange temp2 ;

20814

void *argp3 = 0 ;

20815

int res3 = 0 ;

20816

PyObject * obj0 = 0 ;

20817

PyObject * obj1 = 0 ;

20818

PyObject * obj2 = 0 ;

20819

char * kwnames[] = {

20820

(char *) "self",(char *) "range",(char *) "style", NULL

20821

};

20822

20823

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_GetStyleForRange",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20824

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20825

if (!SWIG_IsOK(res1)) {

20826

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetStyleForRange" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20827

}

20828

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20829

{

20830

arg2 = &temp2;

20831

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

20832

}

20833

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

20834

if (!SWIG_IsOK(res3)) {

20835

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_GetStyleForRange" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

20836

}

20837

if (!argp3) {

20838

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_GetStyleForRange" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

20839

}

20840

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

20841

{

20842

PyThreadState* __tstate = wxPyBeginAllowThreads();

20843

result = (bool)(arg1)->GetStyleForRange((wxRichTextRange const &)*arg2,*arg3);

20844

wxPyEndAllowThreads(__tstate);

20845

if (PyErr_Occurred()) SWIG_fail;

20846

}

20847

{

20848

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20849

}

20850

return resultobj;

20851

fail:

20852

return NULL;

20853

}

20854

20855

20856

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetStyleEx(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20857

PyObject *resultobj = 0;

20858

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20859

wxRichTextRange *arg2 = 0 ;

20860

wxTextAttrEx *arg3 = 0 ;

20861

int arg4 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

20862

bool result;

20863

void *argp1 = 0 ;

20864

int res1 = 0 ;

20865

wxRichTextRange temp2 ;

20866

void *argp3 = 0 ;

20867

int res3 = 0 ;

20868

int val4 ;

20869

int ecode4 = 0 ;

20870

PyObject * obj0 = 0 ;

20871

PyObject * obj1 = 0 ;

20872

PyObject * obj2 = 0 ;

20873

PyObject * obj3 = 0 ;

20874

char * kwnames[] = {

20875

(char *) "self",(char *) "range",(char *) "style",(char *) "flags", NULL

20876

};

20877

20878

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:RichTextCtrl_SetStyleEx",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

20879

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20880

if (!SWIG_IsOK(res1)) {

20881

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetStyleEx" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20882

}

20883

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20884

{

20885

arg2 = &temp2;

20886

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

20887

}

20888

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

20889

if (!SWIG_IsOK(res3)) {

20890

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_SetStyleEx" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

20891

}

20892

if (!argp3) {

20893

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetStyleEx" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

20894

}

20895

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

20896

if (obj3) {

20897

ecode4 = SWIG_AsVal_int(obj3, &val4);

20898

if (!SWIG_IsOK(ecode4)) {

20899

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_SetStyleEx" "', expected argument " "4"" of type '" "int""'");

20900

}

20901

arg4 = static_cast< int >(val4);

20902

}

20903

{

20904

PyThreadState* __tstate = wxPyBeginAllowThreads();

20905

result = (bool)(arg1)->SetStyleEx((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3,arg4);

20906

wxPyEndAllowThreads(__tstate);

20907

if (PyErr_Occurred()) SWIG_fail;

20908

}

20909

{

20910

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20911

}

20912

return resultobj;

20913

fail:

20914

return NULL;

20915

}

20916

20917

20918

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetUncombinedStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20919

PyObject *resultobj = 0;

20920

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20921

long arg2 ;

20922

wxTextAttrEx *arg3 = 0 ;

20923

bool result;

20924

void *argp1 = 0 ;

20925

int res1 = 0 ;

20926

long val2 ;

20927

int ecode2 = 0 ;

20928

void *argp3 = 0 ;

20929

int res3 = 0 ;

20930

PyObject * obj0 = 0 ;

20931

PyObject * obj1 = 0 ;

20932

PyObject * obj2 = 0 ;

20933

char * kwnames[] = {

20934

(char *) "self",(char *) "position",(char *) "style", NULL

20935

};

20936

20937

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_GetUncombinedStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

20938

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20939

if (!SWIG_IsOK(res1)) {

20940

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetUncombinedStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20941

}

20942

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20943

ecode2 = SWIG_AsVal_long(obj1, &val2);

20944

if (!SWIG_IsOK(ecode2)) {

20945

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetUncombinedStyle" "', expected argument " "2"" of type '" "long""'");

20946

}

20947

arg2 = static_cast< long >(val2);

20948

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 );

20949

if (!SWIG_IsOK(res3)) {

20950

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_GetUncombinedStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

20951

}

20952

if (!argp3) {

20953

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_GetUncombinedStyle" "', expected argument " "3"" of type '" "wxTextAttrEx &""'");

20954

}

20955

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

20956

{

20957

PyThreadState* __tstate = wxPyBeginAllowThreads();

20958

result = (bool)(arg1)->GetUncombinedStyle(arg2,*arg3);

20959

wxPyEndAllowThreads(__tstate);

20960

if (PyErr_Occurred()) SWIG_fail;

20961

}

20962

{

20963

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

20964

}

20965

return resultobj;

20966

fail:

20967

return NULL;

20968

}

20969

20970

20971

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

20972

PyObject *resultobj = 0;

20973

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

20974

wxTextAttrEx *arg2 = 0 ;

20975

bool result;

20976

void *argp1 = 0 ;

20977

int res1 = 0 ;

20978

void *argp2 = 0 ;

20979

int res2 = 0 ;

20980

PyObject * obj0 = 0 ;

20981

PyObject * obj1 = 0 ;

20982

char * kwnames[] = {

20983

(char *) "self",(char *) "style", NULL

20984

};

20985

20986

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetDefaultStyle",kwnames,&obj0,&obj1)) SWIG_fail;

20987

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

20988

if (!SWIG_IsOK(res1)) {

20989

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

20990

}

20991

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

20992

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

20993

if (!SWIG_IsOK(res2)) {

20994

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetDefaultStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

20995

}

20996

if (!argp2) {

20997

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetDefaultStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

20998

}

20999

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

21000

{

21001

PyThreadState* __tstate = wxPyBeginAllowThreads();

21002

result = (bool)(arg1)->SetDefaultStyle((wxTextAttrEx const &)*arg2);

21003

wxPyEndAllowThreads(__tstate);

21004

if (PyErr_Occurred()) SWIG_fail;

21005

}

21006

{

21007

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21008

}

21009

return resultobj;

21010

fail:

21011

return NULL;

21012

}

21013

21014

21015

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21016

PyObject *resultobj = 0;

21017

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21018

wxTextAttrEx result;

21019

void *argp1 = 0 ;

21020

int res1 = 0 ;

21021

PyObject *swig_obj[1] ;

21022

21023

if (!args) SWIG_fail;

21024

swig_obj[0] = args;

21025

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21026

if (!SWIG_IsOK(res1)) {

21027

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21028

}

21029

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21030

{

21031

PyThreadState* __tstate = wxPyBeginAllowThreads();

21032

result = ((wxRichTextCtrl const *)arg1)->GetDefaultStyleEx();

21033

wxPyEndAllowThreads(__tstate);

21034

if (PyErr_Occurred()) SWIG_fail;

21035

}

21036

resultobj = SWIG_NewPointerObj((new wxTextAttrEx(static_cast< const wxTextAttrEx& >(result))), SWIGTYPE_p_wxTextAttrEx, SWIG_POINTER_OWN | 0 );

21037

return resultobj;

21038

fail:

21039

return NULL;

21040

}

21041

21042

21043

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21044

PyObject *resultobj = 0;

21045

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21046

wxRichTextRange *arg2 = 0 ;

21047

wxString *arg3 = 0 ;

21048

int arg4 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

21049

int arg5 = (int) 1 ;

21050

int arg6 = (int) -1 ;

21051

bool result;

21052

void *argp1 = 0 ;

21053

int res1 = 0 ;

21054

wxRichTextRange temp2 ;

21055

bool temp3 = false ;

21056

int val4 ;

21057

int ecode4 = 0 ;

21058

int val5 ;

21059

int ecode5 = 0 ;

21060

int val6 ;

21061

int ecode6 = 0 ;

21062

PyObject * obj0 = 0 ;

21063

PyObject * obj1 = 0 ;

21064

PyObject * obj2 = 0 ;

21065

PyObject * obj3 = 0 ;

21066

PyObject * obj4 = 0 ;

21067

PyObject * obj5 = 0 ;

21068

char * kwnames[] = {

21069

(char *) "self",(char *) "range",(char *) "defName",(char *) "flags",(char *) "startFrom",(char *) "specifiedLevel", NULL

21070

};

21071

21072

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:RichTextCtrl_SetListStyle",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

21073

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21074

if (!SWIG_IsOK(res1)) {

21075

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetListStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21076

}

21077

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21078

{

21079

arg2 = &temp2;

21080

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

21081

}

21082

{

21083

arg3 = wxString_in_helper(obj2);

21084

if (arg3 == NULL) SWIG_fail;

21085

temp3 = true;

21086

}

21087

if (obj3) {

21088

ecode4 = SWIG_AsVal_int(obj3, &val4);

21089

if (!SWIG_IsOK(ecode4)) {

21090

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_SetListStyle" "', expected argument " "4"" of type '" "int""'");

21091

}

21092

arg4 = static_cast< int >(val4);

21093

}

21094

if (obj4) {

21095

ecode5 = SWIG_AsVal_int(obj4, &val5);

21096

if (!SWIG_IsOK(ecode5)) {

21097

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_SetListStyle" "', expected argument " "5"" of type '" "int""'");

21098

}

21099

arg5 = static_cast< int >(val5);

21100

}

21101

if (obj5) {

21102

ecode6 = SWIG_AsVal_int(obj5, &val6);

21103

if (!SWIG_IsOK(ecode6)) {

21104

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextCtrl_SetListStyle" "', expected argument " "6"" of type '" "int""'");

21105

}

21106

arg6 = static_cast< int >(val6);

21107

}

21108

{

21109

PyThreadState* __tstate = wxPyBeginAllowThreads();

21110

result = (bool)(arg1)->SetListStyle((wxRichTextRange const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);

21111

wxPyEndAllowThreads(__tstate);

21112

if (PyErr_Occurred()) SWIG_fail;

21113

}

21114

{

21115

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21116

}

21117

{

21118

if (temp3)

21119

delete arg3;

21120

}

21121

return resultobj;

21122

fail:

21123

{

21124

if (temp3)

21125

delete arg3;

21126

}

21127

return NULL;

21128

}

21129

21130

21131

SWIGINTERN PyObject *_wrap_RichTextCtrl_ClearListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21132

PyObject *resultobj = 0;

21133

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21134

wxRichTextRange *arg2 = 0 ;

21135

int arg3 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

21136

bool result;

21137

void *argp1 = 0 ;

21138

int res1 = 0 ;

21139

wxRichTextRange temp2 ;

21140

int val3 ;

21141

int ecode3 = 0 ;

21142

PyObject * obj0 = 0 ;

21143

PyObject * obj1 = 0 ;

21144

PyObject * obj2 = 0 ;

21145

char * kwnames[] = {

21146

(char *) "self",(char *) "range",(char *) "flags", NULL

21147

};

21148

21149

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_ClearListStyle",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

21150

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21151

if (!SWIG_IsOK(res1)) {

21152

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ClearListStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21153

}

21154

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21155

{

21156

arg2 = &temp2;

21157

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

21158

}

21159

if (obj2) {

21160

ecode3 = SWIG_AsVal_int(obj2, &val3);

21161

if (!SWIG_IsOK(ecode3)) {

21162

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_ClearListStyle" "', expected argument " "3"" of type '" "int""'");

21163

}

21164

arg3 = static_cast< int >(val3);

21165

}

21166

{

21167

PyThreadState* __tstate = wxPyBeginAllowThreads();

21168

result = (bool)(arg1)->ClearListStyle((wxRichTextRange const &)*arg2,arg3);

21169

wxPyEndAllowThreads(__tstate);

21170

if (PyErr_Occurred()) SWIG_fail;

21171

}

21172

{

21173

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21174

}

21175

return resultobj;

21176

fail:

21177

return NULL;

21178

}

21179

21180

21181

SWIGINTERN PyObject *_wrap_RichTextCtrl_NumberList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21182

PyObject *resultobj = 0;

21183

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21184

wxRichTextRange *arg2 = 0 ;

21185

wxString *arg3 = 0 ;

21186

int arg4 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

21187

int arg5 = (int) 1 ;

21188

int arg6 = (int) -1 ;

21189

bool result;

21190

void *argp1 = 0 ;

21191

int res1 = 0 ;

21192

wxRichTextRange temp2 ;

21193

bool temp3 = false ;

21194

int val4 ;

21195

int ecode4 = 0 ;

21196

int val5 ;

21197

int ecode5 = 0 ;

21198

int val6 ;

21199

int ecode6 = 0 ;

21200

PyObject * obj0 = 0 ;

21201

PyObject * obj1 = 0 ;

21202

PyObject * obj2 = 0 ;

21203

PyObject * obj3 = 0 ;

21204

PyObject * obj4 = 0 ;

21205

PyObject * obj5 = 0 ;

21206

char * kwnames[] = {

21207

(char *) "self",(char *) "range",(char *) "defName",(char *) "flags",(char *) "startFrom",(char *) "specifiedLevel", NULL

21208

};

21209

21210

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:RichTextCtrl_NumberList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

21211

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21212

if (!SWIG_IsOK(res1)) {

21213

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_NumberList" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21214

}

21215

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21216

{

21217

arg2 = &temp2;

21218

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

21219

}

21220

{

21221

arg3 = wxString_in_helper(obj2);

21222

if (arg3 == NULL) SWIG_fail;

21223

temp3 = true;

21224

}

21225

if (obj3) {

21226

ecode4 = SWIG_AsVal_int(obj3, &val4);

21227

if (!SWIG_IsOK(ecode4)) {

21228

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_NumberList" "', expected argument " "4"" of type '" "int""'");

21229

}

21230

arg4 = static_cast< int >(val4);

21231

}

21232

if (obj4) {

21233

ecode5 = SWIG_AsVal_int(obj4, &val5);

21234

if (!SWIG_IsOK(ecode5)) {

21235

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_NumberList" "', expected argument " "5"" of type '" "int""'");

21236

}

21237

arg5 = static_cast< int >(val5);

21238

}

21239

if (obj5) {

21240

ecode6 = SWIG_AsVal_int(obj5, &val6);

21241

if (!SWIG_IsOK(ecode6)) {

21242

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextCtrl_NumberList" "', expected argument " "6"" of type '" "int""'");

21243

}

21244

arg6 = static_cast< int >(val6);

21245

}

21246

{

21247

PyThreadState* __tstate = wxPyBeginAllowThreads();

21248

result = (bool)(arg1)->NumberList((wxRichTextRange const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6);

21249

wxPyEndAllowThreads(__tstate);

21250

if (PyErr_Occurred()) SWIG_fail;

21251

}

21252

{

21253

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21254

}

21255

{

21256

if (temp3)

21257

delete arg3;

21258

}

21259

return resultobj;

21260

fail:

21261

{

21262

if (temp3)

21263

delete arg3;

21264

}

21265

return NULL;

21266

}

21267

21268

21269

SWIGINTERN PyObject *_wrap_RichTextCtrl_PromoteList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21270

PyObject *resultobj = 0;

21271

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21272

int arg2 ;

21273

wxRichTextRange *arg3 = 0 ;

21274

wxString *arg4 = 0 ;

21275

int arg5 = (int) wxRICHTEXT_SETSTYLE_WITH_UNDO ;

21276

int arg6 = (int) -1 ;

21277

bool result;

21278

void *argp1 = 0 ;

21279

int res1 = 0 ;

21280

int val2 ;

21281

int ecode2 = 0 ;

21282

wxRichTextRange temp3 ;

21283

bool temp4 = false ;

21284

int val5 ;

21285

int ecode5 = 0 ;

21286

int val6 ;

21287

int ecode6 = 0 ;

21288

PyObject * obj0 = 0 ;

21289

PyObject * obj1 = 0 ;

21290

PyObject * obj2 = 0 ;

21291

PyObject * obj3 = 0 ;

21292

PyObject * obj4 = 0 ;

21293

PyObject * obj5 = 0 ;

21294

char * kwnames[] = {

21295

(char *) "self",(char *) "promoteBy",(char *) "range",(char *) "defName",(char *) "flags",(char *) "specifiedLevel", NULL

21296

};

21297

21298

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:RichTextCtrl_PromoteList",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;

21299

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21300

if (!SWIG_IsOK(res1)) {

21301

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PromoteList" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21302

}

21303

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21304

ecode2 = SWIG_AsVal_int(obj1, &val2);

21305

if (!SWIG_IsOK(ecode2)) {

21306

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_PromoteList" "', expected argument " "2"" of type '" "int""'");

21307

}

21308

arg2 = static_cast< int >(val2);

21309

{

21310

arg3 = &temp3;

21311

if ( ! wxRichTextRange_helper(obj2, &arg3)) SWIG_fail;

21312

}

21313

{

21314

arg4 = wxString_in_helper(obj3);

21315

if (arg4 == NULL) SWIG_fail;

21316

temp4 = true;

21317

}

21318

if (obj4) {

21319

ecode5 = SWIG_AsVal_int(obj4, &val5);

21320

if (!SWIG_IsOK(ecode5)) {

21321

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_PromoteList" "', expected argument " "5"" of type '" "int""'");

21322

}

21323

arg5 = static_cast< int >(val5);

21324

}

21325

if (obj5) {

21326

ecode6 = SWIG_AsVal_int(obj5, &val6);

21327

if (!SWIG_IsOK(ecode6)) {

21328

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextCtrl_PromoteList" "', expected argument " "6"" of type '" "int""'");

21329

}

21330

arg6 = static_cast< int >(val6);

21331

}

21332

{

21333

PyThreadState* __tstate = wxPyBeginAllowThreads();

21334

result = (bool)(arg1)->PromoteList(arg2,(wxRichTextRange const &)*arg3,(wxString const &)*arg4,arg5,arg6);

21335

wxPyEndAllowThreads(__tstate);

21336

if (PyErr_Occurred()) SWIG_fail;

21337

}

21338

{

21339

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21340

}

21341

{

21342

if (temp4)

21343

delete arg4;

21344

}

21345

return resultobj;

21346

fail:

21347

{

21348

if (temp4)

21349

delete arg4;

21350

}

21351

return NULL;

21352

}

21353

21354

21355

SWIGINTERN PyObject *_wrap_RichTextCtrl_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21356

PyObject *resultobj = 0;

21357

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21358

wxRichTextRange *arg2 = 0 ;

21359

bool result;

21360

void *argp1 = 0 ;

21361

int res1 = 0 ;

21362

wxRichTextRange temp2 ;

21363

PyObject * obj0 = 0 ;

21364

PyObject * obj1 = 0 ;

21365

char * kwnames[] = {

21366

(char *) "self",(char *) "range", NULL

21367

};

21368

21369

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_Delete",kwnames,&obj0,&obj1)) SWIG_fail;

21370

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21371

if (!SWIG_IsOK(res1)) {

21372

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Delete" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21373

}

21374

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21375

{

21376

arg2 = &temp2;

21377

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

21378

}

21379

{

21380

PyThreadState* __tstate = wxPyBeginAllowThreads();

21381

result = (bool)(arg1)->Delete((wxRichTextRange const &)*arg2);

21382

wxPyEndAllowThreads(__tstate);

21383

if (PyErr_Occurred()) SWIG_fail;

21384

}

21385

{

21386

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21387

}

21388

return resultobj;

21389

fail:

21390

return NULL;

21391

}

21392

21393

21394

SWIGINTERN PyObject *_wrap_RichTextCtrl_XYToPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21395

PyObject *resultobj = 0;

21396

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21397

long arg2 ;

21398

long arg3 ;

21399

long result;

21400

void *argp1 = 0 ;

21401

int res1 = 0 ;

21402

long val2 ;

21403

int ecode2 = 0 ;

21404

long val3 ;

21405

int ecode3 = 0 ;

21406

PyObject * obj0 = 0 ;

21407

PyObject * obj1 = 0 ;

21408

PyObject * obj2 = 0 ;

21409

char * kwnames[] = {

21410

(char *) "self",(char *) "x",(char *) "y", NULL

21411

};

21412

21413

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_XYToPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

21414

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21415

if (!SWIG_IsOK(res1)) {

21416

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_XYToPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21417

}

21418

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21419

ecode2 = SWIG_AsVal_long(obj1, &val2);

21420

if (!SWIG_IsOK(ecode2)) {

21421

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_XYToPosition" "', expected argument " "2"" of type '" "long""'");

21422

}

21423

arg2 = static_cast< long >(val2);

21424

ecode3 = SWIG_AsVal_long(obj2, &val3);

21425

if (!SWIG_IsOK(ecode3)) {

21426

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_XYToPosition" "', expected argument " "3"" of type '" "long""'");

21427

}

21428

arg3 = static_cast< long >(val3);

21429

{

21430

PyThreadState* __tstate = wxPyBeginAllowThreads();

21431

result = (long)((wxRichTextCtrl const *)arg1)->XYToPosition(arg2,arg3);

21432

wxPyEndAllowThreads(__tstate);

21433

if (PyErr_Occurred()) SWIG_fail;

21434

}

21435

resultobj = SWIG_From_long(static_cast< long >(result));

21436

return resultobj;

21437

fail:

21438

return NULL;

21439

}

21440

21441

21442

SWIGINTERN PyObject *_wrap_RichTextCtrl_PositionToXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21443

PyObject *resultobj = 0;

21444

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21445

long arg2 ;

21446

long *arg3 = (long *) 0 ;

21447

long *arg4 = (long *) 0 ;

21448

void *argp1 = 0 ;

21449

int res1 = 0 ;

21450

long val2 ;

21451

int ecode2 = 0 ;

21452

long temp3 ;

21453

int res3 = SWIG_TMPOBJ ;

21454

long temp4 ;

21455

int res4 = SWIG_TMPOBJ ;

21456

PyObject * obj0 = 0 ;

21457

PyObject * obj1 = 0 ;

21458

char * kwnames[] = {

21459

(char *) "self",(char *) "pos", NULL

21460

};

21461

21462

arg3 = &temp3;

21463

arg4 = &temp4;

21464

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_PositionToXY",kwnames,&obj0,&obj1)) SWIG_fail;

21465

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21466

if (!SWIG_IsOK(res1)) {

21467

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PositionToXY" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21468

}

21469

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21470

ecode2 = SWIG_AsVal_long(obj1, &val2);

21471

if (!SWIG_IsOK(ecode2)) {

21472

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_PositionToXY" "', expected argument " "2"" of type '" "long""'");

21473

}

21474

arg2 = static_cast< long >(val2);

21475

{

21476

PyThreadState* __tstate = wxPyBeginAllowThreads();

21477

((wxRichTextCtrl const *)arg1)->PositionToXY(arg2,arg3,arg4);

21478

wxPyEndAllowThreads(__tstate);

21479

if (PyErr_Occurred()) SWIG_fail;

21480

}

21481

resultobj = SWIG_Py_Void();

21482

if (SWIG_IsTmpObj(res3)) {

21483

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));

21484

} else {

21485

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

21486

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));

21487

}

21488

if (SWIG_IsTmpObj(res4)) {

21489

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg4)));

21490

} else {

21491

int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

21492

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags));

21493

}

21494

return resultobj;

21495

fail:

21496

return NULL;

21497

}

21498

21499

21500

SWIGINTERN PyObject *_wrap_RichTextCtrl_ShowPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21501

PyObject *resultobj = 0;

21502

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21503

long arg2 ;

21504

void *argp1 = 0 ;

21505

int res1 = 0 ;

21506

long val2 ;

21507

int ecode2 = 0 ;

21508

PyObject * obj0 = 0 ;

21509

PyObject * obj1 = 0 ;

21510

char * kwnames[] = {

21511

(char *) "self",(char *) "position", NULL

21512

};

21513

21514

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_ShowPosition",kwnames,&obj0,&obj1)) SWIG_fail;

21515

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21516

if (!SWIG_IsOK(res1)) {

21517

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ShowPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21518

}

21519

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21520

ecode2 = SWIG_AsVal_long(obj1, &val2);

21521

if (!SWIG_IsOK(ecode2)) {

21522

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_ShowPosition" "', expected argument " "2"" of type '" "long""'");

21523

}

21524

arg2 = static_cast< long >(val2);

21525

{

21526

PyThreadState* __tstate = wxPyBeginAllowThreads();

21527

(arg1)->ShowPosition(arg2);

21528

wxPyEndAllowThreads(__tstate);

21529

if (PyErr_Occurred()) SWIG_fail;

21530

}

21531

resultobj = SWIG_Py_Void();

21532

return resultobj;

21533

fail:

21534

return NULL;

21535

}

21536

21537

21538

SWIGINTERN PyObject *_wrap_RichTextCtrl_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21539

PyObject *resultobj = 0;

21540

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21541

wxPoint *arg2 = 0 ;

21542

long *arg3 = (long *) 0 ;

21543

wxTextCtrlHitTestResult result;

21544

void *argp1 = 0 ;

21545

int res1 = 0 ;

21546

wxPoint temp2 ;

21547

long temp3 ;

21548

int res3 = SWIG_TMPOBJ ;

21549

PyObject * obj0 = 0 ;

21550

PyObject * obj1 = 0 ;

21551

char * kwnames[] = {

21552

(char *) "self",(char *) "pt", NULL

21553

};

21554

21555

arg3 = &temp3;

21556

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;

21557

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21558

if (!SWIG_IsOK(res1)) {

21559

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_HitTest" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21560

}

21561

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21562

{

21563

arg2 = &temp2;

21564

if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;

21565

}

21566

{

21567

PyThreadState* __tstate = wxPyBeginAllowThreads();

21568

result = (wxTextCtrlHitTestResult)((wxRichTextCtrl const *)arg1)->HitTest((wxPoint const &)*arg2,arg3);

21569

wxPyEndAllowThreads(__tstate);

21570

if (PyErr_Occurred()) SWIG_fail;

21571

}

21572

resultobj = SWIG_From_int(static_cast< int >(result));

21573

if (SWIG_IsTmpObj(res3)) {

21574

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));

21575

} else {

21576

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

21577

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));

21578

}

21579

return resultobj;

21580

fail:

21581

return NULL;

21582

}

21583

21584

21585

SWIGINTERN PyObject *_wrap_RichTextCtrl_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21586

PyObject *resultobj = 0;

21587

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21588

wxPoint *arg2 = 0 ;

21589

wxTextCoord *arg3 = (wxTextCoord *) 0 ;

21590

wxTextCoord *arg4 = (wxTextCoord *) 0 ;

21591

wxTextCtrlHitTestResult result;

21592

void *argp1 = 0 ;

21593

int res1 = 0 ;

21594

wxPoint temp2 ;

21595

void *argp3 = 0 ;

21596

int res3 = 0 ;

21597

void *argp4 = 0 ;

21598

int res4 = 0 ;

21599

PyObject * obj0 = 0 ;

21600

PyObject * obj1 = 0 ;

21601

PyObject * obj2 = 0 ;

21602

PyObject * obj3 = 0 ;

21603

char * kwnames[] = {

21604

(char *) "self",(char *) "pt",(char *) "OUTPUT",(char *) "OUTPUT", NULL

21605

};

21606

21607

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RichTextCtrl_HitTestXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

21608

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21609

if (!SWIG_IsOK(res1)) {

21610

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_HitTestXY" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21611

}

21612

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21613

{

21614

arg2 = &temp2;

21615

if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;

21616

}

21617

res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxTextCoord, 0 | 0 );

21618

if (!SWIG_IsOK(res3)) {

21619

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_HitTestXY" "', expected argument " "3"" of type '" "wxTextCoord *""'");

21620

}

21621

arg3 = reinterpret_cast< wxTextCoord * >(argp3);

21622

res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxTextCoord, 0 | 0 );

21623

if (!SWIG_IsOK(res4)) {

21624

SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RichTextCtrl_HitTestXY" "', expected argument " "4"" of type '" "wxTextCoord *""'");

21625

}

21626

arg4 = reinterpret_cast< wxTextCoord * >(argp4);

21627

{

21628

PyThreadState* __tstate = wxPyBeginAllowThreads();

21629

result = (wxTextCtrlHitTestResult)((wxRichTextCtrl const *)arg1)->HitTest((wxPoint const &)*arg2,arg3,arg4);

21630

wxPyEndAllowThreads(__tstate);

21631

if (PyErr_Occurred()) SWIG_fail;

21632

}

21633

resultobj = SWIG_From_int(static_cast< int >(result));

21634

return resultobj;

21635

fail:

21636

return NULL;

21637

}

21638

21639

21640

SWIGINTERN PyObject *_wrap_RichTextCtrl_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21641

PyObject *resultobj = 0;

21642

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21643

void *argp1 = 0 ;

21644

int res1 = 0 ;

21645

PyObject *swig_obj[1] ;

21646

21647

if (!args) SWIG_fail;

21648

swig_obj[0] = args;

21649

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21650

if (!SWIG_IsOK(res1)) {

21651

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Copy" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21652

}

21653

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21654

{

21655

PyThreadState* __tstate = wxPyBeginAllowThreads();

21656

(arg1)->Copy();

21657

wxPyEndAllowThreads(__tstate);

21658

if (PyErr_Occurred()) SWIG_fail;

21659

}

21660

resultobj = SWIG_Py_Void();

21661

return resultobj;

21662

fail:

21663

return NULL;

21664

}

21665

21666

21667

SWIGINTERN PyObject *_wrap_RichTextCtrl_Cut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21668

PyObject *resultobj = 0;

21669

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21670

void *argp1 = 0 ;

21671

int res1 = 0 ;

21672

PyObject *swig_obj[1] ;

21673

21674

if (!args) SWIG_fail;

21675

swig_obj[0] = args;

21676

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21677

if (!SWIG_IsOK(res1)) {

21678

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Cut" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21679

}

21680

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21681

{

21682

PyThreadState* __tstate = wxPyBeginAllowThreads();

21683

(arg1)->Cut();

21684

wxPyEndAllowThreads(__tstate);

21685

if (PyErr_Occurred()) SWIG_fail;

21686

}

21687

resultobj = SWIG_Py_Void();

21688

return resultobj;

21689

fail:

21690

return NULL;

21691

}

21692

21693

21694

SWIGINTERN PyObject *_wrap_RichTextCtrl_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21695

PyObject *resultobj = 0;

21696

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21697

void *argp1 = 0 ;

21698

int res1 = 0 ;

21699

PyObject *swig_obj[1] ;

21700

21701

if (!args) SWIG_fail;

21702

swig_obj[0] = args;

21703

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21704

if (!SWIG_IsOK(res1)) {

21705

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Paste" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21706

}

21707

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21708

{

21709

PyThreadState* __tstate = wxPyBeginAllowThreads();

21710

(arg1)->Paste();

21711

wxPyEndAllowThreads(__tstate);

21712

if (PyErr_Occurred()) SWIG_fail;

21713

}

21714

resultobj = SWIG_Py_Void();

21715

return resultobj;

21716

fail:

21717

return NULL;

21718

}

21719

21720

21721

SWIGINTERN PyObject *_wrap_RichTextCtrl_DeleteSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21722

PyObject *resultobj = 0;

21723

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21724

void *argp1 = 0 ;

21725

int res1 = 0 ;

21726

PyObject *swig_obj[1] ;

21727

21728

if (!args) SWIG_fail;

21729

swig_obj[0] = args;

21730

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21731

if (!SWIG_IsOK(res1)) {

21732

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_DeleteSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21733

}

21734

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21735

{

21736

PyThreadState* __tstate = wxPyBeginAllowThreads();

21737

(arg1)->DeleteSelection();

21738

wxPyEndAllowThreads(__tstate);

21739

if (PyErr_Occurred()) SWIG_fail;

21740

}

21741

resultobj = SWIG_Py_Void();

21742

return resultobj;

21743

fail:

21744

return NULL;

21745

}

21746

21747

21748

SWIGINTERN PyObject *_wrap_RichTextCtrl_CanCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21749

PyObject *resultobj = 0;

21750

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21751

bool result;

21752

void *argp1 = 0 ;

21753

int res1 = 0 ;

21754

PyObject *swig_obj[1] ;

21755

21756

if (!args) SWIG_fail;

21757

swig_obj[0] = args;

21758

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21759

if (!SWIG_IsOK(res1)) {

21760

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CanCopy" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21761

}

21762

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21763

{

21764

PyThreadState* __tstate = wxPyBeginAllowThreads();

21765

result = (bool)((wxRichTextCtrl const *)arg1)->CanCopy();

21766

wxPyEndAllowThreads(__tstate);

21767

if (PyErr_Occurred()) SWIG_fail;

21768

}

21769

{

21770

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21771

}

21772

return resultobj;

21773

fail:

21774

return NULL;

21775

}

21776

21777

21778

SWIGINTERN PyObject *_wrap_RichTextCtrl_CanCut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21779

PyObject *resultobj = 0;

21780

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21781

bool result;

21782

void *argp1 = 0 ;

21783

int res1 = 0 ;

21784

PyObject *swig_obj[1] ;

21785

21786

if (!args) SWIG_fail;

21787

swig_obj[0] = args;

21788

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21789

if (!SWIG_IsOK(res1)) {

21790

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CanCut" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21791

}

21792

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21793

{

21794

PyThreadState* __tstate = wxPyBeginAllowThreads();

21795

result = (bool)((wxRichTextCtrl const *)arg1)->CanCut();

21796

wxPyEndAllowThreads(__tstate);

21797

if (PyErr_Occurred()) SWIG_fail;

21798

}

21799

{

21800

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21801

}

21802

return resultobj;

21803

fail:

21804

return NULL;

21805

}

21806

21807

21808

SWIGINTERN PyObject *_wrap_RichTextCtrl_CanPaste(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21809

PyObject *resultobj = 0;

21810

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21811

bool result;

21812

void *argp1 = 0 ;

21813

int res1 = 0 ;

21814

PyObject *swig_obj[1] ;

21815

21816

if (!args) SWIG_fail;

21817

swig_obj[0] = args;

21818

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21819

if (!SWIG_IsOK(res1)) {

21820

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CanPaste" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21821

}

21822

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21823

{

21824

PyThreadState* __tstate = wxPyBeginAllowThreads();

21825

result = (bool)((wxRichTextCtrl const *)arg1)->CanPaste();

21826

wxPyEndAllowThreads(__tstate);

21827

if (PyErr_Occurred()) SWIG_fail;

21828

}

21829

{

21830

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21831

}

21832

return resultobj;

21833

fail:

21834

return NULL;

21835

}

21836

21837

21838

SWIGINTERN PyObject *_wrap_RichTextCtrl_CanDeleteSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21839

PyObject *resultobj = 0;

21840

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21841

bool result;

21842

void *argp1 = 0 ;

21843

int res1 = 0 ;

21844

PyObject *swig_obj[1] ;

21845

21846

if (!args) SWIG_fail;

21847

swig_obj[0] = args;

21848

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21849

if (!SWIG_IsOK(res1)) {

21850

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CanDeleteSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21851

}

21852

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21853

{

21854

PyThreadState* __tstate = wxPyBeginAllowThreads();

21855

result = (bool)((wxRichTextCtrl const *)arg1)->CanDeleteSelection();

21856

wxPyEndAllowThreads(__tstate);

21857

if (PyErr_Occurred()) SWIG_fail;

21858

}

21859

{

21860

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21861

}

21862

return resultobj;

21863

fail:

21864

return NULL;

21865

}

21866

21867

21868

SWIGINTERN PyObject *_wrap_RichTextCtrl_Undo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21869

PyObject *resultobj = 0;

21870

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21871

void *argp1 = 0 ;

21872

int res1 = 0 ;

21873

PyObject *swig_obj[1] ;

21874

21875

if (!args) SWIG_fail;

21876

swig_obj[0] = args;

21877

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21878

if (!SWIG_IsOK(res1)) {

21879

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Undo" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21880

}

21881

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21882

{

21883

PyThreadState* __tstate = wxPyBeginAllowThreads();

21884

(arg1)->Undo();

21885

wxPyEndAllowThreads(__tstate);

21886

if (PyErr_Occurred()) SWIG_fail;

21887

}

21888

resultobj = SWIG_Py_Void();

21889

return resultobj;

21890

fail:

21891

return NULL;

21892

}

21893

21894

21895

SWIGINTERN PyObject *_wrap_RichTextCtrl_Redo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21896

PyObject *resultobj = 0;

21897

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21898

void *argp1 = 0 ;

21899

int res1 = 0 ;

21900

PyObject *swig_obj[1] ;

21901

21902

if (!args) SWIG_fail;

21903

swig_obj[0] = args;

21904

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21905

if (!SWIG_IsOK(res1)) {

21906

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Redo" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

21907

}

21908

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21909

{

21910

PyThreadState* __tstate = wxPyBeginAllowThreads();

21911

(arg1)->Redo();

21912

wxPyEndAllowThreads(__tstate);

21913

if (PyErr_Occurred()) SWIG_fail;

21914

}

21915

resultobj = SWIG_Py_Void();

21916

return resultobj;

21917

fail:

21918

return NULL;

21919

}

21920

21921

21922

SWIGINTERN PyObject *_wrap_RichTextCtrl_CanUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21923

PyObject *resultobj = 0;

21924

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21925

bool result;

21926

void *argp1 = 0 ;

21927

int res1 = 0 ;

21928

PyObject *swig_obj[1] ;

21929

21930

if (!args) SWIG_fail;

21931

swig_obj[0] = args;

21932

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21933

if (!SWIG_IsOK(res1)) {

21934

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CanUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21935

}

21936

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21937

{

21938

PyThreadState* __tstate = wxPyBeginAllowThreads();

21939

result = (bool)((wxRichTextCtrl const *)arg1)->CanUndo();

21940

wxPyEndAllowThreads(__tstate);

21941

if (PyErr_Occurred()) SWIG_fail;

21942

}

21943

{

21944

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21945

}

21946

return resultobj;

21947

fail:

21948

return NULL;

21949

}

21950

21951

21952

SWIGINTERN PyObject *_wrap_RichTextCtrl_CanRedo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

21953

PyObject *resultobj = 0;

21954

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21955

bool result;

21956

void *argp1 = 0 ;

21957

int res1 = 0 ;

21958

PyObject *swig_obj[1] ;

21959

21960

if (!args) SWIG_fail;

21961

swig_obj[0] = args;

21962

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21963

if (!SWIG_IsOK(res1)) {

21964

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CanRedo" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

21965

}

21966

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

21967

{

21968

PyThreadState* __tstate = wxPyBeginAllowThreads();

21969

result = (bool)((wxRichTextCtrl const *)arg1)->CanRedo();

21970

wxPyEndAllowThreads(__tstate);

21971

if (PyErr_Occurred()) SWIG_fail;

21972

}

21973

{

21974

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

21975

}

21976

return resultobj;

21977

fail:

21978

return NULL;

21979

}

21980

21981

21982

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetInsertionPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

21983

PyObject *resultobj = 0;

21984

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

21985

long arg2 ;

21986

void *argp1 = 0 ;

21987

int res1 = 0 ;

21988

long val2 ;

21989

int ecode2 = 0 ;

21990

PyObject * obj0 = 0 ;

21991

PyObject * obj1 = 0 ;

21992

char * kwnames[] = {

21993

(char *) "self",(char *) "pos", NULL

21994

};

21995

21996

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetInsertionPoint",kwnames,&obj0,&obj1)) SWIG_fail;

21997

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

21998

if (!SWIG_IsOK(res1)) {

21999

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetInsertionPoint" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22000

}

22001

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22002

ecode2 = SWIG_AsVal_long(obj1, &val2);

22003

if (!SWIG_IsOK(ecode2)) {

22004

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetInsertionPoint" "', expected argument " "2"" of type '" "long""'");

22005

}

22006

arg2 = static_cast< long >(val2);

22007

{

22008

PyThreadState* __tstate = wxPyBeginAllowThreads();

22009

(arg1)->SetInsertionPoint(arg2);

22010

wxPyEndAllowThreads(__tstate);

22011

if (PyErr_Occurred()) SWIG_fail;

22012

}

22013

resultobj = SWIG_Py_Void();

22014

return resultobj;

22015

fail:

22016

return NULL;

22017

}

22018

22019

22020

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetInsertionPointEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22021

PyObject *resultobj = 0;

22022

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22023

void *argp1 = 0 ;

22024

int res1 = 0 ;

22025

PyObject *swig_obj[1] ;

22026

22027

if (!args) SWIG_fail;

22028

swig_obj[0] = args;

22029

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22030

if (!SWIG_IsOK(res1)) {

22031

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetInsertionPointEnd" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22032

}

22033

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22034

{

22035

PyThreadState* __tstate = wxPyBeginAllowThreads();

22036

(arg1)->SetInsertionPointEnd();

22037

wxPyEndAllowThreads(__tstate);

22038

if (PyErr_Occurred()) SWIG_fail;

22039

}

22040

resultobj = SWIG_Py_Void();

22041

return resultobj;

22042

fail:

22043

return NULL;

22044

}

22045

22046

22047

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetInsertionPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22048

PyObject *resultobj = 0;

22049

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22050

long result;

22051

void *argp1 = 0 ;

22052

int res1 = 0 ;

22053

PyObject *swig_obj[1] ;

22054

22055

if (!args) SWIG_fail;

22056

swig_obj[0] = args;

22057

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22058

if (!SWIG_IsOK(res1)) {

22059

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetInsertionPoint" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

22060

}

22061

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22062

{

22063

PyThreadState* __tstate = wxPyBeginAllowThreads();

22064

result = (long)((wxRichTextCtrl const *)arg1)->GetInsertionPoint();

22065

wxPyEndAllowThreads(__tstate);

22066

if (PyErr_Occurred()) SWIG_fail;

22067

}

22068

resultobj = SWIG_From_long(static_cast< long >(result));

22069

return resultobj;

22070

fail:

22071

return NULL;

22072

}

22073

22074

22075

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetLastPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22076

PyObject *resultobj = 0;

22077

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22078

long result;

22079

void *argp1 = 0 ;

22080

int res1 = 0 ;

22081

PyObject *swig_obj[1] ;

22082

22083

if (!args) SWIG_fail;

22084

swig_obj[0] = args;

22085

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22086

if (!SWIG_IsOK(res1)) {

22087

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetLastPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

22088

}

22089

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22090

{

22091

PyThreadState* __tstate = wxPyBeginAllowThreads();

22092

result = (long)((wxRichTextCtrl const *)arg1)->GetLastPosition();

22093

wxPyEndAllowThreads(__tstate);

22094

if (PyErr_Occurred()) SWIG_fail;

22095

}

22096

resultobj = SWIG_From_long(static_cast< long >(result));

22097

return resultobj;

22098

fail:

22099

return NULL;

22100

}

22101

22102

22103

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22104

PyObject *resultobj = 0;

22105

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22106

long arg2 ;

22107

long arg3 ;

22108

void *argp1 = 0 ;

22109

int res1 = 0 ;

22110

long val2 ;

22111

int ecode2 = 0 ;

22112

long val3 ;

22113

int ecode3 = 0 ;

22114

PyObject * obj0 = 0 ;

22115

PyObject * obj1 = 0 ;

22116

PyObject * obj2 = 0 ;

22117

char * kwnames[] = {

22118

(char *) "self",(char *) "from",(char *) "to", NULL

22119

};

22120

22121

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_SetSelection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

22122

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22123

if (!SWIG_IsOK(res1)) {

22124

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22125

}

22126

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22127

ecode2 = SWIG_AsVal_long(obj1, &val2);

22128

if (!SWIG_IsOK(ecode2)) {

22129

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetSelection" "', expected argument " "2"" of type '" "long""'");

22130

}

22131

arg2 = static_cast< long >(val2);

22132

ecode3 = SWIG_AsVal_long(obj2, &val3);

22133

if (!SWIG_IsOK(ecode3)) {

22134

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SetSelection" "', expected argument " "3"" of type '" "long""'");

22135

}

22136

arg3 = static_cast< long >(val3);

22137

{

22138

PyThreadState* __tstate = wxPyBeginAllowThreads();

22139

(arg1)->SetSelection(arg2,arg3);

22140

wxPyEndAllowThreads(__tstate);

22141

if (PyErr_Occurred()) SWIG_fail;

22142

}

22143

resultobj = SWIG_Py_Void();

22144

return resultobj;

22145

fail:

22146

return NULL;

22147

}

22148

22149

22150

SWIGINTERN PyObject *_wrap_RichTextCtrl_SelectAll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22151

PyObject *resultobj = 0;

22152

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22153

void *argp1 = 0 ;

22154

int res1 = 0 ;

22155

PyObject *swig_obj[1] ;

22156

22157

if (!args) SWIG_fail;

22158

swig_obj[0] = args;

22159

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22160

if (!SWIG_IsOK(res1)) {

22161

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SelectAll" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22162

}

22163

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22164

{

22165

PyThreadState* __tstate = wxPyBeginAllowThreads();

22166

(arg1)->SelectAll();

22167

wxPyEndAllowThreads(__tstate);

22168

if (PyErr_Occurred()) SWIG_fail;

22169

}

22170

resultobj = SWIG_Py_Void();

22171

return resultobj;

22172

fail:

22173

return NULL;

22174

}

22175

22176

22177

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetEditable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22178

PyObject *resultobj = 0;

22179

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22180

bool arg2 ;

22181

void *argp1 = 0 ;

22182

int res1 = 0 ;

22183

bool val2 ;

22184

int ecode2 = 0 ;

22185

PyObject * obj0 = 0 ;

22186

PyObject * obj1 = 0 ;

22187

char * kwnames[] = {

22188

(char *) "self",(char *) "editable", NULL

22189

};

22190

22191

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetEditable",kwnames,&obj0,&obj1)) SWIG_fail;

22192

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22193

if (!SWIG_IsOK(res1)) {

22194

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetEditable" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22195

}

22196

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22197

ecode2 = SWIG_AsVal_bool(obj1, &val2);

22198

if (!SWIG_IsOK(ecode2)) {

22199

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetEditable" "', expected argument " "2"" of type '" "bool""'");

22200

}

22201

arg2 = static_cast< bool >(val2);

22202

{

22203

PyThreadState* __tstate = wxPyBeginAllowThreads();

22204

(arg1)->SetEditable(arg2);

22205

wxPyEndAllowThreads(__tstate);

22206

if (PyErr_Occurred()) SWIG_fail;

22207

}

22208

resultobj = SWIG_Py_Void();

22209

return resultobj;

22210

fail:

22211

return NULL;

22212

}

22213

22214

22215

SWIGINTERN PyObject *_wrap_RichTextCtrl_HasSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22216

PyObject *resultobj = 0;

22217

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22218

bool result;

22219

void *argp1 = 0 ;

22220

int res1 = 0 ;

22221

PyObject *swig_obj[1] ;

22222

22223

if (!args) SWIG_fail;

22224

swig_obj[0] = args;

22225

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22226

if (!SWIG_IsOK(res1)) {

22227

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_HasSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

22228

}

22229

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22230

{

22231

PyThreadState* __tstate = wxPyBeginAllowThreads();

22232

result = (bool)((wxRichTextCtrl const *)arg1)->HasSelection();

22233

wxPyEndAllowThreads(__tstate);

22234

if (PyErr_Occurred()) SWIG_fail;

22235

}

22236

{

22237

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22238

}

22239

return resultobj;

22240

fail:

22241

return NULL;

22242

}

22243

22244

22245

SWIGINTERN PyObject *_wrap_RichTextCtrl_WriteImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22246

PyObject *resultobj = 0;

22247

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22248

wxImage *arg2 = 0 ;

22249

int arg3 = (int) wxBITMAP_TYPE_PNG ;

22250

bool result;

22251

void *argp1 = 0 ;

22252

int res1 = 0 ;

22253

void *argp2 = 0 ;

22254

int res2 = 0 ;

22255

int val3 ;

22256

int ecode3 = 0 ;

22257

PyObject * obj0 = 0 ;

22258

PyObject * obj1 = 0 ;

22259

PyObject * obj2 = 0 ;

22260

char * kwnames[] = {

22261

(char *) "self",(char *) "image",(char *) "bitmapType", NULL

22262

};

22263

22264

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_WriteImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

22265

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22266

if (!SWIG_IsOK(res1)) {

22267

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WriteImage" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22268

}

22269

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22270

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);

22271

if (!SWIG_IsOK(res2)) {

22272

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_WriteImage" "', expected argument " "2"" of type '" "wxImage const &""'");

22273

}

22274

if (!argp2) {

22275

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_WriteImage" "', expected argument " "2"" of type '" "wxImage const &""'");

22276

}

22277

arg2 = reinterpret_cast< wxImage * >(argp2);

22278

if (obj2) {

22279

ecode3 = SWIG_AsVal_int(obj2, &val3);

22280

if (!SWIG_IsOK(ecode3)) {

22281

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_WriteImage" "', expected argument " "3"" of type '" "int""'");

22282

}

22283

arg3 = static_cast< int >(val3);

22284

}

22285

{

22286

PyThreadState* __tstate = wxPyBeginAllowThreads();

22287

result = (bool)(arg1)->WriteImage((wxImage const &)*arg2,arg3);

22288

wxPyEndAllowThreads(__tstate);

22289

if (PyErr_Occurred()) SWIG_fail;

22290

}

22291

{

22292

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22293

}

22294

return resultobj;

22295

fail:

22296

return NULL;

22297

}

22298

22299

22300

SWIGINTERN PyObject *_wrap_RichTextCtrl_WriteBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22301

PyObject *resultobj = 0;

22302

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22303

wxBitmap *arg2 = 0 ;

22304

int arg3 = (int) wxBITMAP_TYPE_PNG ;

22305

bool result;

22306

void *argp1 = 0 ;

22307

int res1 = 0 ;

22308

void *argp2 = 0 ;

22309

int res2 = 0 ;

22310

int val3 ;

22311

int ecode3 = 0 ;

22312

PyObject * obj0 = 0 ;

22313

PyObject * obj1 = 0 ;

22314

PyObject * obj2 = 0 ;

22315

char * kwnames[] = {

22316

(char *) "self",(char *) "bitmap",(char *) "bitmapType", NULL

22317

};

22318

22319

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_WriteBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

22320

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22321

if (!SWIG_IsOK(res1)) {

22322

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WriteBitmap" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22323

}

22324

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22325

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);

22326

if (!SWIG_IsOK(res2)) {

22327

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_WriteBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");

22328

}

22329

if (!argp2) {

22330

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_WriteBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");

22331

}

22332

arg2 = reinterpret_cast< wxBitmap * >(argp2);

22333

if (obj2) {

22334

ecode3 = SWIG_AsVal_int(obj2, &val3);

22335

if (!SWIG_IsOK(ecode3)) {

22336

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_WriteBitmap" "', expected argument " "3"" of type '" "int""'");

22337

}

22338

arg3 = static_cast< int >(val3);

22339

}

22340

{

22341

PyThreadState* __tstate = wxPyBeginAllowThreads();

22342

result = (bool)(arg1)->WriteImage((wxBitmap const &)*arg2,arg3);

22343

wxPyEndAllowThreads(__tstate);

22344

if (PyErr_Occurred()) SWIG_fail;

22345

}

22346

{

22347

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22348

}

22349

return resultobj;

22350

fail:

22351

return NULL;

22352

}

22353

22354

22355

SWIGINTERN PyObject *_wrap_RichTextCtrl_WriteImageFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22356

PyObject *resultobj = 0;

22357

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22358

wxString *arg2 = 0 ;

22359

int arg3 ;

22360

bool result;

22361

void *argp1 = 0 ;

22362

int res1 = 0 ;

22363

bool temp2 = false ;

22364

int val3 ;

22365

int ecode3 = 0 ;

22366

PyObject * obj0 = 0 ;

22367

PyObject * obj1 = 0 ;

22368

PyObject * obj2 = 0 ;

22369

char * kwnames[] = {

22370

(char *) "self",(char *) "filename",(char *) "bitmapType", NULL

22371

};

22372

22373

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_WriteImageFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

22374

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22375

if (!SWIG_IsOK(res1)) {

22376

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WriteImageFile" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22377

}

22378

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22379

{

22380

arg2 = wxString_in_helper(obj1);

22381

if (arg2 == NULL) SWIG_fail;

22382

temp2 = true;

22383

}

22384

ecode3 = SWIG_AsVal_int(obj2, &val3);

22385

if (!SWIG_IsOK(ecode3)) {

22386

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_WriteImageFile" "', expected argument " "3"" of type '" "int""'");

22387

}

22388

arg3 = static_cast< int >(val3);

22389

{

22390

PyThreadState* __tstate = wxPyBeginAllowThreads();

22391

result = (bool)(arg1)->WriteImage((wxString const &)*arg2,arg3);

22392

wxPyEndAllowThreads(__tstate);

22393

if (PyErr_Occurred()) SWIG_fail;

22394

}

22395

{

22396

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22397

}

22398

{

22399

if (temp2)

22400

delete arg2;

22401

}

22402

return resultobj;

22403

fail:

22404

{

22405

if (temp2)

22406

delete arg2;

22407

}

22408

return NULL;

22409

}

22410

22411

22412

SWIGINTERN PyObject *_wrap_RichTextCtrl_WriteImageBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22413

PyObject *resultobj = 0;

22414

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22415

wxRichTextImageBlock *arg2 = 0 ;

22416

bool result;

22417

void *argp1 = 0 ;

22418

int res1 = 0 ;

22419

void *argp2 = 0 ;

22420

int res2 = 0 ;

22421

PyObject * obj0 = 0 ;

22422

PyObject * obj1 = 0 ;

22423

char * kwnames[] = {

22424

(char *) "self",(char *) "imageBlock", NULL

22425

};

22426

22427

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_WriteImageBlock",kwnames,&obj0,&obj1)) SWIG_fail;

22428

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22429

if (!SWIG_IsOK(res1)) {

22430

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WriteImageBlock" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22431

}

22432

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22433

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextImageBlock, 0 | 0);

22434

if (!SWIG_IsOK(res2)) {

22435

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_WriteImageBlock" "', expected argument " "2"" of type '" "wxRichTextImageBlock const &""'");

22436

}

22437

if (!argp2) {

22438

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_WriteImageBlock" "', expected argument " "2"" of type '" "wxRichTextImageBlock const &""'");

22439

}

22440

arg2 = reinterpret_cast< wxRichTextImageBlock * >(argp2);

22441

{

22442

PyThreadState* __tstate = wxPyBeginAllowThreads();

22443

result = (bool)(arg1)->WriteImage((wxRichTextImageBlock const &)*arg2);

22444

wxPyEndAllowThreads(__tstate);

22445

if (PyErr_Occurred()) SWIG_fail;

22446

}

22447

{

22448

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22449

}

22450

return resultobj;

22451

fail:

22452

return NULL;

22453

}

22454

22455

22456

SWIGINTERN PyObject *_wrap_RichTextCtrl_Newline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22457

PyObject *resultobj = 0;

22458

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22459

bool result;

22460

void *argp1 = 0 ;

22461

int res1 = 0 ;

22462

PyObject *swig_obj[1] ;

22463

22464

if (!args) SWIG_fail;

22465

swig_obj[0] = args;

22466

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22467

if (!SWIG_IsOK(res1)) {

22468

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Newline" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22469

}

22470

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22471

{

22472

PyThreadState* __tstate = wxPyBeginAllowThreads();

22473

result = (bool)(arg1)->Newline();

22474

wxPyEndAllowThreads(__tstate);

22475

if (PyErr_Occurred()) SWIG_fail;

22476

}

22477

{

22478

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22479

}

22480

return resultobj;

22481

fail:

22482

return NULL;

22483

}

22484

22485

22486

SWIGINTERN PyObject *_wrap_RichTextCtrl_LineBreak(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22487

PyObject *resultobj = 0;

22488

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22489

bool result;

22490

void *argp1 = 0 ;

22491

int res1 = 0 ;

22492

PyObject *swig_obj[1] ;

22493

22494

if (!args) SWIG_fail;

22495

swig_obj[0] = args;

22496

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22497

if (!SWIG_IsOK(res1)) {

22498

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_LineBreak" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22499

}

22500

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22501

{

22502

PyThreadState* __tstate = wxPyBeginAllowThreads();

22503

result = (bool)(arg1)->LineBreak();

22504

wxPyEndAllowThreads(__tstate);

22505

if (PyErr_Occurred()) SWIG_fail;

22506

}

22507

{

22508

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22509

}

22510

return resultobj;

22511

fail:

22512

return NULL;

22513

}

22514

22515

22516

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetBasicStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22517

PyObject *resultobj = 0;

22518

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22519

wxTextAttrEx *arg2 = 0 ;

22520

void *argp1 = 0 ;

22521

int res1 = 0 ;

22522

void *argp2 = 0 ;

22523

int res2 = 0 ;

22524

PyObject * obj0 = 0 ;

22525

PyObject * obj1 = 0 ;

22526

char * kwnames[] = {

22527

(char *) "self",(char *) "style", NULL

22528

};

22529

22530

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetBasicStyle",kwnames,&obj0,&obj1)) SWIG_fail;

22531

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22532

if (!SWIG_IsOK(res1)) {

22533

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetBasicStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22534

}

22535

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22536

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

22537

if (!SWIG_IsOK(res2)) {

22538

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetBasicStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

22539

}

22540

if (!argp2) {

22541

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetBasicStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

22542

}

22543

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

22544

{

22545

PyThreadState* __tstate = wxPyBeginAllowThreads();

22546

(arg1)->SetBasicStyle((wxTextAttrEx const &)*arg2);

22547

wxPyEndAllowThreads(__tstate);

22548

if (PyErr_Occurred()) SWIG_fail;

22549

}

22550

resultobj = SWIG_Py_Void();

22551

return resultobj;

22552

fail:

22553

return NULL;

22554

}

22555

22556

22557

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetBasicStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22558

PyObject *resultobj = 0;

22559

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22560

wxTextAttrEx result;

22561

void *argp1 = 0 ;

22562

int res1 = 0 ;

22563

PyObject *swig_obj[1] ;

22564

22565

if (!args) SWIG_fail;

22566

swig_obj[0] = args;

22567

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22568

if (!SWIG_IsOK(res1)) {

22569

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetBasicStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

22570

}

22571

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22572

{

22573

PyThreadState* __tstate = wxPyBeginAllowThreads();

22574

result = ((wxRichTextCtrl const *)arg1)->GetBasicStyle();

22575

wxPyEndAllowThreads(__tstate);

22576

if (PyErr_Occurred()) SWIG_fail;

22577

}

22578

resultobj = SWIG_NewPointerObj((new wxTextAttrEx(static_cast< const wxTextAttrEx& >(result))), SWIGTYPE_p_wxTextAttrEx, SWIG_POINTER_OWN | 0 );

22579

return resultobj;

22580

fail:

22581

return NULL;

22582

}

22583

22584

22585

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22586

PyObject *resultobj = 0;

22587

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22588

wxTextAttrEx *arg2 = 0 ;

22589

bool result;

22590

void *argp1 = 0 ;

22591

int res1 = 0 ;

22592

void *argp2 = 0 ;

22593

int res2 = 0 ;

22594

PyObject * obj0 = 0 ;

22595

PyObject * obj1 = 0 ;

22596

char * kwnames[] = {

22597

(char *) "self",(char *) "style", NULL

22598

};

22599

22600

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginStyle",kwnames,&obj0,&obj1)) SWIG_fail;

22601

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22602

if (!SWIG_IsOK(res1)) {

22603

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22604

}

22605

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22606

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

22607

if (!SWIG_IsOK(res2)) {

22608

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_BeginStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

22609

}

22610

if (!argp2) {

22611

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_BeginStyle" "', expected argument " "2"" of type '" "wxTextAttrEx const &""'");

22612

}

22613

arg2 = reinterpret_cast< wxTextAttrEx * >(argp2);

22614

{

22615

PyThreadState* __tstate = wxPyBeginAllowThreads();

22616

result = (bool)(arg1)->BeginStyle((wxTextAttrEx const &)*arg2);

22617

wxPyEndAllowThreads(__tstate);

22618

if (PyErr_Occurred()) SWIG_fail;

22619

}

22620

{

22621

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22622

}

22623

return resultobj;

22624

fail:

22625

return NULL;

22626

}

22627

22628

22629

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22630

PyObject *resultobj = 0;

22631

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22632

bool result;

22633

void *argp1 = 0 ;

22634

int res1 = 0 ;

22635

PyObject *swig_obj[1] ;

22636

22637

if (!args) SWIG_fail;

22638

swig_obj[0] = args;

22639

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22640

if (!SWIG_IsOK(res1)) {

22641

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22642

}

22643

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22644

{

22645

PyThreadState* __tstate = wxPyBeginAllowThreads();

22646

result = (bool)(arg1)->EndStyle();

22647

wxPyEndAllowThreads(__tstate);

22648

if (PyErr_Occurred()) SWIG_fail;

22649

}

22650

{

22651

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22652

}

22653

return resultobj;

22654

fail:

22655

return NULL;

22656

}

22657

22658

22659

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndAllStyles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22660

PyObject *resultobj = 0;

22661

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22662

bool result;

22663

void *argp1 = 0 ;

22664

int res1 = 0 ;

22665

PyObject *swig_obj[1] ;

22666

22667

if (!args) SWIG_fail;

22668

swig_obj[0] = args;

22669

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22670

if (!SWIG_IsOK(res1)) {

22671

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndAllStyles" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22672

}

22673

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22674

{

22675

PyThreadState* __tstate = wxPyBeginAllowThreads();

22676

result = (bool)(arg1)->EndAllStyles();

22677

wxPyEndAllowThreads(__tstate);

22678

if (PyErr_Occurred()) SWIG_fail;

22679

}

22680

{

22681

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22682

}

22683

return resultobj;

22684

fail:

22685

return NULL;

22686

}

22687

22688

22689

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22690

PyObject *resultobj = 0;

22691

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22692

bool result;

22693

void *argp1 = 0 ;

22694

int res1 = 0 ;

22695

PyObject *swig_obj[1] ;

22696

22697

if (!args) SWIG_fail;

22698

swig_obj[0] = args;

22699

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22700

if (!SWIG_IsOK(res1)) {

22701

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginBold" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22702

}

22703

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22704

{

22705

PyThreadState* __tstate = wxPyBeginAllowThreads();

22706

result = (bool)(arg1)->BeginBold();

22707

wxPyEndAllowThreads(__tstate);

22708

if (PyErr_Occurred()) SWIG_fail;

22709

}

22710

{

22711

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22712

}

22713

return resultobj;

22714

fail:

22715

return NULL;

22716

}

22717

22718

22719

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22720

PyObject *resultobj = 0;

22721

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22722

bool result;

22723

void *argp1 = 0 ;

22724

int res1 = 0 ;

22725

PyObject *swig_obj[1] ;

22726

22727

if (!args) SWIG_fail;

22728

swig_obj[0] = args;

22729

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22730

if (!SWIG_IsOK(res1)) {

22731

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndBold" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22732

}

22733

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22734

{

22735

PyThreadState* __tstate = wxPyBeginAllowThreads();

22736

result = (bool)(arg1)->EndBold();

22737

wxPyEndAllowThreads(__tstate);

22738

if (PyErr_Occurred()) SWIG_fail;

22739

}

22740

{

22741

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22742

}

22743

return resultobj;

22744

fail:

22745

return NULL;

22746

}

22747

22748

22749

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginItalic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22750

PyObject *resultobj = 0;

22751

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22752

bool result;

22753

void *argp1 = 0 ;

22754

int res1 = 0 ;

22755

PyObject *swig_obj[1] ;

22756

22757

if (!args) SWIG_fail;

22758

swig_obj[0] = args;

22759

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22760

if (!SWIG_IsOK(res1)) {

22761

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginItalic" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22762

}

22763

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22764

{

22765

PyThreadState* __tstate = wxPyBeginAllowThreads();

22766

result = (bool)(arg1)->BeginItalic();

22767

wxPyEndAllowThreads(__tstate);

22768

if (PyErr_Occurred()) SWIG_fail;

22769

}

22770

{

22771

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22772

}

22773

return resultobj;

22774

fail:

22775

return NULL;

22776

}

22777

22778

22779

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndItalic(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22780

PyObject *resultobj = 0;

22781

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22782

bool result;

22783

void *argp1 = 0 ;

22784

int res1 = 0 ;

22785

PyObject *swig_obj[1] ;

22786

22787

if (!args) SWIG_fail;

22788

swig_obj[0] = args;

22789

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22790

if (!SWIG_IsOK(res1)) {

22791

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndItalic" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22792

}

22793

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22794

{

22795

PyThreadState* __tstate = wxPyBeginAllowThreads();

22796

result = (bool)(arg1)->EndItalic();

22797

wxPyEndAllowThreads(__tstate);

22798

if (PyErr_Occurred()) SWIG_fail;

22799

}

22800

{

22801

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22802

}

22803

return resultobj;

22804

fail:

22805

return NULL;

22806

}

22807

22808

22809

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginUnderline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22810

PyObject *resultobj = 0;

22811

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22812

bool result;

22813

void *argp1 = 0 ;

22814

int res1 = 0 ;

22815

PyObject *swig_obj[1] ;

22816

22817

if (!args) SWIG_fail;

22818

swig_obj[0] = args;

22819

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22820

if (!SWIG_IsOK(res1)) {

22821

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginUnderline" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22822

}

22823

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22824

{

22825

PyThreadState* __tstate = wxPyBeginAllowThreads();

22826

result = (bool)(arg1)->BeginUnderline();

22827

wxPyEndAllowThreads(__tstate);

22828

if (PyErr_Occurred()) SWIG_fail;

22829

}

22830

{

22831

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22832

}

22833

return resultobj;

22834

fail:

22835

return NULL;

22836

}

22837

22838

22839

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndUnderline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22840

PyObject *resultobj = 0;

22841

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22842

bool result;

22843

void *argp1 = 0 ;

22844

int res1 = 0 ;

22845

PyObject *swig_obj[1] ;

22846

22847

if (!args) SWIG_fail;

22848

swig_obj[0] = args;

22849

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22850

if (!SWIG_IsOK(res1)) {

22851

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndUnderline" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22852

}

22853

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22854

{

22855

PyThreadState* __tstate = wxPyBeginAllowThreads();

22856

result = (bool)(arg1)->EndUnderline();

22857

wxPyEndAllowThreads(__tstate);

22858

if (PyErr_Occurred()) SWIG_fail;

22859

}

22860

{

22861

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22862

}

22863

return resultobj;

22864

fail:

22865

return NULL;

22866

}

22867

22868

22869

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22870

PyObject *resultobj = 0;

22871

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22872

int arg2 ;

22873

bool result;

22874

void *argp1 = 0 ;

22875

int res1 = 0 ;

22876

int val2 ;

22877

int ecode2 = 0 ;

22878

PyObject * obj0 = 0 ;

22879

PyObject * obj1 = 0 ;

22880

char * kwnames[] = {

22881

(char *) "self",(char *) "pointSize", NULL

22882

};

22883

22884

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginFontSize",kwnames,&obj0,&obj1)) SWIG_fail;

22885

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22886

if (!SWIG_IsOK(res1)) {

22887

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginFontSize" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22888

}

22889

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22890

ecode2 = SWIG_AsVal_int(obj1, &val2);

22891

if (!SWIG_IsOK(ecode2)) {

22892

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginFontSize" "', expected argument " "2"" of type '" "int""'");

22893

}

22894

arg2 = static_cast< int >(val2);

22895

{

22896

PyThreadState* __tstate = wxPyBeginAllowThreads();

22897

result = (bool)(arg1)->BeginFontSize(arg2);

22898

wxPyEndAllowThreads(__tstate);

22899

if (PyErr_Occurred()) SWIG_fail;

22900

}

22901

{

22902

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22903

}

22904

return resultobj;

22905

fail:

22906

return NULL;

22907

}

22908

22909

22910

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndFontSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22911

PyObject *resultobj = 0;

22912

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22913

bool result;

22914

void *argp1 = 0 ;

22915

int res1 = 0 ;

22916

PyObject *swig_obj[1] ;

22917

22918

if (!args) SWIG_fail;

22919

swig_obj[0] = args;

22920

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22921

if (!SWIG_IsOK(res1)) {

22922

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndFontSize" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22923

}

22924

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22925

{

22926

PyThreadState* __tstate = wxPyBeginAllowThreads();

22927

result = (bool)(arg1)->EndFontSize();

22928

wxPyEndAllowThreads(__tstate);

22929

if (PyErr_Occurred()) SWIG_fail;

22930

}

22931

{

22932

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22933

}

22934

return resultobj;

22935

fail:

22936

return NULL;

22937

}

22938

22939

22940

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

22941

PyObject *resultobj = 0;

22942

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22943

wxFont *arg2 = 0 ;

22944

bool result;

22945

void *argp1 = 0 ;

22946

int res1 = 0 ;

22947

void *argp2 = 0 ;

22948

int res2 = 0 ;

22949

PyObject * obj0 = 0 ;

22950

PyObject * obj1 = 0 ;

22951

char * kwnames[] = {

22952

(char *) "self",(char *) "font", NULL

22953

};

22954

22955

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginFont",kwnames,&obj0,&obj1)) SWIG_fail;

22956

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22957

if (!SWIG_IsOK(res1)) {

22958

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginFont" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22959

}

22960

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22961

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);

22962

if (!SWIG_IsOK(res2)) {

22963

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_BeginFont" "', expected argument " "2"" of type '" "wxFont const &""'");

22964

}

22965

if (!argp2) {

22966

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_BeginFont" "', expected argument " "2"" of type '" "wxFont const &""'");

22967

}

22968

arg2 = reinterpret_cast< wxFont * >(argp2);

22969

{

22970

PyThreadState* __tstate = wxPyBeginAllowThreads();

22971

result = (bool)(arg1)->BeginFont((wxFont const &)*arg2);

22972

wxPyEndAllowThreads(__tstate);

22973

if (PyErr_Occurred()) SWIG_fail;

22974

}

22975

{

22976

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

22977

}

22978

return resultobj;

22979

fail:

22980

return NULL;

22981

}

22982

22983

22984

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

22985

PyObject *resultobj = 0;

22986

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

22987

bool result;

22988

void *argp1 = 0 ;

22989

int res1 = 0 ;

22990

PyObject *swig_obj[1] ;

22991

22992

if (!args) SWIG_fail;

22993

swig_obj[0] = args;

22994

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

22995

if (!SWIG_IsOK(res1)) {

22996

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndFont" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

22997

}

22998

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

22999

{

23000

PyThreadState* __tstate = wxPyBeginAllowThreads();

23001

result = (bool)(arg1)->EndFont();

23002

wxPyEndAllowThreads(__tstate);

23003

if (PyErr_Occurred()) SWIG_fail;

23004

}

23005

{

23006

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23007

}

23008

return resultobj;

23009

fail:

23010

return NULL;

23011

}

23012

23013

23014

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23015

PyObject *resultobj = 0;

23016

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23017

wxColour *arg2 = 0 ;

23018

bool result;

23019

void *argp1 = 0 ;

23020

int res1 = 0 ;

23021

wxColour temp2 ;

23022

PyObject * obj0 = 0 ;

23023

PyObject * obj1 = 0 ;

23024

char * kwnames[] = {

23025

(char *) "self",(char *) "colour", NULL

23026

};

23027

23028

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginTextColour",kwnames,&obj0,&obj1)) SWIG_fail;

23029

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23030

if (!SWIG_IsOK(res1)) {

23031

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginTextColour" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23032

}

23033

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23034

{

23035

arg2 = &temp2;

23036

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

23037

}

23038

{

23039

PyThreadState* __tstate = wxPyBeginAllowThreads();

23040

result = (bool)(arg1)->BeginTextColour((wxColour const &)*arg2);

23041

wxPyEndAllowThreads(__tstate);

23042

if (PyErr_Occurred()) SWIG_fail;

23043

}

23044

{

23045

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23046

}

23047

return resultobj;

23048

fail:

23049

return NULL;

23050

}

23051

23052

23053

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23054

PyObject *resultobj = 0;

23055

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23056

bool result;

23057

void *argp1 = 0 ;

23058

int res1 = 0 ;

23059

PyObject *swig_obj[1] ;

23060

23061

if (!args) SWIG_fail;

23062

swig_obj[0] = args;

23063

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23064

if (!SWIG_IsOK(res1)) {

23065

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndTextColour" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23066

}

23067

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23068

{

23069

PyThreadState* __tstate = wxPyBeginAllowThreads();

23070

result = (bool)(arg1)->EndTextColour();

23071

wxPyEndAllowThreads(__tstate);

23072

if (PyErr_Occurred()) SWIG_fail;

23073

}

23074

{

23075

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23076

}

23077

return resultobj;

23078

fail:

23079

return NULL;

23080

}

23081

23082

23083

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23084

PyObject *resultobj = 0;

23085

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23086

wxTextAttrAlignment arg2 ;

23087

bool result;

23088

void *argp1 = 0 ;

23089

int res1 = 0 ;

23090

int val2 ;

23091

int ecode2 = 0 ;

23092

PyObject * obj0 = 0 ;

23093

PyObject * obj1 = 0 ;

23094

char * kwnames[] = {

23095

(char *) "self",(char *) "alignment", NULL

23096

};

23097

23098

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginAlignment",kwnames,&obj0,&obj1)) SWIG_fail;

23099

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23100

if (!SWIG_IsOK(res1)) {

23101

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginAlignment" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23102

}

23103

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23104

ecode2 = SWIG_AsVal_int(obj1, &val2);

23105

if (!SWIG_IsOK(ecode2)) {

23106

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginAlignment" "', expected argument " "2"" of type '" "wxTextAttrAlignment""'");

23107

}

23108

arg2 = static_cast< wxTextAttrAlignment >(val2);

23109

{

23110

PyThreadState* __tstate = wxPyBeginAllowThreads();

23111

result = (bool)(arg1)->BeginAlignment(arg2);

23112

wxPyEndAllowThreads(__tstate);

23113

if (PyErr_Occurred()) SWIG_fail;

23114

}

23115

{

23116

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23117

}

23118

return resultobj;

23119

fail:

23120

return NULL;

23121

}

23122

23123

23124

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23125

PyObject *resultobj = 0;

23126

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23127

bool result;

23128

void *argp1 = 0 ;

23129

int res1 = 0 ;

23130

PyObject *swig_obj[1] ;

23131

23132

if (!args) SWIG_fail;

23133

swig_obj[0] = args;

23134

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23135

if (!SWIG_IsOK(res1)) {

23136

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndAlignment" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23137

}

23138

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23139

{

23140

PyThreadState* __tstate = wxPyBeginAllowThreads();

23141

result = (bool)(arg1)->EndAlignment();

23142

wxPyEndAllowThreads(__tstate);

23143

if (PyErr_Occurred()) SWIG_fail;

23144

}

23145

{

23146

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23147

}

23148

return resultobj;

23149

fail:

23150

return NULL;

23151

}

23152

23153

23154

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23155

PyObject *resultobj = 0;

23156

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23157

int arg2 ;

23158

int arg3 = (int) 0 ;

23159

bool result;

23160

void *argp1 = 0 ;

23161

int res1 = 0 ;

23162

int val2 ;

23163

int ecode2 = 0 ;

23164

int val3 ;

23165

int ecode3 = 0 ;

23166

PyObject * obj0 = 0 ;

23167

PyObject * obj1 = 0 ;

23168

PyObject * obj2 = 0 ;

23169

char * kwnames[] = {

23170

(char *) "self",(char *) "leftIndent",(char *) "leftSubIndent", NULL

23171

};

23172

23173

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_BeginLeftIndent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

23174

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23175

if (!SWIG_IsOK(res1)) {

23176

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginLeftIndent" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23177

}

23178

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23179

ecode2 = SWIG_AsVal_int(obj1, &val2);

23180

if (!SWIG_IsOK(ecode2)) {

23181

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginLeftIndent" "', expected argument " "2"" of type '" "int""'");

23182

}

23183

arg2 = static_cast< int >(val2);

23184

if (obj2) {

23185

ecode3 = SWIG_AsVal_int(obj2, &val3);

23186

if (!SWIG_IsOK(ecode3)) {

23187

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginLeftIndent" "', expected argument " "3"" of type '" "int""'");

23188

}

23189

arg3 = static_cast< int >(val3);

23190

}

23191

{

23192

PyThreadState* __tstate = wxPyBeginAllowThreads();

23193

result = (bool)(arg1)->BeginLeftIndent(arg2,arg3);

23194

wxPyEndAllowThreads(__tstate);

23195

if (PyErr_Occurred()) SWIG_fail;

23196

}

23197

{

23198

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23199

}

23200

return resultobj;

23201

fail:

23202

return NULL;

23203

}

23204

23205

23206

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndLeftIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23207

PyObject *resultobj = 0;

23208

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23209

bool result;

23210

void *argp1 = 0 ;

23211

int res1 = 0 ;

23212

PyObject *swig_obj[1] ;

23213

23214

if (!args) SWIG_fail;

23215

swig_obj[0] = args;

23216

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23217

if (!SWIG_IsOK(res1)) {

23218

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndLeftIndent" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23219

}

23220

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23221

{

23222

PyThreadState* __tstate = wxPyBeginAllowThreads();

23223

result = (bool)(arg1)->EndLeftIndent();

23224

wxPyEndAllowThreads(__tstate);

23225

if (PyErr_Occurred()) SWIG_fail;

23226

}

23227

{

23228

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23229

}

23230

return resultobj;

23231

fail:

23232

return NULL;

23233

}

23234

23235

23236

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23237

PyObject *resultobj = 0;

23238

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23239

int arg2 ;

23240

bool result;

23241

void *argp1 = 0 ;

23242

int res1 = 0 ;

23243

int val2 ;

23244

int ecode2 = 0 ;

23245

PyObject * obj0 = 0 ;

23246

PyObject * obj1 = 0 ;

23247

char * kwnames[] = {

23248

(char *) "self",(char *) "rightIndent", NULL

23249

};

23250

23251

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginRightIndent",kwnames,&obj0,&obj1)) SWIG_fail;

23252

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23253

if (!SWIG_IsOK(res1)) {

23254

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginRightIndent" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23255

}

23256

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23257

ecode2 = SWIG_AsVal_int(obj1, &val2);

23258

if (!SWIG_IsOK(ecode2)) {

23259

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginRightIndent" "', expected argument " "2"" of type '" "int""'");

23260

}

23261

arg2 = static_cast< int >(val2);

23262

{

23263

PyThreadState* __tstate = wxPyBeginAllowThreads();

23264

result = (bool)(arg1)->BeginRightIndent(arg2);

23265

wxPyEndAllowThreads(__tstate);

23266

if (PyErr_Occurred()) SWIG_fail;

23267

}

23268

{

23269

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23270

}

23271

return resultobj;

23272

fail:

23273

return NULL;

23274

}

23275

23276

23277

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndRightIndent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23278

PyObject *resultobj = 0;

23279

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23280

bool result;

23281

void *argp1 = 0 ;

23282

int res1 = 0 ;

23283

PyObject *swig_obj[1] ;

23284

23285

if (!args) SWIG_fail;

23286

swig_obj[0] = args;

23287

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23288

if (!SWIG_IsOK(res1)) {

23289

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndRightIndent" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23290

}

23291

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23292

{

23293

PyThreadState* __tstate = wxPyBeginAllowThreads();

23294

result = (bool)(arg1)->EndRightIndent();

23295

wxPyEndAllowThreads(__tstate);

23296

if (PyErr_Occurred()) SWIG_fail;

23297

}

23298

{

23299

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23300

}

23301

return resultobj;

23302

fail:

23303

return NULL;

23304

}

23305

23306

23307

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginParagraphSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23308

PyObject *resultobj = 0;

23309

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23310

int arg2 ;

23311

int arg3 ;

23312

bool result;

23313

void *argp1 = 0 ;

23314

int res1 = 0 ;

23315

int val2 ;

23316

int ecode2 = 0 ;

23317

int val3 ;

23318

int ecode3 = 0 ;

23319

PyObject * obj0 = 0 ;

23320

PyObject * obj1 = 0 ;

23321

PyObject * obj2 = 0 ;

23322

char * kwnames[] = {

23323

(char *) "self",(char *) "before",(char *) "after", NULL

23324

};

23325

23326

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_BeginParagraphSpacing",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

23327

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23328

if (!SWIG_IsOK(res1)) {

23329

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginParagraphSpacing" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23330

}

23331

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23332

ecode2 = SWIG_AsVal_int(obj1, &val2);

23333

if (!SWIG_IsOK(ecode2)) {

23334

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginParagraphSpacing" "', expected argument " "2"" of type '" "int""'");

23335

}

23336

arg2 = static_cast< int >(val2);

23337

ecode3 = SWIG_AsVal_int(obj2, &val3);

23338

if (!SWIG_IsOK(ecode3)) {

23339

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginParagraphSpacing" "', expected argument " "3"" of type '" "int""'");

23340

}

23341

arg3 = static_cast< int >(val3);

23342

{

23343

PyThreadState* __tstate = wxPyBeginAllowThreads();

23344

result = (bool)(arg1)->BeginParagraphSpacing(arg2,arg3);

23345

wxPyEndAllowThreads(__tstate);

23346

if (PyErr_Occurred()) SWIG_fail;

23347

}

23348

{

23349

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23350

}

23351

return resultobj;

23352

fail:

23353

return NULL;

23354

}

23355

23356

23357

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndParagraphSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23358

PyObject *resultobj = 0;

23359

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23360

bool result;

23361

void *argp1 = 0 ;

23362

int res1 = 0 ;

23363

PyObject *swig_obj[1] ;

23364

23365

if (!args) SWIG_fail;

23366

swig_obj[0] = args;

23367

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23368

if (!SWIG_IsOK(res1)) {

23369

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndParagraphSpacing" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23370

}

23371

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23372

{

23373

PyThreadState* __tstate = wxPyBeginAllowThreads();

23374

result = (bool)(arg1)->EndParagraphSpacing();

23375

wxPyEndAllowThreads(__tstate);

23376

if (PyErr_Occurred()) SWIG_fail;

23377

}

23378

{

23379

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23380

}

23381

return resultobj;

23382

fail:

23383

return NULL;

23384

}

23385

23386

23387

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23388

PyObject *resultobj = 0;

23389

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23390

int arg2 ;

23391

bool result;

23392

void *argp1 = 0 ;

23393

int res1 = 0 ;

23394

int val2 ;

23395

int ecode2 = 0 ;

23396

PyObject * obj0 = 0 ;

23397

PyObject * obj1 = 0 ;

23398

char * kwnames[] = {

23399

(char *) "self",(char *) "lineSpacing", NULL

23400

};

23401

23402

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginLineSpacing",kwnames,&obj0,&obj1)) SWIG_fail;

23403

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23404

if (!SWIG_IsOK(res1)) {

23405

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginLineSpacing" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23406

}

23407

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23408

ecode2 = SWIG_AsVal_int(obj1, &val2);

23409

if (!SWIG_IsOK(ecode2)) {

23410

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginLineSpacing" "', expected argument " "2"" of type '" "int""'");

23411

}

23412

arg2 = static_cast< int >(val2);

23413

{

23414

PyThreadState* __tstate = wxPyBeginAllowThreads();

23415

result = (bool)(arg1)->BeginLineSpacing(arg2);

23416

wxPyEndAllowThreads(__tstate);

23417

if (PyErr_Occurred()) SWIG_fail;

23418

}

23419

{

23420

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23421

}

23422

return resultobj;

23423

fail:

23424

return NULL;

23425

}

23426

23427

23428

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndLineSpacing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23429

PyObject *resultobj = 0;

23430

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23431

bool result;

23432

void *argp1 = 0 ;

23433

int res1 = 0 ;

23434

PyObject *swig_obj[1] ;

23435

23436

if (!args) SWIG_fail;

23437

swig_obj[0] = args;

23438

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23439

if (!SWIG_IsOK(res1)) {

23440

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndLineSpacing" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23441

}

23442

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23443

{

23444

PyThreadState* __tstate = wxPyBeginAllowThreads();

23445

result = (bool)(arg1)->EndLineSpacing();

23446

wxPyEndAllowThreads(__tstate);

23447

if (PyErr_Occurred()) SWIG_fail;

23448

}

23449

{

23450

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23451

}

23452

return resultobj;

23453

fail:

23454

return NULL;

23455

}

23456

23457

23458

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginNumberedBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23459

PyObject *resultobj = 0;

23460

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23461

int arg2 ;

23462

int arg3 ;

23463

int arg4 ;

23464

int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD ;

23465

bool result;

23466

void *argp1 = 0 ;

23467

int res1 = 0 ;

23468

int val2 ;

23469

int ecode2 = 0 ;

23470

int val3 ;

23471

int ecode3 = 0 ;

23472

int val4 ;

23473

int ecode4 = 0 ;

23474

int val5 ;

23475

int ecode5 = 0 ;

23476

PyObject * obj0 = 0 ;

23477

PyObject * obj1 = 0 ;

23478

PyObject * obj2 = 0 ;

23479

PyObject * obj3 = 0 ;

23480

PyObject * obj4 = 0 ;

23481

char * kwnames[] = {

23482

(char *) "self",(char *) "bulletNumber",(char *) "leftIndent",(char *) "leftSubIndent",(char *) "bulletStyle", NULL

23483

};

23484

23485

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextCtrl_BeginNumberedBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

23486

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23487

if (!SWIG_IsOK(res1)) {

23488

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginNumberedBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23489

}

23490

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23491

ecode2 = SWIG_AsVal_int(obj1, &val2);

23492

if (!SWIG_IsOK(ecode2)) {

23493

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginNumberedBullet" "', expected argument " "2"" of type '" "int""'");

23494

}

23495

arg2 = static_cast< int >(val2);

23496

ecode3 = SWIG_AsVal_int(obj2, &val3);

23497

if (!SWIG_IsOK(ecode3)) {

23498

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginNumberedBullet" "', expected argument " "3"" of type '" "int""'");

23499

}

23500

arg3 = static_cast< int >(val3);

23501

ecode4 = SWIG_AsVal_int(obj3, &val4);

23502

if (!SWIG_IsOK(ecode4)) {

23503

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_BeginNumberedBullet" "', expected argument " "4"" of type '" "int""'");

23504

}

23505

arg4 = static_cast< int >(val4);

23506

if (obj4) {

23507

ecode5 = SWIG_AsVal_int(obj4, &val5);

23508

if (!SWIG_IsOK(ecode5)) {

23509

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_BeginNumberedBullet" "', expected argument " "5"" of type '" "int""'");

23510

}

23511

arg5 = static_cast< int >(val5);

23512

}

23513

{

23514

PyThreadState* __tstate = wxPyBeginAllowThreads();

23515

result = (bool)(arg1)->BeginNumberedBullet(arg2,arg3,arg4,arg5);

23516

wxPyEndAllowThreads(__tstate);

23517

if (PyErr_Occurred()) SWIG_fail;

23518

}

23519

{

23520

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23521

}

23522

return resultobj;

23523

fail:

23524

return NULL;

23525

}

23526

23527

23528

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndNumberedBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23529

PyObject *resultobj = 0;

23530

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23531

bool result;

23532

void *argp1 = 0 ;

23533

int res1 = 0 ;

23534

PyObject *swig_obj[1] ;

23535

23536

if (!args) SWIG_fail;

23537

swig_obj[0] = args;

23538

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23539

if (!SWIG_IsOK(res1)) {

23540

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndNumberedBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23541

}

23542

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23543

{

23544

PyThreadState* __tstate = wxPyBeginAllowThreads();

23545

result = (bool)(arg1)->EndNumberedBullet();

23546

wxPyEndAllowThreads(__tstate);

23547

if (PyErr_Occurred()) SWIG_fail;

23548

}

23549

{

23550

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23551

}

23552

return resultobj;

23553

fail:

23554

return NULL;

23555

}

23556

23557

23558

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginSymbolBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23559

PyObject *resultobj = 0;

23560

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23561

wxString *arg2 = 0 ;

23562

int arg3 ;

23563

int arg4 ;

23564

int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_SYMBOL ;

23565

bool result;

23566

void *argp1 = 0 ;

23567

int res1 = 0 ;

23568

bool temp2 = false ;

23569

int val3 ;

23570

int ecode3 = 0 ;

23571

int val4 ;

23572

int ecode4 = 0 ;

23573

int val5 ;

23574

int ecode5 = 0 ;

23575

PyObject * obj0 = 0 ;

23576

PyObject * obj1 = 0 ;

23577

PyObject * obj2 = 0 ;

23578

PyObject * obj3 = 0 ;

23579

PyObject * obj4 = 0 ;

23580

char * kwnames[] = {

23581

(char *) "self",(char *) "symbol",(char *) "leftIndent",(char *) "leftSubIndent",(char *) "bulletStyle", NULL

23582

};

23583

23584

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextCtrl_BeginSymbolBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

23585

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23586

if (!SWIG_IsOK(res1)) {

23587

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23588

}

23589

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23590

{

23591

arg2 = wxString_in_helper(obj1);

23592

if (arg2 == NULL) SWIG_fail;

23593

temp2 = true;

23594

}

23595

ecode3 = SWIG_AsVal_int(obj2, &val3);

23596

if (!SWIG_IsOK(ecode3)) {

23597

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "3"" of type '" "int""'");

23598

}

23599

arg3 = static_cast< int >(val3);

23600

ecode4 = SWIG_AsVal_int(obj3, &val4);

23601

if (!SWIG_IsOK(ecode4)) {

23602

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "4"" of type '" "int""'");

23603

}

23604

arg4 = static_cast< int >(val4);

23605

if (obj4) {

23606

ecode5 = SWIG_AsVal_int(obj4, &val5);

23607

if (!SWIG_IsOK(ecode5)) {

23608

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "5"" of type '" "int""'");

23609

}

23610

arg5 = static_cast< int >(val5);

23611

}

23612

{

23613

PyThreadState* __tstate = wxPyBeginAllowThreads();

23614

result = (bool)(arg1)->BeginSymbolBullet((wxString const &)*arg2,arg3,arg4,arg5);

23615

wxPyEndAllowThreads(__tstate);

23616

if (PyErr_Occurred()) SWIG_fail;

23617

}

23618

{

23619

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23620

}

23621

{

23622

if (temp2)

23623

delete arg2;

23624

}

23625

return resultobj;

23626

fail:

23627

{

23628

if (temp2)

23629

delete arg2;

23630

}

23631

return NULL;

23632

}

23633

23634

23635

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndSymbolBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23636

PyObject *resultobj = 0;

23637

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23638

bool result;

23639

void *argp1 = 0 ;

23640

int res1 = 0 ;

23641

PyObject *swig_obj[1] ;

23642

23643

if (!args) SWIG_fail;

23644

swig_obj[0] = args;

23645

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23646

if (!SWIG_IsOK(res1)) {

23647

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndSymbolBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23648

}

23649

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23650

{

23651

PyThreadState* __tstate = wxPyBeginAllowThreads();

23652

result = (bool)(arg1)->EndSymbolBullet();

23653

wxPyEndAllowThreads(__tstate);

23654

if (PyErr_Occurred()) SWIG_fail;

23655

}

23656

{

23657

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23658

}

23659

return resultobj;

23660

fail:

23661

return NULL;

23662

}

23663

23664

23665

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginStandardBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23666

PyObject *resultobj = 0;

23667

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23668

wxString *arg2 = 0 ;

23669

int arg3 ;

23670

int arg4 ;

23671

int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_STANDARD ;

23672

bool result;

23673

void *argp1 = 0 ;

23674

int res1 = 0 ;

23675

bool temp2 = false ;

23676

int val3 ;

23677

int ecode3 = 0 ;

23678

int val4 ;

23679

int ecode4 = 0 ;

23680

int val5 ;

23681

int ecode5 = 0 ;

23682

PyObject * obj0 = 0 ;

23683

PyObject * obj1 = 0 ;

23684

PyObject * obj2 = 0 ;

23685

PyObject * obj3 = 0 ;

23686

PyObject * obj4 = 0 ;

23687

char * kwnames[] = {

23688

(char *) "self",(char *) "bulletName",(char *) "leftIndent",(char *) "leftSubIndent",(char *) "bulletStyle", NULL

23689

};

23690

23691

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:RichTextCtrl_BeginStandardBullet",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

23692

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23693

if (!SWIG_IsOK(res1)) {

23694

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginStandardBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23695

}

23696

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23697

{

23698

arg2 = wxString_in_helper(obj1);

23699

if (arg2 == NULL) SWIG_fail;

23700

temp2 = true;

23701

}

23702

ecode3 = SWIG_AsVal_int(obj2, &val3);

23703

if (!SWIG_IsOK(ecode3)) {

23704

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginStandardBullet" "', expected argument " "3"" of type '" "int""'");

23705

}

23706

arg3 = static_cast< int >(val3);

23707

ecode4 = SWIG_AsVal_int(obj3, &val4);

23708

if (!SWIG_IsOK(ecode4)) {

23709

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_BeginStandardBullet" "', expected argument " "4"" of type '" "int""'");

23710

}

23711

arg4 = static_cast< int >(val4);

23712

if (obj4) {

23713

ecode5 = SWIG_AsVal_int(obj4, &val5);

23714

if (!SWIG_IsOK(ecode5)) {

23715

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_BeginStandardBullet" "', expected argument " "5"" of type '" "int""'");

23716

}

23717

arg5 = static_cast< int >(val5);

23718

}

23719

{

23720

PyThreadState* __tstate = wxPyBeginAllowThreads();

23721

result = (bool)(arg1)->BeginStandardBullet((wxString const &)*arg2,arg3,arg4,arg5);

23722

wxPyEndAllowThreads(__tstate);

23723

if (PyErr_Occurred()) SWIG_fail;

23724

}

23725

{

23726

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23727

}

23728

{

23729

if (temp2)

23730

delete arg2;

23731

}

23732

return resultobj;

23733

fail:

23734

{

23735

if (temp2)

23736

delete arg2;

23737

}

23738

return NULL;

23739

}

23740

23741

23742

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndStandardBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23743

PyObject *resultobj = 0;

23744

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23745

bool result;

23746

void *argp1 = 0 ;

23747

int res1 = 0 ;

23748

PyObject *swig_obj[1] ;

23749

23750

if (!args) SWIG_fail;

23751

swig_obj[0] = args;

23752

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23753

if (!SWIG_IsOK(res1)) {

23754

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndStandardBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23755

}

23756

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23757

{

23758

PyThreadState* __tstate = wxPyBeginAllowThreads();

23759

result = (bool)(arg1)->EndStandardBullet();

23760

wxPyEndAllowThreads(__tstate);

23761

if (PyErr_Occurred()) SWIG_fail;

23762

}

23763

{

23764

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23765

}

23766

return resultobj;

23767

fail:

23768

return NULL;

23769

}

23770

23771

23772

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginCharacterStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23773

PyObject *resultobj = 0;

23774

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23775

wxString *arg2 = 0 ;

23776

bool result;

23777

void *argp1 = 0 ;

23778

int res1 = 0 ;

23779

bool temp2 = false ;

23780

PyObject * obj0 = 0 ;

23781

PyObject * obj1 = 0 ;

23782

char * kwnames[] = {

23783

(char *) "self",(char *) "characterStyle", NULL

23784

};

23785

23786

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginCharacterStyle",kwnames,&obj0,&obj1)) SWIG_fail;

23787

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23788

if (!SWIG_IsOK(res1)) {

23789

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginCharacterStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23790

}

23791

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23792

{

23793

arg2 = wxString_in_helper(obj1);

23794

if (arg2 == NULL) SWIG_fail;

23795

temp2 = true;

23796

}

23797

{

23798

PyThreadState* __tstate = wxPyBeginAllowThreads();

23799

result = (bool)(arg1)->BeginCharacterStyle((wxString const &)*arg2);

23800

wxPyEndAllowThreads(__tstate);

23801

if (PyErr_Occurred()) SWIG_fail;

23802

}

23803

{

23804

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23805

}

23806

{

23807

if (temp2)

23808

delete arg2;

23809

}

23810

return resultobj;

23811

fail:

23812

{

23813

if (temp2)

23814

delete arg2;

23815

}

23816

return NULL;

23817

}

23818

23819

23820

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndCharacterStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23821

PyObject *resultobj = 0;

23822

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23823

bool result;

23824

void *argp1 = 0 ;

23825

int res1 = 0 ;

23826

PyObject *swig_obj[1] ;

23827

23828

if (!args) SWIG_fail;

23829

swig_obj[0] = args;

23830

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23831

if (!SWIG_IsOK(res1)) {

23832

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndCharacterStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23833

}

23834

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23835

{

23836

PyThreadState* __tstate = wxPyBeginAllowThreads();

23837

result = (bool)(arg1)->EndCharacterStyle();

23838

wxPyEndAllowThreads(__tstate);

23839

if (PyErr_Occurred()) SWIG_fail;

23840

}

23841

{

23842

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23843

}

23844

return resultobj;

23845

fail:

23846

return NULL;

23847

}

23848

23849

23850

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23851

PyObject *resultobj = 0;

23852

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23853

wxString *arg2 = 0 ;

23854

bool result;

23855

void *argp1 = 0 ;

23856

int res1 = 0 ;

23857

bool temp2 = false ;

23858

PyObject * obj0 = 0 ;

23859

PyObject * obj1 = 0 ;

23860

char * kwnames[] = {

23861

(char *) "self",(char *) "paragraphStyle", NULL

23862

};

23863

23864

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginParagraphStyle",kwnames,&obj0,&obj1)) SWIG_fail;

23865

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23866

if (!SWIG_IsOK(res1)) {

23867

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginParagraphStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23868

}

23869

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23870

{

23871

arg2 = wxString_in_helper(obj1);

23872

if (arg2 == NULL) SWIG_fail;

23873

temp2 = true;

23874

}

23875

{

23876

PyThreadState* __tstate = wxPyBeginAllowThreads();

23877

result = (bool)(arg1)->BeginParagraphStyle((wxString const &)*arg2);

23878

wxPyEndAllowThreads(__tstate);

23879

if (PyErr_Occurred()) SWIG_fail;

23880

}

23881

{

23882

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23883

}

23884

{

23885

if (temp2)

23886

delete arg2;

23887

}

23888

return resultobj;

23889

fail:

23890

{

23891

if (temp2)

23892

delete arg2;

23893

}

23894

return NULL;

23895

}

23896

23897

23898

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndParagraphStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23899

PyObject *resultobj = 0;

23900

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23901

bool result;

23902

void *argp1 = 0 ;

23903

int res1 = 0 ;

23904

PyObject *swig_obj[1] ;

23905

23906

if (!args) SWIG_fail;

23907

swig_obj[0] = args;

23908

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23909

if (!SWIG_IsOK(res1)) {

23910

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndParagraphStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23911

}

23912

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23913

{

23914

PyThreadState* __tstate = wxPyBeginAllowThreads();

23915

result = (bool)(arg1)->EndParagraphStyle();

23916

wxPyEndAllowThreads(__tstate);

23917

if (PyErr_Occurred()) SWIG_fail;

23918

}

23919

{

23920

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23921

}

23922

return resultobj;

23923

fail:

23924

return NULL;

23925

}

23926

23927

23928

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

23929

PyObject *resultobj = 0;

23930

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

23931

wxString *arg2 = 0 ;

23932

int arg3 = (int) 1 ;

23933

int arg4 = (int) 1 ;

23934

bool result;

23935

void *argp1 = 0 ;

23936

int res1 = 0 ;

23937

bool temp2 = false ;

23938

int val3 ;

23939

int ecode3 = 0 ;

23940

int val4 ;

23941

int ecode4 = 0 ;

23942

PyObject * obj0 = 0 ;

23943

PyObject * obj1 = 0 ;

23944

PyObject * obj2 = 0 ;

23945

PyObject * obj3 = 0 ;

23946

char * kwnames[] = {

23947

(char *) "self",(char *) "listStyle",(char *) "level",(char *) "number", NULL

23948

};

23949

23950

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextCtrl_BeginListStyle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

23951

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

23952

if (!SWIG_IsOK(res1)) {

23953

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginListStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

23954

}

23955

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

23956

{

23957

arg2 = wxString_in_helper(obj1);

23958

if (arg2 == NULL) SWIG_fail;

23959

temp2 = true;

23960

}

23961

if (obj2) {

23962

ecode3 = SWIG_AsVal_int(obj2, &val3);

23963

if (!SWIG_IsOK(ecode3)) {

23964

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginListStyle" "', expected argument " "3"" of type '" "int""'");

23965

}

23966

arg3 = static_cast< int >(val3);

23967

}

23968

if (obj3) {

23969

ecode4 = SWIG_AsVal_int(obj3, &val4);

23970

if (!SWIG_IsOK(ecode4)) {

23971

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_BeginListStyle" "', expected argument " "4"" of type '" "int""'");

23972

}

23973

arg4 = static_cast< int >(val4);

23974

}

23975

{

23976

PyThreadState* __tstate = wxPyBeginAllowThreads();

23977

result = (bool)(arg1)->BeginListStyle((wxString const &)*arg2,arg3,arg4);

23978

wxPyEndAllowThreads(__tstate);

23979

if (PyErr_Occurred()) SWIG_fail;

23980

}

23981

{

23982

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

23983

}

23984

{

23985

if (temp2)

23986

delete arg2;

23987

}

23988

return resultobj;

23989

fail:

23990

{

23991

if (temp2)

23992

delete arg2;

23993

}

23994

return NULL;

23995

}

23996

23997

23998

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

23999

PyObject *resultobj = 0;

24000

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24001

bool result;

24002

void *argp1 = 0 ;

24003

int res1 = 0 ;

24004

PyObject *swig_obj[1] ;

24005

24006

if (!args) SWIG_fail;

24007

swig_obj[0] = args;

24008

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24009

if (!SWIG_IsOK(res1)) {

24010

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndListStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24011

}

24012

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24013

{

24014

PyThreadState* __tstate = wxPyBeginAllowThreads();

24015

result = (bool)(arg1)->EndListStyle();

24016

wxPyEndAllowThreads(__tstate);

24017

if (PyErr_Occurred()) SWIG_fail;

24018

}

24019

{

24020

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24021

}

24022

return resultobj;

24023

fail:

24024

return NULL;

24025

}

24026

24027

24028

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24029

PyObject *resultobj = 0;

24030

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24031

wxString *arg2 = 0 ;

24032

wxString const &arg3_defvalue = wxEmptyString ;

24033

wxString *arg3 = (wxString *) &arg3_defvalue ;

24034

bool result;

24035

void *argp1 = 0 ;

24036

int res1 = 0 ;

24037

bool temp2 = false ;

24038

bool temp3 = false ;

24039

PyObject * obj0 = 0 ;

24040

PyObject * obj1 = 0 ;

24041

PyObject * obj2 = 0 ;

24042

char * kwnames[] = {

24043

(char *) "self",(char *) "url",(char *) "characterStyle", NULL

24044

};

24045

24046

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_BeginURL",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

24047

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24048

if (!SWIG_IsOK(res1)) {

24049

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginURL" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24050

}

24051

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24052

{

24053

arg2 = wxString_in_helper(obj1);

24054

if (arg2 == NULL) SWIG_fail;

24055

temp2 = true;

24056

}

24057

if (obj2) {

24058

{

24059

arg3 = wxString_in_helper(obj2);

24060

if (arg3 == NULL) SWIG_fail;

24061

temp3 = true;

24062

}

24063

}

24064

{

24065

PyThreadState* __tstate = wxPyBeginAllowThreads();

24066

result = (bool)(arg1)->BeginURL((wxString const &)*arg2,(wxString const &)*arg3);

24067

wxPyEndAllowThreads(__tstate);

24068

if (PyErr_Occurred()) SWIG_fail;

24069

}

24070

{

24071

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24072

}

24073

{

24074

if (temp2)

24075

delete arg2;

24076

}

24077

{

24078

if (temp3)

24079

delete arg3;

24080

}

24081

return resultobj;

24082

fail:

24083

{

24084

if (temp2)

24085

delete arg2;

24086

}

24087

{

24088

if (temp3)

24089

delete arg3;

24090

}

24091

return NULL;

24092

}

24093

24094

24095

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

24096

PyObject *resultobj = 0;

24097

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24098

bool result;

24099

void *argp1 = 0 ;

24100

int res1 = 0 ;

24101

PyObject *swig_obj[1] ;

24102

24103

if (!args) SWIG_fail;

24104

swig_obj[0] = args;

24105

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24106

if (!SWIG_IsOK(res1)) {

24107

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndURL" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24108

}

24109

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24110

{

24111

PyThreadState* __tstate = wxPyBeginAllowThreads();

24112

result = (bool)(arg1)->EndURL();

24113

wxPyEndAllowThreads(__tstate);

24114

if (PyErr_Occurred()) SWIG_fail;

24115

}

24116

{

24117

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24118

}

24119

return resultobj;

24120

fail:

24121

return NULL;

24122

}

24123

24124

24125

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetDefaultStyleToCursorStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

24126

PyObject *resultobj = 0;

24127

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24128

bool result;

24129

void *argp1 = 0 ;

24130

int res1 = 0 ;

24131

PyObject *swig_obj[1] ;

24132

24133

if (!args) SWIG_fail;

24134

swig_obj[0] = args;

24135

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24136

if (!SWIG_IsOK(res1)) {

24137

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetDefaultStyleToCursorStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24138

}

24139

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24140

{

24141

PyThreadState* __tstate = wxPyBeginAllowThreads();

24142

result = (bool)(arg1)->SetDefaultStyleToCursorStyle();

24143

wxPyEndAllowThreads(__tstate);

24144

if (PyErr_Occurred()) SWIG_fail;

24145

}

24146

{

24147

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24148

}

24149

return resultobj;

24150

fail:

24151

return NULL;

24152

}

24153

24154

24155

SWIGINTERN PyObject *_wrap_RichTextCtrl_SelectNone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

24156

PyObject *resultobj = 0;

24157

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24158

void *argp1 = 0 ;

24159

int res1 = 0 ;

24160

PyObject *swig_obj[1] ;

24161

24162

if (!args) SWIG_fail;

24163

swig_obj[0] = args;

24164

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24165

if (!SWIG_IsOK(res1)) {

24166

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SelectNone" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24167

}

24168

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24169

{

24170

PyThreadState* __tstate = wxPyBeginAllowThreads();

24171

(arg1)->SelectNone();

24172

wxPyEndAllowThreads(__tstate);

24173

if (PyErr_Occurred()) SWIG_fail;

24174

}

24175

resultobj = SWIG_Py_Void();

24176

return resultobj;

24177

fail:

24178

return NULL;

24179

}

24180

24181

24182

SWIGINTERN PyObject *_wrap_RichTextCtrl_SelectWord(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24183

PyObject *resultobj = 0;

24184

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24185

long arg2 ;

24186

bool result;

24187

void *argp1 = 0 ;

24188

int res1 = 0 ;

24189

long val2 ;

24190

int ecode2 = 0 ;

24191

PyObject * obj0 = 0 ;

24192

PyObject * obj1 = 0 ;

24193

char * kwnames[] = {

24194

(char *) "self",(char *) "position", NULL

24195

};

24196

24197

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SelectWord",kwnames,&obj0,&obj1)) SWIG_fail;

24198

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24199

if (!SWIG_IsOK(res1)) {

24200

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SelectWord" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24201

}

24202

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24203

ecode2 = SWIG_AsVal_long(obj1, &val2);

24204

if (!SWIG_IsOK(ecode2)) {

24205

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SelectWord" "', expected argument " "2"" of type '" "long""'");

24206

}

24207

arg2 = static_cast< long >(val2);

24208

{

24209

PyThreadState* __tstate = wxPyBeginAllowThreads();

24210

result = (bool)(arg1)->SelectWord(arg2);

24211

wxPyEndAllowThreads(__tstate);

24212

if (PyErr_Occurred()) SWIG_fail;

24213

}

24214

{

24215

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24216

}

24217

return resultobj;

24218

fail:

24219

return NULL;

24220

}

24221

24222

24223

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetSelectionRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

24224

PyObject *resultobj = 0;

24225

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24226

wxRichTextRange result;

24227

void *argp1 = 0 ;

24228

int res1 = 0 ;

24229

PyObject *swig_obj[1] ;

24230

24231

if (!args) SWIG_fail;

24232

swig_obj[0] = args;

24233

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24234

if (!SWIG_IsOK(res1)) {

24235

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetSelectionRange" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

24236

}

24237

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24238

{

24239

PyThreadState* __tstate = wxPyBeginAllowThreads();

24240

result = ((wxRichTextCtrl const *)arg1)->GetSelectionRange();

24241

wxPyEndAllowThreads(__tstate);

24242

if (PyErr_Occurred()) SWIG_fail;

24243

}

24244

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

24245

return resultobj;

24246

fail:

24247

return NULL;

24248

}

24249

24250

24251

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetSelectionRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24252

PyObject *resultobj = 0;

24253

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24254

wxRichTextRange *arg2 = 0 ;

24255

void *argp1 = 0 ;

24256

int res1 = 0 ;

24257

wxRichTextRange temp2 ;

24258

PyObject * obj0 = 0 ;

24259

PyObject * obj1 = 0 ;

24260

char * kwnames[] = {

24261

(char *) "self",(char *) "range", NULL

24262

};

24263

24264

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetSelectionRange",kwnames,&obj0,&obj1)) SWIG_fail;

24265

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24266

if (!SWIG_IsOK(res1)) {

24267

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetSelectionRange" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24268

}

24269

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24270

{

24271

arg2 = &temp2;

24272

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

24273

}

24274

{

24275

PyThreadState* __tstate = wxPyBeginAllowThreads();

24276

(arg1)->SetSelectionRange((wxRichTextRange const &)*arg2);

24277

wxPyEndAllowThreads(__tstate);

24278

if (PyErr_Occurred()) SWIG_fail;

24279

}

24280

resultobj = SWIG_Py_Void();

24281

return resultobj;

24282

fail:

24283

return NULL;

24284

}

24285

24286

24287

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetInternalSelectionRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

24288

PyObject *resultobj = 0;

24289

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24290

wxRichTextRange *result = 0 ;

24291

void *argp1 = 0 ;

24292

int res1 = 0 ;

24293

PyObject *swig_obj[1] ;

24294

24295

if (!args) SWIG_fail;

24296

swig_obj[0] = args;

24297

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24298

if (!SWIG_IsOK(res1)) {

24299

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetInternalSelectionRange" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

24300

}

24301

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24302

{

24303

PyThreadState* __tstate = wxPyBeginAllowThreads();

24304

{

24305

wxRichTextRange const &_result_ref = ((wxRichTextCtrl const *)arg1)->GetInternalSelectionRange();

24306

result = (wxRichTextRange *) &_result_ref;

24307

}

24308

wxPyEndAllowThreads(__tstate);

24309

if (PyErr_Occurred()) SWIG_fail;

24310

}

24311

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextRange, 0 | 0 );

24312

return resultobj;

24313

fail:

24314

return NULL;

24315

}

24316

24317

24318

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetInternalSelectionRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24319

PyObject *resultobj = 0;

24320

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24321

wxRichTextRange *arg2 = 0 ;

24322

void *argp1 = 0 ;

24323

int res1 = 0 ;

24324

wxRichTextRange temp2 ;

24325

PyObject * obj0 = 0 ;

24326

PyObject * obj1 = 0 ;

24327

char * kwnames[] = {

24328

(char *) "self",(char *) "range", NULL

24329

};

24330

24331

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetInternalSelectionRange",kwnames,&obj0,&obj1)) SWIG_fail;

24332

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24333

if (!SWIG_IsOK(res1)) {

24334

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetInternalSelectionRange" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24335

}

24336

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24337

{

24338

arg2 = &temp2;

24339

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

24340

}

24341

{

24342

PyThreadState* __tstate = wxPyBeginAllowThreads();

24343

(arg1)->SetInternalSelectionRange((wxRichTextRange const &)*arg2);

24344

wxPyEndAllowThreads(__tstate);

24345

if (PyErr_Occurred()) SWIG_fail;

24346

}

24347

resultobj = SWIG_Py_Void();

24348

return resultobj;

24349

fail:

24350

return NULL;

24351

}

24352

24353

24354

SWIGINTERN PyObject *_wrap_RichTextCtrl_AddParagraph(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24355

PyObject *resultobj = 0;

24356

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24357

wxString *arg2 = 0 ;

24358

wxRichTextRange result;

24359

void *argp1 = 0 ;

24360

int res1 = 0 ;

24361

bool temp2 = false ;

24362

PyObject * obj0 = 0 ;

24363

PyObject * obj1 = 0 ;

24364

char * kwnames[] = {

24365

(char *) "self",(char *) "text", NULL

24366

};

24367

24368

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_AddParagraph",kwnames,&obj0,&obj1)) SWIG_fail;

24369

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24370

if (!SWIG_IsOK(res1)) {

24371

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_AddParagraph" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24372

}

24373

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24374

{

24375

arg2 = wxString_in_helper(obj1);

24376

if (arg2 == NULL) SWIG_fail;

24377

temp2 = true;

24378

}

24379

{

24380

PyThreadState* __tstate = wxPyBeginAllowThreads();

24381

result = (arg1)->AddParagraph((wxString const &)*arg2);

24382

wxPyEndAllowThreads(__tstate);

24383

if (PyErr_Occurred()) SWIG_fail;

24384

}

24385

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

24386

{

24387

if (temp2)

24388

delete arg2;

24389

}

24390

return resultobj;

24391

fail:

24392

{

24393

if (temp2)

24394

delete arg2;

24395

}

24396

return NULL;

24397

}

24398

24399

24400

SWIGINTERN PyObject *_wrap_RichTextCtrl_AddImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24401

PyObject *resultobj = 0;

24402

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24403

wxImage *arg2 = 0 ;

24404

wxRichTextRange result;

24405

void *argp1 = 0 ;

24406

int res1 = 0 ;

24407

void *argp2 = 0 ;

24408

int res2 = 0 ;

24409

PyObject * obj0 = 0 ;

24410

PyObject * obj1 = 0 ;

24411

char * kwnames[] = {

24412

(char *) "self",(char *) "image", NULL

24413

};

24414

24415

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_AddImage",kwnames,&obj0,&obj1)) SWIG_fail;

24416

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24417

if (!SWIG_IsOK(res1)) {

24418

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_AddImage" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24419

}

24420

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24421

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);

24422

if (!SWIG_IsOK(res2)) {

24423

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_AddImage" "', expected argument " "2"" of type '" "wxImage const &""'");

24424

}

24425

if (!argp2) {

24426

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_AddImage" "', expected argument " "2"" of type '" "wxImage const &""'");

24427

}

24428

arg2 = reinterpret_cast< wxImage * >(argp2);

24429

{

24430

PyThreadState* __tstate = wxPyBeginAllowThreads();

24431

result = (arg1)->AddImage((wxImage const &)*arg2);

24432

wxPyEndAllowThreads(__tstate);

24433

if (PyErr_Occurred()) SWIG_fail;

24434

}

24435

resultobj = SWIG_NewPointerObj((new wxRichTextRange(static_cast< const wxRichTextRange& >(result))), SWIGTYPE_p_wxRichTextRange, SWIG_POINTER_OWN | 0 );

24436

return resultobj;

24437

fail:

24438

return NULL;

24439

}

24440

24441

24442

SWIGINTERN PyObject *_wrap_RichTextCtrl_LayoutContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24443

PyObject *resultobj = 0;

24444

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24445

bool arg2 = (bool) false ;

24446

bool result;

24447

void *argp1 = 0 ;

24448

int res1 = 0 ;

24449

bool val2 ;

24450

int ecode2 = 0 ;

24451

PyObject * obj0 = 0 ;

24452

PyObject * obj1 = 0 ;

24453

char * kwnames[] = {

24454

(char *) "self",(char *) "onlyVisibleRect", NULL

24455

};

24456

24457

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_LayoutContent",kwnames,&obj0,&obj1)) SWIG_fail;

24458

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24459

if (!SWIG_IsOK(res1)) {

24460

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_LayoutContent" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24461

}

24462

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24463

if (obj1) {

24464

ecode2 = SWIG_AsVal_bool(obj1, &val2);

24465

if (!SWIG_IsOK(ecode2)) {

24466

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_LayoutContent" "', expected argument " "2"" of type '" "bool""'");

24467

}

24468

arg2 = static_cast< bool >(val2);

24469

}

24470

{

24471

PyThreadState* __tstate = wxPyBeginAllowThreads();

24472

result = (bool)(arg1)->LayoutContent(arg2);

24473

wxPyEndAllowThreads(__tstate);

24474

if (PyErr_Occurred()) SWIG_fail;

24475

}

24476

{

24477

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24478

}

24479

return resultobj;

24480

fail:

24481

return NULL;

24482

}

24483

24484

24485

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24486

PyObject *resultobj = 0;

24487

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24488

long arg2 ;

24489

bool arg3 = (bool) false ;

24490

bool result;

24491

void *argp1 = 0 ;

24492

int res1 = 0 ;

24493

long val2 ;

24494

int ecode2 = 0 ;

24495

bool val3 ;

24496

int ecode3 = 0 ;

24497

PyObject * obj0 = 0 ;

24498

PyObject * obj1 = 0 ;

24499

PyObject * obj2 = 0 ;

24500

char * kwnames[] = {

24501

(char *) "self",(char *) "pos",(char *) "showAtLineStart", NULL

24502

};

24503

24504

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_MoveCaret",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

24505

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24506

if (!SWIG_IsOK(res1)) {

24507

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveCaret" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24508

}

24509

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24510

ecode2 = SWIG_AsVal_long(obj1, &val2);

24511

if (!SWIG_IsOK(ecode2)) {

24512

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveCaret" "', expected argument " "2"" of type '" "long""'");

24513

}

24514

arg2 = static_cast< long >(val2);

24515

if (obj2) {

24516

ecode3 = SWIG_AsVal_bool(obj2, &val3);

24517

if (!SWIG_IsOK(ecode3)) {

24518

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_MoveCaret" "', expected argument " "3"" of type '" "bool""'");

24519

}

24520

arg3 = static_cast< bool >(val3);

24521

}

24522

{

24523

PyThreadState* __tstate = wxPyBeginAllowThreads();

24524

result = (bool)(arg1)->MoveCaret(arg2,arg3);

24525

wxPyEndAllowThreads(__tstate);

24526

if (PyErr_Occurred()) SWIG_fail;

24527

}

24528

{

24529

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24530

}

24531

return resultobj;

24532

fail:

24533

return NULL;

24534

}

24535

24536

24537

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24538

PyObject *resultobj = 0;

24539

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24540

int arg2 = (int) 1 ;

24541

int arg3 = (int) 0 ;

24542

bool result;

24543

void *argp1 = 0 ;

24544

int res1 = 0 ;

24545

int val2 ;

24546

int ecode2 = 0 ;

24547

int val3 ;

24548

int ecode3 = 0 ;

24549

PyObject * obj0 = 0 ;

24550

PyObject * obj1 = 0 ;

24551

PyObject * obj2 = 0 ;

24552

char * kwnames[] = {

24553

(char *) "self",(char *) "noPositions",(char *) "flags", NULL

24554

};

24555

24556

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_MoveRight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

24557

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24558

if (!SWIG_IsOK(res1)) {

24559

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveRight" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24560

}

24561

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24562

if (obj1) {

24563

ecode2 = SWIG_AsVal_int(obj1, &val2);

24564

if (!SWIG_IsOK(ecode2)) {

24565

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveRight" "', expected argument " "2"" of type '" "int""'");

24566

}

24567

arg2 = static_cast< int >(val2);

24568

}

24569

if (obj2) {

24570

ecode3 = SWIG_AsVal_int(obj2, &val3);

24571

if (!SWIG_IsOK(ecode3)) {

24572

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_MoveRight" "', expected argument " "3"" of type '" "int""'");

24573

}

24574

arg3 = static_cast< int >(val3);

24575

}

24576

{

24577

PyThreadState* __tstate = wxPyBeginAllowThreads();

24578

result = (bool)(arg1)->MoveRight(arg2,arg3);

24579

wxPyEndAllowThreads(__tstate);

24580

if (PyErr_Occurred()) SWIG_fail;

24581

}

24582

{

24583

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24584

}

24585

return resultobj;

24586

fail:

24587

return NULL;

24588

}

24589

24590

24591

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24592

PyObject *resultobj = 0;

24593

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24594

int arg2 = (int) 1 ;

24595

int arg3 = (int) 0 ;

24596

bool result;

24597

void *argp1 = 0 ;

24598

int res1 = 0 ;

24599

int val2 ;

24600

int ecode2 = 0 ;

24601

int val3 ;

24602

int ecode3 = 0 ;

24603

PyObject * obj0 = 0 ;

24604

PyObject * obj1 = 0 ;

24605

PyObject * obj2 = 0 ;

24606

char * kwnames[] = {

24607

(char *) "self",(char *) "noPositions",(char *) "flags", NULL

24608

};

24609

24610

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_MoveLeft",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

24611

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24612

if (!SWIG_IsOK(res1)) {

24613

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveLeft" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24614

}

24615

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24616

if (obj1) {

24617

ecode2 = SWIG_AsVal_int(obj1, &val2);

24618

if (!SWIG_IsOK(ecode2)) {

24619

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveLeft" "', expected argument " "2"" of type '" "int""'");

24620

}

24621

arg2 = static_cast< int >(val2);

24622

}

24623

if (obj2) {

24624

ecode3 = SWIG_AsVal_int(obj2, &val3);

24625

if (!SWIG_IsOK(ecode3)) {

24626

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_MoveLeft" "', expected argument " "3"" of type '" "int""'");

24627

}

24628

arg3 = static_cast< int >(val3);

24629

}

24630

{

24631

PyThreadState* __tstate = wxPyBeginAllowThreads();

24632

result = (bool)(arg1)->MoveLeft(arg2,arg3);

24633

wxPyEndAllowThreads(__tstate);

24634

if (PyErr_Occurred()) SWIG_fail;

24635

}

24636

{

24637

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24638

}

24639

return resultobj;

24640

fail:

24641

return NULL;

24642

}

24643

24644

24645

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24646

PyObject *resultobj = 0;

24647

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24648

int arg2 = (int) 1 ;

24649

int arg3 = (int) 0 ;

24650

bool result;

24651

void *argp1 = 0 ;

24652

int res1 = 0 ;

24653

int val2 ;

24654

int ecode2 = 0 ;

24655

int val3 ;

24656

int ecode3 = 0 ;

24657

PyObject * obj0 = 0 ;

24658

PyObject * obj1 = 0 ;

24659

PyObject * obj2 = 0 ;

24660

char * kwnames[] = {

24661

(char *) "self",(char *) "noLines",(char *) "flags", NULL

24662

};

24663

24664

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_MoveUp",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

24665

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24666

if (!SWIG_IsOK(res1)) {

24667

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveUp" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24668

}

24669

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24670

if (obj1) {

24671

ecode2 = SWIG_AsVal_int(obj1, &val2);

24672

if (!SWIG_IsOK(ecode2)) {

24673

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveUp" "', expected argument " "2"" of type '" "int""'");

24674

}

24675

arg2 = static_cast< int >(val2);

24676

}

24677

if (obj2) {

24678

ecode3 = SWIG_AsVal_int(obj2, &val3);

24679

if (!SWIG_IsOK(ecode3)) {

24680

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_MoveUp" "', expected argument " "3"" of type '" "int""'");

24681

}

24682

arg3 = static_cast< int >(val3);

24683

}

24684

{

24685

PyThreadState* __tstate = wxPyBeginAllowThreads();

24686

result = (bool)(arg1)->MoveUp(arg2,arg3);

24687

wxPyEndAllowThreads(__tstate);

24688

if (PyErr_Occurred()) SWIG_fail;

24689

}

24690

{

24691

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24692

}

24693

return resultobj;

24694

fail:

24695

return NULL;

24696

}

24697

24698

24699

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24700

PyObject *resultobj = 0;

24701

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24702

int arg2 = (int) 1 ;

24703

int arg3 = (int) 0 ;

24704

bool result;

24705

void *argp1 = 0 ;

24706

int res1 = 0 ;

24707

int val2 ;

24708

int ecode2 = 0 ;

24709

int val3 ;

24710

int ecode3 = 0 ;

24711

PyObject * obj0 = 0 ;

24712

PyObject * obj1 = 0 ;

24713

PyObject * obj2 = 0 ;

24714

char * kwnames[] = {

24715

(char *) "self",(char *) "noLines",(char *) "flags", NULL

24716

};

24717

24718

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_MoveDown",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

24719

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24720

if (!SWIG_IsOK(res1)) {

24721

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveDown" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24722

}

24723

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24724

if (obj1) {

24725

ecode2 = SWIG_AsVal_int(obj1, &val2);

24726

if (!SWIG_IsOK(ecode2)) {

24727

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveDown" "', expected argument " "2"" of type '" "int""'");

24728

}

24729

arg2 = static_cast< int >(val2);

24730

}

24731

if (obj2) {

24732

ecode3 = SWIG_AsVal_int(obj2, &val3);

24733

if (!SWIG_IsOK(ecode3)) {

24734

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_MoveDown" "', expected argument " "3"" of type '" "int""'");

24735

}

24736

arg3 = static_cast< int >(val3);

24737

}

24738

{

24739

PyThreadState* __tstate = wxPyBeginAllowThreads();

24740

result = (bool)(arg1)->MoveDown(arg2,arg3);

24741

wxPyEndAllowThreads(__tstate);

24742

if (PyErr_Occurred()) SWIG_fail;

24743

}

24744

{

24745

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24746

}

24747

return resultobj;

24748

fail:

24749

return NULL;

24750

}

24751

24752

24753

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveToLineEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24754

PyObject *resultobj = 0;

24755

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24756

int arg2 = (int) 0 ;

24757

bool result;

24758

void *argp1 = 0 ;

24759

int res1 = 0 ;

24760

int val2 ;

24761

int ecode2 = 0 ;

24762

PyObject * obj0 = 0 ;

24763

PyObject * obj1 = 0 ;

24764

char * kwnames[] = {

24765

(char *) "self",(char *) "flags", NULL

24766

};

24767

24768

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_MoveToLineEnd",kwnames,&obj0,&obj1)) SWIG_fail;

24769

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24770

if (!SWIG_IsOK(res1)) {

24771

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveToLineEnd" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24772

}

24773

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24774

if (obj1) {

24775

ecode2 = SWIG_AsVal_int(obj1, &val2);

24776

if (!SWIG_IsOK(ecode2)) {

24777

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveToLineEnd" "', expected argument " "2"" of type '" "int""'");

24778

}

24779

arg2 = static_cast< int >(val2);

24780

}

24781

{

24782

PyThreadState* __tstate = wxPyBeginAllowThreads();

24783

result = (bool)(arg1)->MoveToLineEnd(arg2);

24784

wxPyEndAllowThreads(__tstate);

24785

if (PyErr_Occurred()) SWIG_fail;

24786

}

24787

{

24788

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24789

}

24790

return resultobj;

24791

fail:

24792

return NULL;

24793

}

24794

24795

24796

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveToLineStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24797

PyObject *resultobj = 0;

24798

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24799

int arg2 = (int) 0 ;

24800

bool result;

24801

void *argp1 = 0 ;

24802

int res1 = 0 ;

24803

int val2 ;

24804

int ecode2 = 0 ;

24805

PyObject * obj0 = 0 ;

24806

PyObject * obj1 = 0 ;

24807

char * kwnames[] = {

24808

(char *) "self",(char *) "flags", NULL

24809

};

24810

24811

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_MoveToLineStart",kwnames,&obj0,&obj1)) SWIG_fail;

24812

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24813

if (!SWIG_IsOK(res1)) {

24814

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveToLineStart" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24815

}

24816

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24817

if (obj1) {

24818

ecode2 = SWIG_AsVal_int(obj1, &val2);

24819

if (!SWIG_IsOK(ecode2)) {

24820

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveToLineStart" "', expected argument " "2"" of type '" "int""'");

24821

}

24822

arg2 = static_cast< int >(val2);

24823

}

24824

{

24825

PyThreadState* __tstate = wxPyBeginAllowThreads();

24826

result = (bool)(arg1)->MoveToLineStart(arg2);

24827

wxPyEndAllowThreads(__tstate);

24828

if (PyErr_Occurred()) SWIG_fail;

24829

}

24830

{

24831

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24832

}

24833

return resultobj;

24834

fail:

24835

return NULL;

24836

}

24837

24838

24839

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveToParagraphEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24840

PyObject *resultobj = 0;

24841

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24842

int arg2 = (int) 0 ;

24843

bool result;

24844

void *argp1 = 0 ;

24845

int res1 = 0 ;

24846

int val2 ;

24847

int ecode2 = 0 ;

24848

PyObject * obj0 = 0 ;

24849

PyObject * obj1 = 0 ;

24850

char * kwnames[] = {

24851

(char *) "self",(char *) "flags", NULL

24852

};

24853

24854

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_MoveToParagraphEnd",kwnames,&obj0,&obj1)) SWIG_fail;

24855

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24856

if (!SWIG_IsOK(res1)) {

24857

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveToParagraphEnd" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24858

}

24859

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24860

if (obj1) {

24861

ecode2 = SWIG_AsVal_int(obj1, &val2);

24862

if (!SWIG_IsOK(ecode2)) {

24863

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveToParagraphEnd" "', expected argument " "2"" of type '" "int""'");

24864

}

24865

arg2 = static_cast< int >(val2);

24866

}

24867

{

24868

PyThreadState* __tstate = wxPyBeginAllowThreads();

24869

result = (bool)(arg1)->MoveToParagraphEnd(arg2);

24870

wxPyEndAllowThreads(__tstate);

24871

if (PyErr_Occurred()) SWIG_fail;

24872

}

24873

{

24874

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24875

}

24876

return resultobj;

24877

fail:

24878

return NULL;

24879

}

24880

24881

24882

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveToParagraphStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24883

PyObject *resultobj = 0;

24884

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24885

int arg2 = (int) 0 ;

24886

bool result;

24887

void *argp1 = 0 ;

24888

int res1 = 0 ;

24889

int val2 ;

24890

int ecode2 = 0 ;

24891

PyObject * obj0 = 0 ;

24892

PyObject * obj1 = 0 ;

24893

char * kwnames[] = {

24894

(char *) "self",(char *) "flags", NULL

24895

};

24896

24897

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_MoveToParagraphStart",kwnames,&obj0,&obj1)) SWIG_fail;

24898

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24899

if (!SWIG_IsOK(res1)) {

24900

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveToParagraphStart" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24901

}

24902

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24903

if (obj1) {

24904

ecode2 = SWIG_AsVal_int(obj1, &val2);

24905

if (!SWIG_IsOK(ecode2)) {

24906

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveToParagraphStart" "', expected argument " "2"" of type '" "int""'");

24907

}

24908

arg2 = static_cast< int >(val2);

24909

}

24910

{

24911

PyThreadState* __tstate = wxPyBeginAllowThreads();

24912

result = (bool)(arg1)->MoveToParagraphStart(arg2);

24913

wxPyEndAllowThreads(__tstate);

24914

if (PyErr_Occurred()) SWIG_fail;

24915

}

24916

{

24917

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24918

}

24919

return resultobj;

24920

fail:

24921

return NULL;

24922

}

24923

24924

24925

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveHome(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24926

PyObject *resultobj = 0;

24927

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24928

int arg2 = (int) 0 ;

24929

bool result;

24930

void *argp1 = 0 ;

24931

int res1 = 0 ;

24932

int val2 ;

24933

int ecode2 = 0 ;

24934

PyObject * obj0 = 0 ;

24935

PyObject * obj1 = 0 ;

24936

char * kwnames[] = {

24937

(char *) "self",(char *) "flags", NULL

24938

};

24939

24940

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_MoveHome",kwnames,&obj0,&obj1)) SWIG_fail;

24941

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24942

if (!SWIG_IsOK(res1)) {

24943

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveHome" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24944

}

24945

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24946

if (obj1) {

24947

ecode2 = SWIG_AsVal_int(obj1, &val2);

24948

if (!SWIG_IsOK(ecode2)) {

24949

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveHome" "', expected argument " "2"" of type '" "int""'");

24950

}

24951

arg2 = static_cast< int >(val2);

24952

}

24953

{

24954

PyThreadState* __tstate = wxPyBeginAllowThreads();

24955

result = (bool)(arg1)->MoveHome(arg2);

24956

wxPyEndAllowThreads(__tstate);

24957

if (PyErr_Occurred()) SWIG_fail;

24958

}

24959

{

24960

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

24961

}

24962

return resultobj;

24963

fail:

24964

return NULL;

24965

}

24966

24967

24968

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveEnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

24969

PyObject *resultobj = 0;

24970

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

24971

int arg2 = (int) 0 ;

24972

bool result;

24973

void *argp1 = 0 ;

24974

int res1 = 0 ;

24975

int val2 ;

24976

int ecode2 = 0 ;

24977

PyObject * obj0 = 0 ;

24978

PyObject * obj1 = 0 ;

24979

char * kwnames[] = {

24980

(char *) "self",(char *) "flags", NULL

24981

};

24982

24983

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_MoveEnd",kwnames,&obj0,&obj1)) SWIG_fail;

24984

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

24985

if (!SWIG_IsOK(res1)) {

24986

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveEnd" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

24987

}

24988

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

24989

if (obj1) {

24990

ecode2 = SWIG_AsVal_int(obj1, &val2);

24991

if (!SWIG_IsOK(ecode2)) {

24992

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveEnd" "', expected argument " "2"" of type '" "int""'");

24993

}

24994

arg2 = static_cast< int >(val2);

24995

}

24996

{

24997

PyThreadState* __tstate = wxPyBeginAllowThreads();

24998

result = (bool)(arg1)->MoveEnd(arg2);

24999

wxPyEndAllowThreads(__tstate);

25000

if (PyErr_Occurred()) SWIG_fail;

25001

}

25002

{

25003

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25004

}

25005

return resultobj;

25006

fail:

25007

return NULL;

25008

}

25009

25010

25011

SWIGINTERN PyObject *_wrap_RichTextCtrl_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25012

PyObject *resultobj = 0;

25013

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25014

int arg2 = (int) 1 ;

25015

int arg3 = (int) 0 ;

25016

bool result;

25017

void *argp1 = 0 ;

25018

int res1 = 0 ;

25019

int val2 ;

25020

int ecode2 = 0 ;

25021

int val3 ;

25022

int ecode3 = 0 ;

25023

PyObject * obj0 = 0 ;

25024

PyObject * obj1 = 0 ;

25025

PyObject * obj2 = 0 ;

25026

char * kwnames[] = {

25027

(char *) "self",(char *) "noPages",(char *) "flags", NULL

25028

};

25029

25030

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_PageUp",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

25031

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25032

if (!SWIG_IsOK(res1)) {

25033

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PageUp" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25034

}

25035

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25036

if (obj1) {

25037

ecode2 = SWIG_AsVal_int(obj1, &val2);

25038

if (!SWIG_IsOK(ecode2)) {

25039

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_PageUp" "', expected argument " "2"" of type '" "int""'");

25040

}

25041

arg2 = static_cast< int >(val2);

25042

}

25043

if (obj2) {

25044

ecode3 = SWIG_AsVal_int(obj2, &val3);

25045

if (!SWIG_IsOK(ecode3)) {

25046

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_PageUp" "', expected argument " "3"" of type '" "int""'");

25047

}

25048

arg3 = static_cast< int >(val3);

25049

}

25050

{

25051

PyThreadState* __tstate = wxPyBeginAllowThreads();

25052

result = (bool)(arg1)->PageUp(arg2,arg3);

25053

wxPyEndAllowThreads(__tstate);

25054

if (PyErr_Occurred()) SWIG_fail;

25055

}

25056

{

25057

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25058

}

25059

return resultobj;

25060

fail:

25061

return NULL;

25062

}

25063

25064

25065

SWIGINTERN PyObject *_wrap_RichTextCtrl_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25066

PyObject *resultobj = 0;

25067

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25068

int arg2 = (int) 1 ;

25069

int arg3 = (int) 0 ;

25070

bool result;

25071

void *argp1 = 0 ;

25072

int res1 = 0 ;

25073

int val2 ;

25074

int ecode2 = 0 ;

25075

int val3 ;

25076

int ecode3 = 0 ;

25077

PyObject * obj0 = 0 ;

25078

PyObject * obj1 = 0 ;

25079

PyObject * obj2 = 0 ;

25080

char * kwnames[] = {

25081

(char *) "self",(char *) "noPages",(char *) "flags", NULL

25082

};

25083

25084

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_PageDown",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

25085

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25086

if (!SWIG_IsOK(res1)) {

25087

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PageDown" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25088

}

25089

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25090

if (obj1) {

25091

ecode2 = SWIG_AsVal_int(obj1, &val2);

25092

if (!SWIG_IsOK(ecode2)) {

25093

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_PageDown" "', expected argument " "2"" of type '" "int""'");

25094

}

25095

arg2 = static_cast< int >(val2);

25096

}

25097

if (obj2) {

25098

ecode3 = SWIG_AsVal_int(obj2, &val3);

25099

if (!SWIG_IsOK(ecode3)) {

25100

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_PageDown" "', expected argument " "3"" of type '" "int""'");

25101

}

25102

arg3 = static_cast< int >(val3);

25103

}

25104

{

25105

PyThreadState* __tstate = wxPyBeginAllowThreads();

25106

result = (bool)(arg1)->PageDown(arg2,arg3);

25107

wxPyEndAllowThreads(__tstate);

25108

if (PyErr_Occurred()) SWIG_fail;

25109

}

25110

{

25111

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25112

}

25113

return resultobj;

25114

fail:

25115

return NULL;

25116

}

25117

25118

25119

SWIGINTERN PyObject *_wrap_RichTextCtrl_WordLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25120

PyObject *resultobj = 0;

25121

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25122

int arg2 = (int) 1 ;

25123

int arg3 = (int) 0 ;

25124

bool result;

25125

void *argp1 = 0 ;

25126

int res1 = 0 ;

25127

int val2 ;

25128

int ecode2 = 0 ;

25129

int val3 ;

25130

int ecode3 = 0 ;

25131

PyObject * obj0 = 0 ;

25132

PyObject * obj1 = 0 ;

25133

PyObject * obj2 = 0 ;

25134

char * kwnames[] = {

25135

(char *) "self",(char *) "noPages",(char *) "flags", NULL

25136

};

25137

25138

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_WordLeft",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

25139

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25140

if (!SWIG_IsOK(res1)) {

25141

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WordLeft" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25142

}

25143

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25144

if (obj1) {

25145

ecode2 = SWIG_AsVal_int(obj1, &val2);

25146

if (!SWIG_IsOK(ecode2)) {

25147

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_WordLeft" "', expected argument " "2"" of type '" "int""'");

25148

}

25149

arg2 = static_cast< int >(val2);

25150

}

25151

if (obj2) {

25152

ecode3 = SWIG_AsVal_int(obj2, &val3);

25153

if (!SWIG_IsOK(ecode3)) {

25154

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_WordLeft" "', expected argument " "3"" of type '" "int""'");

25155

}

25156

arg3 = static_cast< int >(val3);

25157

}

25158

{

25159

PyThreadState* __tstate = wxPyBeginAllowThreads();

25160

result = (bool)(arg1)->WordLeft(arg2,arg3);

25161

wxPyEndAllowThreads(__tstate);

25162

if (PyErr_Occurred()) SWIG_fail;

25163

}

25164

{

25165

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25166

}

25167

return resultobj;

25168

fail:

25169

return NULL;

25170

}

25171

25172

25173

SWIGINTERN PyObject *_wrap_RichTextCtrl_WordRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25174

PyObject *resultobj = 0;

25175

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25176

int arg2 = (int) 1 ;

25177

int arg3 = (int) 0 ;

25178

bool result;

25179

void *argp1 = 0 ;

25180

int res1 = 0 ;

25181

int val2 ;

25182

int ecode2 = 0 ;

25183

int val3 ;

25184

int ecode3 = 0 ;

25185

PyObject * obj0 = 0 ;

25186

PyObject * obj1 = 0 ;

25187

PyObject * obj2 = 0 ;

25188

char * kwnames[] = {

25189

(char *) "self",(char *) "noPages",(char *) "flags", NULL

25190

};

25191

25192

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextCtrl_WordRight",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

25193

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25194

if (!SWIG_IsOK(res1)) {

25195

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_WordRight" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25196

}

25197

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25198

if (obj1) {

25199

ecode2 = SWIG_AsVal_int(obj1, &val2);

25200

if (!SWIG_IsOK(ecode2)) {

25201

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_WordRight" "', expected argument " "2"" of type '" "int""'");

25202

}

25203

arg2 = static_cast< int >(val2);

25204

}

25205

if (obj2) {

25206

ecode3 = SWIG_AsVal_int(obj2, &val3);

25207

if (!SWIG_IsOK(ecode3)) {

25208

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_WordRight" "', expected argument " "3"" of type '" "int""'");

25209

}

25210

arg3 = static_cast< int >(val3);

25211

}

25212

{

25213

PyThreadState* __tstate = wxPyBeginAllowThreads();

25214

result = (bool)(arg1)->WordRight(arg2,arg3);

25215

wxPyEndAllowThreads(__tstate);

25216

if (PyErr_Occurred()) SWIG_fail;

25217

}

25218

{

25219

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25220

}

25221

return resultobj;

25222

fail:

25223

return NULL;

25224

}

25225

25226

25227

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25228

PyObject *resultobj = 0;

25229

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25230

wxRichTextBuffer *result = 0 ;

25231

void *argp1 = 0 ;

25232

int res1 = 0 ;

25233

PyObject *swig_obj[1] ;

25234

25235

if (!args) SWIG_fail;

25236

swig_obj[0] = args;

25237

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25238

if (!SWIG_IsOK(res1)) {

25239

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetBuffer" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25240

}

25241

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25242

{

25243

PyThreadState* __tstate = wxPyBeginAllowThreads();

25244

{

25245

wxRichTextBuffer &_result_ref = (arg1)->GetBuffer();

25246

result = (wxRichTextBuffer *) &_result_ref;

25247

}

25248

wxPyEndAllowThreads(__tstate);

25249

if (PyErr_Occurred()) SWIG_fail;

25250

}

25251

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

25252

return resultobj;

25253

fail:

25254

return NULL;

25255

}

25256

25257

25258

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginBatchUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25259

PyObject *resultobj = 0;

25260

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25261

wxString *arg2 = 0 ;

25262

bool result;

25263

void *argp1 = 0 ;

25264

int res1 = 0 ;

25265

bool temp2 = false ;

25266

PyObject * obj0 = 0 ;

25267

PyObject * obj1 = 0 ;

25268

char * kwnames[] = {

25269

(char *) "self",(char *) "cmdName", NULL

25270

};

25271

25272

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_BeginBatchUndo",kwnames,&obj0,&obj1)) SWIG_fail;

25273

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25274

if (!SWIG_IsOK(res1)) {

25275

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginBatchUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25276

}

25277

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25278

{

25279

arg2 = wxString_in_helper(obj1);

25280

if (arg2 == NULL) SWIG_fail;

25281

temp2 = true;

25282

}

25283

{

25284

PyThreadState* __tstate = wxPyBeginAllowThreads();

25285

result = (bool)(arg1)->BeginBatchUndo((wxString const &)*arg2);

25286

wxPyEndAllowThreads(__tstate);

25287

if (PyErr_Occurred()) SWIG_fail;

25288

}

25289

{

25290

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25291

}

25292

{

25293

if (temp2)

25294

delete arg2;

25295

}

25296

return resultobj;

25297

fail:

25298

{

25299

if (temp2)

25300

delete arg2;

25301

}

25302

return NULL;

25303

}

25304

25305

25306

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndBatchUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25307

PyObject *resultobj = 0;

25308

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25309

bool result;

25310

void *argp1 = 0 ;

25311

int res1 = 0 ;

25312

PyObject *swig_obj[1] ;

25313

25314

if (!args) SWIG_fail;

25315

swig_obj[0] = args;

25316

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25317

if (!SWIG_IsOK(res1)) {

25318

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndBatchUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25319

}

25320

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25321

{

25322

PyThreadState* __tstate = wxPyBeginAllowThreads();

25323

result = (bool)(arg1)->EndBatchUndo();

25324

wxPyEndAllowThreads(__tstate);

25325

if (PyErr_Occurred()) SWIG_fail;

25326

}

25327

{

25328

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25329

}

25330

return resultobj;

25331

fail:

25332

return NULL;

25333

}

25334

25335

25336

SWIGINTERN PyObject *_wrap_RichTextCtrl_BatchingUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25337

PyObject *resultobj = 0;

25338

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25339

bool result;

25340

void *argp1 = 0 ;

25341

int res1 = 0 ;

25342

PyObject *swig_obj[1] ;

25343

25344

if (!args) SWIG_fail;

25345

swig_obj[0] = args;

25346

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25347

if (!SWIG_IsOK(res1)) {

25348

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BatchingUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

25349

}

25350

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25351

{

25352

PyThreadState* __tstate = wxPyBeginAllowThreads();

25353

result = (bool)((wxRichTextCtrl const *)arg1)->BatchingUndo();

25354

wxPyEndAllowThreads(__tstate);

25355

if (PyErr_Occurred()) SWIG_fail;

25356

}

25357

{

25358

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25359

}

25360

return resultobj;

25361

fail:

25362

return NULL;

25363

}

25364

25365

25366

SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginSuppressUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25367

PyObject *resultobj = 0;

25368

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25369

bool result;

25370

void *argp1 = 0 ;

25371

int res1 = 0 ;

25372

PyObject *swig_obj[1] ;

25373

25374

if (!args) SWIG_fail;

25375

swig_obj[0] = args;

25376

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25377

if (!SWIG_IsOK(res1)) {

25378

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginSuppressUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25379

}

25380

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25381

{

25382

PyThreadState* __tstate = wxPyBeginAllowThreads();

25383

result = (bool)(arg1)->BeginSuppressUndo();

25384

wxPyEndAllowThreads(__tstate);

25385

if (PyErr_Occurred()) SWIG_fail;

25386

}

25387

{

25388

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25389

}

25390

return resultobj;

25391

fail:

25392

return NULL;

25393

}

25394

25395

25396

SWIGINTERN PyObject *_wrap_RichTextCtrl_EndSuppressUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25397

PyObject *resultobj = 0;

25398

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25399

bool result;

25400

void *argp1 = 0 ;

25401

int res1 = 0 ;

25402

PyObject *swig_obj[1] ;

25403

25404

if (!args) SWIG_fail;

25405

swig_obj[0] = args;

25406

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25407

if (!SWIG_IsOK(res1)) {

25408

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndSuppressUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25409

}

25410

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25411

{

25412

PyThreadState* __tstate = wxPyBeginAllowThreads();

25413

result = (bool)(arg1)->EndSuppressUndo();

25414

wxPyEndAllowThreads(__tstate);

25415

if (PyErr_Occurred()) SWIG_fail;

25416

}

25417

{

25418

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25419

}

25420

return resultobj;

25421

fail:

25422

return NULL;

25423

}

25424

25425

25426

SWIGINTERN PyObject *_wrap_RichTextCtrl_SuppressingUndo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25427

PyObject *resultobj = 0;

25428

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25429

bool result;

25430

void *argp1 = 0 ;

25431

int res1 = 0 ;

25432

PyObject *swig_obj[1] ;

25433

25434

if (!args) SWIG_fail;

25435

swig_obj[0] = args;

25436

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25437

if (!SWIG_IsOK(res1)) {

25438

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SuppressingUndo" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

25439

}

25440

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25441

{

25442

PyThreadState* __tstate = wxPyBeginAllowThreads();

25443

result = (bool)((wxRichTextCtrl const *)arg1)->SuppressingUndo();

25444

wxPyEndAllowThreads(__tstate);

25445

if (PyErr_Occurred()) SWIG_fail;

25446

}

25447

{

25448

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25449

}

25450

return resultobj;

25451

fail:

25452

return NULL;

25453

}

25454

25455

25456

SWIGINTERN PyObject *_wrap_RichTextCtrl_HasCharacterAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25457

PyObject *resultobj = 0;

25458

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25459

wxRichTextRange *arg2 = 0 ;

25460

wxTextAttrEx *arg3 = 0 ;

25461

bool result;

25462

void *argp1 = 0 ;

25463

int res1 = 0 ;

25464

wxRichTextRange temp2 ;

25465

void *argp3 = 0 ;

25466

int res3 = 0 ;

25467

PyObject * obj0 = 0 ;

25468

PyObject * obj1 = 0 ;

25469

PyObject * obj2 = 0 ;

25470

char * kwnames[] = {

25471

(char *) "self",(char *) "range",(char *) "style", NULL

25472

};

25473

25474

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_HasCharacterAttributes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

25475

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25476

if (!SWIG_IsOK(res1)) {

25477

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_HasCharacterAttributes" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

25478

}

25479

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25480

{

25481

arg2 = &temp2;

25482

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

25483

}

25484

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

25485

if (!SWIG_IsOK(res3)) {

25486

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_HasCharacterAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

25487

}

25488

if (!argp3) {

25489

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_HasCharacterAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

25490

}

25491

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

25492

{

25493

PyThreadState* __tstate = wxPyBeginAllowThreads();

25494

result = (bool)((wxRichTextCtrl const *)arg1)->HasCharacterAttributes((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3);

25495

wxPyEndAllowThreads(__tstate);

25496

if (PyErr_Occurred()) SWIG_fail;

25497

}

25498

{

25499

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25500

}

25501

return resultobj;

25502

fail:

25503

return NULL;

25504

}

25505

25506

25507

SWIGINTERN PyObject *_wrap_RichTextCtrl_HasParagraphAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25508

PyObject *resultobj = 0;

25509

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25510

wxRichTextRange *arg2 = 0 ;

25511

wxTextAttrEx *arg3 = 0 ;

25512

bool result;

25513

void *argp1 = 0 ;

25514

int res1 = 0 ;

25515

wxRichTextRange temp2 ;

25516

void *argp3 = 0 ;

25517

int res3 = 0 ;

25518

PyObject * obj0 = 0 ;

25519

PyObject * obj1 = 0 ;

25520

PyObject * obj2 = 0 ;

25521

char * kwnames[] = {

25522

(char *) "self",(char *) "range",(char *) "style", NULL

25523

};

25524

25525

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_HasParagraphAttributes",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

25526

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25527

if (!SWIG_IsOK(res1)) {

25528

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_HasParagraphAttributes" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

25529

}

25530

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25531

{

25532

arg2 = &temp2;

25533

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

25534

}

25535

res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxTextAttrEx, 0 | 0);

25536

if (!SWIG_IsOK(res3)) {

25537

SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RichTextCtrl_HasParagraphAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

25538

}

25539

if (!argp3) {

25540

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_HasParagraphAttributes" "', expected argument " "3"" of type '" "wxTextAttrEx const &""'");

25541

}

25542

arg3 = reinterpret_cast< wxTextAttrEx * >(argp3);

25543

{

25544

PyThreadState* __tstate = wxPyBeginAllowThreads();

25545

result = (bool)((wxRichTextCtrl const *)arg1)->HasParagraphAttributes((wxRichTextRange const &)*arg2,(wxTextAttrEx const &)*arg3);

25546

wxPyEndAllowThreads(__tstate);

25547

if (PyErr_Occurred()) SWIG_fail;

25548

}

25549

{

25550

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25551

}

25552

return resultobj;

25553

fail:

25554

return NULL;

25555

}

25556

25557

25558

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsSelectionBold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25559

PyObject *resultobj = 0;

25560

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25561

bool result;

25562

void *argp1 = 0 ;

25563

int res1 = 0 ;

25564

PyObject *swig_obj[1] ;

25565

25566

if (!args) SWIG_fail;

25567

swig_obj[0] = args;

25568

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25569

if (!SWIG_IsOK(res1)) {

25570

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsSelectionBold" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25571

}

25572

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25573

{

25574

PyThreadState* __tstate = wxPyBeginAllowThreads();

25575

result = (bool)(arg1)->IsSelectionBold();

25576

wxPyEndAllowThreads(__tstate);

25577

if (PyErr_Occurred()) SWIG_fail;

25578

}

25579

{

25580

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25581

}

25582

return resultobj;

25583

fail:

25584

return NULL;

25585

}

25586

25587

25588

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsSelectionItalics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25589

PyObject *resultobj = 0;

25590

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25591

bool result;

25592

void *argp1 = 0 ;

25593

int res1 = 0 ;

25594

PyObject *swig_obj[1] ;

25595

25596

if (!args) SWIG_fail;

25597

swig_obj[0] = args;

25598

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25599

if (!SWIG_IsOK(res1)) {

25600

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsSelectionItalics" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25601

}

25602

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25603

{

25604

PyThreadState* __tstate = wxPyBeginAllowThreads();

25605

result = (bool)(arg1)->IsSelectionItalics();

25606

wxPyEndAllowThreads(__tstate);

25607

if (PyErr_Occurred()) SWIG_fail;

25608

}

25609

{

25610

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25611

}

25612

return resultobj;

25613

fail:

25614

return NULL;

25615

}

25616

25617

25618

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsSelectionUnderlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25619

PyObject *resultobj = 0;

25620

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25621

bool result;

25622

void *argp1 = 0 ;

25623

int res1 = 0 ;

25624

PyObject *swig_obj[1] ;

25625

25626

if (!args) SWIG_fail;

25627

swig_obj[0] = args;

25628

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25629

if (!SWIG_IsOK(res1)) {

25630

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsSelectionUnderlined" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25631

}

25632

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25633

{

25634

PyThreadState* __tstate = wxPyBeginAllowThreads();

25635

result = (bool)(arg1)->IsSelectionUnderlined();

25636

wxPyEndAllowThreads(__tstate);

25637

if (PyErr_Occurred()) SWIG_fail;

25638

}

25639

{

25640

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25641

}

25642

return resultobj;

25643

fail:

25644

return NULL;

25645

}

25646

25647

25648

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsSelectionAligned(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25649

PyObject *resultobj = 0;

25650

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25651

wxTextAttrAlignment arg2 ;

25652

bool result;

25653

void *argp1 = 0 ;

25654

int res1 = 0 ;

25655

int val2 ;

25656

int ecode2 = 0 ;

25657

PyObject * obj0 = 0 ;

25658

PyObject * obj1 = 0 ;

25659

char * kwnames[] = {

25660

(char *) "self",(char *) "alignment", NULL

25661

};

25662

25663

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_IsSelectionAligned",kwnames,&obj0,&obj1)) SWIG_fail;

25664

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25665

if (!SWIG_IsOK(res1)) {

25666

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsSelectionAligned" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25667

}

25668

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25669

ecode2 = SWIG_AsVal_int(obj1, &val2);

25670

if (!SWIG_IsOK(ecode2)) {

25671

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_IsSelectionAligned" "', expected argument " "2"" of type '" "wxTextAttrAlignment""'");

25672

}

25673

arg2 = static_cast< wxTextAttrAlignment >(val2);

25674

{

25675

PyThreadState* __tstate = wxPyBeginAllowThreads();

25676

result = (bool)(arg1)->IsSelectionAligned(arg2);

25677

wxPyEndAllowThreads(__tstate);

25678

if (PyErr_Occurred()) SWIG_fail;

25679

}

25680

{

25681

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25682

}

25683

return resultobj;

25684

fail:

25685

return NULL;

25686

}

25687

25688

25689

SWIGINTERN PyObject *_wrap_RichTextCtrl_ApplyBoldToSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25690

PyObject *resultobj = 0;

25691

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25692

bool result;

25693

void *argp1 = 0 ;

25694

int res1 = 0 ;

25695

PyObject *swig_obj[1] ;

25696

25697

if (!args) SWIG_fail;

25698

swig_obj[0] = args;

25699

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25700

if (!SWIG_IsOK(res1)) {

25701

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ApplyBoldToSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25702

}

25703

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25704

{

25705

PyThreadState* __tstate = wxPyBeginAllowThreads();

25706

result = (bool)(arg1)->ApplyBoldToSelection();

25707

wxPyEndAllowThreads(__tstate);

25708

if (PyErr_Occurred()) SWIG_fail;

25709

}

25710

{

25711

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25712

}

25713

return resultobj;

25714

fail:

25715

return NULL;

25716

}

25717

25718

25719

SWIGINTERN PyObject *_wrap_RichTextCtrl_ApplyItalicToSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25720

PyObject *resultobj = 0;

25721

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25722

bool result;

25723

void *argp1 = 0 ;

25724

int res1 = 0 ;

25725

PyObject *swig_obj[1] ;

25726

25727

if (!args) SWIG_fail;

25728

swig_obj[0] = args;

25729

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25730

if (!SWIG_IsOK(res1)) {

25731

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ApplyItalicToSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25732

}

25733

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25734

{

25735

PyThreadState* __tstate = wxPyBeginAllowThreads();

25736

result = (bool)(arg1)->ApplyItalicToSelection();

25737

wxPyEndAllowThreads(__tstate);

25738

if (PyErr_Occurred()) SWIG_fail;

25739

}

25740

{

25741

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25742

}

25743

return resultobj;

25744

fail:

25745

return NULL;

25746

}

25747

25748

25749

SWIGINTERN PyObject *_wrap_RichTextCtrl_ApplyUnderlineToSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25750

PyObject *resultobj = 0;

25751

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25752

bool result;

25753

void *argp1 = 0 ;

25754

int res1 = 0 ;

25755

PyObject *swig_obj[1] ;

25756

25757

if (!args) SWIG_fail;

25758

swig_obj[0] = args;

25759

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25760

if (!SWIG_IsOK(res1)) {

25761

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ApplyUnderlineToSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25762

}

25763

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25764

{

25765

PyThreadState* __tstate = wxPyBeginAllowThreads();

25766

result = (bool)(arg1)->ApplyUnderlineToSelection();

25767

wxPyEndAllowThreads(__tstate);

25768

if (PyErr_Occurred()) SWIG_fail;

25769

}

25770

{

25771

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25772

}

25773

return resultobj;

25774

fail:

25775

return NULL;

25776

}

25777

25778

25779

SWIGINTERN PyObject *_wrap_RichTextCtrl_ApplyAlignmentToSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25780

PyObject *resultobj = 0;

25781

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25782

wxTextAttrAlignment arg2 ;

25783

bool result;

25784

void *argp1 = 0 ;

25785

int res1 = 0 ;

25786

int val2 ;

25787

int ecode2 = 0 ;

25788

PyObject * obj0 = 0 ;

25789

PyObject * obj1 = 0 ;

25790

char * kwnames[] = {

25791

(char *) "self",(char *) "alignment", NULL

25792

};

25793

25794

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_ApplyAlignmentToSelection",kwnames,&obj0,&obj1)) SWIG_fail;

25795

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25796

if (!SWIG_IsOK(res1)) {

25797

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ApplyAlignmentToSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25798

}

25799

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25800

ecode2 = SWIG_AsVal_int(obj1, &val2);

25801

if (!SWIG_IsOK(ecode2)) {

25802

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_ApplyAlignmentToSelection" "', expected argument " "2"" of type '" "wxTextAttrAlignment""'");

25803

}

25804

arg2 = static_cast< wxTextAttrAlignment >(val2);

25805

{

25806

PyThreadState* __tstate = wxPyBeginAllowThreads();

25807

result = (bool)(arg1)->ApplyAlignmentToSelection(arg2);

25808

wxPyEndAllowThreads(__tstate);

25809

if (PyErr_Occurred()) SWIG_fail;

25810

}

25811

{

25812

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25813

}

25814

return resultobj;

25815

fail:

25816

return NULL;

25817

}

25818

25819

25820

SWIGINTERN PyObject *_wrap_RichTextCtrl_ApplyStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25821

PyObject *resultobj = 0;

25822

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25823

wxRichTextStyleDefinition *arg2 = (wxRichTextStyleDefinition *) 0 ;

25824

bool result;

25825

void *argp1 = 0 ;

25826

int res1 = 0 ;

25827

void *argp2 = 0 ;

25828

int res2 = 0 ;

25829

PyObject * obj0 = 0 ;

25830

PyObject * obj1 = 0 ;

25831

char * kwnames[] = {

25832

(char *) "self",(char *) "def", NULL

25833

};

25834

25835

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_ApplyStyle",kwnames,&obj0,&obj1)) SWIG_fail;

25836

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25837

if (!SWIG_IsOK(res1)) {

25838

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ApplyStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25839

}

25840

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25841

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleDefinition, 0 | 0 );

25842

if (!SWIG_IsOK(res2)) {

25843

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_ApplyStyle" "', expected argument " "2"" of type '" "wxRichTextStyleDefinition *""'");

25844

}

25845

arg2 = reinterpret_cast< wxRichTextStyleDefinition * >(argp2);

25846

{

25847

PyThreadState* __tstate = wxPyBeginAllowThreads();

25848

result = (bool)(arg1)->ApplyStyle(arg2);

25849

wxPyEndAllowThreads(__tstate);

25850

if (PyErr_Occurred()) SWIG_fail;

25851

}

25852

{

25853

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25854

}

25855

return resultobj;

25856

fail:

25857

return NULL;

25858

}

25859

25860

25861

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25862

PyObject *resultobj = 0;

25863

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25864

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

25865

void *argp1 = 0 ;

25866

int res1 = 0 ;

25867

void *argp2 = 0 ;

25868

int res2 = 0 ;

25869

PyObject * obj0 = 0 ;

25870

PyObject * obj1 = 0 ;

25871

char * kwnames[] = {

25872

(char *) "self",(char *) "styleSheet", NULL

25873

};

25874

25875

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

25876

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25877

if (!SWIG_IsOK(res1)) {

25878

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetStyleSheet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25879

}

25880

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25881

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

25882

if (!SWIG_IsOK(res2)) {

25883

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

25884

}

25885

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

25886

{

25887

PyThreadState* __tstate = wxPyBeginAllowThreads();

25888

(arg1)->SetStyleSheet(arg2);

25889

wxPyEndAllowThreads(__tstate);

25890

if (PyErr_Occurred()) SWIG_fail;

25891

}

25892

resultobj = SWIG_Py_Void();

25893

return resultobj;

25894

fail:

25895

return NULL;

25896

}

25897

25898

25899

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25900

PyObject *resultobj = 0;

25901

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25902

wxRichTextStyleSheet *result = 0 ;

25903

void *argp1 = 0 ;

25904

int res1 = 0 ;

25905

PyObject *swig_obj[1] ;

25906

25907

if (!args) SWIG_fail;

25908

swig_obj[0] = args;

25909

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25910

if (!SWIG_IsOK(res1)) {

25911

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetStyleSheet" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

25912

}

25913

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25914

{

25915

PyThreadState* __tstate = wxPyBeginAllowThreads();

25916

result = (wxRichTextStyleSheet *)((wxRichTextCtrl const *)arg1)->GetStyleSheet();

25917

wxPyEndAllowThreads(__tstate);

25918

if (PyErr_Occurred()) SWIG_fail;

25919

}

25920

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

25921

return resultobj;

25922

fail:

25923

return NULL;

25924

}

25925

25926

25927

SWIGINTERN PyObject *_wrap_RichTextCtrl_PushStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25928

PyObject *resultobj = 0;

25929

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25930

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

25931

bool result;

25932

void *argp1 = 0 ;

25933

int res1 = 0 ;

25934

void *argp2 = 0 ;

25935

int res2 = 0 ;

25936

PyObject * obj0 = 0 ;

25937

PyObject * obj1 = 0 ;

25938

char * kwnames[] = {

25939

(char *) "self",(char *) "styleSheet", NULL

25940

};

25941

25942

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_PushStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

25943

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25944

if (!SWIG_IsOK(res1)) {

25945

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PushStyleSheet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25946

}

25947

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25948

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

25949

if (!SWIG_IsOK(res2)) {

25950

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_PushStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

25951

}

25952

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

25953

{

25954

PyThreadState* __tstate = wxPyBeginAllowThreads();

25955

result = (bool)(arg1)->PushStyleSheet(arg2);

25956

wxPyEndAllowThreads(__tstate);

25957

if (PyErr_Occurred()) SWIG_fail;

25958

}

25959

{

25960

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

25961

}

25962

return resultobj;

25963

fail:

25964

return NULL;

25965

}

25966

25967

25968

SWIGINTERN PyObject *_wrap_RichTextCtrl_PopStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

25969

PyObject *resultobj = 0;

25970

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25971

wxRichTextStyleSheet *result = 0 ;

25972

void *argp1 = 0 ;

25973

int res1 = 0 ;

25974

PyObject *swig_obj[1] ;

25975

25976

if (!args) SWIG_fail;

25977

swig_obj[0] = args;

25978

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

25979

if (!SWIG_IsOK(res1)) {

25980

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PopStyleSheet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

25981

}

25982

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

25983

{

25984

PyThreadState* __tstate = wxPyBeginAllowThreads();

25985

result = (wxRichTextStyleSheet *)(arg1)->PopStyleSheet();

25986

wxPyEndAllowThreads(__tstate);

25987

if (PyErr_Occurred()) SWIG_fail;

25988

}

25989

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

25990

return resultobj;

25991

fail:

25992

return NULL;

25993

}

25994

25995

25996

SWIGINTERN PyObject *_wrap_RichTextCtrl_ApplyStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

25997

PyObject *resultobj = 0;

25998

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

25999

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) NULL ;

26000

bool result;

26001

void *argp1 = 0 ;

26002

int res1 = 0 ;

26003

void *argp2 = 0 ;

26004

int res2 = 0 ;

26005

PyObject * obj0 = 0 ;

26006

PyObject * obj1 = 0 ;

26007

char * kwnames[] = {

26008

(char *) "self",(char *) "styleSheet", NULL

26009

};

26010

26011

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_ApplyStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

26012

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26013

if (!SWIG_IsOK(res1)) {

26014

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ApplyStyleSheet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26015

}

26016

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26017

if (obj1) {

26018

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

26019

if (!SWIG_IsOK(res2)) {

26020

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_ApplyStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

26021

}

26022

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

26023

}

26024

{

26025

PyThreadState* __tstate = wxPyBeginAllowThreads();

26026

result = (bool)(arg1)->ApplyStyleSheet(arg2);

26027

wxPyEndAllowThreads(__tstate);

26028

if (PyErr_Occurred()) SWIG_fail;

26029

}

26030

{

26031

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26032

}

26033

return resultobj;

26034

fail:

26035

return NULL;

26036

}

26037

26038

26039

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetupScrollbars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26040

PyObject *resultobj = 0;

26041

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26042

bool arg2 = (bool) false ;

26043

void *argp1 = 0 ;

26044

int res1 = 0 ;

26045

bool val2 ;

26046

int ecode2 = 0 ;

26047

PyObject * obj0 = 0 ;

26048

PyObject * obj1 = 0 ;

26049

char * kwnames[] = {

26050

(char *) "self",(char *) "atTop", NULL

26051

};

26052

26053

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_SetupScrollbars",kwnames,&obj0,&obj1)) SWIG_fail;

26054

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26055

if (!SWIG_IsOK(res1)) {

26056

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetupScrollbars" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26057

}

26058

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26059

if (obj1) {

26060

ecode2 = SWIG_AsVal_bool(obj1, &val2);

26061

if (!SWIG_IsOK(ecode2)) {

26062

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetupScrollbars" "', expected argument " "2"" of type '" "bool""'");

26063

}

26064

arg2 = static_cast< bool >(val2);

26065

}

26066

{

26067

PyThreadState* __tstate = wxPyBeginAllowThreads();

26068

(arg1)->SetupScrollbars(arg2);

26069

wxPyEndAllowThreads(__tstate);

26070

if (PyErr_Occurred()) SWIG_fail;

26071

}

26072

resultobj = SWIG_Py_Void();

26073

return resultobj;

26074

fail:

26075

return NULL;

26076

}

26077

26078

26079

SWIGINTERN PyObject *_wrap_RichTextCtrl_KeyboardNavigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26080

PyObject *resultobj = 0;

26081

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26082

int arg2 ;

26083

int arg3 ;

26084

bool result;

26085

void *argp1 = 0 ;

26086

int res1 = 0 ;

26087

int val2 ;

26088

int ecode2 = 0 ;

26089

int val3 ;

26090

int ecode3 = 0 ;

26091

PyObject * obj0 = 0 ;

26092

PyObject * obj1 = 0 ;

26093

PyObject * obj2 = 0 ;

26094

char * kwnames[] = {

26095

(char *) "self",(char *) "keyCode",(char *) "flags", NULL

26096

};

26097

26098

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_KeyboardNavigate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

26099

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26100

if (!SWIG_IsOK(res1)) {

26101

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_KeyboardNavigate" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26102

}

26103

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26104

ecode2 = SWIG_AsVal_int(obj1, &val2);

26105

if (!SWIG_IsOK(ecode2)) {

26106

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_KeyboardNavigate" "', expected argument " "2"" of type '" "int""'");

26107

}

26108

arg2 = static_cast< int >(val2);

26109

ecode3 = SWIG_AsVal_int(obj2, &val3);

26110

if (!SWIG_IsOK(ecode3)) {

26111

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_KeyboardNavigate" "', expected argument " "3"" of type '" "int""'");

26112

}

26113

arg3 = static_cast< int >(val3);

26114

{

26115

PyThreadState* __tstate = wxPyBeginAllowThreads();

26116

result = (bool)(arg1)->KeyboardNavigate(arg2,arg3);

26117

wxPyEndAllowThreads(__tstate);

26118

if (PyErr_Occurred()) SWIG_fail;

26119

}

26120

{

26121

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26122

}

26123

return resultobj;

26124

fail:

26125

return NULL;

26126

}

26127

26128

26129

SWIGINTERN PyObject *_wrap_RichTextCtrl_PositionCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26130

PyObject *resultobj = 0;

26131

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26132

void *argp1 = 0 ;

26133

int res1 = 0 ;

26134

PyObject *swig_obj[1] ;

26135

26136

if (!args) SWIG_fail;

26137

swig_obj[0] = args;

26138

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26139

if (!SWIG_IsOK(res1)) {

26140

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_PositionCaret" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26141

}

26142

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26143

{

26144

PyThreadState* __tstate = wxPyBeginAllowThreads();

26145

(arg1)->PositionCaret();

26146

wxPyEndAllowThreads(__tstate);

26147

if (PyErr_Occurred()) SWIG_fail;

26148

}

26149

resultobj = SWIG_Py_Void();

26150

return resultobj;

26151

fail:

26152

return NULL;

26153

}

26154

26155

26156

SWIGINTERN PyObject *_wrap_RichTextCtrl_ExtendSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26157

PyObject *resultobj = 0;

26158

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26159

long arg2 ;

26160

long arg3 ;

26161

int arg4 ;

26162

bool result;

26163

void *argp1 = 0 ;

26164

int res1 = 0 ;

26165

long val2 ;

26166

int ecode2 = 0 ;

26167

long val3 ;

26168

int ecode3 = 0 ;

26169

int val4 ;

26170

int ecode4 = 0 ;

26171

PyObject * obj0 = 0 ;

26172

PyObject * obj1 = 0 ;

26173

PyObject * obj2 = 0 ;

26174

PyObject * obj3 = 0 ;

26175

char * kwnames[] = {

26176

(char *) "self",(char *) "oldPosition",(char *) "newPosition",(char *) "flags", NULL

26177

};

26178

26179

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:RichTextCtrl_ExtendSelection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

26180

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26181

if (!SWIG_IsOK(res1)) {

26182

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ExtendSelection" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26183

}

26184

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26185

ecode2 = SWIG_AsVal_long(obj1, &val2);

26186

if (!SWIG_IsOK(ecode2)) {

26187

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_ExtendSelection" "', expected argument " "2"" of type '" "long""'");

26188

}

26189

arg2 = static_cast< long >(val2);

26190

ecode3 = SWIG_AsVal_long(obj2, &val3);

26191

if (!SWIG_IsOK(ecode3)) {

26192

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_ExtendSelection" "', expected argument " "3"" of type '" "long""'");

26193

}

26194

arg3 = static_cast< long >(val3);

26195

ecode4 = SWIG_AsVal_int(obj3, &val4);

26196

if (!SWIG_IsOK(ecode4)) {

26197

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_ExtendSelection" "', expected argument " "4"" of type '" "int""'");

26198

}

26199

arg4 = static_cast< int >(val4);

26200

{

26201

PyThreadState* __tstate = wxPyBeginAllowThreads();

26202

result = (bool)(arg1)->ExtendSelection(arg2,arg3,arg4);

26203

wxPyEndAllowThreads(__tstate);

26204

if (PyErr_Occurred()) SWIG_fail;

26205

}

26206

{

26207

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26208

}

26209

return resultobj;

26210

fail:

26211

return NULL;

26212

}

26213

26214

26215

SWIGINTERN PyObject *_wrap_RichTextCtrl_ScrollIntoView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26216

PyObject *resultobj = 0;

26217

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26218

long arg2 ;

26219

int arg3 ;

26220

bool result;

26221

void *argp1 = 0 ;

26222

int res1 = 0 ;

26223

long val2 ;

26224

int ecode2 = 0 ;

26225

int val3 ;

26226

int ecode3 = 0 ;

26227

PyObject * obj0 = 0 ;

26228

PyObject * obj1 = 0 ;

26229

PyObject * obj2 = 0 ;

26230

char * kwnames[] = {

26231

(char *) "self",(char *) "position",(char *) "keyCode", NULL

26232

};

26233

26234

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_ScrollIntoView",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

26235

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26236

if (!SWIG_IsOK(res1)) {

26237

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ScrollIntoView" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26238

}

26239

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26240

ecode2 = SWIG_AsVal_long(obj1, &val2);

26241

if (!SWIG_IsOK(ecode2)) {

26242

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_ScrollIntoView" "', expected argument " "2"" of type '" "long""'");

26243

}

26244

arg2 = static_cast< long >(val2);

26245

ecode3 = SWIG_AsVal_int(obj2, &val3);

26246

if (!SWIG_IsOK(ecode3)) {

26247

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_ScrollIntoView" "', expected argument " "3"" of type '" "int""'");

26248

}

26249

arg3 = static_cast< int >(val3);

26250

{

26251

PyThreadState* __tstate = wxPyBeginAllowThreads();

26252

result = (bool)(arg1)->ScrollIntoView(arg2,arg3);

26253

wxPyEndAllowThreads(__tstate);

26254

if (PyErr_Occurred()) SWIG_fail;

26255

}

26256

{

26257

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26258

}

26259

return resultobj;

26260

fail:

26261

return NULL;

26262

}

26263

26264

26265

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetCaretPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26266

PyObject *resultobj = 0;

26267

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26268

long arg2 ;

26269

bool arg3 = (bool) false ;

26270

void *argp1 = 0 ;

26271

int res1 = 0 ;

26272

long val2 ;

26273

int ecode2 = 0 ;

26274

bool val3 ;

26275

int ecode3 = 0 ;

26276

PyObject * obj0 = 0 ;

26277

PyObject * obj1 = 0 ;

26278

PyObject * obj2 = 0 ;

26279

char * kwnames[] = {

26280

(char *) "self",(char *) "position",(char *) "showAtLineStart", NULL

26281

};

26282

26283

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_SetCaretPosition",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

26284

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26285

if (!SWIG_IsOK(res1)) {

26286

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetCaretPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26287

}

26288

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26289

ecode2 = SWIG_AsVal_long(obj1, &val2);

26290

if (!SWIG_IsOK(ecode2)) {

26291

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetCaretPosition" "', expected argument " "2"" of type '" "long""'");

26292

}

26293

arg2 = static_cast< long >(val2);

26294

if (obj2) {

26295

ecode3 = SWIG_AsVal_bool(obj2, &val3);

26296

if (!SWIG_IsOK(ecode3)) {

26297

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SetCaretPosition" "', expected argument " "3"" of type '" "bool""'");

26298

}

26299

arg3 = static_cast< bool >(val3);

26300

}

26301

{

26302

PyThreadState* __tstate = wxPyBeginAllowThreads();

26303

(arg1)->SetCaretPosition(arg2,arg3);

26304

wxPyEndAllowThreads(__tstate);

26305

if (PyErr_Occurred()) SWIG_fail;

26306

}

26307

resultobj = SWIG_Py_Void();

26308

return resultobj;

26309

fail:

26310

return NULL;

26311

}

26312

26313

26314

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetCaretPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26315

PyObject *resultobj = 0;

26316

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26317

long result;

26318

void *argp1 = 0 ;

26319

int res1 = 0 ;

26320

PyObject *swig_obj[1] ;

26321

26322

if (!args) SWIG_fail;

26323

swig_obj[0] = args;

26324

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26325

if (!SWIG_IsOK(res1)) {

26326

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetCaretPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26327

}

26328

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26329

{

26330

PyThreadState* __tstate = wxPyBeginAllowThreads();

26331

result = (long)((wxRichTextCtrl const *)arg1)->GetCaretPosition();

26332

wxPyEndAllowThreads(__tstate);

26333

if (PyErr_Occurred()) SWIG_fail;

26334

}

26335

resultobj = SWIG_From_long(static_cast< long >(result));

26336

return resultobj;

26337

fail:

26338

return NULL;

26339

}

26340

26341

26342

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetAdjustedCaretPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26343

PyObject *resultobj = 0;

26344

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26345

long arg2 ;

26346

long result;

26347

void *argp1 = 0 ;

26348

int res1 = 0 ;

26349

long val2 ;

26350

int ecode2 = 0 ;

26351

PyObject * obj0 = 0 ;

26352

PyObject * obj1 = 0 ;

26353

char * kwnames[] = {

26354

(char *) "self",(char *) "caretPos", NULL

26355

};

26356

26357

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetAdjustedCaretPosition",kwnames,&obj0,&obj1)) SWIG_fail;

26358

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26359

if (!SWIG_IsOK(res1)) {

26360

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetAdjustedCaretPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26361

}

26362

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26363

ecode2 = SWIG_AsVal_long(obj1, &val2);

26364

if (!SWIG_IsOK(ecode2)) {

26365

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetAdjustedCaretPosition" "', expected argument " "2"" of type '" "long""'");

26366

}

26367

arg2 = static_cast< long >(val2);

26368

{

26369

PyThreadState* __tstate = wxPyBeginAllowThreads();

26370

result = (long)((wxRichTextCtrl const *)arg1)->GetAdjustedCaretPosition(arg2);

26371

wxPyEndAllowThreads(__tstate);

26372

if (PyErr_Occurred()) SWIG_fail;

26373

}

26374

resultobj = SWIG_From_long(static_cast< long >(result));

26375

return resultobj;

26376

fail:

26377

return NULL;

26378

}

26379

26380

26381

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveCaretForward(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26382

PyObject *resultobj = 0;

26383

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26384

long arg2 ;

26385

void *argp1 = 0 ;

26386

int res1 = 0 ;

26387

long val2 ;

26388

int ecode2 = 0 ;

26389

PyObject * obj0 = 0 ;

26390

PyObject * obj1 = 0 ;

26391

char * kwnames[] = {

26392

(char *) "self",(char *) "oldPosition", NULL

26393

};

26394

26395

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_MoveCaretForward",kwnames,&obj0,&obj1)) SWIG_fail;

26396

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26397

if (!SWIG_IsOK(res1)) {

26398

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveCaretForward" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26399

}

26400

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26401

ecode2 = SWIG_AsVal_long(obj1, &val2);

26402

if (!SWIG_IsOK(ecode2)) {

26403

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveCaretForward" "', expected argument " "2"" of type '" "long""'");

26404

}

26405

arg2 = static_cast< long >(val2);

26406

{

26407

PyThreadState* __tstate = wxPyBeginAllowThreads();

26408

(arg1)->MoveCaretForward(arg2);

26409

wxPyEndAllowThreads(__tstate);

26410

if (PyErr_Occurred()) SWIG_fail;

26411

}

26412

resultobj = SWIG_Py_Void();

26413

return resultobj;

26414

fail:

26415

return NULL;

26416

}

26417

26418

26419

SWIGINTERN PyObject *_wrap_RichTextCtrl_MoveCaretBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26420

PyObject *resultobj = 0;

26421

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26422

long arg2 ;

26423

void *argp1 = 0 ;

26424

int res1 = 0 ;

26425

long val2 ;

26426

int ecode2 = 0 ;

26427

PyObject * obj0 = 0 ;

26428

PyObject * obj1 = 0 ;

26429

char * kwnames[] = {

26430

(char *) "self",(char *) "oldPosition", NULL

26431

};

26432

26433

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_MoveCaretBack",kwnames,&obj0,&obj1)) SWIG_fail;

26434

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26435

if (!SWIG_IsOK(res1)) {

26436

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_MoveCaretBack" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26437

}

26438

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26439

ecode2 = SWIG_AsVal_long(obj1, &val2);

26440

if (!SWIG_IsOK(ecode2)) {

26441

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_MoveCaretBack" "', expected argument " "2"" of type '" "long""'");

26442

}

26443

arg2 = static_cast< long >(val2);

26444

{

26445

PyThreadState* __tstate = wxPyBeginAllowThreads();

26446

(arg1)->MoveCaretBack(arg2);

26447

wxPyEndAllowThreads(__tstate);

26448

if (PyErr_Occurred()) SWIG_fail;

26449

}

26450

resultobj = SWIG_Py_Void();

26451

return resultobj;

26452

fail:

26453

return NULL;

26454

}

26455

26456

26457

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetCaretPositionForIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26458

PyObject *resultobj = 0;

26459

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26460

long arg2 ;

26461

wxRect *arg3 = 0 ;

26462

bool result;

26463

void *argp1 = 0 ;

26464

int res1 = 0 ;

26465

long val2 ;

26466

int ecode2 = 0 ;

26467

wxRect temp3 ;

26468

PyObject * obj0 = 0 ;

26469

PyObject * obj1 = 0 ;

26470

PyObject * obj2 = 0 ;

26471

char * kwnames[] = {

26472

(char *) "self",(char *) "position",(char *) "rect", NULL

26473

};

26474

26475

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_GetCaretPositionForIndex",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

26476

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26477

if (!SWIG_IsOK(res1)) {

26478

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetCaretPositionForIndex" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26479

}

26480

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26481

ecode2 = SWIG_AsVal_long(obj1, &val2);

26482

if (!SWIG_IsOK(ecode2)) {

26483

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetCaretPositionForIndex" "', expected argument " "2"" of type '" "long""'");

26484

}

26485

arg2 = static_cast< long >(val2);

26486

{

26487

arg3 = &temp3;

26488

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

26489

}

26490

{

26491

PyThreadState* __tstate = wxPyBeginAllowThreads();

26492

result = (bool)(arg1)->GetCaretPositionForIndex(arg2,*arg3);

26493

wxPyEndAllowThreads(__tstate);

26494

if (PyErr_Occurred()) SWIG_fail;

26495

}

26496

{

26497

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26498

}

26499

return resultobj;

26500

fail:

26501

return NULL;

26502

}

26503

26504

26505

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetVisibleLineForCaretPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26506

PyObject *resultobj = 0;

26507

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26508

long arg2 ;

26509

wxRichTextLine *result = 0 ;

26510

void *argp1 = 0 ;

26511

int res1 = 0 ;

26512

long val2 ;

26513

int ecode2 = 0 ;

26514

PyObject * obj0 = 0 ;

26515

PyObject * obj1 = 0 ;

26516

char * kwnames[] = {

26517

(char *) "self",(char *) "caretPosition", NULL

26518

};

26519

26520

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetVisibleLineForCaretPosition",kwnames,&obj0,&obj1)) SWIG_fail;

26521

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26522

if (!SWIG_IsOK(res1)) {

26523

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetVisibleLineForCaretPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26524

}

26525

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26526

ecode2 = SWIG_AsVal_long(obj1, &val2);

26527

if (!SWIG_IsOK(ecode2)) {

26528

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetVisibleLineForCaretPosition" "', expected argument " "2"" of type '" "long""'");

26529

}

26530

arg2 = static_cast< long >(val2);

26531

{

26532

PyThreadState* __tstate = wxPyBeginAllowThreads();

26533

result = (wxRichTextLine *)((wxRichTextCtrl const *)arg1)->GetVisibleLineForCaretPosition(arg2);

26534

wxPyEndAllowThreads(__tstate);

26535

if (PyErr_Occurred()) SWIG_fail;

26536

}

26537

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextLine, 0 | 0 );

26538

return resultobj;

26539

fail:

26540

return NULL;

26541

}

26542

26543

26544

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetCommandProcessor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26545

PyObject *resultobj = 0;

26546

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26547

wxCommandProcessor *result = 0 ;

26548

void *argp1 = 0 ;

26549

int res1 = 0 ;

26550

PyObject *swig_obj[1] ;

26551

26552

if (!args) SWIG_fail;

26553

swig_obj[0] = args;

26554

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26555

if (!SWIG_IsOK(res1)) {

26556

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetCommandProcessor" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26557

}

26558

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26559

{

26560

PyThreadState* __tstate = wxPyBeginAllowThreads();

26561

result = (wxCommandProcessor *)((wxRichTextCtrl const *)arg1)->GetCommandProcessor();

26562

wxPyEndAllowThreads(__tstate);

26563

if (PyErr_Occurred()) SWIG_fail;

26564

}

26565

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandProcessor, 0 | 0 );

26566

return resultobj;

26567

fail:

26568

return NULL;

26569

}

26570

26571

26572

SWIGINTERN PyObject *_wrap_RichTextCtrl_DeleteSelectedContent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26573

PyObject *resultobj = 0;

26574

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26575

long *arg2 = (long *) 0 ;

26576

bool result;

26577

void *argp1 = 0 ;

26578

int res1 = 0 ;

26579

long temp2 ;

26580

int res2 = SWIG_TMPOBJ ;

26581

PyObject *swig_obj[1] ;

26582

26583

arg2 = &temp2;

26584

if (!args) SWIG_fail;

26585

swig_obj[0] = args;

26586

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26587

if (!SWIG_IsOK(res1)) {

26588

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_DeleteSelectedContent" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26589

}

26590

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26591

{

26592

PyThreadState* __tstate = wxPyBeginAllowThreads();

26593

result = (bool)(arg1)->DeleteSelectedContent(arg2);

26594

wxPyEndAllowThreads(__tstate);

26595

if (PyErr_Occurred()) SWIG_fail;

26596

}

26597

{

26598

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26599

}

26600

if (SWIG_IsTmpObj(res2)) {

26601

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));

26602

} else {

26603

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

26604

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));

26605

}

26606

return resultobj;

26607

fail:

26608

return NULL;

26609

}

26610

26611

26612

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetPhysicalPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26613

PyObject *resultobj = 0;

26614

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26615

wxPoint *arg2 = 0 ;

26616

wxPoint result;

26617

void *argp1 = 0 ;

26618

int res1 = 0 ;

26619

wxPoint temp2 ;

26620

PyObject * obj0 = 0 ;

26621

PyObject * obj1 = 0 ;

26622

char * kwnames[] = {

26623

(char *) "self",(char *) "ptLogical", NULL

26624

};

26625

26626

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetPhysicalPoint",kwnames,&obj0,&obj1)) SWIG_fail;

26627

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26628

if (!SWIG_IsOK(res1)) {

26629

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetPhysicalPoint" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26630

}

26631

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26632

{

26633

arg2 = &temp2;

26634

if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;

26635

}

26636

{

26637

PyThreadState* __tstate = wxPyBeginAllowThreads();

26638

result = ((wxRichTextCtrl const *)arg1)->GetPhysicalPoint((wxPoint const &)*arg2);

26639

wxPyEndAllowThreads(__tstate);

26640

if (PyErr_Occurred()) SWIG_fail;

26641

}

26642

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

26643

return resultobj;

26644

fail:

26645

return NULL;

26646

}

26647

26648

26649

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetLogicalPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26650

PyObject *resultobj = 0;

26651

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26652

wxPoint *arg2 = 0 ;

26653

wxPoint result;

26654

void *argp1 = 0 ;

26655

int res1 = 0 ;

26656

wxPoint temp2 ;

26657

PyObject * obj0 = 0 ;

26658

PyObject * obj1 = 0 ;

26659

char * kwnames[] = {

26660

(char *) "self",(char *) "ptPhysical", NULL

26661

};

26662

26663

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetLogicalPoint",kwnames,&obj0,&obj1)) SWIG_fail;

26664

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26665

if (!SWIG_IsOK(res1)) {

26666

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetLogicalPoint" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26667

}

26668

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26669

{

26670

arg2 = &temp2;

26671

if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;

26672

}

26673

{

26674

PyThreadState* __tstate = wxPyBeginAllowThreads();

26675

result = ((wxRichTextCtrl const *)arg1)->GetLogicalPoint((wxPoint const &)*arg2);

26676

wxPyEndAllowThreads(__tstate);

26677

if (PyErr_Occurred()) SWIG_fail;

26678

}

26679

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

26680

return resultobj;

26681

fail:

26682

return NULL;

26683

}

26684

26685

26686

SWIGINTERN PyObject *_wrap_RichTextCtrl_FindNextWordPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26687

PyObject *resultobj = 0;

26688

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26689

int arg2 = (int) 1 ;

26690

long result;

26691

void *argp1 = 0 ;

26692

int res1 = 0 ;

26693

int val2 ;

26694

int ecode2 = 0 ;

26695

PyObject * obj0 = 0 ;

26696

PyObject * obj1 = 0 ;

26697

char * kwnames[] = {

26698

(char *) "self",(char *) "direction", NULL

26699

};

26700

26701

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:RichTextCtrl_FindNextWordPosition",kwnames,&obj0,&obj1)) SWIG_fail;

26702

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26703

if (!SWIG_IsOK(res1)) {

26704

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_FindNextWordPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26705

}

26706

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26707

if (obj1) {

26708

ecode2 = SWIG_AsVal_int(obj1, &val2);

26709

if (!SWIG_IsOK(ecode2)) {

26710

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_FindNextWordPosition" "', expected argument " "2"" of type '" "int""'");

26711

}

26712

arg2 = static_cast< int >(val2);

26713

}

26714

{

26715

PyThreadState* __tstate = wxPyBeginAllowThreads();

26716

result = (long)((wxRichTextCtrl const *)arg1)->FindNextWordPosition(arg2);

26717

wxPyEndAllowThreads(__tstate);

26718

if (PyErr_Occurred()) SWIG_fail;

26719

}

26720

resultobj = SWIG_From_long(static_cast< long >(result));

26721

return resultobj;

26722

fail:

26723

return NULL;

26724

}

26725

26726

26727

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsPositionVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26728

PyObject *resultobj = 0;

26729

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26730

long arg2 ;

26731

bool result;

26732

void *argp1 = 0 ;

26733

int res1 = 0 ;

26734

long val2 ;

26735

int ecode2 = 0 ;

26736

PyObject * obj0 = 0 ;

26737

PyObject * obj1 = 0 ;

26738

char * kwnames[] = {

26739

(char *) "self",(char *) "pos", NULL

26740

};

26741

26742

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_IsPositionVisible",kwnames,&obj0,&obj1)) SWIG_fail;

26743

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26744

if (!SWIG_IsOK(res1)) {

26745

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsPositionVisible" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26746

}

26747

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26748

ecode2 = SWIG_AsVal_long(obj1, &val2);

26749

if (!SWIG_IsOK(ecode2)) {

26750

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_IsPositionVisible" "', expected argument " "2"" of type '" "long""'");

26751

}

26752

arg2 = static_cast< long >(val2);

26753

{

26754

PyThreadState* __tstate = wxPyBeginAllowThreads();

26755

result = (bool)((wxRichTextCtrl const *)arg1)->IsPositionVisible(arg2);

26756

wxPyEndAllowThreads(__tstate);

26757

if (PyErr_Occurred()) SWIG_fail;

26758

}

26759

{

26760

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26761

}

26762

return resultobj;

26763

fail:

26764

return NULL;

26765

}

26766

26767

26768

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetFirstVisiblePosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26769

PyObject *resultobj = 0;

26770

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26771

long result;

26772

void *argp1 = 0 ;

26773

int res1 = 0 ;

26774

PyObject *swig_obj[1] ;

26775

26776

if (!args) SWIG_fail;

26777

swig_obj[0] = args;

26778

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26779

if (!SWIG_IsOK(res1)) {

26780

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetFirstVisiblePosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26781

}

26782

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26783

{

26784

PyThreadState* __tstate = wxPyBeginAllowThreads();

26785

result = (long)((wxRichTextCtrl const *)arg1)->GetFirstVisiblePosition();

26786

wxPyEndAllowThreads(__tstate);

26787

if (PyErr_Occurred()) SWIG_fail;

26788

}

26789

resultobj = SWIG_From_long(static_cast< long >(result));

26790

return resultobj;

26791

fail:

26792

return NULL;

26793

}

26794

26795

26796

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetCaretPositionForDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26797

PyObject *resultobj = 0;

26798

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26799

long result;

26800

void *argp1 = 0 ;

26801

int res1 = 0 ;

26802

PyObject *swig_obj[1] ;

26803

26804

if (!args) SWIG_fail;

26805

swig_obj[0] = args;

26806

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26807

if (!SWIG_IsOK(res1)) {

26808

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetCaretPositionForDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26809

}

26810

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26811

{

26812

PyThreadState* __tstate = wxPyBeginAllowThreads();

26813

result = (long)((wxRichTextCtrl const *)arg1)->GetCaretPositionForDefaultStyle();

26814

wxPyEndAllowThreads(__tstate);

26815

if (PyErr_Occurred()) SWIG_fail;

26816

}

26817

resultobj = SWIG_From_long(static_cast< long >(result));

26818

return resultobj;

26819

fail:

26820

return NULL;

26821

}

26822

26823

26824

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetCaretPositionForDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26825

PyObject *resultobj = 0;

26826

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26827

long arg2 ;

26828

void *argp1 = 0 ;

26829

int res1 = 0 ;

26830

long val2 ;

26831

int ecode2 = 0 ;

26832

PyObject * obj0 = 0 ;

26833

PyObject * obj1 = 0 ;

26834

char * kwnames[] = {

26835

(char *) "self",(char *) "pos", NULL

26836

};

26837

26838

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetCaretPositionForDefaultStyle",kwnames,&obj0,&obj1)) SWIG_fail;

26839

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26840

if (!SWIG_IsOK(res1)) {

26841

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetCaretPositionForDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26842

}

26843

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26844

ecode2 = SWIG_AsVal_long(obj1, &val2);

26845

if (!SWIG_IsOK(ecode2)) {

26846

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetCaretPositionForDefaultStyle" "', expected argument " "2"" of type '" "long""'");

26847

}

26848

arg2 = static_cast< long >(val2);

26849

{

26850

PyThreadState* __tstate = wxPyBeginAllowThreads();

26851

(arg1)->SetCaretPositionForDefaultStyle(arg2);

26852

wxPyEndAllowThreads(__tstate);

26853

if (PyErr_Occurred()) SWIG_fail;

26854

}

26855

resultobj = SWIG_Py_Void();

26856

return resultobj;

26857

fail:

26858

return NULL;

26859

}

26860

26861

26862

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsDefaultStyleShowing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26863

PyObject *resultobj = 0;

26864

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26865

bool result;

26866

void *argp1 = 0 ;

26867

int res1 = 0 ;

26868

PyObject *swig_obj[1] ;

26869

26870

if (!args) SWIG_fail;

26871

swig_obj[0] = args;

26872

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26873

if (!SWIG_IsOK(res1)) {

26874

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsDefaultStyleShowing" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26875

}

26876

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26877

{

26878

PyThreadState* __tstate = wxPyBeginAllowThreads();

26879

result = (bool)((wxRichTextCtrl const *)arg1)->IsDefaultStyleShowing();

26880

wxPyEndAllowThreads(__tstate);

26881

if (PyErr_Occurred()) SWIG_fail;

26882

}

26883

{

26884

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

26885

}

26886

return resultobj;

26887

fail:

26888

return NULL;

26889

}

26890

26891

26892

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetAndShowDefaultStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26893

PyObject *resultobj = 0;

26894

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26895

wxRichTextAttr *arg2 = 0 ;

26896

void *argp1 = 0 ;

26897

int res1 = 0 ;

26898

void *argp2 = 0 ;

26899

int res2 = 0 ;

26900

PyObject * obj0 = 0 ;

26901

PyObject * obj1 = 0 ;

26902

char * kwnames[] = {

26903

(char *) "self",(char *) "attr", NULL

26904

};

26905

26906

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetAndShowDefaultStyle",kwnames,&obj0,&obj1)) SWIG_fail;

26907

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26908

if (!SWIG_IsOK(res1)) {

26909

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetAndShowDefaultStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

26910

}

26911

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26912

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextAttr, 0 | 0);

26913

if (!SWIG_IsOK(res2)) {

26914

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetAndShowDefaultStyle" "', expected argument " "2"" of type '" "wxRichTextAttr const &""'");

26915

}

26916

if (!argp2) {

26917

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_SetAndShowDefaultStyle" "', expected argument " "2"" of type '" "wxRichTextAttr const &""'");

26918

}

26919

arg2 = reinterpret_cast< wxRichTextAttr * >(argp2);

26920

{

26921

PyThreadState* __tstate = wxPyBeginAllowThreads();

26922

(arg1)->SetAndShowDefaultStyle((wxRichTextAttr const &)*arg2);

26923

wxPyEndAllowThreads(__tstate);

26924

if (PyErr_Occurred()) SWIG_fail;

26925

}

26926

resultobj = SWIG_Py_Void();

26927

return resultobj;

26928

fail:

26929

return NULL;

26930

}

26931

26932

26933

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetFirstVisiblePoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

26934

PyObject *resultobj = 0;

26935

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26936

wxPoint result;

26937

void *argp1 = 0 ;

26938

int res1 = 0 ;

26939

PyObject *swig_obj[1] ;

26940

26941

if (!args) SWIG_fail;

26942

swig_obj[0] = args;

26943

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

26944

if (!SWIG_IsOK(res1)) {

26945

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetFirstVisiblePoint" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

26946

}

26947

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

26948

{

26949

PyThreadState* __tstate = wxPyBeginAllowThreads();

26950

result = ((wxRichTextCtrl const *)arg1)->GetFirstVisiblePoint();

26951

wxPyEndAllowThreads(__tstate);

26952

if (PyErr_Occurred()) SWIG_fail;

26953

}

26954

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

26955

return resultobj;

26956

fail:

26957

return NULL;

26958

}

26959

26960

26961

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetScrollbars(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

26962

PyObject *resultobj = 0;

26963

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

26964

int arg2 ;

26965

int arg3 ;

26966

int arg4 ;

26967

int arg5 ;

26968

int arg6 = (int) 0 ;

26969

int arg7 = (int) 0 ;

26970

bool arg8 = (bool) false ;

26971

void *argp1 = 0 ;

26972

int res1 = 0 ;

26973

int val2 ;

26974

int ecode2 = 0 ;

26975

int val3 ;

26976

int ecode3 = 0 ;

26977

int val4 ;

26978

int ecode4 = 0 ;

26979

int val5 ;

26980

int ecode5 = 0 ;

26981

int val6 ;

26982

int ecode6 = 0 ;

26983

int val7 ;

26984

int ecode7 = 0 ;

26985

bool val8 ;

26986

int ecode8 = 0 ;

26987

PyObject * obj0 = 0 ;

26988

PyObject * obj1 = 0 ;

26989

PyObject * obj2 = 0 ;

26990

PyObject * obj3 = 0 ;

26991

PyObject * obj4 = 0 ;

26992

PyObject * obj5 = 0 ;

26993

PyObject * obj6 = 0 ;

26994

PyObject * obj7 = 0 ;

26995

char * kwnames[] = {

26996

(char *) "self",(char *) "pixelsPerUnitX",(char *) "pixelsPerUnitY",(char *) "noUnitsX",(char *) "noUnitsY",(char *) "xPos",(char *) "yPos",(char *) "noRefresh", NULL

26997

};

26998

26999

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|OOO:RichTextCtrl_SetScrollbars",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;

27000

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27001

if (!SWIG_IsOK(res1)) {

27002

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27003

}

27004

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27005

ecode2 = SWIG_AsVal_int(obj1, &val2);

27006

if (!SWIG_IsOK(ecode2)) {

27007

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "2"" of type '" "int""'");

27008

}

27009

arg2 = static_cast< int >(val2);

27010

ecode3 = SWIG_AsVal_int(obj2, &val3);

27011

if (!SWIG_IsOK(ecode3)) {

27012

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "3"" of type '" "int""'");

27013

}

27014

arg3 = static_cast< int >(val3);

27015

ecode4 = SWIG_AsVal_int(obj3, &val4);

27016

if (!SWIG_IsOK(ecode4)) {

27017

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "4"" of type '" "int""'");

27018

}

27019

arg4 = static_cast< int >(val4);

27020

ecode5 = SWIG_AsVal_int(obj4, &val5);

27021

if (!SWIG_IsOK(ecode5)) {

27022

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "5"" of type '" "int""'");

27023

}

27024

arg5 = static_cast< int >(val5);

27025

if (obj5) {

27026

ecode6 = SWIG_AsVal_int(obj5, &val6);

27027

if (!SWIG_IsOK(ecode6)) {

27028

SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "6"" of type '" "int""'");

27029

}

27030

arg6 = static_cast< int >(val6);

27031

}

27032

if (obj6) {

27033

ecode7 = SWIG_AsVal_int(obj6, &val7);

27034

if (!SWIG_IsOK(ecode7)) {

27035

SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "7"" of type '" "int""'");

27036

}

27037

arg7 = static_cast< int >(val7);

27038

}

27039

if (obj7) {

27040

ecode8 = SWIG_AsVal_bool(obj7, &val8);

27041

if (!SWIG_IsOK(ecode8)) {

27042

SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "RichTextCtrl_SetScrollbars" "', expected argument " "8"" of type '" "bool""'");

27043

}

27044

arg8 = static_cast< bool >(val8);

27045

}

27046

{

27047

PyThreadState* __tstate = wxPyBeginAllowThreads();

27048

(arg1)->SetScrollbars(arg2,arg3,arg4,arg5,arg6,arg7,arg8);

27049

wxPyEndAllowThreads(__tstate);

27050

if (PyErr_Occurred()) SWIG_fail;

27051

}

27052

resultobj = SWIG_Py_Void();

27053

return resultobj;

27054

fail:

27055

return NULL;

27056

}

27057

27058

27059

SWIGINTERN PyObject *_wrap_RichTextCtrl_Scroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27060

PyObject *resultobj = 0;

27061

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27062

int arg2 ;

27063

int arg3 ;

27064

void *argp1 = 0 ;

27065

int res1 = 0 ;

27066

int val2 ;

27067

int ecode2 = 0 ;

27068

int val3 ;

27069

int ecode3 = 0 ;

27070

PyObject * obj0 = 0 ;

27071

PyObject * obj1 = 0 ;

27072

PyObject * obj2 = 0 ;

27073

char * kwnames[] = {

27074

(char *) "self",(char *) "x",(char *) "y", NULL

27075

};

27076

27077

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_Scroll",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

27078

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27079

if (!SWIG_IsOK(res1)) {

27080

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_Scroll" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27081

}

27082

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27083

ecode2 = SWIG_AsVal_int(obj1, &val2);

27084

if (!SWIG_IsOK(ecode2)) {

27085

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_Scroll" "', expected argument " "2"" of type '" "int""'");

27086

}

27087

arg2 = static_cast< int >(val2);

27088

ecode3 = SWIG_AsVal_int(obj2, &val3);

27089

if (!SWIG_IsOK(ecode3)) {

27090

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_Scroll" "', expected argument " "3"" of type '" "int""'");

27091

}

27092

arg3 = static_cast< int >(val3);

27093

{

27094

PyThreadState* __tstate = wxPyBeginAllowThreads();

27095

(arg1)->Scroll(arg2,arg3);

27096

wxPyEndAllowThreads(__tstate);

27097

if (PyErr_Occurred()) SWIG_fail;

27098

}

27099

resultobj = SWIG_Py_Void();

27100

return resultobj;

27101

fail:

27102

return NULL;

27103

}

27104

27105

27106

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetScrollPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27107

PyObject *resultobj = 0;

27108

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27109

int arg2 ;

27110

int result;

27111

void *argp1 = 0 ;

27112

int res1 = 0 ;

27113

int val2 ;

27114

int ecode2 = 0 ;

27115

PyObject * obj0 = 0 ;

27116

PyObject * obj1 = 0 ;

27117

char * kwnames[] = {

27118

(char *) "self",(char *) "orient", NULL

27119

};

27120

27121

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_GetScrollPageSize",kwnames,&obj0,&obj1)) SWIG_fail;

27122

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27123

if (!SWIG_IsOK(res1)) {

27124

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetScrollPageSize" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27125

}

27126

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27127

ecode2 = SWIG_AsVal_int(obj1, &val2);

27128

if (!SWIG_IsOK(ecode2)) {

27129

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_GetScrollPageSize" "', expected argument " "2"" of type '" "int""'");

27130

}

27131

arg2 = static_cast< int >(val2);

27132

{

27133

PyThreadState* __tstate = wxPyBeginAllowThreads();

27134

result = (int)((wxRichTextCtrl const *)arg1)->GetScrollPageSize(arg2);

27135

wxPyEndAllowThreads(__tstate);

27136

if (PyErr_Occurred()) SWIG_fail;

27137

}

27138

resultobj = SWIG_From_int(static_cast< int >(result));

27139

return resultobj;

27140

fail:

27141

return NULL;

27142

}

27143

27144

27145

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetScrollPageSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27146

PyObject *resultobj = 0;

27147

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27148

int arg2 ;

27149

int arg3 ;

27150

void *argp1 = 0 ;

27151

int res1 = 0 ;

27152

int val2 ;

27153

int ecode2 = 0 ;

27154

int val3 ;

27155

int ecode3 = 0 ;

27156

PyObject * obj0 = 0 ;

27157

PyObject * obj1 = 0 ;

27158

PyObject * obj2 = 0 ;

27159

char * kwnames[] = {

27160

(char *) "self",(char *) "orient",(char *) "pageSize", NULL

27161

};

27162

27163

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_SetScrollPageSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

27164

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27165

if (!SWIG_IsOK(res1)) {

27166

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetScrollPageSize" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27167

}

27168

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27169

ecode2 = SWIG_AsVal_int(obj1, &val2);

27170

if (!SWIG_IsOK(ecode2)) {

27171

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetScrollPageSize" "', expected argument " "2"" of type '" "int""'");

27172

}

27173

arg2 = static_cast< int >(val2);

27174

ecode3 = SWIG_AsVal_int(obj2, &val3);

27175

if (!SWIG_IsOK(ecode3)) {

27176

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SetScrollPageSize" "', expected argument " "3"" of type '" "int""'");

27177

}

27178

arg3 = static_cast< int >(val3);

27179

{

27180

PyThreadState* __tstate = wxPyBeginAllowThreads();

27181

(arg1)->SetScrollPageSize(arg2,arg3);

27182

wxPyEndAllowThreads(__tstate);

27183

if (PyErr_Occurred()) SWIG_fail;

27184

}

27185

resultobj = SWIG_Py_Void();

27186

return resultobj;

27187

fail:

27188

return NULL;

27189

}

27190

27191

27192

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetScrollRate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27193

PyObject *resultobj = 0;

27194

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27195

int arg2 ;

27196

int arg3 ;

27197

void *argp1 = 0 ;

27198

int res1 = 0 ;

27199

int val2 ;

27200

int ecode2 = 0 ;

27201

int val3 ;

27202

int ecode3 = 0 ;

27203

PyObject * obj0 = 0 ;

27204

PyObject * obj1 = 0 ;

27205

PyObject * obj2 = 0 ;

27206

char * kwnames[] = {

27207

(char *) "self",(char *) "xstep",(char *) "ystep", NULL

27208

};

27209

27210

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_SetScrollRate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

27211

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27212

if (!SWIG_IsOK(res1)) {

27213

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetScrollRate" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27214

}

27215

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27216

ecode2 = SWIG_AsVal_int(obj1, &val2);

27217

if (!SWIG_IsOK(ecode2)) {

27218

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetScrollRate" "', expected argument " "2"" of type '" "int""'");

27219

}

27220

arg2 = static_cast< int >(val2);

27221

ecode3 = SWIG_AsVal_int(obj2, &val3);

27222

if (!SWIG_IsOK(ecode3)) {

27223

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SetScrollRate" "', expected argument " "3"" of type '" "int""'");

27224

}

27225

arg3 = static_cast< int >(val3);

27226

{

27227

PyThreadState* __tstate = wxPyBeginAllowThreads();

27228

(arg1)->SetScrollRate(arg2,arg3);

27229

wxPyEndAllowThreads(__tstate);

27230

if (PyErr_Occurred()) SWIG_fail;

27231

}

27232

resultobj = SWIG_Py_Void();

27233

return resultobj;

27234

fail:

27235

return NULL;

27236

}

27237

27238

27239

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetScrollPixelsPerUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27240

PyObject *resultobj = 0;

27241

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27242

int *arg2 = (int *) 0 ;

27243

int *arg3 = (int *) 0 ;

27244

void *argp1 = 0 ;

27245

int res1 = 0 ;

27246

int temp2 ;

27247

int res2 = SWIG_TMPOBJ ;

27248

int temp3 ;

27249

int res3 = SWIG_TMPOBJ ;

27250

PyObject *swig_obj[1] ;

27251

27252

arg2 = &temp2;

27253

arg3 = &temp3;

27254

if (!args) SWIG_fail;

27255

swig_obj[0] = args;

27256

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27257

if (!SWIG_IsOK(res1)) {

27258

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetScrollPixelsPerUnit" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27259

}

27260

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27261

{

27262

PyThreadState* __tstate = wxPyBeginAllowThreads();

27263

((wxRichTextCtrl const *)arg1)->GetScrollPixelsPerUnit(arg2,arg3);

27264

wxPyEndAllowThreads(__tstate);

27265

if (PyErr_Occurred()) SWIG_fail;

27266

}

27267

resultobj = SWIG_Py_Void();

27268

if (SWIG_IsTmpObj(res2)) {

27269

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));

27270

} else {

27271

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27272

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));

27273

}

27274

if (SWIG_IsTmpObj(res3)) {

27275

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));

27276

} else {

27277

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27278

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));

27279

}

27280

return resultobj;

27281

fail:

27282

return NULL;

27283

}

27284

27285

27286

SWIGINTERN PyObject *_wrap_RichTextCtrl_EnableScrolling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27287

PyObject *resultobj = 0;

27288

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27289

bool arg2 ;

27290

bool arg3 ;

27291

void *argp1 = 0 ;

27292

int res1 = 0 ;

27293

bool val2 ;

27294

int ecode2 = 0 ;

27295

bool val3 ;

27296

int ecode3 = 0 ;

27297

PyObject * obj0 = 0 ;

27298

PyObject * obj1 = 0 ;

27299

PyObject * obj2 = 0 ;

27300

char * kwnames[] = {

27301

(char *) "self",(char *) "x_scrolling",(char *) "y_scrolling", NULL

27302

};

27303

27304

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_EnableScrolling",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

27305

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27306

if (!SWIG_IsOK(res1)) {

27307

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EnableScrolling" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27308

}

27309

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27310

ecode2 = SWIG_AsVal_bool(obj1, &val2);

27311

if (!SWIG_IsOK(ecode2)) {

27312

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_EnableScrolling" "', expected argument " "2"" of type '" "bool""'");

27313

}

27314

arg2 = static_cast< bool >(val2);

27315

ecode3 = SWIG_AsVal_bool(obj2, &val3);

27316

if (!SWIG_IsOK(ecode3)) {

27317

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_EnableScrolling" "', expected argument " "3"" of type '" "bool""'");

27318

}

27319

arg3 = static_cast< bool >(val3);

27320

{

27321

PyThreadState* __tstate = wxPyBeginAllowThreads();

27322

(arg1)->EnableScrolling(arg2,arg3);

27323

wxPyEndAllowThreads(__tstate);

27324

if (PyErr_Occurred()) SWIG_fail;

27325

}

27326

resultobj = SWIG_Py_Void();

27327

return resultobj;

27328

fail:

27329

return NULL;

27330

}

27331

27332

27333

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetViewStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27334

PyObject *resultobj = 0;

27335

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27336

int *arg2 = (int *) 0 ;

27337

int *arg3 = (int *) 0 ;

27338

void *argp1 = 0 ;

27339

int res1 = 0 ;

27340

int temp2 ;

27341

int res2 = SWIG_TMPOBJ ;

27342

int temp3 ;

27343

int res3 = SWIG_TMPOBJ ;

27344

PyObject *swig_obj[1] ;

27345

27346

arg2 = &temp2;

27347

arg3 = &temp3;

27348

if (!args) SWIG_fail;

27349

swig_obj[0] = args;

27350

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27351

if (!SWIG_IsOK(res1)) {

27352

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetViewStart" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27353

}

27354

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27355

{

27356

PyThreadState* __tstate = wxPyBeginAllowThreads();

27357

((wxRichTextCtrl const *)arg1)->GetViewStart(arg2,arg3);

27358

wxPyEndAllowThreads(__tstate);

27359

if (PyErr_Occurred()) SWIG_fail;

27360

}

27361

resultobj = SWIG_Py_Void();

27362

if (SWIG_IsTmpObj(res2)) {

27363

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));

27364

} else {

27365

int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27366

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));

27367

}

27368

if (SWIG_IsTmpObj(res3)) {

27369

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));

27370

} else {

27371

int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27372

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));

27373

}

27374

return resultobj;

27375

fail:

27376

return NULL;

27377

}

27378

27379

27380

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27381

PyObject *resultobj = 0;

27382

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27383

double arg2 ;

27384

double arg3 ;

27385

void *argp1 = 0 ;

27386

int res1 = 0 ;

27387

double val2 ;

27388

int ecode2 = 0 ;

27389

double val3 ;

27390

int ecode3 = 0 ;

27391

PyObject * obj0 = 0 ;

27392

PyObject * obj1 = 0 ;

27393

PyObject * obj2 = 0 ;

27394

char * kwnames[] = {

27395

(char *) "self",(char *) "xs",(char *) "ys", NULL

27396

};

27397

27398

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RichTextCtrl_SetScale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

27399

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27400

if (!SWIG_IsOK(res1)) {

27401

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetScale" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27402

}

27403

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27404

ecode2 = SWIG_AsVal_double(obj1, &val2);

27405

if (!SWIG_IsOK(ecode2)) {

27406

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetScale" "', expected argument " "2"" of type '" "double""'");

27407

}

27408

arg2 = static_cast< double >(val2);

27409

ecode3 = SWIG_AsVal_double(obj2, &val3);

27410

if (!SWIG_IsOK(ecode3)) {

27411

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_SetScale" "', expected argument " "3"" of type '" "double""'");

27412

}

27413

arg3 = static_cast< double >(val3);

27414

{

27415

PyThreadState* __tstate = wxPyBeginAllowThreads();

27416

(arg1)->SetScale(arg2,arg3);

27417

wxPyEndAllowThreads(__tstate);

27418

if (PyErr_Occurred()) SWIG_fail;

27419

}

27420

resultobj = SWIG_Py_Void();

27421

return resultobj;

27422

fail:

27423

return NULL;

27424

}

27425

27426

27427

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetScaleX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27428

PyObject *resultobj = 0;

27429

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27430

double result;

27431

void *argp1 = 0 ;

27432

int res1 = 0 ;

27433

PyObject *swig_obj[1] ;

27434

27435

if (!args) SWIG_fail;

27436

swig_obj[0] = args;

27437

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27438

if (!SWIG_IsOK(res1)) {

27439

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetScaleX" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27440

}

27441

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27442

{

27443

PyThreadState* __tstate = wxPyBeginAllowThreads();

27444

result = (double)((wxRichTextCtrl const *)arg1)->GetScaleX();

27445

wxPyEndAllowThreads(__tstate);

27446

if (PyErr_Occurred()) SWIG_fail;

27447

}

27448

resultobj = SWIG_From_double(static_cast< double >(result));

27449

return resultobj;

27450

fail:

27451

return NULL;

27452

}

27453

27454

27455

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetScaleY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27456

PyObject *resultobj = 0;

27457

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27458

double result;

27459

void *argp1 = 0 ;

27460

int res1 = 0 ;

27461

PyObject *swig_obj[1] ;

27462

27463

if (!args) SWIG_fail;

27464

swig_obj[0] = args;

27465

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27466

if (!SWIG_IsOK(res1)) {

27467

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetScaleY" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27468

}

27469

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27470

{

27471

PyThreadState* __tstate = wxPyBeginAllowThreads();

27472

result = (double)((wxRichTextCtrl const *)arg1)->GetScaleY();

27473

wxPyEndAllowThreads(__tstate);

27474

if (PyErr_Occurred()) SWIG_fail;

27475

}

27476

resultobj = SWIG_From_double(static_cast< double >(result));

27477

return resultobj;

27478

fail:

27479

return NULL;

27480

}

27481

27482

27483

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcScrolledPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {

27484

PyObject *resultobj = 0;

27485

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27486

wxPoint *arg2 = 0 ;

27487

wxPoint result;

27488

void *argp1 = 0 ;

27489

int res1 = 0 ;

27490

wxPoint temp2 ;

27491

27492

if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;

27493

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27494

if (!SWIG_IsOK(res1)) {

27495

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CalcScrolledPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27496

}

27497

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27498

{

27499

arg2 = &temp2;

27500

if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;

27501

}

27502

{

27503

PyThreadState* __tstate = wxPyBeginAllowThreads();

27504

result = ((wxRichTextCtrl const *)arg1)->CalcScrolledPosition((wxPoint const &)*arg2);

27505

wxPyEndAllowThreads(__tstate);

27506

if (PyErr_Occurred()) SWIG_fail;

27507

}

27508

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

27509

return resultobj;

27510

fail:

27511

return NULL;

27512

}

27513

27514

27515

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcScrolledPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {

27516

PyObject *resultobj = 0;

27517

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27518

int arg2 ;

27519

int arg3 ;

27520

int *arg4 = (int *) 0 ;

27521

int *arg5 = (int *) 0 ;

27522

void *argp1 = 0 ;

27523

int res1 = 0 ;

27524

int val2 ;

27525

int ecode2 = 0 ;

27526

int val3 ;

27527

int ecode3 = 0 ;

27528

int temp4 ;

27529

int res4 = SWIG_TMPOBJ ;

27530

int temp5 ;

27531

int res5 = SWIG_TMPOBJ ;

27532

27533

arg4 = &temp4;

27534

arg5 = &temp5;

27535

if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;

27536

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27537

if (!SWIG_IsOK(res1)) {

27538

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CalcScrolledPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27539

}

27540

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27541

ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);

27542

if (!SWIG_IsOK(ecode2)) {

27543

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_CalcScrolledPosition" "', expected argument " "2"" of type '" "int""'");

27544

}

27545

arg2 = static_cast< int >(val2);

27546

ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);

27547

if (!SWIG_IsOK(ecode3)) {

27548

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_CalcScrolledPosition" "', expected argument " "3"" of type '" "int""'");

27549

}

27550

arg3 = static_cast< int >(val3);

27551

{

27552

PyThreadState* __tstate = wxPyBeginAllowThreads();

27553

((wxRichTextCtrl const *)arg1)->CalcScrolledPosition(arg2,arg3,arg4,arg5);

27554

wxPyEndAllowThreads(__tstate);

27555

if (PyErr_Occurred()) SWIG_fail;

27556

}

27557

resultobj = SWIG_Py_Void();

27558

if (SWIG_IsTmpObj(res4)) {

27559

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));

27560

} else {

27561

int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27562

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));

27563

}

27564

if (SWIG_IsTmpObj(res5)) {

27565

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));

27566

} else {

27567

int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27568

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));

27569

}

27570

return resultobj;

27571

fail:

27572

return NULL;

27573

}

27574

27575

27576

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcScrolledPosition(PyObject *self, PyObject *args) {

27577

int argc;

27578

PyObject *argv[4];

27579

27580

if (!(argc = SWIG_Python_UnpackTuple(args,"RichTextCtrl_CalcScrolledPosition",0,3,argv))) SWIG_fail;

27581

--argc;

27582

if (argc == 2) {

27583

return _wrap_RichTextCtrl_CalcScrolledPosition__SWIG_0(self, argc, argv);

27584

}

27585

if (argc == 3) {

27586

return _wrap_RichTextCtrl_CalcScrolledPosition__SWIG_1(self, argc, argv);

27587

}

27588

27589

fail:

27590

SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'RichTextCtrl_CalcScrolledPosition'");

27591

return NULL;

27592

}

27593

27594

27595

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcUnscrolledPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {

27596

PyObject *resultobj = 0;

27597

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27598

wxPoint *arg2 = 0 ;

27599

wxPoint result;

27600

void *argp1 = 0 ;

27601

int res1 = 0 ;

27602

wxPoint temp2 ;

27603

27604

if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;

27605

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27606

if (!SWIG_IsOK(res1)) {

27607

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CalcUnscrolledPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27608

}

27609

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27610

{

27611

arg2 = &temp2;

27612

if ( ! wxPoint_helper(swig_obj[1], &arg2)) SWIG_fail;

27613

}

27614

{

27615

PyThreadState* __tstate = wxPyBeginAllowThreads();

27616

result = ((wxRichTextCtrl const *)arg1)->CalcUnscrolledPosition((wxPoint const &)*arg2);

27617

wxPyEndAllowThreads(__tstate);

27618

if (PyErr_Occurred()) SWIG_fail;

27619

}

27620

resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );

27621

return resultobj;

27622

fail:

27623

return NULL;

27624

}

27625

27626

27627

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcUnscrolledPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {

27628

PyObject *resultobj = 0;

27629

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27630

int arg2 ;

27631

int arg3 ;

27632

int *arg4 = (int *) 0 ;

27633

int *arg5 = (int *) 0 ;

27634

void *argp1 = 0 ;

27635

int res1 = 0 ;

27636

int val2 ;

27637

int ecode2 = 0 ;

27638

int val3 ;

27639

int ecode3 = 0 ;

27640

int temp4 ;

27641

int res4 = SWIG_TMPOBJ ;

27642

int temp5 ;

27643

int res5 = SWIG_TMPOBJ ;

27644

27645

arg4 = &temp4;

27646

arg5 = &temp5;

27647

if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;

27648

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27649

if (!SWIG_IsOK(res1)) {

27650

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CalcUnscrolledPosition" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27651

}

27652

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27653

ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);

27654

if (!SWIG_IsOK(ecode2)) {

27655

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_CalcUnscrolledPosition" "', expected argument " "2"" of type '" "int""'");

27656

}

27657

arg2 = static_cast< int >(val2);

27658

ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);

27659

if (!SWIG_IsOK(ecode3)) {

27660

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_CalcUnscrolledPosition" "', expected argument " "3"" of type '" "int""'");

27661

}

27662

arg3 = static_cast< int >(val3);

27663

{

27664

PyThreadState* __tstate = wxPyBeginAllowThreads();

27665

((wxRichTextCtrl const *)arg1)->CalcUnscrolledPosition(arg2,arg3,arg4,arg5);

27666

wxPyEndAllowThreads(__tstate);

27667

if (PyErr_Occurred()) SWIG_fail;

27668

}

27669

resultobj = SWIG_Py_Void();

27670

if (SWIG_IsTmpObj(res4)) {

27671

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));

27672

} else {

27673

int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27674

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));

27675

}

27676

if (SWIG_IsTmpObj(res5)) {

27677

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));

27678

} else {

27679

int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;

27680

resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));

27681

}

27682

return resultobj;

27683

fail:

27684

return NULL;

27685

}

27686

27687

27688

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcUnscrolledPosition(PyObject *self, PyObject *args) {

27689

int argc;

27690

PyObject *argv[4];

27691

27692

if (!(argc = SWIG_Python_UnpackTuple(args,"RichTextCtrl_CalcUnscrolledPosition",0,3,argv))) SWIG_fail;

27693

--argc;

27694

if (argc == 2) {

27695

return _wrap_RichTextCtrl_CalcUnscrolledPosition__SWIG_0(self, argc, argv);

27696

}

27697

if (argc == 3) {

27698

return _wrap_RichTextCtrl_CalcUnscrolledPosition__SWIG_1(self, argc, argv);

27699

}

27700

27701

fail:

27702

SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'RichTextCtrl_CalcUnscrolledPosition'");

27703

return NULL;

27704

}

27705

27706

27707

SWIGINTERN PyObject *_wrap_RichTextCtrl_AdjustScrollbars(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27708

PyObject *resultobj = 0;

27709

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27710

void *argp1 = 0 ;

27711

int res1 = 0 ;

27712

PyObject *swig_obj[1] ;

27713

27714

if (!args) SWIG_fail;

27715

swig_obj[0] = args;

27716

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27717

if (!SWIG_IsOK(res1)) {

27718

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_AdjustScrollbars" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27719

}

27720

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27721

{

27722

PyThreadState* __tstate = wxPyBeginAllowThreads();

27723

(arg1)->AdjustScrollbars();

27724

wxPyEndAllowThreads(__tstate);

27725

if (PyErr_Occurred()) SWIG_fail;

27726

}

27727

resultobj = SWIG_Py_Void();

27728

return resultobj;

27729

fail:

27730

return NULL;

27731

}

27732

27733

27734

SWIGINTERN PyObject *_wrap_RichTextCtrl_CalcScrollInc(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27735

PyObject *resultobj = 0;

27736

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27737

wxScrollWinEvent *arg2 = 0 ;

27738

int result;

27739

void *argp1 = 0 ;

27740

int res1 = 0 ;

27741

void *argp2 = 0 ;

27742

int res2 = 0 ;

27743

PyObject * obj0 = 0 ;

27744

PyObject * obj1 = 0 ;

27745

char * kwnames[] = {

27746

(char *) "self",(char *) "event", NULL

27747

};

27748

27749

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_CalcScrollInc",kwnames,&obj0,&obj1)) SWIG_fail;

27750

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27751

if (!SWIG_IsOK(res1)) {

27752

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_CalcScrollInc" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27753

}

27754

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27755

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxScrollWinEvent, 0 );

27756

if (!SWIG_IsOK(res2)) {

27757

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_CalcScrollInc" "', expected argument " "2"" of type '" "wxScrollWinEvent &""'");

27758

}

27759

if (!argp2) {

27760

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_CalcScrollInc" "', expected argument " "2"" of type '" "wxScrollWinEvent &""'");

27761

}

27762

arg2 = reinterpret_cast< wxScrollWinEvent * >(argp2);

27763

{

27764

PyThreadState* __tstate = wxPyBeginAllowThreads();

27765

result = (int)(arg1)->CalcScrollInc(*arg2);

27766

wxPyEndAllowThreads(__tstate);

27767

if (PyErr_Occurred()) SWIG_fail;

27768

}

27769

resultobj = SWIG_From_int(static_cast< int >(result));

27770

return resultobj;

27771

fail:

27772

return NULL;

27773

}

27774

27775

27776

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetTargetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27777

PyObject *resultobj = 0;

27778

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27779

wxWindow *arg2 = (wxWindow *) 0 ;

27780

void *argp1 = 0 ;

27781

int res1 = 0 ;

27782

void *argp2 = 0 ;

27783

int res2 = 0 ;

27784

PyObject * obj0 = 0 ;

27785

PyObject * obj1 = 0 ;

27786

char * kwnames[] = {

27787

(char *) "self",(char *) "target", NULL

27788

};

27789

27790

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetTargetWindow",kwnames,&obj0,&obj1)) SWIG_fail;

27791

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27792

if (!SWIG_IsOK(res1)) {

27793

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetTargetWindow" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27794

}

27795

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27796

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

27797

if (!SWIG_IsOK(res2)) {

27798

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_SetTargetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");

27799

}

27800

arg2 = reinterpret_cast< wxWindow * >(argp2);

27801

{

27802

PyThreadState* __tstate = wxPyBeginAllowThreads();

27803

(arg1)->SetTargetWindow(arg2);

27804

wxPyEndAllowThreads(__tstate);

27805

if (PyErr_Occurred()) SWIG_fail;

27806

}

27807

resultobj = SWIG_Py_Void();

27808

return resultobj;

27809

fail:

27810

return NULL;

27811

}

27812

27813

27814

SWIGINTERN PyObject *_wrap_RichTextCtrl_GetTargetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27815

PyObject *resultobj = 0;

27816

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27817

wxWindow *result = 0 ;

27818

void *argp1 = 0 ;

27819

int res1 = 0 ;

27820

PyObject *swig_obj[1] ;

27821

27822

if (!args) SWIG_fail;

27823

swig_obj[0] = args;

27824

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27825

if (!SWIG_IsOK(res1)) {

27826

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetTargetWindow" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27827

}

27828

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27829

{

27830

PyThreadState* __tstate = wxPyBeginAllowThreads();

27831

result = (wxWindow *)((wxRichTextCtrl const *)arg1)->GetTargetWindow();

27832

wxPyEndAllowThreads(__tstate);

27833

if (PyErr_Occurred()) SWIG_fail;

27834

}

27835

{

27836

resultobj = wxPyMake_wxObject(result, 0);

27837

}

27838

return resultobj;

27839

fail:

27840

return NULL;

27841

}

27842

27843

27844

SWIGINTERN PyObject *_wrap_RichTextCtrl_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

27845

PyObject *resultobj = 0;

27846

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27847

bool result;

27848

void *argp1 = 0 ;

27849

int res1 = 0 ;

27850

PyObject *swig_obj[1] ;

27851

27852

if (!args) SWIG_fail;

27853

swig_obj[0] = args;

27854

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27855

if (!SWIG_IsOK(res1)) {

27856

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_IsEmpty" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");

27857

}

27858

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27859

{

27860

PyThreadState* __tstate = wxPyBeginAllowThreads();

27861

result = (bool)((wxRichTextCtrl const *)arg1)->IsEmpty();

27862

wxPyEndAllowThreads(__tstate);

27863

if (PyErr_Occurred()) SWIG_fail;

27864

}

27865

{

27866

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

27867

}

27868

return resultobj;

27869

fail:

27870

return NULL;

27871

}

27872

27873

27874

SWIGINTERN PyObject *_wrap_RichTextCtrl_ChangeValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27875

PyObject *resultobj = 0;

27876

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27877

wxString *arg2 = 0 ;

27878

void *argp1 = 0 ;

27879

int res1 = 0 ;

27880

bool temp2 = false ;

27881

PyObject * obj0 = 0 ;

27882

PyObject * obj1 = 0 ;

27883

char * kwnames[] = {

27884

(char *) "self",(char *) "value", NULL

27885

};

27886

27887

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_ChangeValue",kwnames,&obj0,&obj1)) SWIG_fail;

27888

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27889

if (!SWIG_IsOK(res1)) {

27890

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_ChangeValue" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27891

}

27892

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27893

{

27894

arg2 = wxString_in_helper(obj1);

27895

if (arg2 == NULL) SWIG_fail;

27896

temp2 = true;

27897

}

27898

{

27899

PyThreadState* __tstate = wxPyBeginAllowThreads();

27900

(arg1)->ChangeValue((wxString const &)*arg2);

27901

wxPyEndAllowThreads(__tstate);

27902

if (PyErr_Occurred()) SWIG_fail;

27903

}

27904

resultobj = SWIG_Py_Void();

27905

{

27906

if (temp2)

27907

delete arg2;

27908

}

27909

return resultobj;

27910

fail:

27911

{

27912

if (temp2)

27913

delete arg2;

27914

}

27915

return NULL;

27916

}

27917

27918

27919

SWIGINTERN PyObject *_wrap_RichTextCtrl_SetModified(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27920

PyObject *resultobj = 0;

27921

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27922

bool arg2 ;

27923

void *argp1 = 0 ;

27924

int res1 = 0 ;

27925

bool val2 ;

27926

int ecode2 = 0 ;

27927

PyObject * obj0 = 0 ;

27928

PyObject * obj1 = 0 ;

27929

char * kwnames[] = {

27930

(char *) "self",(char *) "modified", NULL

27931

};

27932

27933

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetModified",kwnames,&obj0,&obj1)) SWIG_fail;

27934

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27935

if (!SWIG_IsOK(res1)) {

27936

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetModified" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27937

}

27938

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27939

ecode2 = SWIG_AsVal_bool(obj1, &val2);

27940

if (!SWIG_IsOK(ecode2)) {

27941

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetModified" "', expected argument " "2"" of type '" "bool""'");

27942

}

27943

arg2 = static_cast< bool >(val2);

27944

{

27945

PyThreadState* __tstate = wxPyBeginAllowThreads();

27946

(arg1)->SetModified(arg2);

27947

wxPyEndAllowThreads(__tstate);

27948

if (PyErr_Occurred()) SWIG_fail;

27949

}

27950

resultobj = SWIG_Py_Void();

27951

return resultobj;

27952

fail:

27953

return NULL;

27954

}

27955

27956

27957

SWIGINTERN PyObject *_wrap_RichTextCtrl_EmulateKeyPress(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

27958

PyObject *resultobj = 0;

27959

wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;

27960

wxKeyEvent *arg2 = 0 ;

27961

bool result;

27962

void *argp1 = 0 ;

27963

int res1 = 0 ;

27964

void *argp2 = 0 ;

27965

int res2 = 0 ;

27966

PyObject * obj0 = 0 ;

27967

PyObject * obj1 = 0 ;

27968

char * kwnames[] = {

27969

(char *) "self",(char *) "event", NULL

27970

};

27971

27972

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_EmulateKeyPress",kwnames,&obj0,&obj1)) SWIG_fail;

27973

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );

27974

if (!SWIG_IsOK(res1)) {

27975

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EmulateKeyPress" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");

27976

}

27977

arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);

27978

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxKeyEvent, 0 | 0);

27979

if (!SWIG_IsOK(res2)) {

27980

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextCtrl_EmulateKeyPress" "', expected argument " "2"" of type '" "wxKeyEvent const &""'");

27981

}

27982

if (!argp2) {

27983

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextCtrl_EmulateKeyPress" "', expected argument " "2"" of type '" "wxKeyEvent const &""'");

27984

}

27985

arg2 = reinterpret_cast< wxKeyEvent * >(argp2);

27986

{

27987

PyThreadState* __tstate = wxPyBeginAllowThreads();

27988

result = (bool)(arg1)->EmulateKeyPress((wxKeyEvent const &)*arg2);

27989

wxPyEndAllowThreads(__tstate);

27990

if (PyErr_Occurred()) SWIG_fail;

27991

}

27992

{

27993

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

27994

}

27995

return resultobj;

27996

fail:

27997

return NULL;

27998

}

27999

28000

28001

SWIGINTERN PyObject *RichTextCtrl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28002

PyObject *obj;

28003

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

28004

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextCtrl, SWIG_NewClientData(obj));

28005

return SWIG_Py_Void();

28006

}

28007

28008

SWIGINTERN PyObject *RichTextCtrl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28009

return SWIG_Python_InitShadowInstance(args);

28010

}

28011

28012

SWIGINTERN PyObject *_wrap_new_RichTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28013

PyObject *resultobj = 0;

28014

wxEventType arg1 = (wxEventType) wxEVT_NULL ;

28015

int arg2 = (int) 0 ;

28016

wxRichTextEvent *result = 0 ;

28017

int val1 ;

28018

int ecode1 = 0 ;

28019

int val2 ;

28020

int ecode2 = 0 ;

28021

PyObject * obj0 = 0 ;

28022

PyObject * obj1 = 0 ;

28023

char * kwnames[] = {

28024

(char *) "commandType",(char *) "winid", NULL

28025

};

28026

28027

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RichTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;

28028

if (obj0) {

28029

ecode1 = SWIG_AsVal_int(obj0, &val1);

28030

if (!SWIG_IsOK(ecode1)) {

28031

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RichTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");

28032

}

28033

arg1 = static_cast< wxEventType >(val1);

28034

}

28035

if (obj1) {

28036

ecode2 = SWIG_AsVal_int(obj1, &val2);

28037

if (!SWIG_IsOK(ecode2)) {

28038

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RichTextEvent" "', expected argument " "2"" of type '" "int""'");

28039

}

28040

arg2 = static_cast< int >(val2);

28041

}

28042

{

28043

PyThreadState* __tstate = wxPyBeginAllowThreads();

28044

result = (wxRichTextEvent *)new wxRichTextEvent(arg1,arg2);

28045

wxPyEndAllowThreads(__tstate);

28046

if (PyErr_Occurred()) SWIG_fail;

28047

}

28048

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextEvent, SWIG_POINTER_NEW | 0 );

28049

return resultobj;

28050

fail:

28051

return NULL;

28052

}

28053

28054

28055

SWIGINTERN PyObject *_wrap_RichTextEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28056

PyObject *resultobj = 0;

28057

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28058

int result;

28059

void *argp1 = 0 ;

28060

int res1 = 0 ;

28061

PyObject *swig_obj[1] ;

28062

28063

if (!args) SWIG_fail;

28064

swig_obj[0] = args;

28065

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28066

if (!SWIG_IsOK(res1)) {

28067

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_GetPosition" "', expected argument " "1"" of type '" "wxRichTextEvent const *""'");

28068

}

28069

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28070

{

28071

PyThreadState* __tstate = wxPyBeginAllowThreads();

28072

result = (int)((wxRichTextEvent const *)arg1)->GetPosition();

28073

wxPyEndAllowThreads(__tstate);

28074

if (PyErr_Occurred()) SWIG_fail;

28075

}

28076

resultobj = SWIG_From_int(static_cast< int >(result));

28077

return resultobj;

28078

fail:

28079

return NULL;

28080

}

28081

28082

28083

SWIGINTERN PyObject *_wrap_RichTextEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28084

PyObject *resultobj = 0;

28085

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28086

int arg2 ;

28087

void *argp1 = 0 ;

28088

int res1 = 0 ;

28089

int val2 ;

28090

int ecode2 = 0 ;

28091

PyObject * obj0 = 0 ;

28092

PyObject * obj1 = 0 ;

28093

char * kwnames[] = {

28094

(char *) "self",(char *) "n", NULL

28095

};

28096

28097

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;

28098

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28099

if (!SWIG_IsOK(res1)) {

28100

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_SetPosition" "', expected argument " "1"" of type '" "wxRichTextEvent *""'");

28101

}

28102

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28103

ecode2 = SWIG_AsVal_int(obj1, &val2);

28104

if (!SWIG_IsOK(ecode2)) {

28105

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");

28106

}

28107

arg2 = static_cast< int >(val2);

28108

{

28109

PyThreadState* __tstate = wxPyBeginAllowThreads();

28110

(arg1)->SetPosition(arg2);

28111

wxPyEndAllowThreads(__tstate);

28112

if (PyErr_Occurred()) SWIG_fail;

28113

}

28114

resultobj = SWIG_Py_Void();

28115

return resultobj;

28116

fail:

28117

return NULL;

28118

}

28119

28120

28121

SWIGINTERN PyObject *_wrap_RichTextEvent_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28122

PyObject *resultobj = 0;

28123

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28124

int result;

28125

void *argp1 = 0 ;

28126

int res1 = 0 ;

28127

PyObject *swig_obj[1] ;

28128

28129

if (!args) SWIG_fail;

28130

swig_obj[0] = args;

28131

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28132

if (!SWIG_IsOK(res1)) {

28133

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_GetFlags" "', expected argument " "1"" of type '" "wxRichTextEvent const *""'");

28134

}

28135

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28136

{

28137

PyThreadState* __tstate = wxPyBeginAllowThreads();

28138

result = (int)((wxRichTextEvent const *)arg1)->GetFlags();

28139

wxPyEndAllowThreads(__tstate);

28140

if (PyErr_Occurred()) SWIG_fail;

28141

}

28142

resultobj = SWIG_From_int(static_cast< int >(result));

28143

return resultobj;

28144

fail:

28145

return NULL;

28146

}

28147

28148

28149

SWIGINTERN PyObject *_wrap_RichTextEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28150

PyObject *resultobj = 0;

28151

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28152

int arg2 ;

28153

void *argp1 = 0 ;

28154

int res1 = 0 ;

28155

int val2 ;

28156

int ecode2 = 0 ;

28157

PyObject * obj0 = 0 ;

28158

PyObject * obj1 = 0 ;

28159

char * kwnames[] = {

28160

(char *) "self",(char *) "flags", NULL

28161

};

28162

28163

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;

28164

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28165

if (!SWIG_IsOK(res1)) {

28166

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_SetFlags" "', expected argument " "1"" of type '" "wxRichTextEvent *""'");

28167

}

28168

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28169

ecode2 = SWIG_AsVal_int(obj1, &val2);

28170

if (!SWIG_IsOK(ecode2)) {

28171

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextEvent_SetFlags" "', expected argument " "2"" of type '" "int""'");

28172

}

28173

arg2 = static_cast< int >(val2);

28174

{

28175

PyThreadState* __tstate = wxPyBeginAllowThreads();

28176

(arg1)->SetFlags(arg2);

28177

wxPyEndAllowThreads(__tstate);

28178

if (PyErr_Occurred()) SWIG_fail;

28179

}

28180

resultobj = SWIG_Py_Void();

28181

return resultobj;

28182

fail:

28183

return NULL;

28184

}

28185

28186

28187

SWIGINTERN PyObject *_wrap_RichTextEvent_GetOldStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28188

PyObject *resultobj = 0;

28189

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28190

wxRichTextStyleSheet *result = 0 ;

28191

void *argp1 = 0 ;

28192

int res1 = 0 ;

28193

PyObject *swig_obj[1] ;

28194

28195

if (!args) SWIG_fail;

28196

swig_obj[0] = args;

28197

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28198

if (!SWIG_IsOK(res1)) {

28199

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_GetOldStyleSheet" "', expected argument " "1"" of type '" "wxRichTextEvent const *""'");

28200

}

28201

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28202

{

28203

PyThreadState* __tstate = wxPyBeginAllowThreads();

28204

result = (wxRichTextStyleSheet *)((wxRichTextEvent const *)arg1)->GetOldStyleSheet();

28205

wxPyEndAllowThreads(__tstate);

28206

if (PyErr_Occurred()) SWIG_fail;

28207

}

28208

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

28209

return resultobj;

28210

fail:

28211

return NULL;

28212

}

28213

28214

28215

SWIGINTERN PyObject *_wrap_RichTextEvent_SetOldStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28216

PyObject *resultobj = 0;

28217

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28218

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

28219

void *argp1 = 0 ;

28220

int res1 = 0 ;

28221

void *argp2 = 0 ;

28222

int res2 = 0 ;

28223

PyObject * obj0 = 0 ;

28224

PyObject * obj1 = 0 ;

28225

char * kwnames[] = {

28226

(char *) "self",(char *) "sheet", NULL

28227

};

28228

28229

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextEvent_SetOldStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

28230

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28231

if (!SWIG_IsOK(res1)) {

28232

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_SetOldStyleSheet" "', expected argument " "1"" of type '" "wxRichTextEvent *""'");

28233

}

28234

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28235

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

28236

if (!SWIG_IsOK(res2)) {

28237

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextEvent_SetOldStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

28238

}

28239

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

28240

{

28241

PyThreadState* __tstate = wxPyBeginAllowThreads();

28242

(arg1)->SetOldStyleSheet(arg2);

28243

wxPyEndAllowThreads(__tstate);

28244

if (PyErr_Occurred()) SWIG_fail;

28245

}

28246

resultobj = SWIG_Py_Void();

28247

return resultobj;

28248

fail:

28249

return NULL;

28250

}

28251

28252

28253

SWIGINTERN PyObject *_wrap_RichTextEvent_GetNewStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28254

PyObject *resultobj = 0;

28255

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28256

wxRichTextStyleSheet *result = 0 ;

28257

void *argp1 = 0 ;

28258

int res1 = 0 ;

28259

PyObject *swig_obj[1] ;

28260

28261

if (!args) SWIG_fail;

28262

swig_obj[0] = args;

28263

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28264

if (!SWIG_IsOK(res1)) {

28265

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_GetNewStyleSheet" "', expected argument " "1"" of type '" "wxRichTextEvent const *""'");

28266

}

28267

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28268

{

28269

PyThreadState* __tstate = wxPyBeginAllowThreads();

28270

result = (wxRichTextStyleSheet *)((wxRichTextEvent const *)arg1)->GetNewStyleSheet();

28271

wxPyEndAllowThreads(__tstate);

28272

if (PyErr_Occurred()) SWIG_fail;

28273

}

28274

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

28275

return resultobj;

28276

fail:

28277

return NULL;

28278

}

28279

28280

28281

SWIGINTERN PyObject *_wrap_RichTextEvent_SetNewStyleSheet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28282

PyObject *resultobj = 0;

28283

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28284

wxRichTextStyleSheet *arg2 = (wxRichTextStyleSheet *) 0 ;

28285

void *argp1 = 0 ;

28286

int res1 = 0 ;

28287

void *argp2 = 0 ;

28288

int res2 = 0 ;

28289

PyObject * obj0 = 0 ;

28290

PyObject * obj1 = 0 ;

28291

char * kwnames[] = {

28292

(char *) "self",(char *) "sheet", NULL

28293

};

28294

28295

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextEvent_SetNewStyleSheet",kwnames,&obj0,&obj1)) SWIG_fail;

28296

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28297

if (!SWIG_IsOK(res1)) {

28298

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_SetNewStyleSheet" "', expected argument " "1"" of type '" "wxRichTextEvent *""'");

28299

}

28300

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28301

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextStyleSheet, 0 | 0 );

28302

if (!SWIG_IsOK(res2)) {

28303

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextEvent_SetNewStyleSheet" "', expected argument " "2"" of type '" "wxRichTextStyleSheet *""'");

28304

}

28305

arg2 = reinterpret_cast< wxRichTextStyleSheet * >(argp2);

28306

{

28307

PyThreadState* __tstate = wxPyBeginAllowThreads();

28308

(arg1)->SetNewStyleSheet(arg2);

28309

wxPyEndAllowThreads(__tstate);

28310

if (PyErr_Occurred()) SWIG_fail;

28311

}

28312

resultobj = SWIG_Py_Void();

28313

return resultobj;

28314

fail:

28315

return NULL;

28316

}

28317

28318

28319

SWIGINTERN PyObject *_wrap_RichTextEvent_GetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28320

PyObject *resultobj = 0;

28321

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28322

wxRichTextRange *result = 0 ;

28323

void *argp1 = 0 ;

28324

int res1 = 0 ;

28325

PyObject *swig_obj[1] ;

28326

28327

if (!args) SWIG_fail;

28328

swig_obj[0] = args;

28329

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28330

if (!SWIG_IsOK(res1)) {

28331

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_GetRange" "', expected argument " "1"" of type '" "wxRichTextEvent const *""'");

28332

}

28333

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28334

{

28335

PyThreadState* __tstate = wxPyBeginAllowThreads();

28336

{

28337

wxRichTextRange const &_result_ref = ((wxRichTextEvent const *)arg1)->GetRange();

28338

result = (wxRichTextRange *) &_result_ref;

28339

}

28340

wxPyEndAllowThreads(__tstate);

28341

if (PyErr_Occurred()) SWIG_fail;

28342

}

28343

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextRange, 0 | 0 );

28344

return resultobj;

28345

fail:

28346

return NULL;

28347

}

28348

28349

28350

SWIGINTERN PyObject *_wrap_RichTextEvent_SetRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28351

PyObject *resultobj = 0;

28352

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28353

wxRichTextRange *arg2 = 0 ;

28354

void *argp1 = 0 ;

28355

int res1 = 0 ;

28356

wxRichTextRange temp2 ;

28357

PyObject * obj0 = 0 ;

28358

PyObject * obj1 = 0 ;

28359

char * kwnames[] = {

28360

(char *) "self",(char *) "range", NULL

28361

};

28362

28363

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextEvent_SetRange",kwnames,&obj0,&obj1)) SWIG_fail;

28364

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28365

if (!SWIG_IsOK(res1)) {

28366

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_SetRange" "', expected argument " "1"" of type '" "wxRichTextEvent *""'");

28367

}

28368

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28369

{

28370

arg2 = &temp2;

28371

if ( ! wxRichTextRange_helper(obj1, &arg2)) SWIG_fail;

28372

}

28373

{

28374

PyThreadState* __tstate = wxPyBeginAllowThreads();

28375

(arg1)->SetRange((wxRichTextRange const &)*arg2);

28376

wxPyEndAllowThreads(__tstate);

28377

if (PyErr_Occurred()) SWIG_fail;

28378

}

28379

resultobj = SWIG_Py_Void();

28380

return resultobj;

28381

fail:

28382

return NULL;

28383

}

28384

28385

28386

SWIGINTERN PyObject *_wrap_RichTextEvent_GetCharacter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28387

PyObject *resultobj = 0;

28388

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28389

wxChar result;

28390

void *argp1 = 0 ;

28391

int res1 = 0 ;

28392

PyObject *swig_obj[1] ;

28393

28394

if (!args) SWIG_fail;

28395

swig_obj[0] = args;

28396

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28397

if (!SWIG_IsOK(res1)) {

28398

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_GetCharacter" "', expected argument " "1"" of type '" "wxRichTextEvent const *""'");

28399

}

28400

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28401

{

28402

PyThreadState* __tstate = wxPyBeginAllowThreads();

28403

result = ((wxRichTextEvent const *)arg1)->GetCharacter();

28404

wxPyEndAllowThreads(__tstate);

28405

if (PyErr_Occurred()) SWIG_fail;

28406

}

28407

{

28408

wxString s(result);

28409

resultobj = wx2PyString(s);

28410

}

28411

return resultobj;

28412

fail:

28413

return NULL;

28414

}

28415

28416

28417

SWIGINTERN PyObject *_wrap_RichTextEvent_SetCharacter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28418

PyObject *resultobj = 0;

28419

wxRichTextEvent *arg1 = (wxRichTextEvent *) 0 ;

28420

wxChar arg2 ;

28421

void *argp1 = 0 ;

28422

int res1 = 0 ;

28423

PyObject * obj0 = 0 ;

28424

PyObject * obj1 = 0 ;

28425

char * kwnames[] = {

28426

(char *) "self",(char *) "ch", NULL

28427

};

28428

28429

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextEvent_SetCharacter",kwnames,&obj0,&obj1)) SWIG_fail;

28430

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextEvent, 0 | 0 );

28431

if (!SWIG_IsOK(res1)) {

28432

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextEvent_SetCharacter" "', expected argument " "1"" of type '" "wxRichTextEvent *""'");

28433

}

28434

arg1 = reinterpret_cast< wxRichTextEvent * >(argp1);

28435

{

28436

wxString s = Py2wxString(obj1);

28437

arg2 = s[0];

28438

}

28439

{

28440

PyThreadState* __tstate = wxPyBeginAllowThreads();

28441

(arg1)->SetCharacter(arg2);

28442

wxPyEndAllowThreads(__tstate);

28443

if (PyErr_Occurred()) SWIG_fail;

28444

}

28445

resultobj = SWIG_Py_Void();

28446

return resultobj;

28447

fail:

28448

return NULL;

28449

}

28450

28451

28452

SWIGINTERN PyObject *RichTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28453

PyObject *obj;

28454

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

28455

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextEvent, SWIG_NewClientData(obj));

28456

return SWIG_Py_Void();

28457

}

28458

28459

SWIGINTERN PyObject *RichTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28460

return SWIG_Python_InitShadowInstance(args);

28461

}

28462

28463

SWIGINTERN int HtmlName_set(PyObject *) {

28464

SWIG_Error(SWIG_AttributeError,"Variable HtmlName is read-only.");

28465

return 1;

28466

}

28467

28468

28469

SWIGINTERN PyObject *HtmlName_get(void) {

28470

PyObject *pyobj = 0;

28471

28472

{

28473

#if wxUSE_UNICODE

28474

pyobj = PyUnicode_FromWideChar((&wxPyHtmlName)->c_str(), (&wxPyHtmlName)->Len());

28475

#else

28476

pyobj = PyString_FromStringAndSize((&wxPyHtmlName)->c_str(), (&wxPyHtmlName)->Len());

28477

#endif

28478

}

28479

return pyobj;

28480

}

28481

28482

28483

SWIGINTERN int HtmlExt_set(PyObject *) {

28484

SWIG_Error(SWIG_AttributeError,"Variable HtmlExt is read-only.");

28485

return 1;

28486

}

28487

28488

28489

SWIGINTERN PyObject *HtmlExt_get(void) {

28490

PyObject *pyobj = 0;

28491

28492

{

28493

#if wxUSE_UNICODE

28494

pyobj = PyUnicode_FromWideChar((&wxPyHtmlExt)->c_str(), (&wxPyHtmlExt)->Len());

28495

#else

28496

pyobj = PyString_FromStringAndSize((&wxPyHtmlExt)->c_str(), (&wxPyHtmlExt)->Len());

28497

#endif

28498

}

28499

return pyobj;

28500

}

28501

28502

28503

SWIGINTERN PyObject *_wrap_new_RichTextHTMLHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28504

PyObject *resultobj = 0;

28505

wxString const &arg1_defvalue = wxPyHtmlName ;

28506

wxString *arg1 = (wxString *) &arg1_defvalue ;

28507

wxString const &arg2_defvalue = wxPyHtmlExt ;

28508

wxString *arg2 = (wxString *) &arg2_defvalue ;

28509

int arg3 = (int) wxRICHTEXT_TYPE_HTML ;

28510

wxRichTextHTMLHandler *result = 0 ;

28511

bool temp1 = false ;

28512

bool temp2 = false ;

28513

int val3 ;

28514

int ecode3 = 0 ;

28515

PyObject * obj0 = 0 ;

28516

PyObject * obj1 = 0 ;

28517

PyObject * obj2 = 0 ;

28518

char * kwnames[] = {

28519

(char *) "name",(char *) "ext",(char *) "type", NULL

28520

};

28521

28522

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_RichTextHTMLHandler",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

28523

if (obj0) {

28524

{

28525

arg1 = wxString_in_helper(obj0);

28526

if (arg1 == NULL) SWIG_fail;

28527

temp1 = true;

28528

}

28529

}

28530

if (obj1) {

28531

{

28532

arg2 = wxString_in_helper(obj1);

28533

if (arg2 == NULL) SWIG_fail;

28534

temp2 = true;

28535

}

28536

}

28537

if (obj2) {

28538

ecode3 = SWIG_AsVal_int(obj2, &val3);

28539

if (!SWIG_IsOK(ecode3)) {

28540

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RichTextHTMLHandler" "', expected argument " "3"" of type '" "int""'");

28541

}

28542

arg3 = static_cast< int >(val3);

28543

}

28544

{

28545

PyThreadState* __tstate = wxPyBeginAllowThreads();

28546

result = (wxRichTextHTMLHandler *)new wxRichTextHTMLHandler((wxString const &)*arg1,(wxString const &)*arg2,arg3);

28547

wxPyEndAllowThreads(__tstate);

28548

if (PyErr_Occurred()) SWIG_fail;

28549

}

28550

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextHTMLHandler, SWIG_POINTER_NEW | 0 );

28551

{

28552

if (temp1)

28553

delete arg1;

28554

}

28555

{

28556

if (temp2)

28557

delete arg2;

28558

}

28559

return resultobj;

28560

fail:

28561

{

28562

if (temp1)

28563

delete arg1;

28564

}

28565

{

28566

if (temp2)

28567

delete arg2;

28568

}

28569

return NULL;

28570

}

28571

28572

28573

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_SetTemporaryImageLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28574

PyObject *resultobj = 0;

28575

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28576

wxArrayString *arg2 = 0 ;

28577

void *argp1 = 0 ;

28578

int res1 = 0 ;

28579

bool temp2 = false ;

28580

PyObject * obj0 = 0 ;

28581

PyObject * obj1 = 0 ;

28582

char * kwnames[] = {

28583

(char *) "self",(char *) "locations", NULL

28584

};

28585

28586

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextHTMLHandler_SetTemporaryImageLocations",kwnames,&obj0,&obj1)) SWIG_fail;

28587

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28588

if (!SWIG_IsOK(res1)) {

28589

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_SetTemporaryImageLocations" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler *""'");

28590

}

28591

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28592

{

28593

if (! PySequence_Check(obj1)) {

28594

PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");

28595

SWIG_fail;

28596

}

28597

arg2 = new wxArrayString;

28598

temp2 = true;

28599

int i, len=PySequence_Length(obj1);

28600

for (i=0; i<len; i++) {

28601

PyObject* item = PySequence_GetItem(obj1, i);

28602

wxString* s = wxString_in_helper(item);

28603

if (PyErr_Occurred()) SWIG_fail;

28604

arg2->Add(*s);

28605

delete s;

28606

Py_DECREF(item);

28607

}

28608

}

28609

{

28610

PyThreadState* __tstate = wxPyBeginAllowThreads();

28611

(arg1)->SetTemporaryImageLocations((wxArrayString const &)*arg2);

28612

wxPyEndAllowThreads(__tstate);

28613

if (PyErr_Occurred()) SWIG_fail;

28614

}

28615

resultobj = SWIG_Py_Void();

28616

{

28617

if (temp2) delete arg2;

28618

}

28619

return resultobj;

28620

fail:

28621

{

28622

if (temp2) delete arg2;

28623

}

28624

return NULL;

28625

}

28626

28627

28628

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_GetTemporaryImageLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28629

PyObject *resultobj = 0;

28630

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28631

wxArrayString *result = 0 ;

28632

void *argp1 = 0 ;

28633

int res1 = 0 ;

28634

PyObject *swig_obj[1] ;

28635

28636

if (!args) SWIG_fail;

28637

swig_obj[0] = args;

28638

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28639

if (!SWIG_IsOK(res1)) {

28640

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_GetTemporaryImageLocations" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler const *""'");

28641

}

28642

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28643

{

28644

PyThreadState* __tstate = wxPyBeginAllowThreads();

28645

{

28646

wxArrayString const &_result_ref = ((wxRichTextHTMLHandler const *)arg1)->GetTemporaryImageLocations();

28647

result = (wxArrayString *) &_result_ref;

28648

}

28649

wxPyEndAllowThreads(__tstate);

28650

if (PyErr_Occurred()) SWIG_fail;

28651

}

28652

{

28653

resultobj = wxArrayString2PyList_helper(*result);

28654

}

28655

return resultobj;

28656

fail:

28657

return NULL;

28658

}

28659

28660

28661

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_ClearTemporaryImageLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28662

PyObject *resultobj = 0;

28663

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28664

void *argp1 = 0 ;

28665

int res1 = 0 ;

28666

PyObject *swig_obj[1] ;

28667

28668

if (!args) SWIG_fail;

28669

swig_obj[0] = args;

28670

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28671

if (!SWIG_IsOK(res1)) {

28672

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_ClearTemporaryImageLocations" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler *""'");

28673

}

28674

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28675

{

28676

PyThreadState* __tstate = wxPyBeginAllowThreads();

28677

(arg1)->ClearTemporaryImageLocations();

28678

wxPyEndAllowThreads(__tstate);

28679

if (PyErr_Occurred()) SWIG_fail;

28680

}

28681

resultobj = SWIG_Py_Void();

28682

return resultobj;

28683

fail:

28684

return NULL;

28685

}

28686

28687

28688

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_DeleteTemporaryImages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28689

PyObject *resultobj = 0;

28690

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28691

bool result;

28692

void *argp1 = 0 ;

28693

int res1 = 0 ;

28694

PyObject *swig_obj[1] ;

28695

28696

if (!args) SWIG_fail;

28697

swig_obj[0] = args;

28698

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28699

if (!SWIG_IsOK(res1)) {

28700

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_DeleteTemporaryImages" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler *""'");

28701

}

28702

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28703

{

28704

PyThreadState* __tstate = wxPyBeginAllowThreads();

28705

result = (bool)(arg1)->DeleteTemporaryImages();

28706

wxPyEndAllowThreads(__tstate);

28707

if (PyErr_Occurred()) SWIG_fail;

28708

}

28709

{

28710

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

28711

}

28712

return resultobj;

28713

fail:

28714

return NULL;

28715

}

28716

28717

28718

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_SetFileCounter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28719

PyObject *resultobj = 0;

28720

int arg1 ;

28721

int val1 ;

28722

int ecode1 = 0 ;

28723

PyObject * obj0 = 0 ;

28724

char * kwnames[] = {

28725

(char *) "counter", NULL

28726

};

28727

28728

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RichTextHTMLHandler_SetFileCounter",kwnames,&obj0)) SWIG_fail;

28729

ecode1 = SWIG_AsVal_int(obj0, &val1);

28730

if (!SWIG_IsOK(ecode1)) {

28731

SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RichTextHTMLHandler_SetFileCounter" "', expected argument " "1"" of type '" "int""'");

28732

}

28733

arg1 = static_cast< int >(val1);

28734

{

28735

PyThreadState* __tstate = wxPyBeginAllowThreads();

28736

wxRichTextHTMLHandler::SetFileCounter(arg1);

28737

wxPyEndAllowThreads(__tstate);

28738

if (PyErr_Occurred()) SWIG_fail;

28739

}

28740

resultobj = SWIG_Py_Void();

28741

return resultobj;

28742

fail:

28743

return NULL;

28744

}

28745

28746

28747

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_SetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28748

PyObject *resultobj = 0;

28749

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28750

wxString *arg2 = 0 ;

28751

void *argp1 = 0 ;

28752

int res1 = 0 ;

28753

bool temp2 = false ;

28754

PyObject * obj0 = 0 ;

28755

PyObject * obj1 = 0 ;

28756

char * kwnames[] = {

28757

(char *) "self",(char *) "tempDir", NULL

28758

};

28759

28760

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextHTMLHandler_SetTempDir",kwnames,&obj0,&obj1)) SWIG_fail;

28761

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28762

if (!SWIG_IsOK(res1)) {

28763

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_SetTempDir" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler *""'");

28764

}

28765

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28766

{

28767

arg2 = wxString_in_helper(obj1);

28768

if (arg2 == NULL) SWIG_fail;

28769

temp2 = true;

28770

}

28771

{

28772

PyThreadState* __tstate = wxPyBeginAllowThreads();

28773

(arg1)->SetTempDir((wxString const &)*arg2);

28774

wxPyEndAllowThreads(__tstate);

28775

if (PyErr_Occurred()) SWIG_fail;

28776

}

28777

resultobj = SWIG_Py_Void();

28778

{

28779

if (temp2)

28780

delete arg2;

28781

}

28782

return resultobj;

28783

fail:

28784

{

28785

if (temp2)

28786

delete arg2;

28787

}

28788

return NULL;

28789

}

28790

28791

28792

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_GetTempDir(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28793

PyObject *resultobj = 0;

28794

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28795

wxString *result = 0 ;

28796

void *argp1 = 0 ;

28797

int res1 = 0 ;

28798

PyObject *swig_obj[1] ;

28799

28800

if (!args) SWIG_fail;

28801

swig_obj[0] = args;

28802

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28803

if (!SWIG_IsOK(res1)) {

28804

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_GetTempDir" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler const *""'");

28805

}

28806

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28807

{

28808

PyThreadState* __tstate = wxPyBeginAllowThreads();

28809

{

28810

wxString const &_result_ref = ((wxRichTextHTMLHandler const *)arg1)->GetTempDir();

28811

result = (wxString *) &_result_ref;

28812

}

28813

wxPyEndAllowThreads(__tstate);

28814

if (PyErr_Occurred()) SWIG_fail;

28815

}

28816

{

28817

#if wxUSE_UNICODE

28818

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

28819

#else

28820

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

28821

#endif

28822

}

28823

return resultobj;

28824

fail:

28825

return NULL;

28826

}

28827

28828

28829

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_SetFontSizeMapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28830

PyObject *resultobj = 0;

28831

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28832

wxArrayInt *arg2 = 0 ;

28833

void *argp1 = 0 ;

28834

int res1 = 0 ;

28835

bool temp2 = false ;

28836

PyObject * obj0 = 0 ;

28837

PyObject * obj1 = 0 ;

28838

char * kwnames[] = {

28839

(char *) "self",(char *) "fontSizeMapping", NULL

28840

};

28841

28842

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextHTMLHandler_SetFontSizeMapping",kwnames,&obj0,&obj1)) SWIG_fail;

28843

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28844

if (!SWIG_IsOK(res1)) {

28845

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_SetFontSizeMapping" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler *""'");

28846

}

28847

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28848

{

28849

if (! PySequence_Check(obj1)) {

28850

PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");

28851

SWIG_fail;

28852

}

28853

arg2 = new wxArrayInt;

28854

temp2 = true;

28855

int i, len=PySequence_Length(obj1);

28856

for (i=0; i<len; i++) {

28857

PyObject* item = PySequence_GetItem(obj1, i);

28858

PyObject* number = PyNumber_Int(item);

28859

if (!number) {

28860

PyErr_SetString(PyExc_TypeError, "Sequence of integers expected.");

28861

SWIG_fail;

28862

}

28863

arg2->Add(PyInt_AS_LONG(number));

28864

Py_DECREF(item);

28865

Py_DECREF(number);

28866

}

28867

}

28868

{

28869

PyThreadState* __tstate = wxPyBeginAllowThreads();

28870

(arg1)->SetFontSizeMapping((wxArrayInt const &)*arg2);

28871

wxPyEndAllowThreads(__tstate);

28872

if (PyErr_Occurred()) SWIG_fail;

28873

}

28874

resultobj = SWIG_Py_Void();

28875

{

28876

if (temp2) delete arg2;

28877

}

28878

return resultobj;

28879

fail:

28880

{

28881

if (temp2) delete arg2;

28882

}

28883

return NULL;

28884

}

28885

28886

28887

SWIGINTERN PyObject *_wrap_RichTextHTMLHandler_GetFontSizeMapping(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28888

PyObject *resultobj = 0;

28889

wxRichTextHTMLHandler *arg1 = (wxRichTextHTMLHandler *) 0 ;

28890

wxArrayInt result;

28891

void *argp1 = 0 ;

28892

int res1 = 0 ;

28893

PyObject *swig_obj[1] ;

28894

28895

if (!args) SWIG_fail;

28896

swig_obj[0] = args;

28897

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextHTMLHandler, 0 | 0 );

28898

if (!SWIG_IsOK(res1)) {

28899

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextHTMLHandler_GetFontSizeMapping" "', expected argument " "1"" of type '" "wxRichTextHTMLHandler const *""'");

28900

}

28901

arg1 = reinterpret_cast< wxRichTextHTMLHandler * >(argp1);

28902

{

28903

PyThreadState* __tstate = wxPyBeginAllowThreads();

28904

result = ((wxRichTextHTMLHandler const *)arg1)->GetFontSizeMapping();

28905

wxPyEndAllowThreads(__tstate);

28906

if (PyErr_Occurred()) SWIG_fail;

28907

}

28908

{

28909

resultobj = wxArrayInt2PyList_helper(result);

28910

}

28911

return resultobj;

28912

fail:

28913

return NULL;

28914

}

28915

28916

28917

SWIGINTERN PyObject *RichTextHTMLHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28918

PyObject *obj;

28919

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

28920

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextHTMLHandler, SWIG_NewClientData(obj));

28921

return SWIG_Py_Void();

28922

}

28923

28924

SWIGINTERN PyObject *RichTextHTMLHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

28925

return SWIG_Python_InitShadowInstance(args);

28926

}

28927

28928

SWIGINTERN int XmlName_set(PyObject *) {

28929

SWIG_Error(SWIG_AttributeError,"Variable XmlName is read-only.");

28930

return 1;

28931

}

28932

28933

28934

SWIGINTERN PyObject *XmlName_get(void) {

28935

PyObject *pyobj = 0;

28936

28937

{

28938

#if wxUSE_UNICODE

28939

pyobj = PyUnicode_FromWideChar((&wxPyXmlName)->c_str(), (&wxPyXmlName)->Len());

28940

#else

28941

pyobj = PyString_FromStringAndSize((&wxPyXmlName)->c_str(), (&wxPyXmlName)->Len());

28942

#endif

28943

}

28944

return pyobj;

28945

}

28946

28947

28948

SWIGINTERN int XmlExt_set(PyObject *) {

28949

SWIG_Error(SWIG_AttributeError,"Variable XmlExt is read-only.");

28950

return 1;

28951

}

28952

28953

28954

SWIGINTERN PyObject *XmlExt_get(void) {

28955

PyObject *pyobj = 0;

28956

28957

{

28958

#if wxUSE_UNICODE

28959

pyobj = PyUnicode_FromWideChar((&wxPyXmlExt)->c_str(), (&wxPyXmlExt)->Len());

28960

#else

28961

pyobj = PyString_FromStringAndSize((&wxPyXmlExt)->c_str(), (&wxPyXmlExt)->Len());

28962

#endif

28963

}

28964

return pyobj;

28965

}

28966

28967

28968

SWIGINTERN PyObject *_wrap_new_RichTextXMLHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

28969

PyObject *resultobj = 0;

28970

wxString const &arg1_defvalue = wxPyXmlName ;

28971

wxString *arg1 = (wxString *) &arg1_defvalue ;

28972

wxString const &arg2_defvalue = wxPyXmlExt ;

28973

wxString *arg2 = (wxString *) &arg2_defvalue ;

28974

int arg3 = (int) wxRICHTEXT_TYPE_XML ;

28975

wxRichTextXMLHandler *result = 0 ;

28976

bool temp1 = false ;

28977

bool temp2 = false ;

28978

int val3 ;

28979

int ecode3 = 0 ;

28980

PyObject * obj0 = 0 ;

28981

PyObject * obj1 = 0 ;

28982

PyObject * obj2 = 0 ;

28983

char * kwnames[] = {

28984

(char *) "name",(char *) "ext",(char *) "type", NULL

28985

};

28986

28987

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_RichTextXMLHandler",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

28988

if (obj0) {

28989

{

28990

arg1 = wxString_in_helper(obj0);

28991

if (arg1 == NULL) SWIG_fail;

28992

temp1 = true;

28993

}

28994

}

28995

if (obj1) {

28996

{

28997

arg2 = wxString_in_helper(obj1);

28998

if (arg2 == NULL) SWIG_fail;

28999

temp2 = true;

29000

}

29001

}

29002

if (obj2) {

29003

ecode3 = SWIG_AsVal_int(obj2, &val3);

29004

if (!SWIG_IsOK(ecode3)) {

29005

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RichTextXMLHandler" "', expected argument " "3"" of type '" "int""'");

29006

}

29007

arg3 = static_cast< int >(val3);

29008

}

29009

{

29010

PyThreadState* __tstate = wxPyBeginAllowThreads();

29011

result = (wxRichTextXMLHandler *)new wxRichTextXMLHandler((wxString const &)*arg1,(wxString const &)*arg2,arg3);

29012

wxPyEndAllowThreads(__tstate);

29013

if (PyErr_Occurred()) SWIG_fail;

29014

}

29015

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextXMLHandler, SWIG_POINTER_NEW | 0 );

29016

{

29017

if (temp1)

29018

delete arg1;

29019

}

29020

{

29021

if (temp2)

29022

delete arg2;

29023

}

29024

return resultobj;

29025

fail:

29026

{

29027

if (temp1)

29028

delete arg1;

29029

}

29030

{

29031

if (temp2)

29032

delete arg2;

29033

}

29034

return NULL;

29035

}

29036

29037

29038

SWIGINTERN PyObject *RichTextXMLHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29039

PyObject *obj;

29040

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

29041

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextXMLHandler, SWIG_NewClientData(obj));

29042

return SWIG_Py_Void();

29043

}

29044

29045

SWIGINTERN PyObject *RichTextXMLHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29046

return SWIG_Python_InitShadowInstance(args);

29047

}

29048

29049

SWIGINTERN PyObject *_wrap_new_RichTextPrintout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29050

PyObject *resultobj = 0;

29051

wxString const &arg1_defvalue = wxT("Printout") ;

29052

wxString *arg1 = (wxString *) &arg1_defvalue ;

29053

wxRichTextPrintout *result = 0 ;

29054

bool temp1 = false ;

29055

PyObject * obj0 = 0 ;

29056

char * kwnames[] = {

29057

(char *) "title", NULL

29058

};

29059

29060

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_RichTextPrintout",kwnames,&obj0)) SWIG_fail;

29061

if (obj0) {

29062

{

29063

arg1 = wxString_in_helper(obj0);

29064

if (arg1 == NULL) SWIG_fail;

29065

temp1 = true;

29066

}

29067

}

29068

{

29069

PyThreadState* __tstate = wxPyBeginAllowThreads();

29070

result = (wxRichTextPrintout *)new wxRichTextPrintout((wxString const &)*arg1);

29071

wxPyEndAllowThreads(__tstate);

29072

if (PyErr_Occurred()) SWIG_fail;

29073

}

29074

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextPrintout, SWIG_POINTER_NEW | 0 );

29075

{

29076

if (temp1)

29077

delete arg1;

29078

}

29079

return resultobj;

29080

fail:

29081

{

29082

if (temp1)

29083

delete arg1;

29084

}

29085

return NULL;

29086

}

29087

29088

29089

SWIGINTERN PyObject *_wrap_delete_RichTextPrintout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29090

PyObject *resultobj = 0;

29091

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29092

void *argp1 = 0 ;

29093

int res1 = 0 ;

29094

PyObject *swig_obj[1] ;

29095

29096

if (!args) SWIG_fail;

29097

swig_obj[0] = args;

29098

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrintout, SWIG_POINTER_DISOWN | 0 );

29099

if (!SWIG_IsOK(res1)) {

29100

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextPrintout" "', expected argument " "1"" of type '" "wxRichTextPrintout *""'");

29101

}

29102

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29103

{

29104

PyThreadState* __tstate = wxPyBeginAllowThreads();

29105

delete arg1;

29106

29107

wxPyEndAllowThreads(__tstate);

29108

if (PyErr_Occurred()) SWIG_fail;

29109

}

29110

resultobj = SWIG_Py_Void();

29111

return resultobj;

29112

fail:

29113

return NULL;

29114

}

29115

29116

29117

SWIGINTERN PyObject *_wrap_RichTextPrintout_SetRichTextBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29118

PyObject *resultobj = 0;

29119

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29120

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

29121

void *argp1 = 0 ;

29122

int res1 = 0 ;

29123

void *argp2 = 0 ;

29124

int res2 = 0 ;

29125

PyObject * obj0 = 0 ;

29126

PyObject * obj1 = 0 ;

29127

char * kwnames[] = {

29128

(char *) "self",(char *) "buffer", NULL

29129

};

29130

29131

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrintout_SetRichTextBuffer",kwnames,&obj0,&obj1)) SWIG_fail;

29132

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrintout, 0 | 0 );

29133

if (!SWIG_IsOK(res1)) {

29134

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrintout_SetRichTextBuffer" "', expected argument " "1"" of type '" "wxRichTextPrintout *""'");

29135

}

29136

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29137

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

29138

if (!SWIG_IsOK(res2)) {

29139

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrintout_SetRichTextBuffer" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

29140

}

29141

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

29142

{

29143

PyThreadState* __tstate = wxPyBeginAllowThreads();

29144

(arg1)->SetRichTextBuffer(arg2);

29145

wxPyEndAllowThreads(__tstate);

29146

if (PyErr_Occurred()) SWIG_fail;

29147

}

29148

resultobj = SWIG_Py_Void();

29149

return resultobj;

29150

fail:

29151

return NULL;

29152

}

29153

29154

29155

SWIGINTERN PyObject *_wrap_RichTextPrintout_GetRichTextBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29156

PyObject *resultobj = 0;

29157

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29158

wxRichTextBuffer *result = 0 ;

29159

void *argp1 = 0 ;

29160

int res1 = 0 ;

29161

PyObject *swig_obj[1] ;

29162

29163

if (!args) SWIG_fail;

29164

swig_obj[0] = args;

29165

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrintout, 0 | 0 );

29166

if (!SWIG_IsOK(res1)) {

29167

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrintout_GetRichTextBuffer" "', expected argument " "1"" of type '" "wxRichTextPrintout const *""'");

29168

}

29169

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29170

{

29171

PyThreadState* __tstate = wxPyBeginAllowThreads();

29172

result = (wxRichTextBuffer *)((wxRichTextPrintout const *)arg1)->GetRichTextBuffer();

29173

wxPyEndAllowThreads(__tstate);

29174

if (PyErr_Occurred()) SWIG_fail;

29175

}

29176

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

29177

return resultobj;

29178

fail:

29179

return NULL;

29180

}

29181

29182

29183

SWIGINTERN PyObject *_wrap_RichTextPrintout_SetHeaderFooterData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29184

PyObject *resultobj = 0;

29185

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29186

wxRichTextHeaderFooterData *arg2 = 0 ;

29187

void *argp1 = 0 ;

29188

int res1 = 0 ;

29189

void *argp2 = 0 ;

29190

int res2 = 0 ;

29191

PyObject * obj0 = 0 ;

29192

PyObject * obj1 = 0 ;

29193

char * kwnames[] = {

29194

(char *) "self",(char *) "data", NULL

29195

};

29196

29197

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrintout_SetHeaderFooterData",kwnames,&obj0,&obj1)) SWIG_fail;

29198

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrintout, 0 | 0 );

29199

if (!SWIG_IsOK(res1)) {

29200

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrintout_SetHeaderFooterData" "', expected argument " "1"" of type '" "wxRichTextPrintout *""'");

29201

}

29202

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29203

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextHeaderFooterData, 0 | 0);

29204

if (!SWIG_IsOK(res2)) {

29205

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrintout_SetHeaderFooterData" "', expected argument " "2"" of type '" "wxRichTextHeaderFooterData const &""'");

29206

}

29207

if (!argp2) {

29208

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrintout_SetHeaderFooterData" "', expected argument " "2"" of type '" "wxRichTextHeaderFooterData const &""'");

29209

}

29210

arg2 = reinterpret_cast< wxRichTextHeaderFooterData * >(argp2);

29211

{

29212

PyThreadState* __tstate = wxPyBeginAllowThreads();

29213

(arg1)->SetHeaderFooterData((wxRichTextHeaderFooterData const &)*arg2);

29214

wxPyEndAllowThreads(__tstate);

29215

if (PyErr_Occurred()) SWIG_fail;

29216

}

29217

resultobj = SWIG_Py_Void();

29218

return resultobj;

29219

fail:

29220

return NULL;

29221

}

29222

29223

29224

SWIGINTERN PyObject *_wrap_RichTextPrintout_GetHeaderFooterData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29225

PyObject *resultobj = 0;

29226

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29227

wxRichTextHeaderFooterData *result = 0 ;

29228

void *argp1 = 0 ;

29229

int res1 = 0 ;

29230

PyObject *swig_obj[1] ;

29231

29232

if (!args) SWIG_fail;

29233

swig_obj[0] = args;

29234

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrintout, 0 | 0 );

29235

if (!SWIG_IsOK(res1)) {

29236

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrintout_GetHeaderFooterData" "', expected argument " "1"" of type '" "wxRichTextPrintout const *""'");

29237

}

29238

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29239

{

29240

PyThreadState* __tstate = wxPyBeginAllowThreads();

29241

{

29242

wxRichTextHeaderFooterData const &_result_ref = ((wxRichTextPrintout const *)arg1)->GetHeaderFooterData();

29243

result = (wxRichTextHeaderFooterData *) &_result_ref;

29244

}

29245

wxPyEndAllowThreads(__tstate);

29246

if (PyErr_Occurred()) SWIG_fail;

29247

}

29248

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextHeaderFooterData, 0 | 0 );

29249

return resultobj;

29250

fail:

29251

return NULL;

29252

}

29253

29254

29255

SWIGINTERN PyObject *_wrap_RichTextPrintout_SetMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29256

PyObject *resultobj = 0;

29257

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29258

int arg2 = (int) 254 ;

29259

int arg3 = (int) 254 ;

29260

int arg4 = (int) 254 ;

29261

int arg5 = (int) 254 ;

29262

void *argp1 = 0 ;

29263

int res1 = 0 ;

29264

int val2 ;

29265

int ecode2 = 0 ;

29266

int val3 ;

29267

int ecode3 = 0 ;

29268

int val4 ;

29269

int ecode4 = 0 ;

29270

int val5 ;

29271

int ecode5 = 0 ;

29272

PyObject * obj0 = 0 ;

29273

PyObject * obj1 = 0 ;

29274

PyObject * obj2 = 0 ;

29275

PyObject * obj3 = 0 ;

29276

PyObject * obj4 = 0 ;

29277

char * kwnames[] = {

29278

(char *) "self",(char *) "top",(char *) "bottom",(char *) "left",(char *) "right", NULL

29279

};

29280

29281

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:RichTextPrintout_SetMargins",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

29282

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrintout, 0 | 0 );

29283

if (!SWIG_IsOK(res1)) {

29284

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrintout_SetMargins" "', expected argument " "1"" of type '" "wxRichTextPrintout *""'");

29285

}

29286

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29287

if (obj1) {

29288

ecode2 = SWIG_AsVal_int(obj1, &val2);

29289

if (!SWIG_IsOK(ecode2)) {

29290

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextPrintout_SetMargins" "', expected argument " "2"" of type '" "int""'");

29291

}

29292

arg2 = static_cast< int >(val2);

29293

}

29294

if (obj2) {

29295

ecode3 = SWIG_AsVal_int(obj2, &val3);

29296

if (!SWIG_IsOK(ecode3)) {

29297

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextPrintout_SetMargins" "', expected argument " "3"" of type '" "int""'");

29298

}

29299

arg3 = static_cast< int >(val3);

29300

}

29301

if (obj3) {

29302

ecode4 = SWIG_AsVal_int(obj3, &val4);

29303

if (!SWIG_IsOK(ecode4)) {

29304

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextPrintout_SetMargins" "', expected argument " "4"" of type '" "int""'");

29305

}

29306

arg4 = static_cast< int >(val4);

29307

}

29308

if (obj4) {

29309

ecode5 = SWIG_AsVal_int(obj4, &val5);

29310

if (!SWIG_IsOK(ecode5)) {

29311

SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RichTextPrintout_SetMargins" "', expected argument " "5"" of type '" "int""'");

29312

}

29313

arg5 = static_cast< int >(val5);

29314

}

29315

{

29316

PyThreadState* __tstate = wxPyBeginAllowThreads();

29317

(arg1)->SetMargins(arg2,arg3,arg4,arg5);

29318

wxPyEndAllowThreads(__tstate);

29319

if (PyErr_Occurred()) SWIG_fail;

29320

}

29321

resultobj = SWIG_Py_Void();

29322

return resultobj;

29323

fail:

29324

return NULL;

29325

}

29326

29327

29328

SWIGINTERN PyObject *_wrap_RichTextPrintout_CalculateScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29329

PyObject *resultobj = 0;

29330

wxRichTextPrintout *arg1 = (wxRichTextPrintout *) 0 ;

29331

wxDC *arg2 = (wxDC *) 0 ;

29332

wxRect *arg3 = 0 ;

29333

wxRect *arg4 = 0 ;

29334

wxRect *arg5 = 0 ;

29335

void *argp1 = 0 ;

29336

int res1 = 0 ;

29337

void *argp2 = 0 ;

29338

int res2 = 0 ;

29339

wxRect temp3 ;

29340

wxRect temp4 ;

29341

wxRect temp5 ;

29342

PyObject * obj0 = 0 ;

29343

PyObject * obj1 = 0 ;

29344

PyObject * obj2 = 0 ;

29345

PyObject * obj3 = 0 ;

29346

PyObject * obj4 = 0 ;

29347

char * kwnames[] = {

29348

(char *) "self",(char *) "dc",(char *) "textRect",(char *) "headerRect",(char *) "footerRect", NULL

29349

};

29350

29351

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:RichTextPrintout_CalculateScaling",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;

29352

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrintout, 0 | 0 );

29353

if (!SWIG_IsOK(res1)) {

29354

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrintout_CalculateScaling" "', expected argument " "1"" of type '" "wxRichTextPrintout *""'");

29355

}

29356

arg1 = reinterpret_cast< wxRichTextPrintout * >(argp1);

29357

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );

29358

if (!SWIG_IsOK(res2)) {

29359

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrintout_CalculateScaling" "', expected argument " "2"" of type '" "wxDC *""'");

29360

}

29361

arg2 = reinterpret_cast< wxDC * >(argp2);

29362

{

29363

arg3 = &temp3;

29364

if ( ! wxRect_helper(obj2, &arg3)) SWIG_fail;

29365

}

29366

{

29367

arg4 = &temp4;

29368

if ( ! wxRect_helper(obj3, &arg4)) SWIG_fail;

29369

}

29370

{

29371

arg5 = &temp5;

29372

if ( ! wxRect_helper(obj4, &arg5)) SWIG_fail;

29373

}

29374

{

29375

PyThreadState* __tstate = wxPyBeginAllowThreads();

29376

(arg1)->CalculateScaling(arg2,*arg3,*arg4,*arg5);

29377

wxPyEndAllowThreads(__tstate);

29378

if (PyErr_Occurred()) SWIG_fail;

29379

}

29380

resultobj = SWIG_Py_Void();

29381

return resultobj;

29382

fail:

29383

return NULL;

29384

}

29385

29386

29387

SWIGINTERN PyObject *RichTextPrintout_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29388

PyObject *obj;

29389

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

29390

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextPrintout, SWIG_NewClientData(obj));

29391

return SWIG_Py_Void();

29392

}

29393

29394

SWIGINTERN PyObject *RichTextPrintout_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29395

return SWIG_Python_InitShadowInstance(args);

29396

}

29397

29398

SWIGINTERN PyObject *_wrap_new_RichTextPrinting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29399

PyObject *resultobj = 0;

29400

wxString const &arg1_defvalue = wxT("Printing") ;

29401

wxString *arg1 = (wxString *) &arg1_defvalue ;

29402

wxWindow *arg2 = (wxWindow *) NULL ;

29403

wxRichTextPrinting *result = 0 ;

29404

bool temp1 = false ;

29405

void *argp2 = 0 ;

29406

int res2 = 0 ;

29407

PyObject * obj0 = 0 ;

29408

PyObject * obj1 = 0 ;

29409

char * kwnames[] = {

29410

(char *) "name",(char *) "parentWindow", NULL

29411

};

29412

29413

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RichTextPrinting",kwnames,&obj0,&obj1)) SWIG_fail;

29414

if (obj0) {

29415

{

29416

arg1 = wxString_in_helper(obj0);

29417

if (arg1 == NULL) SWIG_fail;

29418

temp1 = true;

29419

}

29420

}

29421

if (obj1) {

29422

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

29423

if (!SWIG_IsOK(res2)) {

29424

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RichTextPrinting" "', expected argument " "2"" of type '" "wxWindow *""'");

29425

}

29426

arg2 = reinterpret_cast< wxWindow * >(argp2);

29427

}

29428

{

29429

PyThreadState* __tstate = wxPyBeginAllowThreads();

29430

result = (wxRichTextPrinting *)new wxRichTextPrinting((wxString const &)*arg1,arg2);

29431

wxPyEndAllowThreads(__tstate);

29432

if (PyErr_Occurred()) SWIG_fail;

29433

}

29434

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextPrinting, SWIG_POINTER_NEW | 0 );

29435

{

29436

if (temp1)

29437

delete arg1;

29438

}

29439

return resultobj;

29440

fail:

29441

{

29442

if (temp1)

29443

delete arg1;

29444

}

29445

return NULL;

29446

}

29447

29448

29449

SWIGINTERN PyObject *_wrap_delete_RichTextPrinting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29450

PyObject *resultobj = 0;

29451

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29452

void *argp1 = 0 ;

29453

int res1 = 0 ;

29454

PyObject *swig_obj[1] ;

29455

29456

if (!args) SWIG_fail;

29457

swig_obj[0] = args;

29458

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, SWIG_POINTER_DISOWN | 0 );

29459

if (!SWIG_IsOK(res1)) {

29460

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RichTextPrinting" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29461

}

29462

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29463

{

29464

PyThreadState* __tstate = wxPyBeginAllowThreads();

29465

delete arg1;

29466

29467

wxPyEndAllowThreads(__tstate);

29468

if (PyErr_Occurred()) SWIG_fail;

29469

}

29470

resultobj = SWIG_Py_Void();

29471

return resultobj;

29472

fail:

29473

return NULL;

29474

}

29475

29476

29477

SWIGINTERN PyObject *_wrap_RichTextPrinting_PreviewFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29478

PyObject *resultobj = 0;

29479

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29480

wxString *arg2 = 0 ;

29481

bool result;

29482

void *argp1 = 0 ;

29483

int res1 = 0 ;

29484

bool temp2 = false ;

29485

PyObject * obj0 = 0 ;

29486

PyObject * obj1 = 0 ;

29487

char * kwnames[] = {

29488

(char *) "self",(char *) "richTextFile", NULL

29489

};

29490

29491

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_PreviewFile",kwnames,&obj0,&obj1)) SWIG_fail;

29492

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29493

if (!SWIG_IsOK(res1)) {

29494

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_PreviewFile" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29495

}

29496

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29497

{

29498

arg2 = wxString_in_helper(obj1);

29499

if (arg2 == NULL) SWIG_fail;

29500

temp2 = true;

29501

}

29502

{

29503

PyThreadState* __tstate = wxPyBeginAllowThreads();

29504

result = (bool)(arg1)->PreviewFile((wxString const &)*arg2);

29505

wxPyEndAllowThreads(__tstate);

29506

if (PyErr_Occurred()) SWIG_fail;

29507

}

29508

{

29509

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

29510

}

29511

{

29512

if (temp2)

29513

delete arg2;

29514

}

29515

return resultobj;

29516

fail:

29517

{

29518

if (temp2)

29519

delete arg2;

29520

}

29521

return NULL;

29522

}

29523

29524

29525

SWIGINTERN PyObject *_wrap_RichTextPrinting_PreviewBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29526

PyObject *resultobj = 0;

29527

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29528

wxRichTextBuffer *arg2 = 0 ;

29529

bool result;

29530

void *argp1 = 0 ;

29531

int res1 = 0 ;

29532

void *argp2 = 0 ;

29533

int res2 = 0 ;

29534

PyObject * obj0 = 0 ;

29535

PyObject * obj1 = 0 ;

29536

char * kwnames[] = {

29537

(char *) "self",(char *) "buffer", NULL

29538

};

29539

29540

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_PreviewBuffer",kwnames,&obj0,&obj1)) SWIG_fail;

29541

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29542

if (!SWIG_IsOK(res1)) {

29543

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_PreviewBuffer" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29544

}

29545

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29546

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextBuffer, 0 | 0);

29547

if (!SWIG_IsOK(res2)) {

29548

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_PreviewBuffer" "', expected argument " "2"" of type '" "wxRichTextBuffer const &""'");

29549

}

29550

if (!argp2) {

29551

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrinting_PreviewBuffer" "', expected argument " "2"" of type '" "wxRichTextBuffer const &""'");

29552

}

29553

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

29554

{

29555

PyThreadState* __tstate = wxPyBeginAllowThreads();

29556

result = (bool)(arg1)->PreviewBuffer((wxRichTextBuffer const &)*arg2);

29557

wxPyEndAllowThreads(__tstate);

29558

if (PyErr_Occurred()) SWIG_fail;

29559

}

29560

{

29561

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

29562

}

29563

return resultobj;

29564

fail:

29565

return NULL;

29566

}

29567

29568

29569

SWIGINTERN PyObject *_wrap_RichTextPrinting_PrintFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29570

PyObject *resultobj = 0;

29571

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29572

wxString *arg2 = 0 ;

29573

bool result;

29574

void *argp1 = 0 ;

29575

int res1 = 0 ;

29576

bool temp2 = false ;

29577

PyObject * obj0 = 0 ;

29578

PyObject * obj1 = 0 ;

29579

char * kwnames[] = {

29580

(char *) "self",(char *) "richTextFile", NULL

29581

};

29582

29583

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_PrintFile",kwnames,&obj0,&obj1)) SWIG_fail;

29584

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29585

if (!SWIG_IsOK(res1)) {

29586

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_PrintFile" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29587

}

29588

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29589

{

29590

arg2 = wxString_in_helper(obj1);

29591

if (arg2 == NULL) SWIG_fail;

29592

temp2 = true;

29593

}

29594

{

29595

PyThreadState* __tstate = wxPyBeginAllowThreads();

29596

result = (bool)(arg1)->PrintFile((wxString const &)*arg2);

29597

wxPyEndAllowThreads(__tstate);

29598

if (PyErr_Occurred()) SWIG_fail;

29599

}

29600

{

29601

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

29602

}

29603

{

29604

if (temp2)

29605

delete arg2;

29606

}

29607

return resultobj;

29608

fail:

29609

{

29610

if (temp2)

29611

delete arg2;

29612

}

29613

return NULL;

29614

}

29615

29616

29617

SWIGINTERN PyObject *_wrap_RichTextPrinting_PrintBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29618

PyObject *resultobj = 0;

29619

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29620

wxRichTextBuffer *arg2 = 0 ;

29621

bool result;

29622

void *argp1 = 0 ;

29623

int res1 = 0 ;

29624

void *argp2 = 0 ;

29625

int res2 = 0 ;

29626

PyObject * obj0 = 0 ;

29627

PyObject * obj1 = 0 ;

29628

char * kwnames[] = {

29629

(char *) "self",(char *) "buffer", NULL

29630

};

29631

29632

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_PrintBuffer",kwnames,&obj0,&obj1)) SWIG_fail;

29633

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29634

if (!SWIG_IsOK(res1)) {

29635

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_PrintBuffer" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29636

}

29637

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29638

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextBuffer, 0 | 0);

29639

if (!SWIG_IsOK(res2)) {

29640

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_PrintBuffer" "', expected argument " "2"" of type '" "wxRichTextBuffer const &""'");

29641

}

29642

if (!argp2) {

29643

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrinting_PrintBuffer" "', expected argument " "2"" of type '" "wxRichTextBuffer const &""'");

29644

}

29645

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

29646

{

29647

PyThreadState* __tstate = wxPyBeginAllowThreads();

29648

result = (bool)(arg1)->PrintBuffer((wxRichTextBuffer const &)*arg2);

29649

wxPyEndAllowThreads(__tstate);

29650

if (PyErr_Occurred()) SWIG_fail;

29651

}

29652

{

29653

resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);

29654

}

29655

return resultobj;

29656

fail:

29657

return NULL;

29658

}

29659

29660

29661

SWIGINTERN PyObject *_wrap_RichTextPrinting_PageSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29662

PyObject *resultobj = 0;

29663

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29664

void *argp1 = 0 ;

29665

int res1 = 0 ;

29666

PyObject *swig_obj[1] ;

29667

29668

if (!args) SWIG_fail;

29669

swig_obj[0] = args;

29670

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29671

if (!SWIG_IsOK(res1)) {

29672

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_PageSetup" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29673

}

29674

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29675

{

29676

PyThreadState* __tstate = wxPyBeginAllowThreads();

29677

(arg1)->PageSetup();

29678

wxPyEndAllowThreads(__tstate);

29679

if (PyErr_Occurred()) SWIG_fail;

29680

}

29681

resultobj = SWIG_Py_Void();

29682

return resultobj;

29683

fail:

29684

return NULL;

29685

}

29686

29687

29688

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetHeaderFooterData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29689

PyObject *resultobj = 0;

29690

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29691

wxRichTextHeaderFooterData *arg2 = 0 ;

29692

void *argp1 = 0 ;

29693

int res1 = 0 ;

29694

void *argp2 = 0 ;

29695

int res2 = 0 ;

29696

PyObject * obj0 = 0 ;

29697

PyObject * obj1 = 0 ;

29698

char * kwnames[] = {

29699

(char *) "self",(char *) "data", NULL

29700

};

29701

29702

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetHeaderFooterData",kwnames,&obj0,&obj1)) SWIG_fail;

29703

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29704

if (!SWIG_IsOK(res1)) {

29705

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetHeaderFooterData" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29706

}

29707

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29708

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRichTextHeaderFooterData, 0 | 0);

29709

if (!SWIG_IsOK(res2)) {

29710

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetHeaderFooterData" "', expected argument " "2"" of type '" "wxRichTextHeaderFooterData const &""'");

29711

}

29712

if (!argp2) {

29713

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrinting_SetHeaderFooterData" "', expected argument " "2"" of type '" "wxRichTextHeaderFooterData const &""'");

29714

}

29715

arg2 = reinterpret_cast< wxRichTextHeaderFooterData * >(argp2);

29716

{

29717

PyThreadState* __tstate = wxPyBeginAllowThreads();

29718

(arg1)->SetHeaderFooterData((wxRichTextHeaderFooterData const &)*arg2);

29719

wxPyEndAllowThreads(__tstate);

29720

if (PyErr_Occurred()) SWIG_fail;

29721

}

29722

resultobj = SWIG_Py_Void();

29723

return resultobj;

29724

fail:

29725

return NULL;

29726

}

29727

29728

29729

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetHeaderFooterData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

29730

PyObject *resultobj = 0;

29731

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29732

wxRichTextHeaderFooterData *result = 0 ;

29733

void *argp1 = 0 ;

29734

int res1 = 0 ;

29735

PyObject *swig_obj[1] ;

29736

29737

if (!args) SWIG_fail;

29738

swig_obj[0] = args;

29739

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29740

if (!SWIG_IsOK(res1)) {

29741

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetHeaderFooterData" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

29742

}

29743

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29744

{

29745

PyThreadState* __tstate = wxPyBeginAllowThreads();

29746

{

29747

wxRichTextHeaderFooterData const &_result_ref = ((wxRichTextPrinting const *)arg1)->GetHeaderFooterData();

29748

result = (wxRichTextHeaderFooterData *) &_result_ref;

29749

}

29750

wxPyEndAllowThreads(__tstate);

29751

if (PyErr_Occurred()) SWIG_fail;

29752

}

29753

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextHeaderFooterData, 0 | 0 );

29754

return resultobj;

29755

fail:

29756

return NULL;

29757

}

29758

29759

29760

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetHeaderText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29761

PyObject *resultobj = 0;

29762

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29763

wxString *arg2 = 0 ;

29764

wxRichTextOddEvenPage arg3 = (wxRichTextOddEvenPage) wxRICHTEXT_PAGE_ALL ;

29765

wxRichTextPageLocation arg4 = (wxRichTextPageLocation) wxRICHTEXT_PAGE_CENTRE ;

29766

void *argp1 = 0 ;

29767

int res1 = 0 ;

29768

bool temp2 = false ;

29769

int val3 ;

29770

int ecode3 = 0 ;

29771

int val4 ;

29772

int ecode4 = 0 ;

29773

PyObject * obj0 = 0 ;

29774

PyObject * obj1 = 0 ;

29775

PyObject * obj2 = 0 ;

29776

PyObject * obj3 = 0 ;

29777

char * kwnames[] = {

29778

(char *) "self",(char *) "text",(char *) "page",(char *) "location", NULL

29779

};

29780

29781

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextPrinting_SetHeaderText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

29782

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29783

if (!SWIG_IsOK(res1)) {

29784

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetHeaderText" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29785

}

29786

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29787

{

29788

arg2 = wxString_in_helper(obj1);

29789

if (arg2 == NULL) SWIG_fail;

29790

temp2 = true;

29791

}

29792

if (obj2) {

29793

ecode3 = SWIG_AsVal_int(obj2, &val3);

29794

if (!SWIG_IsOK(ecode3)) {

29795

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextPrinting_SetHeaderText" "', expected argument " "3"" of type '" "wxRichTextOddEvenPage""'");

29796

}

29797

arg3 = static_cast< wxRichTextOddEvenPage >(val3);

29798

}

29799

if (obj3) {

29800

ecode4 = SWIG_AsVal_int(obj3, &val4);

29801

if (!SWIG_IsOK(ecode4)) {

29802

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextPrinting_SetHeaderText" "', expected argument " "4"" of type '" "wxRichTextPageLocation""'");

29803

}

29804

arg4 = static_cast< wxRichTextPageLocation >(val4);

29805

}

29806

{

29807

PyThreadState* __tstate = wxPyBeginAllowThreads();

29808

(arg1)->SetHeaderText((wxString const &)*arg2,arg3,arg4);

29809

wxPyEndAllowThreads(__tstate);

29810

if (PyErr_Occurred()) SWIG_fail;

29811

}

29812

resultobj = SWIG_Py_Void();

29813

{

29814

if (temp2)

29815

delete arg2;

29816

}

29817

return resultobj;

29818

fail:

29819

{

29820

if (temp2)

29821

delete arg2;

29822

}

29823

return NULL;

29824

}

29825

29826

29827

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetHeaderText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29828

PyObject *resultobj = 0;

29829

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29830

wxRichTextOddEvenPage arg2 = (wxRichTextOddEvenPage) wxRICHTEXT_PAGE_EVEN ;

29831

wxRichTextPageLocation arg3 = (wxRichTextPageLocation) wxRICHTEXT_PAGE_CENTRE ;

29832

wxString result;

29833

void *argp1 = 0 ;

29834

int res1 = 0 ;

29835

int val2 ;

29836

int ecode2 = 0 ;

29837

int val3 ;

29838

int ecode3 = 0 ;

29839

PyObject * obj0 = 0 ;

29840

PyObject * obj1 = 0 ;

29841

PyObject * obj2 = 0 ;

29842

char * kwnames[] = {

29843

(char *) "self",(char *) "page",(char *) "location", NULL

29844

};

29845

29846

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextPrinting_GetHeaderText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

29847

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29848

if (!SWIG_IsOK(res1)) {

29849

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetHeaderText" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

29850

}

29851

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29852

if (obj1) {

29853

ecode2 = SWIG_AsVal_int(obj1, &val2);

29854

if (!SWIG_IsOK(ecode2)) {

29855

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextPrinting_GetHeaderText" "', expected argument " "2"" of type '" "wxRichTextOddEvenPage""'");

29856

}

29857

arg2 = static_cast< wxRichTextOddEvenPage >(val2);

29858

}

29859

if (obj2) {

29860

ecode3 = SWIG_AsVal_int(obj2, &val3);

29861

if (!SWIG_IsOK(ecode3)) {

29862

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextPrinting_GetHeaderText" "', expected argument " "3"" of type '" "wxRichTextPageLocation""'");

29863

}

29864

arg3 = static_cast< wxRichTextPageLocation >(val3);

29865

}

29866

{

29867

PyThreadState* __tstate = wxPyBeginAllowThreads();

29868

result = ((wxRichTextPrinting const *)arg1)->GetHeaderText(arg2,arg3);

29869

wxPyEndAllowThreads(__tstate);

29870

if (PyErr_Occurred()) SWIG_fail;

29871

}

29872

{

29873

#if wxUSE_UNICODE

29874

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

29875

#else

29876

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

29877

#endif

29878

}

29879

return resultobj;

29880

fail:

29881

return NULL;

29882

}

29883

29884

29885

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetFooterText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29886

PyObject *resultobj = 0;

29887

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29888

wxString *arg2 = 0 ;

29889

wxRichTextOddEvenPage arg3 = (wxRichTextOddEvenPage) wxRICHTEXT_PAGE_ALL ;

29890

wxRichTextPageLocation arg4 = (wxRichTextPageLocation) wxRICHTEXT_PAGE_CENTRE ;

29891

void *argp1 = 0 ;

29892

int res1 = 0 ;

29893

bool temp2 = false ;

29894

int val3 ;

29895

int ecode3 = 0 ;

29896

int val4 ;

29897

int ecode4 = 0 ;

29898

PyObject * obj0 = 0 ;

29899

PyObject * obj1 = 0 ;

29900

PyObject * obj2 = 0 ;

29901

PyObject * obj3 = 0 ;

29902

char * kwnames[] = {

29903

(char *) "self",(char *) "text",(char *) "page",(char *) "location", NULL

29904

};

29905

29906

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextPrinting_SetFooterText",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;

29907

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29908

if (!SWIG_IsOK(res1)) {

29909

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetFooterText" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

29910

}

29911

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29912

{

29913

arg2 = wxString_in_helper(obj1);

29914

if (arg2 == NULL) SWIG_fail;

29915

temp2 = true;

29916

}

29917

if (obj2) {

29918

ecode3 = SWIG_AsVal_int(obj2, &val3);

29919

if (!SWIG_IsOK(ecode3)) {

29920

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextPrinting_SetFooterText" "', expected argument " "3"" of type '" "wxRichTextOddEvenPage""'");

29921

}

29922

arg3 = static_cast< wxRichTextOddEvenPage >(val3);

29923

}

29924

if (obj3) {

29925

ecode4 = SWIG_AsVal_int(obj3, &val4);

29926

if (!SWIG_IsOK(ecode4)) {

29927

SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextPrinting_SetFooterText" "', expected argument " "4"" of type '" "wxRichTextPageLocation""'");

29928

}

29929

arg4 = static_cast< wxRichTextPageLocation >(val4);

29930

}

29931

{

29932

PyThreadState* __tstate = wxPyBeginAllowThreads();

29933

(arg1)->SetFooterText((wxString const &)*arg2,arg3,arg4);

29934

wxPyEndAllowThreads(__tstate);

29935

if (PyErr_Occurred()) SWIG_fail;

29936

}

29937

resultobj = SWIG_Py_Void();

29938

{

29939

if (temp2)

29940

delete arg2;

29941

}

29942

return resultobj;

29943

fail:

29944

{

29945

if (temp2)

29946

delete arg2;

29947

}

29948

return NULL;

29949

}

29950

29951

29952

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetFooterText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

29953

PyObject *resultobj = 0;

29954

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

29955

wxRichTextOddEvenPage arg2 = (wxRichTextOddEvenPage) wxRICHTEXT_PAGE_EVEN ;

29956

wxRichTextPageLocation arg3 = (wxRichTextPageLocation) wxRICHTEXT_PAGE_CENTRE ;

29957

wxString result;

29958

void *argp1 = 0 ;

29959

int res1 = 0 ;

29960

int val2 ;

29961

int ecode2 = 0 ;

29962

int val3 ;

29963

int ecode3 = 0 ;

29964

PyObject * obj0 = 0 ;

29965

PyObject * obj1 = 0 ;

29966

PyObject * obj2 = 0 ;

29967

char * kwnames[] = {

29968

(char *) "self",(char *) "page",(char *) "location", NULL

29969

};

29970

29971

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:RichTextPrinting_GetFooterText",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;

29972

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

29973

if (!SWIG_IsOK(res1)) {

29974

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetFooterText" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

29975

}

29976

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

29977

if (obj1) {

29978

ecode2 = SWIG_AsVal_int(obj1, &val2);

29979

if (!SWIG_IsOK(ecode2)) {

29980

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextPrinting_GetFooterText" "', expected argument " "2"" of type '" "wxRichTextOddEvenPage""'");

29981

}

29982

arg2 = static_cast< wxRichTextOddEvenPage >(val2);

29983

}

29984

if (obj2) {

29985

ecode3 = SWIG_AsVal_int(obj2, &val3);

29986

if (!SWIG_IsOK(ecode3)) {

29987

SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextPrinting_GetFooterText" "', expected argument " "3"" of type '" "wxRichTextPageLocation""'");

29988

}

29989

arg3 = static_cast< wxRichTextPageLocation >(val3);

29990

}

29991

{

29992

PyThreadState* __tstate = wxPyBeginAllowThreads();

29993

result = ((wxRichTextPrinting const *)arg1)->GetFooterText(arg2,arg3);

29994

wxPyEndAllowThreads(__tstate);

29995

if (PyErr_Occurred()) SWIG_fail;

29996

}

29997

{

29998

#if wxUSE_UNICODE

29999

resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());

30000

#else

30001

resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());

30002

#endif

30003

}

30004

return resultobj;

30005

fail:

30006

return NULL;

30007

}

30008

30009

30010

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetShowOnFirstPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30011

PyObject *resultobj = 0;

30012

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30013

bool arg2 ;

30014

void *argp1 = 0 ;

30015

int res1 = 0 ;

30016

bool val2 ;

30017

int ecode2 = 0 ;

30018

PyObject * obj0 = 0 ;

30019

PyObject * obj1 = 0 ;

30020

char * kwnames[] = {

30021

(char *) "self",(char *) "show", NULL

30022

};

30023

30024

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetShowOnFirstPage",kwnames,&obj0,&obj1)) SWIG_fail;

30025

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30026

if (!SWIG_IsOK(res1)) {

30027

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetShowOnFirstPage" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30028

}

30029

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30030

ecode2 = SWIG_AsVal_bool(obj1, &val2);

30031

if (!SWIG_IsOK(ecode2)) {

30032

SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextPrinting_SetShowOnFirstPage" "', expected argument " "2"" of type '" "bool""'");

30033

}

30034

arg2 = static_cast< bool >(val2);

30035

{

30036

PyThreadState* __tstate = wxPyBeginAllowThreads();

30037

(arg1)->SetShowOnFirstPage(arg2);

30038

wxPyEndAllowThreads(__tstate);

30039

if (PyErr_Occurred()) SWIG_fail;

30040

}

30041

resultobj = SWIG_Py_Void();

30042

return resultobj;

30043

fail:

30044

return NULL;

30045

}

30046

30047

30048

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetHeaderFooterFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30049

PyObject *resultobj = 0;

30050

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30051

wxFont *arg2 = 0 ;

30052

void *argp1 = 0 ;

30053

int res1 = 0 ;

30054

void *argp2 = 0 ;

30055

int res2 = 0 ;

30056

PyObject * obj0 = 0 ;

30057

PyObject * obj1 = 0 ;

30058

char * kwnames[] = {

30059

(char *) "self",(char *) "font", NULL

30060

};

30061

30062

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetHeaderFooterFont",kwnames,&obj0,&obj1)) SWIG_fail;

30063

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30064

if (!SWIG_IsOK(res1)) {

30065

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetHeaderFooterFont" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30066

}

30067

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30068

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);

30069

if (!SWIG_IsOK(res2)) {

30070

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetHeaderFooterFont" "', expected argument " "2"" of type '" "wxFont const &""'");

30071

}

30072

if (!argp2) {

30073

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrinting_SetHeaderFooterFont" "', expected argument " "2"" of type '" "wxFont const &""'");

30074

}

30075

arg2 = reinterpret_cast< wxFont * >(argp2);

30076

{

30077

PyThreadState* __tstate = wxPyBeginAllowThreads();

30078

(arg1)->SetHeaderFooterFont((wxFont const &)*arg2);

30079

wxPyEndAllowThreads(__tstate);

30080

if (PyErr_Occurred()) SWIG_fail;

30081

}

30082

resultobj = SWIG_Py_Void();

30083

return resultobj;

30084

fail:

30085

return NULL;

30086

}

30087

30088

30089

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetHeaderFooterTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30090

PyObject *resultobj = 0;

30091

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30092

wxColour *arg2 = 0 ;

30093

void *argp1 = 0 ;

30094

int res1 = 0 ;

30095

wxColour temp2 ;

30096

PyObject * obj0 = 0 ;

30097

PyObject * obj1 = 0 ;

30098

char * kwnames[] = {

30099

(char *) "self",(char *) "font", NULL

30100

};

30101

30102

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetHeaderFooterTextColour",kwnames,&obj0,&obj1)) SWIG_fail;

30103

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30104

if (!SWIG_IsOK(res1)) {

30105

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetHeaderFooterTextColour" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30106

}

30107

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30108

{

30109

arg2 = &temp2;

30110

if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;

30111

}

30112

{

30113

PyThreadState* __tstate = wxPyBeginAllowThreads();

30114

(arg1)->SetHeaderFooterTextColour((wxColour const &)*arg2);

30115

wxPyEndAllowThreads(__tstate);

30116

if (PyErr_Occurred()) SWIG_fail;

30117

}

30118

resultobj = SWIG_Py_Void();

30119

return resultobj;

30120

fail:

30121

return NULL;

30122

}

30123

30124

30125

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30126

PyObject *resultobj = 0;

30127

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30128

wxPrintData *result = 0 ;

30129

void *argp1 = 0 ;

30130

int res1 = 0 ;

30131

PyObject *swig_obj[1] ;

30132

30133

if (!args) SWIG_fail;

30134

swig_obj[0] = args;

30135

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30136

if (!SWIG_IsOK(res1)) {

30137

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetPrintData" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30138

}

30139

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30140

{

30141

PyThreadState* __tstate = wxPyBeginAllowThreads();

30142

result = (wxPrintData *)(arg1)->GetPrintData();

30143

wxPyEndAllowThreads(__tstate);

30144

if (PyErr_Occurred()) SWIG_fail;

30145

}

30146

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPrintData, 0 | 0 );

30147

return resultobj;

30148

fail:

30149

return NULL;

30150

}

30151

30152

30153

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetPageSetupData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30154

PyObject *resultobj = 0;

30155

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30156

wxPageSetupDialogData *result = 0 ;

30157

void *argp1 = 0 ;

30158

int res1 = 0 ;

30159

PyObject *swig_obj[1] ;

30160

30161

if (!args) SWIG_fail;

30162

swig_obj[0] = args;

30163

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30164

if (!SWIG_IsOK(res1)) {

30165

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetPageSetupData" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30166

}

30167

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30168

{

30169

PyThreadState* __tstate = wxPyBeginAllowThreads();

30170

result = (wxPageSetupDialogData *)(arg1)->GetPageSetupData();

30171

wxPyEndAllowThreads(__tstate);

30172

if (PyErr_Occurred()) SWIG_fail;

30173

}

30174

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPageSetupDialogData, 0 | 0 );

30175

return resultobj;

30176

fail:

30177

return NULL;

30178

}

30179

30180

30181

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetPrintData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30182

PyObject *resultobj = 0;

30183

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30184

wxPrintData *arg2 = 0 ;

30185

void *argp1 = 0 ;

30186

int res1 = 0 ;

30187

void *argp2 = 0 ;

30188

int res2 = 0 ;

30189

PyObject * obj0 = 0 ;

30190

PyObject * obj1 = 0 ;

30191

char * kwnames[] = {

30192

(char *) "self",(char *) "printData", NULL

30193

};

30194

30195

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetPrintData",kwnames,&obj0,&obj1)) SWIG_fail;

30196

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30197

if (!SWIG_IsOK(res1)) {

30198

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetPrintData" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30199

}

30200

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30201

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPrintData, 0 | 0);

30202

if (!SWIG_IsOK(res2)) {

30203

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");

30204

}

30205

if (!argp2) {

30206

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrinting_SetPrintData" "', expected argument " "2"" of type '" "wxPrintData const &""'");

30207

}

30208

arg2 = reinterpret_cast< wxPrintData * >(argp2);

30209

{

30210

PyThreadState* __tstate = wxPyBeginAllowThreads();

30211

(arg1)->SetPrintData((wxPrintData const &)*arg2);

30212

wxPyEndAllowThreads(__tstate);

30213

if (PyErr_Occurred()) SWIG_fail;

30214

}

30215

resultobj = SWIG_Py_Void();

30216

return resultobj;

30217

fail:

30218

return NULL;

30219

}

30220

30221

30222

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetPageSetupData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30223

PyObject *resultobj = 0;

30224

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30225

wxPageSetupData *arg2 = 0 ;

30226

void *argp1 = 0 ;

30227

int res1 = 0 ;

30228

void *argp2 = 0 ;

30229

int res2 = 0 ;

30230

PyObject * obj0 = 0 ;

30231

PyObject * obj1 = 0 ;

30232

char * kwnames[] = {

30233

(char *) "self",(char *) "pageSetupData", NULL

30234

};

30235

30236

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetPageSetupData",kwnames,&obj0,&obj1)) SWIG_fail;

30237

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30238

if (!SWIG_IsOK(res1)) {

30239

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetPageSetupData" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30240

}

30241

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30242

res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPageSetupData, 0 | 0);

30243

if (!SWIG_IsOK(res2)) {

30244

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetPageSetupData" "', expected argument " "2"" of type '" "wxPageSetupData const &""'");

30245

}

30246

if (!argp2) {

30247

SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextPrinting_SetPageSetupData" "', expected argument " "2"" of type '" "wxPageSetupData const &""'");

30248

}

30249

arg2 = reinterpret_cast< wxPageSetupData * >(argp2);

30250

{

30251

PyThreadState* __tstate = wxPyBeginAllowThreads();

30252

(arg1)->SetPageSetupData((wxPageSetupData const &)*arg2);

30253

wxPyEndAllowThreads(__tstate);

30254

if (PyErr_Occurred()) SWIG_fail;

30255

}

30256

resultobj = SWIG_Py_Void();

30257

return resultobj;

30258

fail:

30259

return NULL;

30260

}

30261

30262

30263

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetRichTextBufferPreview(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30264

PyObject *resultobj = 0;

30265

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30266

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

30267

void *argp1 = 0 ;

30268

int res1 = 0 ;

30269

void *argp2 = 0 ;

30270

int res2 = 0 ;

30271

PyObject * obj0 = 0 ;

30272

PyObject * obj1 = 0 ;

30273

char * kwnames[] = {

30274

(char *) "self",(char *) "buf", NULL

30275

};

30276

30277

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetRichTextBufferPreview",kwnames,&obj0,&obj1)) SWIG_fail;

30278

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30279

if (!SWIG_IsOK(res1)) {

30280

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetRichTextBufferPreview" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30281

}

30282

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30283

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

30284

if (!SWIG_IsOK(res2)) {

30285

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetRichTextBufferPreview" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

30286

}

30287

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

30288

{

30289

PyThreadState* __tstate = wxPyBeginAllowThreads();

30290

(arg1)->SetRichTextBufferPreview(arg2);

30291

wxPyEndAllowThreads(__tstate);

30292

if (PyErr_Occurred()) SWIG_fail;

30293

}

30294

resultobj = SWIG_Py_Void();

30295

return resultobj;

30296

fail:

30297

return NULL;

30298

}

30299

30300

30301

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetRichTextBufferPreview(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30302

PyObject *resultobj = 0;

30303

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30304

wxRichTextBuffer *result = 0 ;

30305

void *argp1 = 0 ;

30306

int res1 = 0 ;

30307

PyObject *swig_obj[1] ;

30308

30309

if (!args) SWIG_fail;

30310

swig_obj[0] = args;

30311

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30312

if (!SWIG_IsOK(res1)) {

30313

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetRichTextBufferPreview" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

30314

}

30315

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30316

{

30317

PyThreadState* __tstate = wxPyBeginAllowThreads();

30318

result = (wxRichTextBuffer *)((wxRichTextPrinting const *)arg1)->GetRichTextBufferPreview();

30319

wxPyEndAllowThreads(__tstate);

30320

if (PyErr_Occurred()) SWIG_fail;

30321

}

30322

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

30323

return resultobj;

30324

fail:

30325

return NULL;

30326

}

30327

30328

30329

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetRichTextBufferPrinting(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30330

PyObject *resultobj = 0;

30331

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30332

wxRichTextBuffer *arg2 = (wxRichTextBuffer *) 0 ;

30333

void *argp1 = 0 ;

30334

int res1 = 0 ;

30335

void *argp2 = 0 ;

30336

int res2 = 0 ;

30337

PyObject * obj0 = 0 ;

30338

PyObject * obj1 = 0 ;

30339

char * kwnames[] = {

30340

(char *) "self",(char *) "buf", NULL

30341

};

30342

30343

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetRichTextBufferPrinting",kwnames,&obj0,&obj1)) SWIG_fail;

30344

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30345

if (!SWIG_IsOK(res1)) {

30346

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetRichTextBufferPrinting" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30347

}

30348

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30349

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

30350

if (!SWIG_IsOK(res2)) {

30351

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetRichTextBufferPrinting" "', expected argument " "2"" of type '" "wxRichTextBuffer *""'");

30352

}

30353

arg2 = reinterpret_cast< wxRichTextBuffer * >(argp2);

30354

{

30355

PyThreadState* __tstate = wxPyBeginAllowThreads();

30356

(arg1)->SetRichTextBufferPrinting(arg2);

30357

wxPyEndAllowThreads(__tstate);

30358

if (PyErr_Occurred()) SWIG_fail;

30359

}

30360

resultobj = SWIG_Py_Void();

30361

return resultobj;

30362

fail:

30363

return NULL;

30364

}

30365

30366

30367

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetRichTextBufferPrinting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30368

PyObject *resultobj = 0;

30369

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30370

wxRichTextBuffer *result = 0 ;

30371

void *argp1 = 0 ;

30372

int res1 = 0 ;

30373

PyObject *swig_obj[1] ;

30374

30375

if (!args) SWIG_fail;

30376

swig_obj[0] = args;

30377

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30378

if (!SWIG_IsOK(res1)) {

30379

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetRichTextBufferPrinting" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

30380

}

30381

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30382

{

30383

PyThreadState* __tstate = wxPyBeginAllowThreads();

30384

result = (wxRichTextBuffer *)((wxRichTextPrinting const *)arg1)->GetRichTextBufferPrinting();

30385

wxPyEndAllowThreads(__tstate);

30386

if (PyErr_Occurred()) SWIG_fail;

30387

}

30388

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRichTextBuffer, 0 | 0 );

30389

return resultobj;

30390

fail:

30391

return NULL;

30392

}

30393

30394

30395

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetParentWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30396

PyObject *resultobj = 0;

30397

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30398

wxWindow *arg2 = (wxWindow *) 0 ;

30399

void *argp1 = 0 ;

30400

int res1 = 0 ;

30401

void *argp2 = 0 ;

30402

int res2 = 0 ;

30403

PyObject * obj0 = 0 ;

30404

PyObject * obj1 = 0 ;

30405

char * kwnames[] = {

30406

(char *) "self",(char *) "parent", NULL

30407

};

30408

30409

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetParentWindow",kwnames,&obj0,&obj1)) SWIG_fail;

30410

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30411

if (!SWIG_IsOK(res1)) {

30412

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetParentWindow" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30413

}

30414

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30415

res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );

30416

if (!SWIG_IsOK(res2)) {

30417

SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextPrinting_SetParentWindow" "', expected argument " "2"" of type '" "wxWindow *""'");

30418

}

30419

arg2 = reinterpret_cast< wxWindow * >(argp2);

30420

{

30421

PyThreadState* __tstate = wxPyBeginAllowThreads();

30422

(arg1)->SetParentWindow(arg2);

30423

wxPyEndAllowThreads(__tstate);

30424

if (PyErr_Occurred()) SWIG_fail;

30425

}

30426

resultobj = SWIG_Py_Void();

30427

return resultobj;

30428

fail:

30429

return NULL;

30430

}

30431

30432

30433

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetParentWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30434

PyObject *resultobj = 0;

30435

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30436

wxWindow *result = 0 ;

30437

void *argp1 = 0 ;

30438

int res1 = 0 ;

30439

PyObject *swig_obj[1] ;

30440

30441

if (!args) SWIG_fail;

30442

swig_obj[0] = args;

30443

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30444

if (!SWIG_IsOK(res1)) {

30445

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetParentWindow" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

30446

}

30447

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30448

{

30449

PyThreadState* __tstate = wxPyBeginAllowThreads();

30450

result = (wxWindow *)((wxRichTextPrinting const *)arg1)->GetParentWindow();

30451

wxPyEndAllowThreads(__tstate);

30452

if (PyErr_Occurred()) SWIG_fail;

30453

}

30454

{

30455

resultobj = wxPyMake_wxObject(result, 0);

30456

}

30457

return resultobj;

30458

fail:

30459

return NULL;

30460

}

30461

30462

30463

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30464

PyObject *resultobj = 0;

30465

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30466

wxString *arg2 = 0 ;

30467

void *argp1 = 0 ;

30468

int res1 = 0 ;

30469

bool temp2 = false ;

30470

PyObject * obj0 = 0 ;

30471

PyObject * obj1 = 0 ;

30472

char * kwnames[] = {

30473

(char *) "self",(char *) "title", NULL

30474

};

30475

30476

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;

30477

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30478

if (!SWIG_IsOK(res1)) {

30479

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetTitle" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30480

}

30481

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30482

{

30483

arg2 = wxString_in_helper(obj1);

30484

if (arg2 == NULL) SWIG_fail;

30485

temp2 = true;

30486

}

30487

{

30488

PyThreadState* __tstate = wxPyBeginAllowThreads();

30489

(arg1)->SetTitle((wxString const &)*arg2);

30490

wxPyEndAllowThreads(__tstate);

30491

if (PyErr_Occurred()) SWIG_fail;

30492

}

30493

resultobj = SWIG_Py_Void();

30494

{

30495

if (temp2)

30496

delete arg2;

30497

}

30498

return resultobj;

30499

fail:

30500

{

30501

if (temp2)

30502

delete arg2;

30503

}

30504

return NULL;

30505

}

30506

30507

30508

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30509

PyObject *resultobj = 0;

30510

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30511

wxString *result = 0 ;

30512

void *argp1 = 0 ;

30513

int res1 = 0 ;

30514

PyObject *swig_obj[1] ;

30515

30516

if (!args) SWIG_fail;

30517

swig_obj[0] = args;

30518

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30519

if (!SWIG_IsOK(res1)) {

30520

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetTitle" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

30521

}

30522

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30523

{

30524

PyThreadState* __tstate = wxPyBeginAllowThreads();

30525

{

30526

wxString const &_result_ref = ((wxRichTextPrinting const *)arg1)->GetTitle();

30527

result = (wxString *) &_result_ref;

30528

}

30529

wxPyEndAllowThreads(__tstate);

30530

if (PyErr_Occurred()) SWIG_fail;

30531

}

30532

{

30533

#if wxUSE_UNICODE

30534

resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());

30535

#else

30536

resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());

30537

#endif

30538

}

30539

return resultobj;

30540

fail:

30541

return NULL;

30542

}

30543

30544

30545

SWIGINTERN PyObject *_wrap_RichTextPrinting_SetPreviewRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {

30546

PyObject *resultobj = 0;

30547

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30548

wxRect *arg2 = 0 ;

30549

void *argp1 = 0 ;

30550

int res1 = 0 ;

30551

wxRect temp2 ;

30552

PyObject * obj0 = 0 ;

30553

PyObject * obj1 = 0 ;

30554

char * kwnames[] = {

30555

(char *) "self",(char *) "rect", NULL

30556

};

30557

30558

if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextPrinting_SetPreviewRect",kwnames,&obj0,&obj1)) SWIG_fail;

30559

res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30560

if (!SWIG_IsOK(res1)) {

30561

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_SetPreviewRect" "', expected argument " "1"" of type '" "wxRichTextPrinting *""'");

30562

}

30563

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30564

{

30565

arg2 = &temp2;

30566

if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;

30567

}

30568

{

30569

PyThreadState* __tstate = wxPyBeginAllowThreads();

30570

(arg1)->SetPreviewRect((wxRect const &)*arg2);

30571

wxPyEndAllowThreads(__tstate);

30572

if (PyErr_Occurred()) SWIG_fail;

30573

}

30574

resultobj = SWIG_Py_Void();

30575

return resultobj;

30576

fail:

30577

return NULL;

30578

}

30579

30580

30581

SWIGINTERN PyObject *_wrap_RichTextPrinting_GetPreviewRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30582

PyObject *resultobj = 0;

30583

wxRichTextPrinting *arg1 = (wxRichTextPrinting *) 0 ;

30584

wxRect *result = 0 ;

30585

void *argp1 = 0 ;

30586

int res1 = 0 ;

30587

PyObject *swig_obj[1] ;

30588

30589

if (!args) SWIG_fail;

30590

swig_obj[0] = args;

30591

res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextPrinting, 0 | 0 );

30592

if (!SWIG_IsOK(res1)) {

30593

SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextPrinting_GetPreviewRect" "', expected argument " "1"" of type '" "wxRichTextPrinting const *""'");

30594

}

30595

arg1 = reinterpret_cast< wxRichTextPrinting * >(argp1);

30596

{

30597

PyThreadState* __tstate = wxPyBeginAllowThreads();

30598

{

30599

wxRect const &_result_ref = ((wxRichTextPrinting const *)arg1)->GetPreviewRect();

30600

result = (wxRect *) &_result_ref;

30601

}

30602

wxPyEndAllowThreads(__tstate);

30603

if (PyErr_Occurred()) SWIG_fail;

30604

}

30605

resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );

30606

return resultobj;

30607

fail:

30608

return NULL;

30609

}

30610

30611

30612

SWIGINTERN PyObject *RichTextPrinting_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30613

PyObject *obj;

30614

if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;

30615

SWIG_TypeNewClientData(SWIGTYPE_p_wxRichTextPrinting, SWIG_NewClientData(obj));

30616

return SWIG_Py_Void();

30617

}

30618

30619

SWIGINTERN PyObject *RichTextPrinting_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {

30620

return SWIG_Python_InitShadowInstance(args);

30621

}

30622

30623

static PyMethodDef SwigMethods[] = {

30624

{ (char *)"new_RichTextRange", (PyCFunction) _wrap_new_RichTextRange, METH_VARARGS | METH_KEYWORDS, NULL},

30625

{ (char *)"delete_RichTextRange", (PyCFunction)_wrap_delete_RichTextRange, METH_O, NULL},

30626

{ (char *)"RichTextRange___eq__", (PyCFunction) _wrap_RichTextRange___eq__, METH_VARARGS | METH_KEYWORDS, NULL},

30627

{ (char *)"RichTextRange___sub__", (PyCFunction) _wrap_RichTextRange___sub__, METH_VARARGS | METH_KEYWORDS, NULL},

30628

{ (char *)"RichTextRange___add__", (PyCFunction) _wrap_RichTextRange___add__, METH_VARARGS | METH_KEYWORDS, NULL},

30629

{ (char *)"RichTextRange_SetRange", (PyCFunction) _wrap_RichTextRange_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},

30630

{ (char *)"RichTextRange_SetStart", (PyCFunction) _wrap_RichTextRange_SetStart, METH_VARARGS | METH_KEYWORDS, NULL},

30631

{ (char *)"RichTextRange_GetStart", (PyCFunction)_wrap_RichTextRange_GetStart, METH_O, NULL},

30632

{ (char *)"RichTextRange_SetEnd", (PyCFunction) _wrap_RichTextRange_SetEnd, METH_VARARGS | METH_KEYWORDS, NULL},

30633

{ (char *)"RichTextRange_GetEnd", (PyCFunction)_wrap_RichTextRange_GetEnd, METH_O, NULL},

30634

{ (char *)"RichTextRange_IsOutside", (PyCFunction) _wrap_RichTextRange_IsOutside, METH_VARARGS | METH_KEYWORDS, NULL},

30635

{ (char *)"RichTextRange_IsWithin", (PyCFunction) _wrap_RichTextRange_IsWithin, METH_VARARGS | METH_KEYWORDS, NULL},

30636

{ (char *)"RichTextRange_Contains", (PyCFunction) _wrap_RichTextRange_Contains, METH_VARARGS | METH_KEYWORDS, NULL},

30637

{ (char *)"RichTextRange_LimitTo", (PyCFunction) _wrap_RichTextRange_LimitTo, METH_VARARGS | METH_KEYWORDS, NULL},

30638

{ (char *)"RichTextRange_GetLength", (PyCFunction)_wrap_RichTextRange_GetLength, METH_O, NULL},

30639

{ (char *)"RichTextRange_Swap", (PyCFunction)_wrap_RichTextRange_Swap, METH_O, NULL},

30640

{ (char *)"RichTextRange_ToInternal", (PyCFunction)_wrap_RichTextRange_ToInternal, METH_O, NULL},

30641

{ (char *)"RichTextRange_FromInternal", (PyCFunction)_wrap_RichTextRange_FromInternal, METH_O, NULL},

30642

{ (char *)"RichTextRange_Get", (PyCFunction)_wrap_RichTextRange_Get, METH_O, NULL},

30643

{ (char *)"RichTextRange_swigregister", RichTextRange_swigregister, METH_VARARGS, NULL},

30644

{ (char *)"RichTextRange_swiginit", RichTextRange_swiginit, METH_VARARGS, NULL},

30645

{ (char *)"new_TextAttrEx", (PyCFunction)_wrap_new_TextAttrEx, METH_NOARGS, NULL},

30646

{ (char *)"delete_TextAttrEx", (PyCFunction)_wrap_delete_TextAttrEx, METH_O, NULL},

30647

{ (char *)"TextAttrEx_Init", (PyCFunction)_wrap_TextAttrEx_Init, METH_O, NULL},

30648

{ (char *)"TextAttrEx_Copy", (PyCFunction) _wrap_TextAttrEx_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30649

{ (char *)"TextAttrEx_SetTextColour", (PyCFunction) _wrap_TextAttrEx_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},

30650

{ (char *)"TextAttrEx_SetBackgroundColour", (PyCFunction) _wrap_TextAttrEx_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},

30651

{ (char *)"TextAttrEx_SetFont", (PyCFunction) _wrap_TextAttrEx_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},

30652

{ (char *)"TextAttrEx_SetAlignment", (PyCFunction) _wrap_TextAttrEx_SetAlignment, METH_VARARGS | METH_KEYWORDS, NULL},

30653

{ (char *)"TextAttrEx_SetTabs", (PyCFunction) _wrap_TextAttrEx_SetTabs, METH_VARARGS | METH_KEYWORDS, NULL},

30654

{ (char *)"TextAttrEx_SetLeftIndent", (PyCFunction) _wrap_TextAttrEx_SetLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},

30655

{ (char *)"TextAttrEx_SetRightIndent", (PyCFunction) _wrap_TextAttrEx_SetRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},

30656

{ (char *)"TextAttrEx_SetFlags", (PyCFunction) _wrap_TextAttrEx_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},

30657

{ (char *)"TextAttrEx_HasTextColour", (PyCFunction)_wrap_TextAttrEx_HasTextColour, METH_O, NULL},

30658

{ (char *)"TextAttrEx_HasBackgroundColour", (PyCFunction)_wrap_TextAttrEx_HasBackgroundColour, METH_O, NULL},

30659

{ (char *)"TextAttrEx_HasFont", (PyCFunction)_wrap_TextAttrEx_HasFont, METH_O, NULL},

30660

{ (char *)"TextAttrEx_HasAlignment", (PyCFunction)_wrap_TextAttrEx_HasAlignment, METH_O, NULL},

30661

{ (char *)"TextAttrEx_HasTabs", (PyCFunction)_wrap_TextAttrEx_HasTabs, METH_O, NULL},

30662

{ (char *)"TextAttrEx_HasLeftIndent", (PyCFunction)_wrap_TextAttrEx_HasLeftIndent, METH_O, NULL},

30663

{ (char *)"TextAttrEx_HasRightIndent", (PyCFunction)_wrap_TextAttrEx_HasRightIndent, METH_O, NULL},

30664

{ (char *)"TextAttrEx_HasFlag", (PyCFunction) _wrap_TextAttrEx_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},

30665

{ (char *)"TextAttrEx_GetTextColour", (PyCFunction)_wrap_TextAttrEx_GetTextColour, METH_O, NULL},

30666

{ (char *)"TextAttrEx_GetBackgroundColour", (PyCFunction)_wrap_TextAttrEx_GetBackgroundColour, METH_O, NULL},

30667

{ (char *)"TextAttrEx_GetFont", (PyCFunction)_wrap_TextAttrEx_GetFont, METH_O, NULL},

30668

{ (char *)"TextAttrEx_GetAlignment", (PyCFunction)_wrap_TextAttrEx_GetAlignment, METH_O, NULL},

30669

{ (char *)"TextAttrEx_GetTabs", (PyCFunction)_wrap_TextAttrEx_GetTabs, METH_O, NULL},

30670

{ (char *)"TextAttrEx_GetLeftIndent", (PyCFunction)_wrap_TextAttrEx_GetLeftIndent, METH_O, NULL},

30671

{ (char *)"TextAttrEx_GetLeftSubIndent", (PyCFunction)_wrap_TextAttrEx_GetLeftSubIndent, METH_O, NULL},

30672

{ (char *)"TextAttrEx_GetRightIndent", (PyCFunction)_wrap_TextAttrEx_GetRightIndent, METH_O, NULL},

30673

{ (char *)"TextAttrEx_GetFlags", (PyCFunction)_wrap_TextAttrEx_GetFlags, METH_O, NULL},

30674

{ (char *)"TextAttrEx_SetCharacterStyleName", (PyCFunction) _wrap_TextAttrEx_SetCharacterStyleName, METH_VARARGS | METH_KEYWORDS, NULL},

30675

{ (char *)"TextAttrEx_SetParagraphStyleName", (PyCFunction) _wrap_TextAttrEx_SetParagraphStyleName, METH_VARARGS | METH_KEYWORDS, NULL},

30676

{ (char *)"TextAttrEx_SetListStyleName", (PyCFunction) _wrap_TextAttrEx_SetListStyleName, METH_VARARGS | METH_KEYWORDS, NULL},

30677

{ (char *)"TextAttrEx_SetParagraphSpacingAfter", (PyCFunction) _wrap_TextAttrEx_SetParagraphSpacingAfter, METH_VARARGS | METH_KEYWORDS, NULL},

30678

{ (char *)"TextAttrEx_SetParagraphSpacingBefore", (PyCFunction) _wrap_TextAttrEx_SetParagraphSpacingBefore, METH_VARARGS | METH_KEYWORDS, NULL},

30679

{ (char *)"TextAttrEx_SetLineSpacing", (PyCFunction) _wrap_TextAttrEx_SetLineSpacing, METH_VARARGS | METH_KEYWORDS, NULL},

30680

{ (char *)"TextAttrEx_SetBulletStyle", (PyCFunction) _wrap_TextAttrEx_SetBulletStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30681

{ (char *)"TextAttrEx_SetBulletNumber", (PyCFunction) _wrap_TextAttrEx_SetBulletNumber, METH_VARARGS | METH_KEYWORDS, NULL},

30682

{ (char *)"TextAttrEx_SetBulletText", (PyCFunction) _wrap_TextAttrEx_SetBulletText, METH_VARARGS | METH_KEYWORDS, NULL},

30683

{ (char *)"TextAttrEx_SetBulletName", (PyCFunction) _wrap_TextAttrEx_SetBulletName, METH_VARARGS | METH_KEYWORDS, NULL},

30684

{ (char *)"TextAttrEx_SetBulletFont", (PyCFunction) _wrap_TextAttrEx_SetBulletFont, METH_VARARGS | METH_KEYWORDS, NULL},

30685

{ (char *)"TextAttrEx_SetURL", (PyCFunction) _wrap_TextAttrEx_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},

30686

{ (char *)"TextAttrEx_SetPageBreak", (PyCFunction) _wrap_TextAttrEx_SetPageBreak, METH_VARARGS | METH_KEYWORDS, NULL},

30687

{ (char *)"TextAttrEx_SetTextEffects", (PyCFunction) _wrap_TextAttrEx_SetTextEffects, METH_VARARGS | METH_KEYWORDS, NULL},

30688

{ (char *)"TextAttrEx_SetTextEffectFlags", (PyCFunction) _wrap_TextAttrEx_SetTextEffectFlags, METH_VARARGS | METH_KEYWORDS, NULL},

30689

{ (char *)"TextAttrEx_SetOutlineLevel", (PyCFunction) _wrap_TextAttrEx_SetOutlineLevel, METH_VARARGS | METH_KEYWORDS, NULL},

30690

{ (char *)"TextAttrEx_SetFontSize", (PyCFunction) _wrap_TextAttrEx_SetFontSize, METH_VARARGS | METH_KEYWORDS, NULL},

30691

{ (char *)"TextAttrEx_SetFontStyle", (PyCFunction) _wrap_TextAttrEx_SetFontStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30692

{ (char *)"TextAttrEx_SetFontWeight", (PyCFunction) _wrap_TextAttrEx_SetFontWeight, METH_VARARGS | METH_KEYWORDS, NULL},

30693

{ (char *)"TextAttrEx_SetFontFaceName", (PyCFunction) _wrap_TextAttrEx_SetFontFaceName, METH_VARARGS | METH_KEYWORDS, NULL},

30694

{ (char *)"TextAttrEx_SetFontUnderlined", (PyCFunction) _wrap_TextAttrEx_SetFontUnderlined, METH_VARARGS | METH_KEYWORDS, NULL},

30695

{ (char *)"TextAttrEx_GetCharacterStyleName", (PyCFunction)_wrap_TextAttrEx_GetCharacterStyleName, METH_O, NULL},

30696

{ (char *)"TextAttrEx_GetParagraphStyleName", (PyCFunction)_wrap_TextAttrEx_GetParagraphStyleName, METH_O, NULL},

30697

{ (char *)"TextAttrEx_GetListStyleName", (PyCFunction)_wrap_TextAttrEx_GetListStyleName, METH_O, NULL},

30698

{ (char *)"TextAttrEx_GetParagraphSpacingAfter", (PyCFunction)_wrap_TextAttrEx_GetParagraphSpacingAfter, METH_O, NULL},

30699

{ (char *)"TextAttrEx_GetParagraphSpacingBefore", (PyCFunction)_wrap_TextAttrEx_GetParagraphSpacingBefore, METH_O, NULL},

30700

{ (char *)"TextAttrEx_GetLineSpacing", (PyCFunction)_wrap_TextAttrEx_GetLineSpacing, METH_O, NULL},

30701

{ (char *)"TextAttrEx_GetBulletStyle", (PyCFunction)_wrap_TextAttrEx_GetBulletStyle, METH_O, NULL},

30702

{ (char *)"TextAttrEx_GetBulletNumber", (PyCFunction)_wrap_TextAttrEx_GetBulletNumber, METH_O, NULL},

30703

{ (char *)"TextAttrEx_GetBulletText", (PyCFunction)_wrap_TextAttrEx_GetBulletText, METH_O, NULL},

30704

{ (char *)"TextAttrEx_GetBulletName", (PyCFunction)_wrap_TextAttrEx_GetBulletName, METH_O, NULL},

30705

{ (char *)"TextAttrEx_GetBulletFont", (PyCFunction)_wrap_TextAttrEx_GetBulletFont, METH_O, NULL},

30706

{ (char *)"TextAttrEx_GetURL", (PyCFunction)_wrap_TextAttrEx_GetURL, METH_O, NULL},

30707

{ (char *)"TextAttrEx_GetTextEffects", (PyCFunction)_wrap_TextAttrEx_GetTextEffects, METH_O, NULL},

30708

{ (char *)"TextAttrEx_GetTextEffectFlags", (PyCFunction)_wrap_TextAttrEx_GetTextEffectFlags, METH_O, NULL},

30709

{ (char *)"TextAttrEx_GetOutlineLevel", (PyCFunction)_wrap_TextAttrEx_GetOutlineLevel, METH_O, NULL},

30710

{ (char *)"TextAttrEx_HasFontWeight", (PyCFunction)_wrap_TextAttrEx_HasFontWeight, METH_O, NULL},

30711

{ (char *)"TextAttrEx_HasFontSize", (PyCFunction)_wrap_TextAttrEx_HasFontSize, METH_O, NULL},

30712

{ (char *)"TextAttrEx_HasFontItalic", (PyCFunction)_wrap_TextAttrEx_HasFontItalic, METH_O, NULL},

30713

{ (char *)"TextAttrEx_HasFontUnderlined", (PyCFunction)_wrap_TextAttrEx_HasFontUnderlined, METH_O, NULL},

30714

{ (char *)"TextAttrEx_HasFontFaceName", (PyCFunction)_wrap_TextAttrEx_HasFontFaceName, METH_O, NULL},

30715

{ (char *)"TextAttrEx_HasParagraphSpacingAfter", (PyCFunction)_wrap_TextAttrEx_HasParagraphSpacingAfter, METH_O, NULL},

30716

{ (char *)"TextAttrEx_HasParagraphSpacingBefore", (PyCFunction)_wrap_TextAttrEx_HasParagraphSpacingBefore, METH_O, NULL},

30717

{ (char *)"TextAttrEx_HasLineSpacing", (PyCFunction)_wrap_TextAttrEx_HasLineSpacing, METH_O, NULL},

30718

{ (char *)"TextAttrEx_HasCharacterStyleName", (PyCFunction)_wrap_TextAttrEx_HasCharacterStyleName, METH_O, NULL},

30719

{ (char *)"TextAttrEx_HasParagraphStyleName", (PyCFunction)_wrap_TextAttrEx_HasParagraphStyleName, METH_O, NULL},

30720

{ (char *)"TextAttrEx_HasListStyleName", (PyCFunction)_wrap_TextAttrEx_HasListStyleName, METH_O, NULL},

30721

{ (char *)"TextAttrEx_HasBulletStyle", (PyCFunction)_wrap_TextAttrEx_HasBulletStyle, METH_O, NULL},

30722

{ (char *)"TextAttrEx_HasBulletNumber", (PyCFunction)_wrap_TextAttrEx_HasBulletNumber, METH_O, NULL},

30723

{ (char *)"TextAttrEx_HasBulletText", (PyCFunction)_wrap_TextAttrEx_HasBulletText, METH_O, NULL},

30724

{ (char *)"TextAttrEx_HasBulletName", (PyCFunction)_wrap_TextAttrEx_HasBulletName, METH_O, NULL},

30725

{ (char *)"TextAttrEx_HasURL", (PyCFunction)_wrap_TextAttrEx_HasURL, METH_O, NULL},

30726

{ (char *)"TextAttrEx_HasPageBreak", (PyCFunction)_wrap_TextAttrEx_HasPageBreak, METH_O, NULL},

30727

{ (char *)"TextAttrEx_HasTextEffects", (PyCFunction)_wrap_TextAttrEx_HasTextEffects, METH_O, NULL},

30728

{ (char *)"TextAttrEx_HasTextEffect", (PyCFunction) _wrap_TextAttrEx_HasTextEffect, METH_VARARGS | METH_KEYWORDS, NULL},

30729

{ (char *)"TextAttrEx_HasOutlineLevel", (PyCFunction)_wrap_TextAttrEx_HasOutlineLevel, METH_O, NULL},

30730

{ (char *)"TextAttrEx_IsCharacterStyle", (PyCFunction)_wrap_TextAttrEx_IsCharacterStyle, METH_O, NULL},

30731

{ (char *)"TextAttrEx_IsParagraphStyle", (PyCFunction)_wrap_TextAttrEx_IsParagraphStyle, METH_O, NULL},

30732

{ (char *)"TextAttrEx_IsDefault", (PyCFunction)_wrap_TextAttrEx_IsDefault, METH_O, NULL},

30733

{ (char *)"TextAttrEx_CombineEx", (PyCFunction) _wrap_TextAttrEx_CombineEx, METH_VARARGS | METH_KEYWORDS, NULL},

30734

{ (char *)"TextAttrEx_swigregister", TextAttrEx_swigregister, METH_VARARGS, NULL},

30735

{ (char *)"TextAttrEx_swiginit", TextAttrEx_swiginit, METH_VARARGS, NULL},

30736

{ (char *)"delete_RichTextObject", (PyCFunction)_wrap_delete_RichTextObject, METH_O, NULL},

30737

{ (char *)"RichTextObject_Draw", (PyCFunction) _wrap_RichTextObject_Draw, METH_VARARGS | METH_KEYWORDS, NULL},

30738

{ (char *)"RichTextObject_Layout", (PyCFunction) _wrap_RichTextObject_Layout, METH_VARARGS | METH_KEYWORDS, NULL},

30739

{ (char *)"RichTextObject_HitTest", (PyCFunction) _wrap_RichTextObject_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},

30740

{ (char *)"RichTextObject_FindPosition", (PyCFunction) _wrap_RichTextObject_FindPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30741

{ (char *)"RichTextObject_GetBestSize", (PyCFunction)_wrap_RichTextObject_GetBestSize, METH_O, NULL},

30742

{ (char *)"RichTextObject_GetRangeSize", (PyCFunction) _wrap_RichTextObject_GetRangeSize, METH_VARARGS | METH_KEYWORDS, NULL},

30743

{ (char *)"RichTextObject_DoSplit", (PyCFunction) _wrap_RichTextObject_DoSplit, METH_VARARGS | METH_KEYWORDS, NULL},

30744

{ (char *)"RichTextObject_CalculateRange", (PyCFunction) _wrap_RichTextObject_CalculateRange, METH_VARARGS | METH_KEYWORDS, NULL},

30745

{ (char *)"RichTextObject_DeleteRange", (PyCFunction) _wrap_RichTextObject_DeleteRange, METH_VARARGS | METH_KEYWORDS, NULL},

30746

{ (char *)"RichTextObject_IsEmpty", (PyCFunction)_wrap_RichTextObject_IsEmpty, METH_O, NULL},

30747

{ (char *)"RichTextObject_GetTextForRange", (PyCFunction) _wrap_RichTextObject_GetTextForRange, METH_VARARGS | METH_KEYWORDS, NULL},

30748

{ (char *)"RichTextObject_CanMerge", (PyCFunction) _wrap_RichTextObject_CanMerge, METH_VARARGS | METH_KEYWORDS, NULL},

30749

{ (char *)"RichTextObject_Merge", (PyCFunction) _wrap_RichTextObject_Merge, METH_VARARGS | METH_KEYWORDS, NULL},

30750

{ (char *)"RichTextObject_Dump", (PyCFunction)_wrap_RichTextObject_Dump, METH_O, NULL},

30751

{ (char *)"RichTextObject_GetCachedSize", (PyCFunction)_wrap_RichTextObject_GetCachedSize, METH_O, NULL},

30752

{ (char *)"RichTextObject_SetCachedSize", (PyCFunction) _wrap_RichTextObject_SetCachedSize, METH_VARARGS | METH_KEYWORDS, NULL},

30753

{ (char *)"RichTextObject_GetPosition", (PyCFunction)_wrap_RichTextObject_GetPosition, METH_O, NULL},

30754

{ (char *)"RichTextObject_SetPosition", (PyCFunction) _wrap_RichTextObject_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30755

{ (char *)"RichTextObject_GetRect", (PyCFunction)_wrap_RichTextObject_GetRect, METH_O, NULL},

30756

{ (char *)"RichTextObject_SetRange", (PyCFunction) _wrap_RichTextObject_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},

30757

{ (char *)"RichTextObject_GetRange", (PyCFunction)_wrap_RichTextObject_GetRange, METH_O, NULL},

30758

{ (char *)"RichTextObject_GetDirty", (PyCFunction)_wrap_RichTextObject_GetDirty, METH_O, NULL},

30759

{ (char *)"RichTextObject_SetDirty", (PyCFunction) _wrap_RichTextObject_SetDirty, METH_VARARGS | METH_KEYWORDS, NULL},

30760

{ (char *)"RichTextObject_IsComposite", (PyCFunction)_wrap_RichTextObject_IsComposite, METH_O, NULL},

30761

{ (char *)"RichTextObject_GetParent", (PyCFunction)_wrap_RichTextObject_GetParent, METH_O, NULL},

30762

{ (char *)"RichTextObject_SetParent", (PyCFunction) _wrap_RichTextObject_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},

30763

{ (char *)"RichTextObject_SetSameMargins", (PyCFunction) _wrap_RichTextObject_SetSameMargins, METH_VARARGS | METH_KEYWORDS, NULL},

30764

{ (char *)"RichTextObject_SetMargins", (PyCFunction) _wrap_RichTextObject_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},

30765

{ (char *)"RichTextObject_GetLeftMargin", (PyCFunction)_wrap_RichTextObject_GetLeftMargin, METH_O, NULL},

30766

{ (char *)"RichTextObject_GetRightMargin", (PyCFunction)_wrap_RichTextObject_GetRightMargin, METH_O, NULL},

30767

{ (char *)"RichTextObject_GetTopMargin", (PyCFunction)_wrap_RichTextObject_GetTopMargin, METH_O, NULL},

30768

{ (char *)"RichTextObject_GetBottomMargin", (PyCFunction)_wrap_RichTextObject_GetBottomMargin, METH_O, NULL},

30769

{ (char *)"RichTextObject_SetAttributes", (PyCFunction) _wrap_RichTextObject_SetAttributes, METH_VARARGS | METH_KEYWORDS, NULL},

30770

{ (char *)"RichTextObject_GetAttributes", (PyCFunction)_wrap_RichTextObject_GetAttributes, METH_O, NULL},

30771

{ (char *)"RichTextObject_SetDescent", (PyCFunction) _wrap_RichTextObject_SetDescent, METH_VARARGS | METH_KEYWORDS, NULL},

30772

{ (char *)"RichTextObject_GetDescent", (PyCFunction)_wrap_RichTextObject_GetDescent, METH_O, NULL},

30773

{ (char *)"RichTextObject_GetBuffer", (PyCFunction)_wrap_RichTextObject_GetBuffer, METH_O, NULL},

30774

{ (char *)"RichTextObject_Clone", (PyCFunction)_wrap_RichTextObject_Clone, METH_O, NULL},

30775

{ (char *)"RichTextObject_Copy", (PyCFunction) _wrap_RichTextObject_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30776

{ (char *)"RichTextObject_Reference", (PyCFunction)_wrap_RichTextObject_Reference, METH_O, NULL},

30777

{ (char *)"RichTextObject_Dereference", (PyCFunction)_wrap_RichTextObject_Dereference, METH_O, NULL},

30778

{ (char *)"RichTextObject_ConvertTenthsMMToPixelsDC", (PyCFunction) _wrap_RichTextObject_ConvertTenthsMMToPixelsDC, METH_VARARGS | METH_KEYWORDS, NULL},

30779

{ (char *)"RichTextObject_ConvertTenthsMMToPixels", (PyCFunction) _wrap_RichTextObject_ConvertTenthsMMToPixels, METH_VARARGS | METH_KEYWORDS, NULL},

30780

{ (char *)"RichTextObject_swigregister", RichTextObject_swigregister, METH_VARARGS, NULL},

30781

{ (char *)"delete_RichTextObjectList_iterator", (PyCFunction)_wrap_delete_RichTextObjectList_iterator, METH_O, NULL},

30782

{ (char *)"RichTextObjectList_iterator_next", (PyCFunction)_wrap_RichTextObjectList_iterator_next, METH_O, NULL},

30783

{ (char *)"RichTextObjectList_iterator_swigregister", RichTextObjectList_iterator_swigregister, METH_VARARGS, NULL},

30784

{ (char *)"delete_RichTextObjectList", (PyCFunction)_wrap_delete_RichTextObjectList, METH_O, NULL},

30785

{ (char *)"RichTextObjectList___len__", (PyCFunction)_wrap_RichTextObjectList___len__, METH_O, NULL},

30786

{ (char *)"RichTextObjectList___getitem__", (PyCFunction) _wrap_RichTextObjectList___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},

30787

{ (char *)"RichTextObjectList___contains__", (PyCFunction) _wrap_RichTextObjectList___contains__, METH_VARARGS | METH_KEYWORDS, NULL},

30788

{ (char *)"RichTextObjectList___iter__", (PyCFunction)_wrap_RichTextObjectList___iter__, METH_O, NULL},

30789

{ (char *)"RichTextObjectList_index", (PyCFunction) _wrap_RichTextObjectList_index, METH_VARARGS | METH_KEYWORDS, NULL},

30790

{ (char *)"RichTextObjectList_swigregister", RichTextObjectList_swigregister, METH_VARARGS, NULL},

30791

{ (char *)"delete_RichTextCompositeObject", (PyCFunction)_wrap_delete_RichTextCompositeObject, METH_O, NULL},

30792

{ (char *)"RichTextCompositeObject_GetChildren", (PyCFunction)_wrap_RichTextCompositeObject_GetChildren, METH_O, NULL},

30793

{ (char *)"RichTextCompositeObject_GetChildCount", (PyCFunction)_wrap_RichTextCompositeObject_GetChildCount, METH_O, NULL},

30794

{ (char *)"RichTextCompositeObject_GetChild", (PyCFunction) _wrap_RichTextCompositeObject_GetChild, METH_VARARGS | METH_KEYWORDS, NULL},

30795

{ (char *)"RichTextCompositeObject_Copy", (PyCFunction) _wrap_RichTextCompositeObject_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30796

{ (char *)"RichTextCompositeObject_AppendChild", (PyCFunction) _wrap_RichTextCompositeObject_AppendChild, METH_VARARGS | METH_KEYWORDS, NULL},

30797

{ (char *)"RichTextCompositeObject_InsertChild", (PyCFunction) _wrap_RichTextCompositeObject_InsertChild, METH_VARARGS | METH_KEYWORDS, NULL},

30798

{ (char *)"RichTextCompositeObject_RemoveChild", (PyCFunction) _wrap_RichTextCompositeObject_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},

30799

{ (char *)"RichTextCompositeObject_DeleteChildren", (PyCFunction)_wrap_RichTextCompositeObject_DeleteChildren, METH_O, NULL},

30800

{ (char *)"RichTextCompositeObject_Defragment", (PyCFunction)_wrap_RichTextCompositeObject_Defragment, METH_O, NULL},

30801

{ (char *)"RichTextCompositeObject_swigregister", RichTextCompositeObject_swigregister, METH_VARARGS, NULL},

30802

{ (char *)"new_RichTextBox", (PyCFunction) _wrap_new_RichTextBox, METH_VARARGS | METH_KEYWORDS, NULL},

30803

{ (char *)"RichTextBox_Copy", (PyCFunction) _wrap_RichTextBox_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30804

{ (char *)"RichTextBox_swigregister", RichTextBox_swigregister, METH_VARARGS, NULL},

30805

{ (char *)"RichTextBox_swiginit", RichTextBox_swiginit, METH_VARARGS, NULL},

30806

{ (char *)"new_RichTextParagraphLayoutBox", (PyCFunction) _wrap_new_RichTextParagraphLayoutBox, METH_VARARGS | METH_KEYWORDS, NULL},

30807

{ (char *)"RichTextParagraphLayoutBox_SetRichTextCtrl", (PyCFunction) _wrap_RichTextParagraphLayoutBox_SetRichTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},

30808

{ (char *)"RichTextParagraphLayoutBox_GetRichTextCtrl", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetRichTextCtrl, METH_O, NULL},

30809

{ (char *)"RichTextParagraphLayoutBox_SetPartialParagraph", (PyCFunction) _wrap_RichTextParagraphLayoutBox_SetPartialParagraph, METH_VARARGS | METH_KEYWORDS, NULL},

30810

{ (char *)"RichTextParagraphLayoutBox_GetPartialParagraph", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetPartialParagraph, METH_O, NULL},

30811

{ (char *)"RichTextParagraphLayoutBox_GetStyleSheet", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetStyleSheet, METH_O, NULL},

30812

{ (char *)"RichTextParagraphLayoutBox_Init", (PyCFunction)_wrap_RichTextParagraphLayoutBox_Init, METH_O, NULL},

30813

{ (char *)"RichTextParagraphLayoutBox_Clear", (PyCFunction)_wrap_RichTextParagraphLayoutBox_Clear, METH_O, NULL},

30814

{ (char *)"RichTextParagraphLayoutBox_Reset", (PyCFunction)_wrap_RichTextParagraphLayoutBox_Reset, METH_O, NULL},

30815

{ (char *)"RichTextParagraphLayoutBox_AddParagraph", (PyCFunction) _wrap_RichTextParagraphLayoutBox_AddParagraph, METH_VARARGS | METH_KEYWORDS, NULL},

30816

{ (char *)"RichTextParagraphLayoutBox_AddImage", (PyCFunction) _wrap_RichTextParagraphLayoutBox_AddImage, METH_VARARGS | METH_KEYWORDS, NULL},

30817

{ (char *)"RichTextParagraphLayoutBox_AddParagraphs", (PyCFunction) _wrap_RichTextParagraphLayoutBox_AddParagraphs, METH_VARARGS | METH_KEYWORDS, NULL},

30818

{ (char *)"RichTextParagraphLayoutBox_GetLineAtPosition", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetLineAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30819

{ (char *)"RichTextParagraphLayoutBox_GetLineAtYPosition", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetLineAtYPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30820

{ (char *)"RichTextParagraphLayoutBox_GetParagraphAtPosition", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetParagraphAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30821

{ (char *)"RichTextParagraphLayoutBox_GetLineSizeAtPosition", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetLineSizeAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30822

{ (char *)"RichTextParagraphLayoutBox_GetVisibleLineNumber", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetVisibleLineNumber, METH_VARARGS | METH_KEYWORDS, NULL},

30823

{ (char *)"RichTextParagraphLayoutBox_GetLineForVisibleLineNumber", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetLineForVisibleLineNumber, METH_VARARGS | METH_KEYWORDS, NULL},

30824

{ (char *)"RichTextParagraphLayoutBox_GetLeafObjectAtPosition", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetLeafObjectAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30825

{ (char *)"RichTextParagraphLayoutBox_GetParagraphAtLine", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetParagraphAtLine, METH_VARARGS | METH_KEYWORDS, NULL},

30826

{ (char *)"RichTextParagraphLayoutBox_GetParagraphForLine", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetParagraphForLine, METH_VARARGS | METH_KEYWORDS, NULL},

30827

{ (char *)"RichTextParagraphLayoutBox_GetParagraphLength", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetParagraphLength, METH_VARARGS | METH_KEYWORDS, NULL},

30828

{ (char *)"RichTextParagraphLayoutBox_GetParagraphCount", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetParagraphCount, METH_O, NULL},

30829

{ (char *)"RichTextParagraphLayoutBox_GetLineCount", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetLineCount, METH_O, NULL},

30830

{ (char *)"RichTextParagraphLayoutBox_GetParagraphText", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetParagraphText, METH_VARARGS | METH_KEYWORDS, NULL},

30831

{ (char *)"RichTextParagraphLayoutBox_XYToPosition", (PyCFunction) _wrap_RichTextParagraphLayoutBox_XYToPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30832

{ (char *)"RichTextParagraphLayoutBox_PositionToXY", (PyCFunction) _wrap_RichTextParagraphLayoutBox_PositionToXY, METH_VARARGS | METH_KEYWORDS, NULL},

30833

{ (char *)"RichTextParagraphLayoutBox_SetStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30834

{ (char *)"RichTextParagraphLayoutBox_GetStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30835

{ (char *)"RichTextParagraphLayoutBox_GetUncombinedStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetUncombinedStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30836

{ (char *)"RichTextParagraphLayoutBox_GetStyleForRange", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetStyleForRange, METH_VARARGS | METH_KEYWORDS, NULL},

30837

{ (char *)"RichTextParagraphLayoutBox_CollectStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_CollectStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30838

{ (char *)"RichTextParagraphLayoutBox_SetListStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_SetListStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30839

{ (char *)"RichTextParagraphLayoutBox_ClearListStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_ClearListStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30840

{ (char *)"RichTextParagraphLayoutBox_NumberList", (PyCFunction) _wrap_RichTextParagraphLayoutBox_NumberList, METH_VARARGS | METH_KEYWORDS, NULL},

30841

{ (char *)"RichTextParagraphLayoutBox_PromoteList", (PyCFunction) _wrap_RichTextParagraphLayoutBox_PromoteList, METH_VARARGS | METH_KEYWORDS, NULL},

30842

{ (char *)"RichTextParagraphLayoutBox_DoNumberList", (PyCFunction) _wrap_RichTextParagraphLayoutBox_DoNumberList, METH_VARARGS | METH_KEYWORDS, NULL},

30843

{ (char *)"RichTextParagraphLayoutBox_FindNextParagraphNumber", (PyCFunction) _wrap_RichTextParagraphLayoutBox_FindNextParagraphNumber, METH_VARARGS | METH_KEYWORDS, NULL},

30844

{ (char *)"RichTextParagraphLayoutBox_HasCharacterAttributes", (PyCFunction) _wrap_RichTextParagraphLayoutBox_HasCharacterAttributes, METH_VARARGS | METH_KEYWORDS, NULL},

30845

{ (char *)"RichTextParagraphLayoutBox_HasParagraphAttributes", (PyCFunction) _wrap_RichTextParagraphLayoutBox_HasParagraphAttributes, METH_VARARGS | METH_KEYWORDS, NULL},

30846

{ (char *)"RichTextParagraphLayoutBox_InsertFragment", (PyCFunction) _wrap_RichTextParagraphLayoutBox_InsertFragment, METH_VARARGS | METH_KEYWORDS, NULL},

30847

{ (char *)"RichTextParagraphLayoutBox_CopyFragment", (PyCFunction) _wrap_RichTextParagraphLayoutBox_CopyFragment, METH_VARARGS | METH_KEYWORDS, NULL},

30848

{ (char *)"RichTextParagraphLayoutBox_ApplyStyleSheet", (PyCFunction) _wrap_RichTextParagraphLayoutBox_ApplyStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

30849

{ (char *)"RichTextParagraphLayoutBox_Copy", (PyCFunction) _wrap_RichTextParagraphLayoutBox_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30850

{ (char *)"RichTextParagraphLayoutBox_UpdateRanges", (PyCFunction)_wrap_RichTextParagraphLayoutBox_UpdateRanges, METH_O, NULL},

30851

{ (char *)"RichTextParagraphLayoutBox_GetText", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetText, METH_O, NULL},

30852

{ (char *)"RichTextParagraphLayoutBox_SetDefaultStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_SetDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30853

{ (char *)"RichTextParagraphLayoutBox_GetDefaultStyle", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetDefaultStyle, METH_O, NULL},

30854

{ (char *)"RichTextParagraphLayoutBox_SetBasicStyle", (PyCFunction) _wrap_RichTextParagraphLayoutBox_SetBasicStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30855

{ (char *)"RichTextParagraphLayoutBox_GetBasicStyle", (PyCFunction)_wrap_RichTextParagraphLayoutBox_GetBasicStyle, METH_O, NULL},

30856

{ (char *)"RichTextParagraphLayoutBox_Invalidate", (PyCFunction) _wrap_RichTextParagraphLayoutBox_Invalidate, METH_VARARGS | METH_KEYWORDS, NULL},

30857

{ (char *)"RichTextParagraphLayoutBox_GetInvalidRange", (PyCFunction) _wrap_RichTextParagraphLayoutBox_GetInvalidRange, METH_VARARGS | METH_KEYWORDS, NULL},

30858

{ (char *)"RichTextParagraphLayoutBox_swigregister", RichTextParagraphLayoutBox_swigregister, METH_VARARGS, NULL},

30859

{ (char *)"RichTextParagraphLayoutBox_swiginit", RichTextParagraphLayoutBox_swiginit, METH_VARARGS, NULL},

30860

{ (char *)"new_RichTextLine", (PyCFunction) _wrap_new_RichTextLine, METH_VARARGS | METH_KEYWORDS, NULL},

30861

{ (char *)"delete_RichTextLine", (PyCFunction)_wrap_delete_RichTextLine, METH_O, NULL},

30862

{ (char *)"RichTextLine_SetRange", (PyCFunction) _wrap_RichTextLine_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},

30863

{ (char *)"RichTextLine_GetParent", (PyCFunction)_wrap_RichTextLine_GetParent, METH_O, NULL},

30864

{ (char *)"RichTextLine_GetRange", (PyCFunction)_wrap_RichTextLine_GetRange, METH_O, NULL},

30865

{ (char *)"RichTextLine_GetAbsoluteRange", (PyCFunction)_wrap_RichTextLine_GetAbsoluteRange, METH_O, NULL},

30866

{ (char *)"RichTextLine_GetSize", (PyCFunction)_wrap_RichTextLine_GetSize, METH_O, NULL},

30867

{ (char *)"RichTextLine_SetSize", (PyCFunction) _wrap_RichTextLine_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},

30868

{ (char *)"RichTextLine_GetPosition", (PyCFunction)_wrap_RichTextLine_GetPosition, METH_O, NULL},

30869

{ (char *)"RichTextLine_SetPosition", (PyCFunction) _wrap_RichTextLine_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30870

{ (char *)"RichTextLine_GetAbsolutePosition", (PyCFunction)_wrap_RichTextLine_GetAbsolutePosition, METH_O, NULL},

30871

{ (char *)"RichTextLine_GetRect", (PyCFunction)_wrap_RichTextLine_GetRect, METH_O, NULL},

30872

{ (char *)"RichTextLine_SetDescent", (PyCFunction) _wrap_RichTextLine_SetDescent, METH_VARARGS | METH_KEYWORDS, NULL},

30873

{ (char *)"RichTextLine_GetDescent", (PyCFunction)_wrap_RichTextLine_GetDescent, METH_O, NULL},

30874

{ (char *)"RichTextLine_Init", (PyCFunction) _wrap_RichTextLine_Init, METH_VARARGS | METH_KEYWORDS, NULL},

30875

{ (char *)"RichTextLine_Copy", (PyCFunction) _wrap_RichTextLine_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30876

{ (char *)"RichTextLine_Clone", (PyCFunction)_wrap_RichTextLine_Clone, METH_O, NULL},

30877

{ (char *)"RichTextLine_swigregister", RichTextLine_swigregister, METH_VARARGS, NULL},

30878

{ (char *)"RichTextLine_swiginit", RichTextLine_swiginit, METH_VARARGS, NULL},

30879

{ (char *)"new_RichTextParagraph", (PyCFunction) _wrap_new_RichTextParagraph, METH_VARARGS | METH_KEYWORDS, NULL},

30880

{ (char *)"delete_RichTextParagraph", (PyCFunction)_wrap_delete_RichTextParagraph, METH_O, NULL},

30881

{ (char *)"RichTextParagraph_GetLines", (PyCFunction)_wrap_RichTextParagraph_GetLines, METH_O, NULL},

30882

{ (char *)"RichTextParagraph_Copy", (PyCFunction) _wrap_RichTextParagraph_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30883

{ (char *)"RichTextParagraph_ClearLines", (PyCFunction)_wrap_RichTextParagraph_ClearLines, METH_O, NULL},

30884

{ (char *)"RichTextParagraph_ApplyParagraphStyle", (PyCFunction) _wrap_RichTextParagraph_ApplyParagraphStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30885

{ (char *)"RichTextParagraph_InsertText", (PyCFunction) _wrap_RichTextParagraph_InsertText, METH_VARARGS | METH_KEYWORDS, NULL},

30886

{ (char *)"RichTextParagraph_SplitAt", (PyCFunction) _wrap_RichTextParagraph_SplitAt, METH_VARARGS | METH_KEYWORDS, NULL},

30887

{ (char *)"RichTextParagraph_MoveToList", (PyCFunction) _wrap_RichTextParagraph_MoveToList, METH_VARARGS | METH_KEYWORDS, NULL},

30888

{ (char *)"RichTextParagraph_MoveFromList", (PyCFunction) _wrap_RichTextParagraph_MoveFromList, METH_VARARGS | METH_KEYWORDS, NULL},

30889

{ (char *)"RichTextParagraph_GetContiguousPlainText", (PyCFunction) _wrap_RichTextParagraph_GetContiguousPlainText, METH_VARARGS | METH_KEYWORDS, NULL},

30890

{ (char *)"RichTextParagraph_FindWrapPosition", (PyCFunction) _wrap_RichTextParagraph_FindWrapPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30891

{ (char *)"RichTextParagraph_FindObjectAtPosition", (PyCFunction) _wrap_RichTextParagraph_FindObjectAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30892

{ (char *)"RichTextParagraph_GetBulletText", (PyCFunction)_wrap_RichTextParagraph_GetBulletText, METH_O, NULL},

30893

{ (char *)"RichTextParagraph_AllocateLine", (PyCFunction) _wrap_RichTextParagraph_AllocateLine, METH_VARARGS | METH_KEYWORDS, NULL},

30894

{ (char *)"RichTextParagraph_ClearUnusedLines", (PyCFunction) _wrap_RichTextParagraph_ClearUnusedLines, METH_VARARGS | METH_KEYWORDS, NULL},

30895

{ (char *)"RichTextParagraph_GetCombinedAttributes", (PyCFunction) _wrap_RichTextParagraph_GetCombinedAttributes, METH_VARARGS | METH_KEYWORDS, NULL},

30896

{ (char *)"RichTextParagraph_GetFirstLineBreakPosition", (PyCFunction) _wrap_RichTextParagraph_GetFirstLineBreakPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30897

{ (char *)"RichTextParagraph_InitDefaultTabs", (PyCFunction)_wrap_RichTextParagraph_InitDefaultTabs, METH_NOARGS, NULL},

30898

{ (char *)"RichTextParagraph_ClearDefaultTabs", (PyCFunction)_wrap_RichTextParagraph_ClearDefaultTabs, METH_NOARGS, NULL},

30899

{ (char *)"RichTextParagraph_GetDefaultTabs", (PyCFunction)_wrap_RichTextParagraph_GetDefaultTabs, METH_NOARGS, NULL},

30900

{ (char *)"RichTextParagraph_swigregister", RichTextParagraph_swigregister, METH_VARARGS, NULL},

30901

{ (char *)"RichTextParagraph_swiginit", RichTextParagraph_swiginit, METH_VARARGS, NULL},

30902

{ (char *)"new_RichTextPlainText", (PyCFunction) _wrap_new_RichTextPlainText, METH_VARARGS | METH_KEYWORDS, NULL},

30903

{ (char *)"RichTextPlainText_GetFirstLineBreakPosition", (PyCFunction) _wrap_RichTextPlainText_GetFirstLineBreakPosition, METH_VARARGS | METH_KEYWORDS, NULL},

30904

{ (char *)"RichTextPlainText_GetText", (PyCFunction)_wrap_RichTextPlainText_GetText, METH_O, NULL},

30905

{ (char *)"RichTextPlainText_SetText", (PyCFunction) _wrap_RichTextPlainText_SetText, METH_VARARGS | METH_KEYWORDS, NULL},

30906

{ (char *)"RichTextPlainText_Copy", (PyCFunction) _wrap_RichTextPlainText_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30907

{ (char *)"RichTextPlainText_swigregister", RichTextPlainText_swigregister, METH_VARARGS, NULL},

30908

{ (char *)"RichTextPlainText_swiginit", RichTextPlainText_swiginit, METH_VARARGS, NULL},

30909

{ (char *)"new_RichTextImage", (PyCFunction) _wrap_new_RichTextImage, METH_VARARGS | METH_KEYWORDS, NULL},

30910

{ (char *)"RichTextImage_GetImage", (PyCFunction)_wrap_RichTextImage_GetImage, METH_O, NULL},

30911

{ (char *)"RichTextImage_SetImage", (PyCFunction) _wrap_RichTextImage_SetImage, METH_VARARGS | METH_KEYWORDS, NULL},

30912

{ (char *)"RichTextImage_GetImageBlock", (PyCFunction)_wrap_RichTextImage_GetImageBlock, METH_O, NULL},

30913

{ (char *)"RichTextImage_Copy", (PyCFunction) _wrap_RichTextImage_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30914

{ (char *)"RichTextImage_LoadFromBlock", (PyCFunction)_wrap_RichTextImage_LoadFromBlock, METH_O, NULL},

30915

{ (char *)"RichTextImage_MakeBlock", (PyCFunction)_wrap_RichTextImage_MakeBlock, METH_O, NULL},

30916

{ (char *)"RichTextImage_swigregister", RichTextImage_swigregister, METH_VARARGS, NULL},

30917

{ (char *)"RichTextImage_swiginit", RichTextImage_swiginit, METH_VARARGS, NULL},

30918

{ (char *)"delete_RichTextFileHandlerList_iterator", (PyCFunction)_wrap_delete_RichTextFileHandlerList_iterator, METH_O, NULL},

30919

{ (char *)"RichTextFileHandlerList_iterator_next", (PyCFunction)_wrap_RichTextFileHandlerList_iterator_next, METH_O, NULL},

30920

{ (char *)"RichTextFileHandlerList_iterator_swigregister", RichTextFileHandlerList_iterator_swigregister, METH_VARARGS, NULL},

30921

{ (char *)"delete_RichTextFileHandlerList", (PyCFunction)_wrap_delete_RichTextFileHandlerList, METH_O, NULL},

30922

{ (char *)"RichTextFileHandlerList___len__", (PyCFunction)_wrap_RichTextFileHandlerList___len__, METH_O, NULL},

30923

{ (char *)"RichTextFileHandlerList___getitem__", (PyCFunction) _wrap_RichTextFileHandlerList___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},

30924

{ (char *)"RichTextFileHandlerList___contains__", (PyCFunction) _wrap_RichTextFileHandlerList___contains__, METH_VARARGS | METH_KEYWORDS, NULL},

30925

{ (char *)"RichTextFileHandlerList___iter__", (PyCFunction)_wrap_RichTextFileHandlerList___iter__, METH_O, NULL},

30926

{ (char *)"RichTextFileHandlerList_swigregister", RichTextFileHandlerList_swigregister, METH_VARARGS, NULL},

30927

{ (char *)"new_RichTextBuffer", _wrap_new_RichTextBuffer, METH_VARARGS, NULL},

30928

{ (char *)"delete_RichTextBuffer", (PyCFunction)_wrap_delete_RichTextBuffer, METH_O, NULL},

30929

{ (char *)"RichTextBuffer_GetCommandProcessor", (PyCFunction)_wrap_RichTextBuffer_GetCommandProcessor, METH_O, NULL},

30930

{ (char *)"RichTextBuffer_SetStyleSheet", (PyCFunction) _wrap_RichTextBuffer_SetStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

30931

{ (char *)"RichTextBuffer_SetStyleSheetAndNotify", (PyCFunction) _wrap_RichTextBuffer_SetStyleSheetAndNotify, METH_VARARGS | METH_KEYWORDS, NULL},

30932

{ (char *)"RichTextBuffer_PushStyleSheet", (PyCFunction) _wrap_RichTextBuffer_PushStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

30933

{ (char *)"RichTextBuffer_PopStyleSheet", (PyCFunction)_wrap_RichTextBuffer_PopStyleSheet, METH_O, NULL},

30934

{ (char *)"RichTextBuffer_Init", (PyCFunction)_wrap_RichTextBuffer_Init, METH_O, NULL},

30935

{ (char *)"RichTextBuffer_ResetAndClearCommands", (PyCFunction)_wrap_RichTextBuffer_ResetAndClearCommands, METH_O, NULL},

30936

{ (char *)"RichTextBuffer_LoadFile", (PyCFunction) _wrap_RichTextBuffer_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},

30937

{ (char *)"RichTextBuffer_SaveFile", (PyCFunction) _wrap_RichTextBuffer_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},

30938

{ (char *)"RichTextBuffer_LoadStream", (PyCFunction) _wrap_RichTextBuffer_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},

30939

{ (char *)"RichTextBuffer_SaveStream", (PyCFunction) _wrap_RichTextBuffer_SaveStream, METH_VARARGS | METH_KEYWORDS, NULL},

30940

{ (char *)"RichTextBuffer_SetHandlerFlags", (PyCFunction) _wrap_RichTextBuffer_SetHandlerFlags, METH_VARARGS | METH_KEYWORDS, NULL},

30941

{ (char *)"RichTextBuffer_GetHandlerFlags", (PyCFunction)_wrap_RichTextBuffer_GetHandlerFlags, METH_O, NULL},

30942

{ (char *)"RichTextBuffer_BeginBatchUndo", (PyCFunction) _wrap_RichTextBuffer_BeginBatchUndo, METH_VARARGS | METH_KEYWORDS, NULL},

30943

{ (char *)"RichTextBuffer_EndBatchUndo", (PyCFunction)_wrap_RichTextBuffer_EndBatchUndo, METH_O, NULL},

30944

{ (char *)"RichTextBuffer_BatchingUndo", (PyCFunction)_wrap_RichTextBuffer_BatchingUndo, METH_O, NULL},

30945

{ (char *)"RichTextBuffer_SubmitAction", (PyCFunction) _wrap_RichTextBuffer_SubmitAction, METH_VARARGS | METH_KEYWORDS, NULL},

30946

{ (char *)"RichTextBuffer_GetBatchedCommand", (PyCFunction)_wrap_RichTextBuffer_GetBatchedCommand, METH_O, NULL},

30947

{ (char *)"RichTextBuffer_BeginSuppressUndo", (PyCFunction)_wrap_RichTextBuffer_BeginSuppressUndo, METH_O, NULL},

30948

{ (char *)"RichTextBuffer_EndSuppressUndo", (PyCFunction)_wrap_RichTextBuffer_EndSuppressUndo, METH_O, NULL},

30949

{ (char *)"RichTextBuffer_SuppressingUndo", (PyCFunction)_wrap_RichTextBuffer_SuppressingUndo, METH_O, NULL},

30950

{ (char *)"RichTextBuffer_CopyToClipboard", (PyCFunction) _wrap_RichTextBuffer_CopyToClipboard, METH_VARARGS | METH_KEYWORDS, NULL},

30951

{ (char *)"RichTextBuffer_PasteFromClipboard", (PyCFunction) _wrap_RichTextBuffer_PasteFromClipboard, METH_VARARGS | METH_KEYWORDS, NULL},

30952

{ (char *)"RichTextBuffer_CanPasteFromClipboard", (PyCFunction)_wrap_RichTextBuffer_CanPasteFromClipboard, METH_O, NULL},

30953

{ (char *)"RichTextBuffer_BeginStyle", (PyCFunction) _wrap_RichTextBuffer_BeginStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30954

{ (char *)"RichTextBuffer_EndStyle", (PyCFunction)_wrap_RichTextBuffer_EndStyle, METH_O, NULL},

30955

{ (char *)"RichTextBuffer_EndAllStyles", (PyCFunction)_wrap_RichTextBuffer_EndAllStyles, METH_O, NULL},

30956

{ (char *)"RichTextBuffer_ClearStyleStack", (PyCFunction)_wrap_RichTextBuffer_ClearStyleStack, METH_O, NULL},

30957

{ (char *)"RichTextBuffer_GetStyleStackSize", (PyCFunction)_wrap_RichTextBuffer_GetStyleStackSize, METH_O, NULL},

30958

{ (char *)"RichTextBuffer_BeginBold", (PyCFunction)_wrap_RichTextBuffer_BeginBold, METH_O, NULL},

30959

{ (char *)"RichTextBuffer_EndBold", (PyCFunction)_wrap_RichTextBuffer_EndBold, METH_O, NULL},

30960

{ (char *)"RichTextBuffer_BeginItalic", (PyCFunction)_wrap_RichTextBuffer_BeginItalic, METH_O, NULL},

30961

{ (char *)"RichTextBuffer_EndItalic", (PyCFunction)_wrap_RichTextBuffer_EndItalic, METH_O, NULL},

30962

{ (char *)"RichTextBuffer_BeginUnderline", (PyCFunction)_wrap_RichTextBuffer_BeginUnderline, METH_O, NULL},

30963

{ (char *)"RichTextBuffer_EndUnderline", (PyCFunction)_wrap_RichTextBuffer_EndUnderline, METH_O, NULL},

30964

{ (char *)"RichTextBuffer_BeginFontSize", (PyCFunction) _wrap_RichTextBuffer_BeginFontSize, METH_VARARGS | METH_KEYWORDS, NULL},

30965

{ (char *)"RichTextBuffer_EndFontSize", (PyCFunction)_wrap_RichTextBuffer_EndFontSize, METH_O, NULL},

30966

{ (char *)"RichTextBuffer_BeginFont", (PyCFunction) _wrap_RichTextBuffer_BeginFont, METH_VARARGS | METH_KEYWORDS, NULL},

30967

{ (char *)"RichTextBuffer_EndFont", (PyCFunction)_wrap_RichTextBuffer_EndFont, METH_O, NULL},

30968

{ (char *)"RichTextBuffer_BeginTextColour", (PyCFunction) _wrap_RichTextBuffer_BeginTextColour, METH_VARARGS | METH_KEYWORDS, NULL},

30969

{ (char *)"RichTextBuffer_EndTextColour", (PyCFunction)_wrap_RichTextBuffer_EndTextColour, METH_O, NULL},

30970

{ (char *)"RichTextBuffer_BeginAlignment", (PyCFunction) _wrap_RichTextBuffer_BeginAlignment, METH_VARARGS | METH_KEYWORDS, NULL},

30971

{ (char *)"RichTextBuffer_EndAlignment", (PyCFunction)_wrap_RichTextBuffer_EndAlignment, METH_O, NULL},

30972

{ (char *)"RichTextBuffer_BeginLeftIndent", (PyCFunction) _wrap_RichTextBuffer_BeginLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},

30973

{ (char *)"RichTextBuffer_EndLeftIndent", (PyCFunction)_wrap_RichTextBuffer_EndLeftIndent, METH_O, NULL},

30974

{ (char *)"RichTextBuffer_BeginRightIndent", (PyCFunction) _wrap_RichTextBuffer_BeginRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},

30975

{ (char *)"RichTextBuffer_EndRightIndent", (PyCFunction)_wrap_RichTextBuffer_EndRightIndent, METH_O, NULL},

30976

{ (char *)"RichTextBuffer_BeginParagraphSpacing", (PyCFunction) _wrap_RichTextBuffer_BeginParagraphSpacing, METH_VARARGS | METH_KEYWORDS, NULL},

30977

{ (char *)"RichTextBuffer_EndParagraphSpacing", (PyCFunction)_wrap_RichTextBuffer_EndParagraphSpacing, METH_O, NULL},

30978

{ (char *)"RichTextBuffer_BeginLineSpacing", (PyCFunction) _wrap_RichTextBuffer_BeginLineSpacing, METH_VARARGS | METH_KEYWORDS, NULL},

30979

{ (char *)"RichTextBuffer_EndLineSpacing", (PyCFunction)_wrap_RichTextBuffer_EndLineSpacing, METH_O, NULL},

30980

{ (char *)"RichTextBuffer_BeginNumberedBullet", (PyCFunction) _wrap_RichTextBuffer_BeginNumberedBullet, METH_VARARGS | METH_KEYWORDS, NULL},

30981

{ (char *)"RichTextBuffer_EndNumberedBullet", (PyCFunction)_wrap_RichTextBuffer_EndNumberedBullet, METH_O, NULL},

30982

{ (char *)"RichTextBuffer_BeginSymbolBullet", (PyCFunction) _wrap_RichTextBuffer_BeginSymbolBullet, METH_VARARGS | METH_KEYWORDS, NULL},

30983

{ (char *)"RichTextBuffer_EndSymbolBullet", (PyCFunction)_wrap_RichTextBuffer_EndSymbolBullet, METH_O, NULL},

30984

{ (char *)"RichTextBuffer_BeginStandardBullet", (PyCFunction) _wrap_RichTextBuffer_BeginStandardBullet, METH_VARARGS | METH_KEYWORDS, NULL},

30985

{ (char *)"RichTextBuffer_EndStandardBullet", (PyCFunction)_wrap_RichTextBuffer_EndStandardBullet, METH_O, NULL},

30986

{ (char *)"RichTextBuffer_BeginCharacterStyle", (PyCFunction) _wrap_RichTextBuffer_BeginCharacterStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30987

{ (char *)"RichTextBuffer_EndCharacterStyle", (PyCFunction)_wrap_RichTextBuffer_EndCharacterStyle, METH_O, NULL},

30988

{ (char *)"RichTextBuffer_BeginParagraphStyle", (PyCFunction) _wrap_RichTextBuffer_BeginParagraphStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30989

{ (char *)"RichTextBuffer_EndParagraphStyle", (PyCFunction)_wrap_RichTextBuffer_EndParagraphStyle, METH_O, NULL},

30990

{ (char *)"RichTextBuffer_BeginListStyle", (PyCFunction) _wrap_RichTextBuffer_BeginListStyle, METH_VARARGS | METH_KEYWORDS, NULL},

30991

{ (char *)"RichTextBuffer_EndListStyle", (PyCFunction)_wrap_RichTextBuffer_EndListStyle, METH_O, NULL},

30992

{ (char *)"RichTextBuffer_BeginURL", (PyCFunction) _wrap_RichTextBuffer_BeginURL, METH_VARARGS | METH_KEYWORDS, NULL},

30993

{ (char *)"RichTextBuffer_EndURL", (PyCFunction)_wrap_RichTextBuffer_EndURL, METH_O, NULL},

30994

{ (char *)"RichTextBuffer_AddEventHandler", (PyCFunction) _wrap_RichTextBuffer_AddEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},

30995

{ (char *)"RichTextBuffer_RemoveEventHandler", (PyCFunction) _wrap_RichTextBuffer_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},

30996

{ (char *)"RichTextBuffer_ClearEventHandlers", (PyCFunction)_wrap_RichTextBuffer_ClearEventHandlers, METH_O, NULL},

30997

{ (char *)"RichTextBuffer_SendEvent", (PyCFunction) _wrap_RichTextBuffer_SendEvent, METH_VARARGS | METH_KEYWORDS, NULL},

30998

{ (char *)"RichTextBuffer_Copy", (PyCFunction) _wrap_RichTextBuffer_Copy, METH_VARARGS | METH_KEYWORDS, NULL},

30999

{ (char *)"RichTextBuffer_InsertParagraphsWithUndo", (PyCFunction) _wrap_RichTextBuffer_InsertParagraphsWithUndo, METH_VARARGS | METH_KEYWORDS, NULL},

31000

{ (char *)"RichTextBuffer_InsertTextWithUndo", (PyCFunction) _wrap_RichTextBuffer_InsertTextWithUndo, METH_VARARGS | METH_KEYWORDS, NULL},

31001

{ (char *)"RichTextBuffer_InsertNewlineWithUndo", (PyCFunction) _wrap_RichTextBuffer_InsertNewlineWithUndo, METH_VARARGS | METH_KEYWORDS, NULL},

31002

{ (char *)"RichTextBuffer_InsertImageWithUndo", (PyCFunction) _wrap_RichTextBuffer_InsertImageWithUndo, METH_VARARGS | METH_KEYWORDS, NULL},

31003

{ (char *)"RichTextBuffer_DeleteRangeWithUndo", (PyCFunction) _wrap_RichTextBuffer_DeleteRangeWithUndo, METH_VARARGS | METH_KEYWORDS, NULL},

31004

{ (char *)"RichTextBuffer_Modify", (PyCFunction) _wrap_RichTextBuffer_Modify, METH_VARARGS | METH_KEYWORDS, NULL},

31005

{ (char *)"RichTextBuffer_IsModified", (PyCFunction)_wrap_RichTextBuffer_IsModified, METH_O, NULL},

31006

{ (char *)"RichTextBuffer_GetStyleForNewParagraph", (PyCFunction) _wrap_RichTextBuffer_GetStyleForNewParagraph, METH_VARARGS | METH_KEYWORDS, NULL},

31007

{ (char *)"RichTextBuffer_GetHandlers", (PyCFunction)_wrap_RichTextBuffer_GetHandlers, METH_NOARGS, NULL},

31008

{ (char *)"RichTextBuffer_AddHandler", (PyCFunction) _wrap_RichTextBuffer_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},

31009

{ (char *)"RichTextBuffer_InsertHandler", (PyCFunction) _wrap_RichTextBuffer_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},

31010

{ (char *)"RichTextBuffer_RemoveHandler", (PyCFunction) _wrap_RichTextBuffer_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},

31011

{ (char *)"RichTextBuffer_FindHandlerByName", (PyCFunction) _wrap_RichTextBuffer_FindHandlerByName, METH_VARARGS | METH_KEYWORDS, NULL},

31012

{ (char *)"RichTextBuffer_FindHandlerByExtension", (PyCFunction) _wrap_RichTextBuffer_FindHandlerByExtension, METH_VARARGS | METH_KEYWORDS, NULL},

31013

{ (char *)"RichTextBuffer_FindHandlerByFilename", (PyCFunction) _wrap_RichTextBuffer_FindHandlerByFilename, METH_VARARGS | METH_KEYWORDS, NULL},

31014

{ (char *)"RichTextBuffer_FindHandlerByType", (PyCFunction) _wrap_RichTextBuffer_FindHandlerByType, METH_VARARGS | METH_KEYWORDS, NULL},

31015

{ (char *)"RichTextBuffer_GetExtWildcard", (PyCFunction) _wrap_RichTextBuffer_GetExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},

31016

{ (char *)"RichTextBuffer_CleanUpHandlers", (PyCFunction)_wrap_RichTextBuffer_CleanUpHandlers, METH_NOARGS, NULL},

31017

{ (char *)"RichTextBuffer_InitStandardHandlers", (PyCFunction)_wrap_RichTextBuffer_InitStandardHandlers, METH_NOARGS, NULL},

31018

{ (char *)"RichTextBuffer_GetRenderer", (PyCFunction)_wrap_RichTextBuffer_GetRenderer, METH_NOARGS, NULL},

31019

{ (char *)"RichTextBuffer_SetRenderer", (PyCFunction) _wrap_RichTextBuffer_SetRenderer, METH_VARARGS | METH_KEYWORDS, NULL},

31020

{ (char *)"RichTextBuffer_GetBulletRightMargin", (PyCFunction)_wrap_RichTextBuffer_GetBulletRightMargin, METH_NOARGS, NULL},

31021

{ (char *)"RichTextBuffer_SetBulletRightMargin", (PyCFunction) _wrap_RichTextBuffer_SetBulletRightMargin, METH_VARARGS | METH_KEYWORDS, NULL},

31022

{ (char *)"RichTextBuffer_GetBulletProportion", (PyCFunction)_wrap_RichTextBuffer_GetBulletProportion, METH_NOARGS, NULL},

31023

{ (char *)"RichTextBuffer_SetBulletProportion", (PyCFunction) _wrap_RichTextBuffer_SetBulletProportion, METH_VARARGS | METH_KEYWORDS, NULL},

31024

{ (char *)"RichTextBuffer_GetScale", (PyCFunction)_wrap_RichTextBuffer_GetScale, METH_O, NULL},

31025

{ (char *)"RichTextBuffer_SetScale", (PyCFunction) _wrap_RichTextBuffer_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},

31026

{ (char *)"RichTextBuffer_swigregister", RichTextBuffer_swigregister, METH_VARARGS, NULL},

31027

{ (char *)"RichTextBuffer_swiginit", RichTextBuffer_swiginit, METH_VARARGS, NULL},

31028

{ (char *)"delete_RichTextFileHandler", (PyCFunction)_wrap_delete_RichTextFileHandler, METH_O, NULL},

31029

{ (char *)"RichTextFileHandler_LoadStream", (PyCFunction) _wrap_RichTextFileHandler_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},

31030

{ (char *)"RichTextFileHandler_SaveStream", (PyCFunction) _wrap_RichTextFileHandler_SaveStream, METH_VARARGS | METH_KEYWORDS, NULL},

31031

{ (char *)"RichTextFileHandler_LoadFile", (PyCFunction) _wrap_RichTextFileHandler_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},

31032

{ (char *)"RichTextFileHandler_SaveFile", (PyCFunction) _wrap_RichTextFileHandler_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},

31033

{ (char *)"RichTextFileHandler_CanHandle", (PyCFunction) _wrap_RichTextFileHandler_CanHandle, METH_VARARGS | METH_KEYWORDS, NULL},

31034

{ (char *)"RichTextFileHandler_CanSave", (PyCFunction)_wrap_RichTextFileHandler_CanSave, METH_O, NULL},

31035

{ (char *)"RichTextFileHandler_CanLoad", (PyCFunction)_wrap_RichTextFileHandler_CanLoad, METH_O, NULL},

31036

{ (char *)"RichTextFileHandler_IsVisible", (PyCFunction)_wrap_RichTextFileHandler_IsVisible, METH_O, NULL},

31037

{ (char *)"RichTextFileHandler_SetVisible", (PyCFunction) _wrap_RichTextFileHandler_SetVisible, METH_VARARGS | METH_KEYWORDS, NULL},

31038

{ (char *)"RichTextFileHandler_SetName", (PyCFunction) _wrap_RichTextFileHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},

31039

{ (char *)"RichTextFileHandler_GetName", (PyCFunction)_wrap_RichTextFileHandler_GetName, METH_O, NULL},

31040

{ (char *)"RichTextFileHandler_SetExtension", (PyCFunction) _wrap_RichTextFileHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},

31041

{ (char *)"RichTextFileHandler_GetExtension", (PyCFunction)_wrap_RichTextFileHandler_GetExtension, METH_O, NULL},

31042

{ (char *)"RichTextFileHandler_SetType", (PyCFunction) _wrap_RichTextFileHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},

31043

{ (char *)"RichTextFileHandler_GetType", (PyCFunction)_wrap_RichTextFileHandler_GetType, METH_O, NULL},

31044

{ (char *)"RichTextFileHandler_SetFlags", (PyCFunction) _wrap_RichTextFileHandler_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},

31045

{ (char *)"RichTextFileHandler_GetFlags", (PyCFunction)_wrap_RichTextFileHandler_GetFlags, METH_O, NULL},

31046

{ (char *)"RichTextFileHandler_SetEncoding", (PyCFunction) _wrap_RichTextFileHandler_SetEncoding, METH_VARARGS | METH_KEYWORDS, NULL},

31047

{ (char *)"RichTextFileHandler_GetEncoding", (PyCFunction)_wrap_RichTextFileHandler_GetEncoding, METH_O, NULL},

31048

{ (char *)"RichTextFileHandler_swigregister", RichTextFileHandler_swigregister, METH_VARARGS, NULL},

31049

{ (char *)"new_RichTextPlainTextHandler", (PyCFunction) _wrap_new_RichTextPlainTextHandler, METH_VARARGS | METH_KEYWORDS, NULL},

31050

{ (char *)"RichTextPlainTextHandler_swigregister", RichTextPlainTextHandler_swigregister, METH_VARARGS, NULL},

31051

{ (char *)"RichTextPlainTextHandler_swiginit", RichTextPlainTextHandler_swiginit, METH_VARARGS, NULL},

31052

{ (char *)"delete_RichTextRenderer", (PyCFunction)_wrap_delete_RichTextRenderer, METH_O, NULL},

31053

{ (char *)"RichTextRenderer_DrawStandardBullet", (PyCFunction) _wrap_RichTextRenderer_DrawStandardBullet, METH_VARARGS | METH_KEYWORDS, NULL},

31054

{ (char *)"RichTextRenderer_DrawTextBullet", (PyCFunction) _wrap_RichTextRenderer_DrawTextBullet, METH_VARARGS | METH_KEYWORDS, NULL},

31055

{ (char *)"RichTextRenderer_DrawBitmapBullet", (PyCFunction) _wrap_RichTextRenderer_DrawBitmapBullet, METH_VARARGS | METH_KEYWORDS, NULL},

31056

{ (char *)"RichTextRenderer_EnumerateStandardBulletNames", (PyCFunction) _wrap_RichTextRenderer_EnumerateStandardBulletNames, METH_VARARGS | METH_KEYWORDS, NULL},

31057

{ (char *)"RichTextRenderer_swigregister", RichTextRenderer_swigregister, METH_VARARGS, NULL},

31058

{ (char *)"new_RichTextStdRenderer", (PyCFunction)_wrap_new_RichTextStdRenderer, METH_NOARGS, NULL},

31059

{ (char *)"RichTextStdRenderer_swigregister", RichTextStdRenderer_swigregister, METH_VARARGS, NULL},

31060

{ (char *)"RichTextStdRenderer_swiginit", RichTextStdRenderer_swiginit, METH_VARARGS, NULL},

31061

{ (char *)"new_RichTextCtrl", (PyCFunction) _wrap_new_RichTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},

31062

{ (char *)"new_PreRichTextCtrl", (PyCFunction)_wrap_new_PreRichTextCtrl, METH_NOARGS, NULL},

31063

{ (char *)"RichTextCtrl_Create", (PyCFunction) _wrap_RichTextCtrl_Create, METH_VARARGS | METH_KEYWORDS, NULL},

31064

{ (char *)"RichTextCtrl_GetValue", (PyCFunction)_wrap_RichTextCtrl_GetValue, METH_O, NULL},

31065

{ (char *)"RichTextCtrl_SetValue", (PyCFunction) _wrap_RichTextCtrl_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},

31066

{ (char *)"RichTextCtrl_GetRange", (PyCFunction) _wrap_RichTextCtrl_GetRange, METH_VARARGS | METH_KEYWORDS, NULL},

31067

{ (char *)"RichTextCtrl_GetLineLength", (PyCFunction) _wrap_RichTextCtrl_GetLineLength, METH_VARARGS | METH_KEYWORDS, NULL},

31068

{ (char *)"RichTextCtrl_GetLineText", (PyCFunction) _wrap_RichTextCtrl_GetLineText, METH_VARARGS | METH_KEYWORDS, NULL},

31069

{ (char *)"RichTextCtrl_GetNumberOfLines", (PyCFunction)_wrap_RichTextCtrl_GetNumberOfLines, METH_O, NULL},

31070

{ (char *)"RichTextCtrl_IsModified", (PyCFunction)_wrap_RichTextCtrl_IsModified, METH_O, NULL},

31071

{ (char *)"RichTextCtrl_IsEditable", (PyCFunction)_wrap_RichTextCtrl_IsEditable, METH_O, NULL},

31072

{ (char *)"RichTextCtrl_IsSingleLine", (PyCFunction)_wrap_RichTextCtrl_IsSingleLine, METH_O, NULL},

31073

{ (char *)"RichTextCtrl_IsMultiLine", (PyCFunction)_wrap_RichTextCtrl_IsMultiLine, METH_O, NULL},

31074

{ (char *)"RichTextCtrl_GetSelection", (PyCFunction)_wrap_RichTextCtrl_GetSelection, METH_O, NULL},

31075

{ (char *)"RichTextCtrl_GetStringSelection", (PyCFunction)_wrap_RichTextCtrl_GetStringSelection, METH_O, NULL},

31076

{ (char *)"RichTextCtrl_GetFilename", (PyCFunction)_wrap_RichTextCtrl_GetFilename, METH_O, NULL},

31077

{ (char *)"RichTextCtrl_SetFilename", (PyCFunction) _wrap_RichTextCtrl_SetFilename, METH_VARARGS | METH_KEYWORDS, NULL},

31078

{ (char *)"RichTextCtrl_SetDelayedLayoutThreshold", (PyCFunction) _wrap_RichTextCtrl_SetDelayedLayoutThreshold, METH_VARARGS | METH_KEYWORDS, NULL},

31079

{ (char *)"RichTextCtrl_GetDelayedLayoutThreshold", (PyCFunction)_wrap_RichTextCtrl_GetDelayedLayoutThreshold, METH_O, NULL},

31080

{ (char *)"RichTextCtrl_SetTextCursor", (PyCFunction) _wrap_RichTextCtrl_SetTextCursor, METH_VARARGS | METH_KEYWORDS, NULL},

31081

{ (char *)"RichTextCtrl_GetTextCursor", (PyCFunction)_wrap_RichTextCtrl_GetTextCursor, METH_O, NULL},

31082

{ (char *)"RichTextCtrl_SetURLCursor", (PyCFunction) _wrap_RichTextCtrl_SetURLCursor, METH_VARARGS | METH_KEYWORDS, NULL},

31083

{ (char *)"RichTextCtrl_GetURLCursor", (PyCFunction)_wrap_RichTextCtrl_GetURLCursor, METH_O, NULL},

31084

{ (char *)"RichTextCtrl_GetContextMenu", (PyCFunction)_wrap_RichTextCtrl_GetContextMenu, METH_O, NULL},

31085

{ (char *)"RichTextCtrl_SetContextMenu", (PyCFunction) _wrap_RichTextCtrl_SetContextMenu, METH_VARARGS | METH_KEYWORDS, NULL},

31086

{ (char *)"RichTextCtrl_Clear", (PyCFunction)_wrap_RichTextCtrl_Clear, METH_O, NULL},

31087

{ (char *)"RichTextCtrl_Replace", (PyCFunction) _wrap_RichTextCtrl_Replace, METH_VARARGS | METH_KEYWORDS, NULL},

31088

{ (char *)"RichTextCtrl_Remove", (PyCFunction) _wrap_RichTextCtrl_Remove, METH_VARARGS | METH_KEYWORDS, NULL},

31089

{ (char *)"RichTextCtrl_LoadFile", (PyCFunction) _wrap_RichTextCtrl_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},

31090

{ (char *)"RichTextCtrl_SaveFile", (PyCFunction) _wrap_RichTextCtrl_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},

31091

{ (char *)"RichTextCtrl_SetHandlerFlags", (PyCFunction) _wrap_RichTextCtrl_SetHandlerFlags, METH_VARARGS | METH_KEYWORDS, NULL},

31092

{ (char *)"RichTextCtrl_GetHandlerFlags", (PyCFunction)_wrap_RichTextCtrl_GetHandlerFlags, METH_O, NULL},

31093

{ (char *)"RichTextCtrl_MarkDirty", (PyCFunction)_wrap_RichTextCtrl_MarkDirty, METH_O, NULL},

31094

{ (char *)"RichTextCtrl_DiscardEdits", (PyCFunction)_wrap_RichTextCtrl_DiscardEdits, METH_O, NULL},

31095

{ (char *)"RichTextCtrl_SetMaxLength", (PyCFunction) _wrap_RichTextCtrl_SetMaxLength, METH_VARARGS | METH_KEYWORDS, NULL},

31096

{ (char *)"RichTextCtrl_WriteText", (PyCFunction) _wrap_RichTextCtrl_WriteText, METH_VARARGS | METH_KEYWORDS, NULL},

31097

{ (char *)"RichTextCtrl_AppendText", (PyCFunction) _wrap_RichTextCtrl_AppendText, METH_VARARGS | METH_KEYWORDS, NULL},

31098

{ (char *)"RichTextCtrl_SetStyle", (PyCFunction) _wrap_RichTextCtrl_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31099

{ (char *)"RichTextCtrl_GetStyle", (PyCFunction) _wrap_RichTextCtrl_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31100

{ (char *)"RichTextCtrl_GetStyleForRange", (PyCFunction) _wrap_RichTextCtrl_GetStyleForRange, METH_VARARGS | METH_KEYWORDS, NULL},

31101

{ (char *)"RichTextCtrl_SetStyleEx", (PyCFunction) _wrap_RichTextCtrl_SetStyleEx, METH_VARARGS | METH_KEYWORDS, NULL},

31102

{ (char *)"RichTextCtrl_GetUncombinedStyle", (PyCFunction) _wrap_RichTextCtrl_GetUncombinedStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31103

{ (char *)"RichTextCtrl_SetDefaultStyle", (PyCFunction) _wrap_RichTextCtrl_SetDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31104

{ (char *)"RichTextCtrl_GetDefaultStyle", (PyCFunction)_wrap_RichTextCtrl_GetDefaultStyle, METH_O, NULL},

31105

{ (char *)"RichTextCtrl_SetListStyle", (PyCFunction) _wrap_RichTextCtrl_SetListStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31106

{ (char *)"RichTextCtrl_ClearListStyle", (PyCFunction) _wrap_RichTextCtrl_ClearListStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31107

{ (char *)"RichTextCtrl_NumberList", (PyCFunction) _wrap_RichTextCtrl_NumberList, METH_VARARGS | METH_KEYWORDS, NULL},

31108

{ (char *)"RichTextCtrl_PromoteList", (PyCFunction) _wrap_RichTextCtrl_PromoteList, METH_VARARGS | METH_KEYWORDS, NULL},

31109

{ (char *)"RichTextCtrl_Delete", (PyCFunction) _wrap_RichTextCtrl_Delete, METH_VARARGS | METH_KEYWORDS, NULL},

31110

{ (char *)"RichTextCtrl_XYToPosition", (PyCFunction) _wrap_RichTextCtrl_XYToPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31111

{ (char *)"RichTextCtrl_PositionToXY", (PyCFunction) _wrap_RichTextCtrl_PositionToXY, METH_VARARGS | METH_KEYWORDS, NULL},

31112

{ (char *)"RichTextCtrl_ShowPosition", (PyCFunction) _wrap_RichTextCtrl_ShowPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31113

{ (char *)"RichTextCtrl_HitTest", (PyCFunction) _wrap_RichTextCtrl_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},

31114

{ (char *)"RichTextCtrl_HitTestXY", (PyCFunction) _wrap_RichTextCtrl_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},

31115

{ (char *)"RichTextCtrl_Copy", (PyCFunction)_wrap_RichTextCtrl_Copy, METH_O, NULL},

31116

{ (char *)"RichTextCtrl_Cut", (PyCFunction)_wrap_RichTextCtrl_Cut, METH_O, NULL},

31117

{ (char *)"RichTextCtrl_Paste", (PyCFunction)_wrap_RichTextCtrl_Paste, METH_O, NULL},

31118

{ (char *)"RichTextCtrl_DeleteSelection", (PyCFunction)_wrap_RichTextCtrl_DeleteSelection, METH_O, NULL},

31119

{ (char *)"RichTextCtrl_CanCopy", (PyCFunction)_wrap_RichTextCtrl_CanCopy, METH_O, NULL},

31120

{ (char *)"RichTextCtrl_CanCut", (PyCFunction)_wrap_RichTextCtrl_CanCut, METH_O, NULL},

31121

{ (char *)"RichTextCtrl_CanPaste", (PyCFunction)_wrap_RichTextCtrl_CanPaste, METH_O, NULL},

31122

{ (char *)"RichTextCtrl_CanDeleteSelection", (PyCFunction)_wrap_RichTextCtrl_CanDeleteSelection, METH_O, NULL},

31123

{ (char *)"RichTextCtrl_Undo", (PyCFunction)_wrap_RichTextCtrl_Undo, METH_O, NULL},

31124

{ (char *)"RichTextCtrl_Redo", (PyCFunction)_wrap_RichTextCtrl_Redo, METH_O, NULL},

31125

{ (char *)"RichTextCtrl_CanUndo", (PyCFunction)_wrap_RichTextCtrl_CanUndo, METH_O, NULL},

31126

{ (char *)"RichTextCtrl_CanRedo", (PyCFunction)_wrap_RichTextCtrl_CanRedo, METH_O, NULL},

31127

{ (char *)"RichTextCtrl_SetInsertionPoint", (PyCFunction) _wrap_RichTextCtrl_SetInsertionPoint, METH_VARARGS | METH_KEYWORDS, NULL},

31128

{ (char *)"RichTextCtrl_SetInsertionPointEnd", (PyCFunction)_wrap_RichTextCtrl_SetInsertionPointEnd, METH_O, NULL},

31129

{ (char *)"RichTextCtrl_GetInsertionPoint", (PyCFunction)_wrap_RichTextCtrl_GetInsertionPoint, METH_O, NULL},

31130

{ (char *)"RichTextCtrl_GetLastPosition", (PyCFunction)_wrap_RichTextCtrl_GetLastPosition, METH_O, NULL},

31131

{ (char *)"RichTextCtrl_SetSelection", (PyCFunction) _wrap_RichTextCtrl_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},

31132

{ (char *)"RichTextCtrl_SelectAll", (PyCFunction)_wrap_RichTextCtrl_SelectAll, METH_O, NULL},

31133

{ (char *)"RichTextCtrl_SetEditable", (PyCFunction) _wrap_RichTextCtrl_SetEditable, METH_VARARGS | METH_KEYWORDS, NULL},

31134

{ (char *)"RichTextCtrl_HasSelection", (PyCFunction)_wrap_RichTextCtrl_HasSelection, METH_O, NULL},

31135

{ (char *)"RichTextCtrl_WriteImage", (PyCFunction) _wrap_RichTextCtrl_WriteImage, METH_VARARGS | METH_KEYWORDS, NULL},

31136

{ (char *)"RichTextCtrl_WriteBitmap", (PyCFunction) _wrap_RichTextCtrl_WriteBitmap, METH_VARARGS | METH_KEYWORDS, NULL},

31137

{ (char *)"RichTextCtrl_WriteImageFile", (PyCFunction) _wrap_RichTextCtrl_WriteImageFile, METH_VARARGS | METH_KEYWORDS, NULL},

31138

{ (char *)"RichTextCtrl_WriteImageBlock", (PyCFunction) _wrap_RichTextCtrl_WriteImageBlock, METH_VARARGS | METH_KEYWORDS, NULL},

31139

{ (char *)"RichTextCtrl_Newline", (PyCFunction)_wrap_RichTextCtrl_Newline, METH_O, NULL},

31140

{ (char *)"RichTextCtrl_LineBreak", (PyCFunction)_wrap_RichTextCtrl_LineBreak, METH_O, NULL},

31141

{ (char *)"RichTextCtrl_SetBasicStyle", (PyCFunction) _wrap_RichTextCtrl_SetBasicStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31142

{ (char *)"RichTextCtrl_GetBasicStyle", (PyCFunction)_wrap_RichTextCtrl_GetBasicStyle, METH_O, NULL},

31143

{ (char *)"RichTextCtrl_BeginStyle", (PyCFunction) _wrap_RichTextCtrl_BeginStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31144

{ (char *)"RichTextCtrl_EndStyle", (PyCFunction)_wrap_RichTextCtrl_EndStyle, METH_O, NULL},

31145

{ (char *)"RichTextCtrl_EndAllStyles", (PyCFunction)_wrap_RichTextCtrl_EndAllStyles, METH_O, NULL},

31146

{ (char *)"RichTextCtrl_BeginBold", (PyCFunction)_wrap_RichTextCtrl_BeginBold, METH_O, NULL},

31147

{ (char *)"RichTextCtrl_EndBold", (PyCFunction)_wrap_RichTextCtrl_EndBold, METH_O, NULL},

31148

{ (char *)"RichTextCtrl_BeginItalic", (PyCFunction)_wrap_RichTextCtrl_BeginItalic, METH_O, NULL},

31149

{ (char *)"RichTextCtrl_EndItalic", (PyCFunction)_wrap_RichTextCtrl_EndItalic, METH_O, NULL},

31150

{ (char *)"RichTextCtrl_BeginUnderline", (PyCFunction)_wrap_RichTextCtrl_BeginUnderline, METH_O, NULL},

31151

{ (char *)"RichTextCtrl_EndUnderline", (PyCFunction)_wrap_RichTextCtrl_EndUnderline, METH_O, NULL},

31152

{ (char *)"RichTextCtrl_BeginFontSize", (PyCFunction) _wrap_RichTextCtrl_BeginFontSize, METH_VARARGS | METH_KEYWORDS, NULL},

31153

{ (char *)"RichTextCtrl_EndFontSize", (PyCFunction)_wrap_RichTextCtrl_EndFontSize, METH_O, NULL},

31154

{ (char *)"RichTextCtrl_BeginFont", (PyCFunction) _wrap_RichTextCtrl_BeginFont, METH_VARARGS | METH_KEYWORDS, NULL},

31155

{ (char *)"RichTextCtrl_EndFont", (PyCFunction)_wrap_RichTextCtrl_EndFont, METH_O, NULL},

31156

{ (char *)"RichTextCtrl_BeginTextColour", (PyCFunction) _wrap_RichTextCtrl_BeginTextColour, METH_VARARGS | METH_KEYWORDS, NULL},

31157

{ (char *)"RichTextCtrl_EndTextColour", (PyCFunction)_wrap_RichTextCtrl_EndTextColour, METH_O, NULL},

31158

{ (char *)"RichTextCtrl_BeginAlignment", (PyCFunction) _wrap_RichTextCtrl_BeginAlignment, METH_VARARGS | METH_KEYWORDS, NULL},

31159

{ (char *)"RichTextCtrl_EndAlignment", (PyCFunction)_wrap_RichTextCtrl_EndAlignment, METH_O, NULL},

31160

{ (char *)"RichTextCtrl_BeginLeftIndent", (PyCFunction) _wrap_RichTextCtrl_BeginLeftIndent, METH_VARARGS | METH_KEYWORDS, NULL},

31161

{ (char *)"RichTextCtrl_EndLeftIndent", (PyCFunction)_wrap_RichTextCtrl_EndLeftIndent, METH_O, NULL},

31162

{ (char *)"RichTextCtrl_BeginRightIndent", (PyCFunction) _wrap_RichTextCtrl_BeginRightIndent, METH_VARARGS | METH_KEYWORDS, NULL},

31163

{ (char *)"RichTextCtrl_EndRightIndent", (PyCFunction)_wrap_RichTextCtrl_EndRightIndent, METH_O, NULL},

31164

{ (char *)"RichTextCtrl_BeginParagraphSpacing", (PyCFunction) _wrap_RichTextCtrl_BeginParagraphSpacing, METH_VARARGS | METH_KEYWORDS, NULL},

31165

{ (char *)"RichTextCtrl_EndParagraphSpacing", (PyCFunction)_wrap_RichTextCtrl_EndParagraphSpacing, METH_O, NULL},

31166

{ (char *)"RichTextCtrl_BeginLineSpacing", (PyCFunction) _wrap_RichTextCtrl_BeginLineSpacing, METH_VARARGS | METH_KEYWORDS, NULL},

31167

{ (char *)"RichTextCtrl_EndLineSpacing", (PyCFunction)_wrap_RichTextCtrl_EndLineSpacing, METH_O, NULL},

31168

{ (char *)"RichTextCtrl_BeginNumberedBullet", (PyCFunction) _wrap_RichTextCtrl_BeginNumberedBullet, METH_VARARGS | METH_KEYWORDS, NULL},

31169

{ (char *)"RichTextCtrl_EndNumberedBullet", (PyCFunction)_wrap_RichTextCtrl_EndNumberedBullet, METH_O, NULL},

31170

{ (char *)"RichTextCtrl_BeginSymbolBullet", (PyCFunction) _wrap_RichTextCtrl_BeginSymbolBullet, METH_VARARGS | METH_KEYWORDS, NULL},

31171

{ (char *)"RichTextCtrl_EndSymbolBullet", (PyCFunction)_wrap_RichTextCtrl_EndSymbolBullet, METH_O, NULL},

31172

{ (char *)"RichTextCtrl_BeginStandardBullet", (PyCFunction) _wrap_RichTextCtrl_BeginStandardBullet, METH_VARARGS | METH_KEYWORDS, NULL},

31173

{ (char *)"RichTextCtrl_EndStandardBullet", (PyCFunction)_wrap_RichTextCtrl_EndStandardBullet, METH_O, NULL},

31174

{ (char *)"RichTextCtrl_BeginCharacterStyle", (PyCFunction) _wrap_RichTextCtrl_BeginCharacterStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31175

{ (char *)"RichTextCtrl_EndCharacterStyle", (PyCFunction)_wrap_RichTextCtrl_EndCharacterStyle, METH_O, NULL},

31176

{ (char *)"RichTextCtrl_BeginParagraphStyle", (PyCFunction) _wrap_RichTextCtrl_BeginParagraphStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31177

{ (char *)"RichTextCtrl_EndParagraphStyle", (PyCFunction)_wrap_RichTextCtrl_EndParagraphStyle, METH_O, NULL},

31178

{ (char *)"RichTextCtrl_BeginListStyle", (PyCFunction) _wrap_RichTextCtrl_BeginListStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31179

{ (char *)"RichTextCtrl_EndListStyle", (PyCFunction)_wrap_RichTextCtrl_EndListStyle, METH_O, NULL},

31180

{ (char *)"RichTextCtrl_BeginURL", (PyCFunction) _wrap_RichTextCtrl_BeginURL, METH_VARARGS | METH_KEYWORDS, NULL},

31181

{ (char *)"RichTextCtrl_EndURL", (PyCFunction)_wrap_RichTextCtrl_EndURL, METH_O, NULL},

31182

{ (char *)"RichTextCtrl_SetDefaultStyleToCursorStyle", (PyCFunction)_wrap_RichTextCtrl_SetDefaultStyleToCursorStyle, METH_O, NULL},

31183

{ (char *)"RichTextCtrl_SelectNone", (PyCFunction)_wrap_RichTextCtrl_SelectNone, METH_O, NULL},

31184

{ (char *)"RichTextCtrl_SelectWord", (PyCFunction) _wrap_RichTextCtrl_SelectWord, METH_VARARGS | METH_KEYWORDS, NULL},

31185

{ (char *)"RichTextCtrl_GetSelectionRange", (PyCFunction)_wrap_RichTextCtrl_GetSelectionRange, METH_O, NULL},

31186

{ (char *)"RichTextCtrl_SetSelectionRange", (PyCFunction) _wrap_RichTextCtrl_SetSelectionRange, METH_VARARGS | METH_KEYWORDS, NULL},

31187

{ (char *)"RichTextCtrl_GetInternalSelectionRange", (PyCFunction)_wrap_RichTextCtrl_GetInternalSelectionRange, METH_O, NULL},

31188

{ (char *)"RichTextCtrl_SetInternalSelectionRange", (PyCFunction) _wrap_RichTextCtrl_SetInternalSelectionRange, METH_VARARGS | METH_KEYWORDS, NULL},

31189

{ (char *)"RichTextCtrl_AddParagraph", (PyCFunction) _wrap_RichTextCtrl_AddParagraph, METH_VARARGS | METH_KEYWORDS, NULL},

31190

{ (char *)"RichTextCtrl_AddImage", (PyCFunction) _wrap_RichTextCtrl_AddImage, METH_VARARGS | METH_KEYWORDS, NULL},

31191

{ (char *)"RichTextCtrl_LayoutContent", (PyCFunction) _wrap_RichTextCtrl_LayoutContent, METH_VARARGS | METH_KEYWORDS, NULL},

31192

{ (char *)"RichTextCtrl_MoveCaret", (PyCFunction) _wrap_RichTextCtrl_MoveCaret, METH_VARARGS | METH_KEYWORDS, NULL},

31193

{ (char *)"RichTextCtrl_MoveRight", (PyCFunction) _wrap_RichTextCtrl_MoveRight, METH_VARARGS | METH_KEYWORDS, NULL},

31194

{ (char *)"RichTextCtrl_MoveLeft", (PyCFunction) _wrap_RichTextCtrl_MoveLeft, METH_VARARGS | METH_KEYWORDS, NULL},

31195

{ (char *)"RichTextCtrl_MoveUp", (PyCFunction) _wrap_RichTextCtrl_MoveUp, METH_VARARGS | METH_KEYWORDS, NULL},

31196

{ (char *)"RichTextCtrl_MoveDown", (PyCFunction) _wrap_RichTextCtrl_MoveDown, METH_VARARGS | METH_KEYWORDS, NULL},

31197

{ (char *)"RichTextCtrl_MoveToLineEnd", (PyCFunction) _wrap_RichTextCtrl_MoveToLineEnd, METH_VARARGS | METH_KEYWORDS, NULL},

31198

{ (char *)"RichTextCtrl_MoveToLineStart", (PyCFunction) _wrap_RichTextCtrl_MoveToLineStart, METH_VARARGS | METH_KEYWORDS, NULL},

31199

{ (char *)"RichTextCtrl_MoveToParagraphEnd", (PyCFunction) _wrap_RichTextCtrl_MoveToParagraphEnd, METH_VARARGS | METH_KEYWORDS, NULL},

31200

{ (char *)"RichTextCtrl_MoveToParagraphStart", (PyCFunction) _wrap_RichTextCtrl_MoveToParagraphStart, METH_VARARGS | METH_KEYWORDS, NULL},

31201

{ (char *)"RichTextCtrl_MoveHome", (PyCFunction) _wrap_RichTextCtrl_MoveHome, METH_VARARGS | METH_KEYWORDS, NULL},

31202

{ (char *)"RichTextCtrl_MoveEnd", (PyCFunction) _wrap_RichTextCtrl_MoveEnd, METH_VARARGS | METH_KEYWORDS, NULL},

31203

{ (char *)"RichTextCtrl_PageUp", (PyCFunction) _wrap_RichTextCtrl_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},

31204

{ (char *)"RichTextCtrl_PageDown", (PyCFunction) _wrap_RichTextCtrl_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},

31205

{ (char *)"RichTextCtrl_WordLeft", (PyCFunction) _wrap_RichTextCtrl_WordLeft, METH_VARARGS | METH_KEYWORDS, NULL},

31206

{ (char *)"RichTextCtrl_WordRight", (PyCFunction) _wrap_RichTextCtrl_WordRight, METH_VARARGS | METH_KEYWORDS, NULL},

31207

{ (char *)"RichTextCtrl_GetBuffer", (PyCFunction)_wrap_RichTextCtrl_GetBuffer, METH_O, NULL},

31208

{ (char *)"RichTextCtrl_BeginBatchUndo", (PyCFunction) _wrap_RichTextCtrl_BeginBatchUndo, METH_VARARGS | METH_KEYWORDS, NULL},

31209

{ (char *)"RichTextCtrl_EndBatchUndo", (PyCFunction)_wrap_RichTextCtrl_EndBatchUndo, METH_O, NULL},

31210

{ (char *)"RichTextCtrl_BatchingUndo", (PyCFunction)_wrap_RichTextCtrl_BatchingUndo, METH_O, NULL},

31211

{ (char *)"RichTextCtrl_BeginSuppressUndo", (PyCFunction)_wrap_RichTextCtrl_BeginSuppressUndo, METH_O, NULL},

31212

{ (char *)"RichTextCtrl_EndSuppressUndo", (PyCFunction)_wrap_RichTextCtrl_EndSuppressUndo, METH_O, NULL},

31213

{ (char *)"RichTextCtrl_SuppressingUndo", (PyCFunction)_wrap_RichTextCtrl_SuppressingUndo, METH_O, NULL},

31214

{ (char *)"RichTextCtrl_HasCharacterAttributes", (PyCFunction) _wrap_RichTextCtrl_HasCharacterAttributes, METH_VARARGS | METH_KEYWORDS, NULL},

31215

{ (char *)"RichTextCtrl_HasParagraphAttributes", (PyCFunction) _wrap_RichTextCtrl_HasParagraphAttributes, METH_VARARGS | METH_KEYWORDS, NULL},

31216

{ (char *)"RichTextCtrl_IsSelectionBold", (PyCFunction)_wrap_RichTextCtrl_IsSelectionBold, METH_O, NULL},

31217

{ (char *)"RichTextCtrl_IsSelectionItalics", (PyCFunction)_wrap_RichTextCtrl_IsSelectionItalics, METH_O, NULL},

31218

{ (char *)"RichTextCtrl_IsSelectionUnderlined", (PyCFunction)_wrap_RichTextCtrl_IsSelectionUnderlined, METH_O, NULL},

31219

{ (char *)"RichTextCtrl_IsSelectionAligned", (PyCFunction) _wrap_RichTextCtrl_IsSelectionAligned, METH_VARARGS | METH_KEYWORDS, NULL},

31220

{ (char *)"RichTextCtrl_ApplyBoldToSelection", (PyCFunction)_wrap_RichTextCtrl_ApplyBoldToSelection, METH_O, NULL},

31221

{ (char *)"RichTextCtrl_ApplyItalicToSelection", (PyCFunction)_wrap_RichTextCtrl_ApplyItalicToSelection, METH_O, NULL},

31222

{ (char *)"RichTextCtrl_ApplyUnderlineToSelection", (PyCFunction)_wrap_RichTextCtrl_ApplyUnderlineToSelection, METH_O, NULL},

31223

{ (char *)"RichTextCtrl_ApplyAlignmentToSelection", (PyCFunction) _wrap_RichTextCtrl_ApplyAlignmentToSelection, METH_VARARGS | METH_KEYWORDS, NULL},

31224

{ (char *)"RichTextCtrl_ApplyStyle", (PyCFunction) _wrap_RichTextCtrl_ApplyStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31225

{ (char *)"RichTextCtrl_SetStyleSheet", (PyCFunction) _wrap_RichTextCtrl_SetStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

31226

{ (char *)"RichTextCtrl_GetStyleSheet", (PyCFunction)_wrap_RichTextCtrl_GetStyleSheet, METH_O, NULL},

31227

{ (char *)"RichTextCtrl_PushStyleSheet", (PyCFunction) _wrap_RichTextCtrl_PushStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

31228

{ (char *)"RichTextCtrl_PopStyleSheet", (PyCFunction)_wrap_RichTextCtrl_PopStyleSheet, METH_O, NULL},

31229

{ (char *)"RichTextCtrl_ApplyStyleSheet", (PyCFunction) _wrap_RichTextCtrl_ApplyStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

31230

{ (char *)"RichTextCtrl_SetupScrollbars", (PyCFunction) _wrap_RichTextCtrl_SetupScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},

31231

{ (char *)"RichTextCtrl_KeyboardNavigate", (PyCFunction) _wrap_RichTextCtrl_KeyboardNavigate, METH_VARARGS | METH_KEYWORDS, NULL},

31232

{ (char *)"RichTextCtrl_PositionCaret", (PyCFunction)_wrap_RichTextCtrl_PositionCaret, METH_O, NULL},

31233

{ (char *)"RichTextCtrl_ExtendSelection", (PyCFunction) _wrap_RichTextCtrl_ExtendSelection, METH_VARARGS | METH_KEYWORDS, NULL},

31234

{ (char *)"RichTextCtrl_ScrollIntoView", (PyCFunction) _wrap_RichTextCtrl_ScrollIntoView, METH_VARARGS | METH_KEYWORDS, NULL},

31235

{ (char *)"RichTextCtrl_SetCaretPosition", (PyCFunction) _wrap_RichTextCtrl_SetCaretPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31236

{ (char *)"RichTextCtrl_GetCaretPosition", (PyCFunction)_wrap_RichTextCtrl_GetCaretPosition, METH_O, NULL},

31237

{ (char *)"RichTextCtrl_GetAdjustedCaretPosition", (PyCFunction) _wrap_RichTextCtrl_GetAdjustedCaretPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31238

{ (char *)"RichTextCtrl_MoveCaretForward", (PyCFunction) _wrap_RichTextCtrl_MoveCaretForward, METH_VARARGS | METH_KEYWORDS, NULL},

31239

{ (char *)"RichTextCtrl_MoveCaretBack", (PyCFunction) _wrap_RichTextCtrl_MoveCaretBack, METH_VARARGS | METH_KEYWORDS, NULL},

31240

{ (char *)"RichTextCtrl_GetCaretPositionForIndex", (PyCFunction) _wrap_RichTextCtrl_GetCaretPositionForIndex, METH_VARARGS | METH_KEYWORDS, NULL},

31241

{ (char *)"RichTextCtrl_GetVisibleLineForCaretPosition", (PyCFunction) _wrap_RichTextCtrl_GetVisibleLineForCaretPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31242

{ (char *)"RichTextCtrl_GetCommandProcessor", (PyCFunction)_wrap_RichTextCtrl_GetCommandProcessor, METH_O, NULL},

31243

{ (char *)"RichTextCtrl_DeleteSelectedContent", (PyCFunction)_wrap_RichTextCtrl_DeleteSelectedContent, METH_O, NULL},

31244

{ (char *)"RichTextCtrl_GetPhysicalPoint", (PyCFunction) _wrap_RichTextCtrl_GetPhysicalPoint, METH_VARARGS | METH_KEYWORDS, NULL},

31245

{ (char *)"RichTextCtrl_GetLogicalPoint", (PyCFunction) _wrap_RichTextCtrl_GetLogicalPoint, METH_VARARGS | METH_KEYWORDS, NULL},

31246

{ (char *)"RichTextCtrl_FindNextWordPosition", (PyCFunction) _wrap_RichTextCtrl_FindNextWordPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31247

{ (char *)"RichTextCtrl_IsPositionVisible", (PyCFunction) _wrap_RichTextCtrl_IsPositionVisible, METH_VARARGS | METH_KEYWORDS, NULL},

31248

{ (char *)"RichTextCtrl_GetFirstVisiblePosition", (PyCFunction)_wrap_RichTextCtrl_GetFirstVisiblePosition, METH_O, NULL},

31249

{ (char *)"RichTextCtrl_GetCaretPositionForDefaultStyle", (PyCFunction)_wrap_RichTextCtrl_GetCaretPositionForDefaultStyle, METH_O, NULL},

31250

{ (char *)"RichTextCtrl_SetCaretPositionForDefaultStyle", (PyCFunction) _wrap_RichTextCtrl_SetCaretPositionForDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31251

{ (char *)"RichTextCtrl_IsDefaultStyleShowing", (PyCFunction)_wrap_RichTextCtrl_IsDefaultStyleShowing, METH_O, NULL},

31252

{ (char *)"RichTextCtrl_SetAndShowDefaultStyle", (PyCFunction) _wrap_RichTextCtrl_SetAndShowDefaultStyle, METH_VARARGS | METH_KEYWORDS, NULL},

31253

{ (char *)"RichTextCtrl_GetFirstVisiblePoint", (PyCFunction)_wrap_RichTextCtrl_GetFirstVisiblePoint, METH_O, NULL},

31254

{ (char *)"RichTextCtrl_SetScrollbars", (PyCFunction) _wrap_RichTextCtrl_SetScrollbars, METH_VARARGS | METH_KEYWORDS, NULL},

31255

{ (char *)"RichTextCtrl_Scroll", (PyCFunction) _wrap_RichTextCtrl_Scroll, METH_VARARGS | METH_KEYWORDS, NULL},

31256

{ (char *)"RichTextCtrl_GetScrollPageSize", (PyCFunction) _wrap_RichTextCtrl_GetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},

31257

{ (char *)"RichTextCtrl_SetScrollPageSize", (PyCFunction) _wrap_RichTextCtrl_SetScrollPageSize, METH_VARARGS | METH_KEYWORDS, NULL},

31258

{ (char *)"RichTextCtrl_SetScrollRate", (PyCFunction) _wrap_RichTextCtrl_SetScrollRate, METH_VARARGS | METH_KEYWORDS, NULL},

31259

{ (char *)"RichTextCtrl_GetScrollPixelsPerUnit", (PyCFunction)_wrap_RichTextCtrl_GetScrollPixelsPerUnit, METH_O, NULL},

31260

{ (char *)"RichTextCtrl_EnableScrolling", (PyCFunction) _wrap_RichTextCtrl_EnableScrolling, METH_VARARGS | METH_KEYWORDS, NULL},

31261

{ (char *)"RichTextCtrl_GetViewStart", (PyCFunction)_wrap_RichTextCtrl_GetViewStart, METH_O, NULL},

31262

{ (char *)"RichTextCtrl_SetScale", (PyCFunction) _wrap_RichTextCtrl_SetScale, METH_VARARGS | METH_KEYWORDS, NULL},

31263

{ (char *)"RichTextCtrl_GetScaleX", (PyCFunction)_wrap_RichTextCtrl_GetScaleX, METH_O, NULL},

31264

{ (char *)"RichTextCtrl_GetScaleY", (PyCFunction)_wrap_RichTextCtrl_GetScaleY, METH_O, NULL},

31265

{ (char *)"RichTextCtrl_CalcScrolledPosition", _wrap_RichTextCtrl_CalcScrolledPosition, METH_VARARGS, NULL},

31266

{ (char *)"RichTextCtrl_CalcUnscrolledPosition", _wrap_RichTextCtrl_CalcUnscrolledPosition, METH_VARARGS, NULL},

31267

{ (char *)"RichTextCtrl_AdjustScrollbars", (PyCFunction)_wrap_RichTextCtrl_AdjustScrollbars, METH_O, NULL},

31268

{ (char *)"RichTextCtrl_CalcScrollInc", (PyCFunction) _wrap_RichTextCtrl_CalcScrollInc, METH_VARARGS | METH_KEYWORDS, NULL},

31269

{ (char *)"RichTextCtrl_SetTargetWindow", (PyCFunction) _wrap_RichTextCtrl_SetTargetWindow, METH_VARARGS | METH_KEYWORDS, NULL},

31270

{ (char *)"RichTextCtrl_GetTargetWindow", (PyCFunction)_wrap_RichTextCtrl_GetTargetWindow, METH_O, NULL},

31271

{ (char *)"RichTextCtrl_IsEmpty", (PyCFunction)_wrap_RichTextCtrl_IsEmpty, METH_O, NULL},

31272

{ (char *)"RichTextCtrl_ChangeValue", (PyCFunction) _wrap_RichTextCtrl_ChangeValue, METH_VARARGS | METH_KEYWORDS, NULL},

31273

{ (char *)"RichTextCtrl_SetModified", (PyCFunction) _wrap_RichTextCtrl_SetModified, METH_VARARGS | METH_KEYWORDS, NULL},

31274

{ (char *)"RichTextCtrl_EmulateKeyPress", (PyCFunction) _wrap_RichTextCtrl_EmulateKeyPress, METH_VARARGS | METH_KEYWORDS, NULL},

31275

{ (char *)"RichTextCtrl_swigregister", RichTextCtrl_swigregister, METH_VARARGS, NULL},

31276

{ (char *)"RichTextCtrl_swiginit", RichTextCtrl_swiginit, METH_VARARGS, NULL},

31277

{ (char *)"new_RichTextEvent", (PyCFunction) _wrap_new_RichTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},

31278

{ (char *)"RichTextEvent_GetPosition", (PyCFunction)_wrap_RichTextEvent_GetPosition, METH_O, NULL},

31279

{ (char *)"RichTextEvent_SetPosition", (PyCFunction) _wrap_RichTextEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},

31280

{ (char *)"RichTextEvent_GetFlags", (PyCFunction)_wrap_RichTextEvent_GetFlags, METH_O, NULL},

31281

{ (char *)"RichTextEvent_SetFlags", (PyCFunction) _wrap_RichTextEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},

31282

{ (char *)"RichTextEvent_GetOldStyleSheet", (PyCFunction)_wrap_RichTextEvent_GetOldStyleSheet, METH_O, NULL},

31283

{ (char *)"RichTextEvent_SetOldStyleSheet", (PyCFunction) _wrap_RichTextEvent_SetOldStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

31284

{ (char *)"RichTextEvent_GetNewStyleSheet", (PyCFunction)_wrap_RichTextEvent_GetNewStyleSheet, METH_O, NULL},

31285

{ (char *)"RichTextEvent_SetNewStyleSheet", (PyCFunction) _wrap_RichTextEvent_SetNewStyleSheet, METH_VARARGS | METH_KEYWORDS, NULL},

31286

{ (char *)"RichTextEvent_GetRange", (PyCFunction)_wrap_RichTextEvent_GetRange, METH_O, NULL},

31287

{ (char *)"RichTextEvent_SetRange", (PyCFunction) _wrap_RichTextEvent_SetRange, METH_VARARGS | METH_KEYWORDS, NULL},

31288

{ (char *)"RichTextEvent_GetCharacter", (PyCFunction)_wrap_RichTextEvent_GetCharacter, METH_O, NULL},

31289

{ (char *)"RichTextEvent_SetCharacter", (PyCFunction) _wrap_RichTextEvent_SetCharacter, METH_VARARGS | METH_KEYWORDS, NULL},

31290

{ (char *)"RichTextEvent_swigregister", RichTextEvent_swigregister, METH_VARARGS, NULL},

31291

{ (char *)"RichTextEvent_swiginit", RichTextEvent_swiginit, METH_VARARGS, NULL},

31292

{ (char *)"new_RichTextHTMLHandler", (PyCFunction) _wrap_new_RichTextHTMLHandler, METH_VARARGS | METH_KEYWORDS, NULL},

31293

{ (char *)"RichTextHTMLHandler_SetTemporaryImageLocations", (PyCFunction) _wrap_RichTextHTMLHandler_SetTemporaryImageLocations, METH_VARARGS | METH_KEYWORDS, NULL},

31294

{ (char *)"RichTextHTMLHandler_GetTemporaryImageLocations", (PyCFunction)_wrap_RichTextHTMLHandler_GetTemporaryImageLocations, METH_O, NULL},

31295

{ (char *)"RichTextHTMLHandler_ClearTemporaryImageLocations", (PyCFunction)_wrap_RichTextHTMLHandler_ClearTemporaryImageLocations, METH_O, NULL},

31296

{ (char *)"RichTextHTMLHandler_DeleteTemporaryImages", (PyCFunction)_wrap_RichTextHTMLHandler_DeleteTemporaryImages, METH_O, NULL},

31297

{ (char *)"RichTextHTMLHandler_SetFileCounter", (PyCFunction) _wrap_RichTextHTMLHandler_SetFileCounter, METH_VARARGS | METH_KEYWORDS, NULL},

31298

{ (char *)"RichTextHTMLHandler_SetTempDir", (PyCFunction) _wrap_RichTextHTMLHandler_SetTempDir, METH_VARARGS | METH_KEYWORDS, NULL},

31299

{ (char *)"RichTextHTMLHandler_GetTempDir", (PyCFunction)_wrap_RichTextHTMLHandler_GetTempDir, METH_O, NULL},

31300

{ (char *)"RichTextHTMLHandler_SetFontSizeMapping", (PyCFunction) _wrap_RichTextHTMLHandler_SetFontSizeMapping, METH_VARARGS | METH_KEYWORDS, NULL},

31301

{ (char *)"RichTextHTMLHandler_GetFontSizeMapping", (PyCFunction)_wrap_RichTextHTMLHandler_GetFontSizeMapping, METH_O, NULL},

31302

{ (char *)"RichTextHTMLHandler_swigregister", RichTextHTMLHandler_swigregister, METH_VARARGS, NULL},

31303

{ (char *)"RichTextHTMLHandler_swiginit", RichTextHTMLHandler_swiginit, METH_VARARGS, NULL},

31304

{ (char *)"new_RichTextXMLHandler", (PyCFunction) _wrap_new_RichTextXMLHandler, METH_VARARGS | METH_KEYWORDS, NULL},

31305

{ (char *)"RichTextXMLHandler_swigregister", RichTextXMLHandler_swigregister, METH_VARARGS, NULL},

31306

{ (char *)"RichTextXMLHandler_swiginit", RichTextXMLHandler_swiginit, METH_VARARGS, NULL},

31307

{ (char *)"new_RichTextPrintout", (PyCFunction) _wrap_new_RichTextPrintout, METH_VARARGS | METH_KEYWORDS, NULL},

31308

{ (char *)"delete_RichTextPrintout", (PyCFunction)_wrap_delete_RichTextPrintout, METH_O, NULL},

31309

{ (char *)"RichTextPrintout_SetRichTextBuffer", (PyCFunction) _wrap_RichTextPrintout_SetRichTextBuffer, METH_VARARGS | METH_KEYWORDS, NULL},

31310

{ (char *)"RichTextPrintout_GetRichTextBuffer", (PyCFunction)_wrap_RichTextPrintout_GetRichTextBuffer, METH_O, NULL},

31311

{ (char *)"RichTextPrintout_SetHeaderFooterData", (PyCFunction) _wrap_RichTextPrintout_SetHeaderFooterData, METH_VARARGS | METH_KEYWORDS, NULL},

31312

{ (char *)"RichTextPrintout_GetHeaderFooterData", (PyCFunction)_wrap_RichTextPrintout_GetHeaderFooterData, METH_O, NULL},

31313

{ (char *)"RichTextPrintout_SetMargins", (PyCFunction) _wrap_RichTextPrintout_SetMargins, METH_VARARGS | METH_KEYWORDS, NULL},

31314

{ (char *)"RichTextPrintout_CalculateScaling", (PyCFunction) _wrap_RichTextPrintout_CalculateScaling, METH_VARARGS | METH_KEYWORDS, NULL},

31315

{ (char *)"RichTextPrintout_swigregister", RichTextPrintout_swigregister, METH_VARARGS, NULL},

31316

{ (char *)"RichTextPrintout_swiginit", RichTextPrintout_swiginit, METH_VARARGS, NULL},

31317

{ (char *)"new_RichTextPrinting", (PyCFunction) _wrap_new_RichTextPrinting, METH_VARARGS | METH_KEYWORDS, NULL},

31318

{ (char *)"delete_RichTextPrinting", (PyCFunction)_wrap_delete_RichTextPrinting, METH_O, NULL},

31319

{ (char *)"RichTextPrinting_PreviewFile", (PyCFunction) _wrap_RichTextPrinting_PreviewFile, METH_VARARGS | METH_KEYWORDS, NULL},

31320

{ (char *)"RichTextPrinting_PreviewBuffer", (PyCFunction) _wrap_RichTextPrinting_PreviewBuffer, METH_VARARGS | METH_KEYWORDS, NULL},

31321

{ (char *)"RichTextPrinting_PrintFile", (PyCFunction) _wrap_RichTextPrinting_PrintFile, METH_VARARGS | METH_KEYWORDS, NULL},

31322

{ (char *)"RichTextPrinting_PrintBuffer", (PyCFunction) _wrap_RichTextPrinting_PrintBuffer, METH_VARARGS | METH_KEYWORDS, NULL},

31323

{ (char *)"RichTextPrinting_PageSetup", (PyCFunction)_wrap_RichTextPrinting_PageSetup, METH_O, NULL},

31324

{ (char *)"RichTextPrinting_SetHeaderFooterData", (PyCFunction) _wrap_RichTextPrinting_SetHeaderFooterData, METH_VARARGS | METH_KEYWORDS, NULL},

31325

{ (char *)"RichTextPrinting_GetHeaderFooterData", (PyCFunction)_wrap_RichTextPrinting_GetHeaderFooterData, METH_O, NULL},

31326

{ (char *)"RichTextPrinting_SetHeaderText", (PyCFunction) _wrap_RichTextPrinting_SetHeaderText, METH_VARARGS | METH_KEYWORDS, NULL},

31327

{ (char *)"RichTextPrinting_GetHeaderText", (PyCFunction) _wrap_RichTextPrinting_GetHeaderText, METH_VARARGS | METH_KEYWORDS, NULL},

31328

{ (char *)"RichTextPrinting_SetFooterText", (PyCFunction) _wrap_RichTextPrinting_SetFooterText, METH_VARARGS | METH_KEYWORDS, NULL},

31329

{ (char *)"RichTextPrinting_GetFooterText", (PyCFunction) _wrap_RichTextPrinting_GetFooterText, METH_VARARGS | METH_KEYWORDS, NULL},

31330

{ (char *)"RichTextPrinting_SetShowOnFirstPage", (PyCFunction) _wrap_RichTextPrinting_SetShowOnFirstPage, METH_VARARGS | METH_KEYWORDS, NULL},

31331

{ (char *)"RichTextPrinting_SetHeaderFooterFont", (PyCFunction) _wrap_RichTextPrinting_SetHeaderFooterFont, METH_VARARGS | METH_KEYWORDS, NULL},

31332

{ (char *)"RichTextPrinting_SetHeaderFooterTextColour", (PyCFunction) _wrap_RichTextPrinting_SetHeaderFooterTextColour, METH_VARARGS | METH_KEYWORDS, NULL},

31333

{ (char *)"RichTextPrinting_GetPrintData", (PyCFunction)_wrap_RichTextPrinting_GetPrintData, METH_O, NULL},

31334

{ (char *)"RichTextPrinting_GetPageSetupData", (PyCFunction)_wrap_RichTextPrinting_GetPageSetupData, METH_O, NULL},

31335

{ (char *)"RichTextPrinting_SetPrintData", (PyCFunction) _wrap_RichTextPrinting_SetPrintData, METH_VARARGS | METH_KEYWORDS, NULL},

31336

{ (char *)"RichTextPrinting_SetPageSetupData", (PyCFunction) _wrap_RichTextPrinting_SetPageSetupData, METH_VARARGS | METH_KEYWORDS, NULL},

31337

{ (char *)"RichTextPrinting_SetRichTextBufferPreview", (PyCFunction) _wrap_RichTextPrinting_SetRichTextBufferPreview, METH_VARARGS | METH_KEYWORDS, NULL},

31338

{ (char *)"RichTextPrinting_GetRichTextBufferPreview", (PyCFunction)_wrap_RichTextPrinting_GetRichTextBufferPreview, METH_O, NULL},

31339

{ (char *)"RichTextPrinting_SetRichTextBufferPrinting", (PyCFunction) _wrap_RichTextPrinting_SetRichTextBufferPrinting, METH_VARARGS | METH_KEYWORDS, NULL},

31340

{ (char *)"RichTextPrinting_GetRichTextBufferPrinting", (PyCFunction)_wrap_RichTextPrinting_GetRichTextBufferPrinting, METH_O, NULL},

31341

{ (char *)"RichTextPrinting_SetParentWindow", (PyCFunction) _wrap_RichTextPrinting_SetParentWindow, METH_VARARGS | METH_KEYWORDS, NULL},

31342

{ (char *)"RichTextPrinting_GetParentWindow", (PyCFunction)_wrap_RichTextPrinting_GetParentWindow, METH_O, NULL},

31343

{ (char *)"RichTextPrinting_SetTitle", (PyCFunction) _wrap_RichTextPrinting_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},

31344

{ (char *)"RichTextPrinting_GetTitle", (PyCFunction)_wrap_RichTextPrinting_GetTitle, METH_O, NULL},

31345

{ (char *)"RichTextPrinting_SetPreviewRect", (PyCFunction) _wrap_RichTextPrinting_SetPreviewRect, METH_VARARGS | METH_KEYWORDS, NULL},

31346

{ (char *)"RichTextPrinting_GetPreviewRect", (PyCFunction)_wrap_RichTextPrinting_GetPreviewRect, METH_O, NULL},

31347

{ (char *)"RichTextPrinting_swigregister", RichTextPrinting_swigregister, METH_VARARGS, NULL},

31348

{ (char *)"RichTextPrinting_swiginit", RichTextPrinting_swiginit, METH_VARARGS, NULL},

31349

{ NULL, NULL, 0, NULL }

31350

};

31351

31352

31353

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

31354

31355

static void *_p_wxRichTextBufferTo_p_wxRichTextParagraphLayoutBox(void *x) {

31356

return (void *)((wxRichTextParagraphLayoutBox *) ((wxRichTextBuffer *) x));

31357

}

31358

static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {

31359

return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));

31360

}

31361

static void *_p_wxMenuEventTo_p_wxEvent(void *x) {

31362

return (void *)((wxEvent *) ((wxMenuEvent *) x));

31363

}

31364

static void *_p_wxCloseEventTo_p_wxEvent(void *x) {

31365

return (void *)((wxEvent *) ((wxCloseEvent *) x));

31366

}

31367

static void *_p_wxMouseEventTo_p_wxEvent(void *x) {

31368

return (void *)((wxEvent *) ((wxMouseEvent *) x));

31369

}

31370

static void *_p_wxEraseEventTo_p_wxEvent(void *x) {

31371

return (void *)((wxEvent *) ((wxEraseEvent *) x));

31372

}

31373

static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {

31374

return (void *)((wxEvent *) ((wxSetCursorEvent *) x));

31375

}

31376

static void *_p_wxSplitterEventTo_p_wxEvent(void *x) {

31377

return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));

31378

}

31379

static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {

31380

return (void *)((wxEvent *) ((wxInitDialogEvent *) x));

31381

}

31382

static void *_p_wxScrollEventTo_p_wxEvent(void *x) {

31383

return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));

31384

}

31385

static void *_p_wxFindDialogEventTo_p_wxEvent(void *x) {

31386

return (void *)((wxEvent *) (wxCommandEvent *) ((wxFindDialogEvent *) x));

31387

}

31388

static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {

31389

return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));

31390

}

31391

static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {

31392

return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));

31393

}

31394

static void *_p_wxPyEventTo_p_wxEvent(void *x) {

31395

return (void *)((wxEvent *) ((wxPyEvent *) x));

31396

}

31397

static void *_p_wxCalculateLayoutEventTo_p_wxEvent(void *x) {

31398

return (void *)((wxEvent *) ((wxCalculateLayoutEvent *) x));

31399

}

31400

static void *_p_wxIdleEventTo_p_wxEvent(void *x) {

31401

return (void *)((wxEvent *) ((wxIdleEvent *) x));

31402

}

31403

static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {

31404

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));

31405

}

31406

static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {

31407

return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));

31408

}

31409

static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {

31410

return (void *)((wxEvent *) ((wxMaximizeEvent *) x));

31411

}

31412

static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {

31413

return (void *)((wxEvent *) ((wxIconizeEvent *) x));

31414

}

31415

static void *_p_wxActivateEventTo_p_wxEvent(void *x) {

31416

return (void *)((wxEvent *) ((wxActivateEvent *) x));

31417

}

31418

static void *_p_wxSizeEventTo_p_wxEvent(void *x) {

31419

return (void *)((wxEvent *) ((wxSizeEvent *) x));

31420

}

31421

static void *_p_wxMoveEventTo_p_wxEvent(void *x) {

31422

return (void *)((wxEvent *) ((wxMoveEvent *) x));

31423

}

31424

static void *_p_wxDateEventTo_p_wxEvent(void *x) {

31425

return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));

31426

}

31427

static void *_p_wxPaintEventTo_p_wxEvent(void *x) {

31428

return (void *)((wxEvent *) ((wxPaintEvent *) x));

31429

}

31430

static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {

31431

return (void *)((wxEvent *) ((wxNcPaintEvent *) x));

31432

}

31433

static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {

31434

return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));

31435

}

31436

static void *_p_wxRichTextEventTo_p_wxEvent(void *x) {

31437

return (void *)((wxEvent *) (wxCommandEvent *)(wxNotifyEvent *) ((wxRichTextEvent *) x));

31438

}

31439

static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {

31440

return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));

31441

}

31442

static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {

31443

return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));

31444

}

31445

static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {

31446

return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));

31447

}

31448

static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {

31449

return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));

31450

}

31451

static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {

31452

return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));

31453

}

31454

static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {

31455

return (void *)((wxEvent *) ((wxDropFilesEvent *) x));

31456

}

31457

static void *_p_wxFocusEventTo_p_wxEvent(void *x) {

31458

return (void *)((wxEvent *) ((wxFocusEvent *) x));

31459

}

31460

static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {

31461

return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));

31462

}

31463

static void *_p_wxSashEventTo_p_wxEvent(void *x) {

31464

return (void *)((wxEvent *) (wxCommandEvent *) ((wxSashEvent *) x));

31465

}

31466

static void *_p_wxQueryLayoutInfoEventTo_p_wxEvent(void *x) {

31467

return (void *)((wxEvent *) ((wxQueryLayoutInfoEvent *) x));

31468

}

31469

static void *_p_wxShowEventTo_p_wxEvent(void *x) {

31470

return (void *)((wxEvent *) ((wxShowEvent *) x));

31471

}

31472

static void *_p_wxCommandEventTo_p_wxEvent(void *x) {

31473

return (void *)((wxEvent *) ((wxCommandEvent *) x));

31474

}

31475

static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {

31476

return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));

31477

}

31478

static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {

31479

return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));

31480

}

31481

static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {

31482

return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));

31483

}

31484

static void *_p_wxKeyEventTo_p_wxEvent(void *x) {

31485

return (void *)((wxEvent *) ((wxKeyEvent *) x));

31486

}

31487

static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {

31488

return (void *)((wxEvent *) ((wxScrollWinEvent *) x));

31489

}

31490

static void *_p_wxTaskBarIconEventTo_p_wxEvent(void *x) {

31491

return (void *)((wxEvent *) ((wxTaskBarIconEvent *) x));

31492

}

31493

static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {

31494

return (void *)((wxControl *) ((wxControlWithItems *) x));

31495

}

31496

static void *_p_wxRichTextCtrlTo_p_wxControl(void *x) {

31497

return (void *)((wxControl *) ((wxRichTextCtrl *) x));

31498

}

31499

static void *_p_wxRichTextBoxTo_p_wxRichTextCompositeObject(void *x) {

31500

return (void *)((wxRichTextCompositeObject *) ((wxRichTextBox *) x));

31501

}

31502

static void *_p_wxRichTextParagraphLayoutBoxTo_p_wxRichTextCompositeObject(void *x) {

31503

return (void *)((wxRichTextCompositeObject *) (wxRichTextBox *) ((wxRichTextParagraphLayoutBox *) x));

31504

}

31505

static void *_p_wxRichTextParagraphTo_p_wxRichTextCompositeObject(void *x) {

31506

return (void *)((wxRichTextCompositeObject *) (wxRichTextBox *) ((wxRichTextParagraph *) x));

31507

}

31508

static void *_p_wxRichTextBufferTo_p_wxRichTextCompositeObject(void *x) {

31509

return (void *)((wxRichTextCompositeObject *) (wxRichTextBox *)(wxRichTextParagraphLayoutBox *) ((wxRichTextBuffer *) x));

31510

}

31511

static void *_p_wxRichTextEventTo_p_wxNotifyEvent(void *x) {

31512

return (void *)((wxNotifyEvent *) ((wxRichTextEvent *) x));

31513

}

31514

static void *_p_wxSplitterEventTo_p_wxNotifyEvent(void *x) {

31515

return (void *)((wxNotifyEvent *) ((wxSplitterEvent *) x));

31516

}

31517

static void *_p_wxRichTextParagraphLayoutBoxTo_p_wxRichTextBox(void *x) {

31518

return (void *)((wxRichTextBox *) ((wxRichTextParagraphLayoutBox *) x));

31519

}

31520

static void *_p_wxRichTextParagraphTo_p_wxRichTextBox(void *x) {

31521

return (void *)((wxRichTextBox *) ((wxRichTextParagraph *) x));

31522

}

31523

static void *_p_wxRichTextBufferTo_p_wxRichTextBox(void *x) {

31524

return (void *)((wxRichTextBox *) (wxRichTextParagraphLayoutBox *) ((wxRichTextBuffer *) x));

31525

}

31526

static void *_p_wxSplashScreenTo_p_wxEvtHandler(void *x) {

31527

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));

31528

}

31529

static void *_p_wxMiniFrameTo_p_wxEvtHandler(void *x) {

31530

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));

31531

}

31532

static void *_p_wxPyPanelTo_p_wxEvtHandler(void *x) {

31533

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyPanel *) x));

31534

}

31535

static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {

31536

return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));

31537

}

31538

static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {

31539

return (void *)((wxEvtHandler *) ((wxValidator *) x));

31540

}

31541

static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {

31542

return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));

31543

}

31544

static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {

31545

return (void *)((wxEvtHandler *) ((wxMenu *) x));

31546

}

31547

static void *_p_wxSingleChoiceDialogTo_p_wxEvtHandler(void *x) {

31548

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));

31549

}

31550

static void *_p_wxMultiChoiceDialogTo_p_wxEvtHandler(void *x) {

31551

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));

31552

}

31553

static void *_p_wxFileDialogTo_p_wxEvtHandler(void *x) {

31554

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));

31555

}

31556

static void *_p_wxTextEntryDialogTo_p_wxEvtHandler(void *x) {

31557

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));

31558

}

31559

static void *_p_wxPasswordEntryDialogTo_p_wxEvtHandler(void *x) {

31560

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));

31561

}

31562

static void *_p_wxNumberEntryDialogTo_p_wxEvtHandler(void *x) {

31563

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));

31564

}

31565

static void *_p_wxMessageDialogTo_p_wxEvtHandler(void *x) {

31566

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));

31567

}

31568

static void *_p_wxProgressDialogTo_p_wxEvtHandler(void *x) {

31569

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxProgressDialog *) x));

31570

}

31571

static void *_p_wxFindReplaceDialogTo_p_wxEvtHandler(void *x) {

31572

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));

31573

}

31574

static void *_p_wxPanelTo_p_wxEvtHandler(void *x) {

31575

return (void *)((wxEvtHandler *) (wxWindow *) ((wxPanel *) x));

31576

}

31577

static void *_p_wxStatusBarTo_p_wxEvtHandler(void *x) {

31578

return (void *)((wxEvtHandler *) (wxWindow *) ((wxStatusBar *) x));

31579

}

31580

static void *_p_wxPyVScrolledWindowTo_p_wxEvtHandler(void *x) {

31581

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));

31582

}

31583

static void *_p_wxTipWindowTo_p_wxEvtHandler(void *x) {

31584

return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));

31585

}

31586

static void *_p_wxPyPopupTransientWindowTo_p_wxEvtHandler(void *x) {

31587

return (void *)((wxEvtHandler *) (wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));

31588

}

31589

static void *_p_wxPopupWindowTo_p_wxEvtHandler(void *x) {

31590

return (void *)((wxEvtHandler *) (wxWindow *) ((wxPopupWindow *) x));

31591

}

31592

static void *_p_wxSashLayoutWindowTo_p_wxEvtHandler(void *x) {

31593

return (void *)((wxEvtHandler *) (wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));

31594

}

31595

static void *_p_wxSashWindowTo_p_wxEvtHandler(void *x) {

31596

return (void *)((wxEvtHandler *) (wxWindow *) ((wxSashWindow *) x));

31597

}

31598

static void *_p_wxSplitterWindowTo_p_wxEvtHandler(void *x) {

31599

return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplitterWindow *) x));

31600

}

31601

static void *_p_wxSplashScreenWindowTo_p_wxEvtHandler(void *x) {

31602

return (void *)((wxEvtHandler *) (wxWindow *) ((wxSplashScreenWindow *) x));

31603

}

31604

static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {

31605

return (void *)((wxEvtHandler *) ((wxWindow *) x));

31606

}

31607

static void *_p_wxScrolledWindowTo_p_wxEvtHandler(void *x) {

31608

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));

31609

}

31610

static void *_p_wxTopLevelWindowTo_p_wxEvtHandler(void *x) {

31611

return (void *)((wxEvtHandler *) (wxWindow *) ((wxTopLevelWindow *) x));

31612

}

31613

static void *_p_wxMDIClientWindowTo_p_wxEvtHandler(void *x) {

31614

return (void *)((wxEvtHandler *) (wxWindow *) ((wxMDIClientWindow *) x));

31615

}

31616

static void *_p_wxPyScrolledWindowTo_p_wxEvtHandler(void *x) {

31617

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));

31618

}

31619

static void *_p_wxControlTo_p_wxEvtHandler(void *x) {

31620

return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));

31621

}

31622

static void *_p_wxPreviewFrameTo_p_wxEvtHandler(void *x) {

31623

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));

31624

}

31625

static void *_p_wxPyPreviewFrameTo_p_wxEvtHandler(void *x) {

31626

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));

31627

}

31628

static void *_p_wxMDIChildFrameTo_p_wxEvtHandler(void *x) {

31629

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));

31630

}

31631

static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {

31632

return (void *)((wxEvtHandler *) ((wxPyApp *) x));

31633

}

31634

static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {

31635

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));

31636

}

31637

static void *_p_wxPyEvtHandlerTo_p_wxEvtHandler(void *x) {

31638

return (void *)((wxEvtHandler *) ((wxPyEvtHandler *) x));

31639

}

31640

static void *_p_wxPyWindowTo_p_wxEvtHandler(void *x) {

31641

return (void *)((wxEvtHandler *) (wxWindow *) ((wxPyWindow *) x));

31642

}

31643

static void *_p_wxPreviewCanvasTo_p_wxEvtHandler(void *x) {

31644

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));

31645

}

31646

static void *_p_wxSimpleHtmlListBoxTo_p_wxEvtHandler(void *x) {

31647

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));

31648

}

31649

static void *_p_wxPyHtmlListBoxTo_p_wxEvtHandler(void *x) {

31650

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));

31651

}

31652

static void *_p_wxPyVListBoxTo_p_wxEvtHandler(void *x) {

31653

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));

31654

}

31655

static void *_p_wxPreviewControlBarTo_p_wxEvtHandler(void *x) {

31656

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));

31657

}

31658

static void *_p_wxPyPreviewControlBarTo_p_wxEvtHandler(void *x) {

31659

return (void *)((wxEvtHandler *) (wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));

31660

}

31661

static void *_p_wxPyTaskBarIconTo_p_wxEvtHandler(void *x) {

31662

return (void *)((wxEvtHandler *) ((wxPyTaskBarIcon *) x));

31663

}

31664

static void *_p_wxFrameTo_p_wxEvtHandler(void *x) {

31665

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));

31666

}

31667

static void *_p_wxDirDialogTo_p_wxEvtHandler(void *x) {

31668

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));

31669

}

31670

static void *_p_wxColourDialogTo_p_wxEvtHandler(void *x) {

31671

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));

31672

}

31673

static void *_p_wxDialogTo_p_wxEvtHandler(void *x) {

31674

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));

31675

}

31676

static void *_p_wxFontDialogTo_p_wxEvtHandler(void *x) {

31677

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));

31678

}

31679

static void *_p_wxMDIParentFrameTo_p_wxEvtHandler(void *x) {

31680

return (void *)((wxEvtHandler *) (wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));

31681

}

31682

static void *_p_wxRichTextCtrlTo_p_wxEvtHandler(void *x) {

31683

return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxRichTextCtrl *) x));

31684

}

31685

static void *_p_wxRichTextPlainTextHandlerTo_p_wxRichTextFileHandler(void *x) {

31686

return (void *)((wxRichTextFileHandler *) ((wxRichTextPlainTextHandler *) x));

31687

}

31688

static void *_p_wxRichTextHTMLHandlerTo_p_wxRichTextFileHandler(void *x) {

31689

return (void *)((wxRichTextFileHandler *) ((wxRichTextHTMLHandler *) x));

31690

}

31691

static void *_p_wxRichTextXMLHandlerTo_p_wxRichTextFileHandler(void *x) {

31692

return (void *)((wxRichTextFileHandler *) ((wxRichTextXMLHandler *) x));

31693

}

31694

static void *_p_wxRichTextPrintoutTo_p_wxPyPrintout(void *x) {

31695

return (void *)((wxPyPrintout *) ((wxRichTextPrintout *) x));

31696

}

31697

static void *_p_wxRichTextStdRendererTo_p_wxRichTextRenderer(void *x) {

31698

return (void *)((wxRichTextRenderer *) ((wxRichTextStdRenderer *) x));

31699

}

31700

static void *_p_p_wxRichTextBoxTo_p_p_wxRichTextObject(void *x) {

31701

return (void *)((wxRichTextObject **) (wxRichTextCompositeObject *) ((wxRichTextBox **) x));

31702

}

31703

static void *_p_p_wxRichTextParagraphLayoutBoxTo_p_p_wxRichTextObject(void *x) {

31704

return (void *)((wxRichTextObject **) (wxRichTextCompositeObject *)(wxRichTextBox *) ((wxRichTextParagraphLayoutBox **) x));

31705

}

31706

static void *_p_p_wxRichTextParagraphTo_p_p_wxRichTextObject(void *x) {

31707

return (void *)((wxRichTextObject **) (wxRichTextCompositeObject *)(wxRichTextBox *) ((wxRichTextParagraph **) x));

31708

}

31709

static void *_p_p_wxRichTextImageTo_p_p_wxRichTextObject(void *x) {

31710

return (void *)((wxRichTextObject **) ((wxRichTextImage **) x));

31711

}

31712

static void *_p_p_wxRichTextBufferTo_p_p_wxRichTextObject(void *x) {

31713

return (void *)((wxRichTextObject **) (wxRichTextCompositeObject *)(wxRichTextBox *)(wxRichTextParagraphLayoutBox *) ((wxRichTextBuffer **) x));

31714

}

31715

static void *_p_p_wxRichTextPlainTextTo_p_p_wxRichTextObject(void *x) {

31716

return (void *)((wxRichTextObject **) ((wxRichTextPlainText **) x));

31717

}

31718

static void *_p_p_wxRichTextCompositeObjectTo_p_p_wxRichTextObject(void *x) {

31719

return (void *)((wxRichTextObject **) ((wxRichTextCompositeObject **) x));

31720

}

31721

static void *_p_wxRichTextBoxTo_p_wxRichTextObject(void *x) {

31722

return (void *)((wxRichTextObject *) (wxRichTextCompositeObject *) ((wxRichTextBox *) x));

31723

}

31724

static void *_p_wxRichTextParagraphLayoutBoxTo_p_wxRichTextObject(void *x) {

31725

return (void *)((wxRichTextObject *) (wxRichTextCompositeObject *)(wxRichTextBox *) ((wxRichTextParagraphLayoutBox *) x));

31726

}

31727

static void *_p_wxRichTextParagraphTo_p_wxRichTextObject(void *x) {

31728

return (void *)((wxRichTextObject *) (wxRichTextCompositeObject *)(wxRichTextBox *) ((wxRichTextParagraph *) x));

31729

}

31730

static void *_p_wxRichTextImageTo_p_wxRichTextObject(void *x) {

31731

return (void *)((wxRichTextObject *) ((wxRichTextImage *) x));

31732

}

31733

static void *_p_wxRichTextBufferTo_p_wxRichTextObject(void *x) {

31734

return (void *)((wxRichTextObject *) (wxRichTextCompositeObject *)(wxRichTextBox *)(wxRichTextParagraphLayoutBox *) ((wxRichTextBuffer *) x));

31735

}

31736

static void *_p_wxRichTextPlainTextTo_p_wxRichTextObject(void *x) {

31737

return (void *)((wxRichTextObject *) ((wxRichTextPlainText *) x));

31738

}

31739

static void *_p_wxRichTextCompositeObjectTo_p_wxRichTextObject(void *x) {

31740

return (void *)((wxRichTextObject *) ((wxRichTextCompositeObject *) x));

31741

}

31742

static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {

31743

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));

31744

}

31745

static void *_p_wxRichTextPlainTextTo_p_wxObject(void *x) {

31746

return (void *)((wxObject *) (wxRichTextObject *) ((wxRichTextPlainText *) x));

31747

}

31748

static void *_p_wxPreviewCanvasTo_p_wxObject(void *x) {

31749

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));

31750

}

31751

static void *_p_wxEventTo_p_wxObject(void *x) {

31752

return (void *)((wxObject *) ((wxEvent *) x));

31753

}

31754

static void *_p_wxFindDialogEventTo_p_wxObject(void *x) {

31755

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxFindDialogEvent *) x));

31756

}

31757

static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {

31758

return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));

31759

}

31760

static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {

31761

return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));

31762

}

31763

static void *_p_wxPyPreviewFrameTo_p_wxObject(void *x) {

31764

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));

31765

}

31766

static void *_p_wxPreviewFrameTo_p_wxObject(void *x) {

31767

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));

31768

}

31769

static void *_p_wxMenuItemTo_p_wxObject(void *x) {

31770

return (void *)((wxObject *) ((wxMenuItem *) x));

31771

}

31772

static void *_p_wxImageTo_p_wxObject(void *x) {

31773

return (void *)((wxObject *) ((wxImage *) x));

31774

}

31775

static void *_p_wxPySizerTo_p_wxObject(void *x) {

31776

return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));

31777

}

31778

static void *_p_wxPyTaskBarIconTo_p_wxObject(void *x) {

31779

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTaskBarIcon *) x));

31780

}

31781

static void *_p_wxLayoutAlgorithmTo_p_wxObject(void *x) {

31782

return (void *)((wxObject *) ((wxLayoutAlgorithm *) x));

31783

}

31784

static void *_p_wxRichTextBufferTo_p_wxObject(void *x) {

31785

return (void *)((wxObject *) (wxRichTextObject *)(wxRichTextCompositeObject *)(wxRichTextBox *)(wxRichTextParagraphLayoutBox *) ((wxRichTextBuffer *) x));

31786

}

31787

static void *_p_wxPyAppTo_p_wxObject(void *x) {

31788

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));

31789

}

31790

static void *_p_wxRichTextParagraphTo_p_wxObject(void *x) {

31791

return (void *)((wxObject *) (wxRichTextObject *)(wxRichTextCompositeObject *)(wxRichTextBox *) ((wxRichTextParagraph *) x));

31792

}

31793

static void *_p_wxPyPreviewControlBarTo_p_wxObject(void *x) {

31794

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));

31795

}

31796

static void *_p_wxPreviewControlBarTo_p_wxObject(void *x) {

31797

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPreviewControlBar *) x));

31798

}

31799

static void *_p_wxFindReplaceDataTo_p_wxObject(void *x) {

31800

return (void *)((wxObject *) ((wxFindReplaceData *) x));

31801

}

31802

static void *_p_wxValidatorTo_p_wxObject(void *x) {

31803

return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));

31804

}

31805

static void *_p_wxPyValidatorTo_p_wxObject(void *x) {

31806

return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));

31807

}

31808

static void *_p_wxEraseEventTo_p_wxObject(void *x) {

31809

return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));

31810

}

31811

static void *_p_wxMouseEventTo_p_wxObject(void *x) {

31812

return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));

31813

}

31814

static void *_p_wxCloseEventTo_p_wxObject(void *x) {

31815

return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));

31816

}

31817

static void *_p_wxScrollEventTo_p_wxObject(void *x) {

31818

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));

31819

}

31820

static void *_p_wxRichTextPrintingTo_p_wxObject(void *x) {

31821

return (void *)((wxObject *) ((wxRichTextPrinting *) x));

31822

}

31823

static void *_p_wxPrintDialogDataTo_p_wxObject(void *x) {

31824

return (void *)((wxObject *) ((wxPrintDialogData *) x));

31825

}

31826

static void *_p_wxPageSetupDialogDataTo_p_wxObject(void *x) {

31827

return (void *)((wxObject *) ((wxPageSetupDialogData *) x));

31828

}

31829

static void *_p_wxPrinterTo_p_wxObject(void *x) {

31830

return (void *)((wxObject *) ((wxPrinter *) x));

31831

}

31832

static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {

31833

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));

31834

}

31835

static void *_p_wxRichTextObjectTo_p_wxObject(void *x) {

31836

return (void *)((wxObject *) ((wxRichTextObject *) x));

31837

}

31838

static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {

31839

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));

31840

}

31841

static void *_p_wxGridSizerTo_p_wxObject(void *x) {

31842

return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));

31843

}

31844

static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {

31845

return (void *)((wxObject *) ((wxAcceleratorTable *) x));

31846

}

31847

static void *_p_wxControlTo_p_wxObject(void *x) {

31848

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));

31849

}

31850

static void *_p_wxColourDataTo_p_wxObject(void *x) {

31851

return (void *)((wxObject *) ((wxColourData *) x));

31852

}

31853

static void *_p_wxMoveEventTo_p_wxObject(void *x) {

31854

return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));

31855

}

31856

static void *_p_wxSizeEventTo_p_wxObject(void *x) {

31857

return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));

31858

}

31859

static void *_p_wxActivateEventTo_p_wxObject(void *x) {

31860

return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));

31861

}

31862

static void *_p_wxIconizeEventTo_p_wxObject(void *x) {

31863

return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));

31864

}

31865

static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {

31866

return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));

31867

}

31868

static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {

31869

return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));

31870

}

31871

static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {

31872

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));

31873

}

31874

static void *_p_wxIdleEventTo_p_wxObject(void *x) {

31875

return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));

31876

}

31877

static void *_p_wxDateEventTo_p_wxObject(void *x) {

31878

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));

31879

}

31880

static void *_p_wxCalculateLayoutEventTo_p_wxObject(void *x) {

31881

return (void *)((wxObject *) (wxEvent *) ((wxCalculateLayoutEvent *) x));

31882

}

31883

static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {

31884

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));

31885

}

31886

static void *_p_wxPyPrintoutTo_p_wxObject(void *x) {

31887

return (void *)((wxObject *) ((wxPyPrintout *) x));

31888

}

31889

static void *_p_wxRichTextPrintoutTo_p_wxObject(void *x) {

31890

return (void *)((wxObject *) (wxPyPrintout *) ((wxRichTextPrintout *) x));

31891

}

31892

static void *_p_wxMDIChildFrameTo_p_wxObject(void *x) {

31893

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));

31894

}

31895

static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {

31896

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));

31897

}

31898

static void *_p_wxRichTextCompositeObjectTo_p_wxObject(void *x) {

31899

return (void *)((wxObject *) (wxRichTextObject *) ((wxRichTextCompositeObject *) x));

31900

}

31901

static void *_p_wxKeyEventTo_p_wxObject(void *x) {

31902

return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));

31903

}

31904

static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {

31905

return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));

31906

}

31907

static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {

31908

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));

31909

}

31910

static void *_p_wxSashEventTo_p_wxObject(void *x) {

31911

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxSashEvent *) x));

31912

}

31913

static void *_p_wxSimpleHtmlListBoxTo_p_wxObject(void *x) {

31914

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));

31915

}

31916

static void *_p_wxPyHtmlListBoxTo_p_wxObject(void *x) {

31917

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));

31918

}

31919

static void *_p_wxPyVListBoxTo_p_wxObject(void *x) {

31920

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));

31921

}

31922

static void *_p_wxPrintDataTo_p_wxObject(void *x) {

31923

return (void *)((wxObject *) ((wxPrintData *) x));

31924

}

31925

static void *_p_wxFontDataTo_p_wxObject(void *x) {

31926

return (void *)((wxObject *) ((wxFontData *) x));

31927

}

31928

static void *_p_wxMiniFrameTo_p_wxObject(void *x) {

31929

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));

31930

}

31931

static void *_p_wxFrameTo_p_wxObject(void *x) {

31932

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxFrame *) x));

31933

}

31934

static void *_p_wxPyPanelTo_p_wxObject(void *x) {

31935

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyPanel *) x));

31936

}

31937

static void *_p_wxQueryLayoutInfoEventTo_p_wxObject(void *x) {

31938

return (void *)((wxObject *) (wxEvent *) ((wxQueryLayoutInfoEvent *) x));

31939

}

31940

static void *_p_wxSplashScreenTo_p_wxObject(void *x) {

31941

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));

31942

}

31943

static void *_p_wxFileSystemTo_p_wxObject(void *x) {

31944

return (void *)((wxObject *) ((wxFileSystem *) x));

31945

}

31946

static void *_p_wxPyPrintPreviewTo_p_wxObject(void *x) {

31947

return (void *)((wxObject *) (wxPrintPreview *) ((wxPyPrintPreview *) x));

31948

}

31949

static void *_p_wxPrintPreviewTo_p_wxObject(void *x) {

31950

return (void *)((wxObject *) ((wxPrintPreview *) x));

31951

}

31952

static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {

31953

return (void *)((wxObject *) ((wxLayoutConstraints *) x));

31954

}

31955

static void *_p_wxSizerTo_p_wxObject(void *x) {

31956

return (void *)((wxObject *) ((wxSizer *) x));

31957

}

31958

static void *_p_wxBoxSizerTo_p_wxObject(void *x) {

31959

return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));

31960

}

31961

static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {

31962

return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));

31963

}

31964

static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {

31965

return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));

31966

}

31967

static void *_p_wxRichTextEventTo_p_wxObject(void *x) {

31968

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxRichTextEvent *) x));

31969

}

31970

static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {

31971

return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));

31972

}

31973

static void *_p_wxPaintEventTo_p_wxObject(void *x) {

31974

return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));

31975

}

31976

static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {

31977

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));

31978

}

31979

static void *_p_wxFSFileTo_p_wxObject(void *x) {

31980

return (void *)((wxObject *) ((wxFSFile *) x));

31981

}

31982

static void *_p_wxSplitterEventTo_p_wxObject(void *x) {

31983

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *)(wxNotifyEvent *) ((wxSplitterEvent *) x));

31984

}

31985

static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {

31986

return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));

31987

}

31988

static void *_p_wxRichTextCtrlTo_p_wxObject(void *x) {

31989

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxRichTextCtrl *) x));

31990

}

31991

static void *_p_wxMenuTo_p_wxObject(void *x) {

31992

return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));

31993

}

31994

static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {

31995

return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));

31996

}

31997

static void *_p_wxSizerItemTo_p_wxObject(void *x) {

31998

return (void *)((wxObject *) ((wxSizerItem *) x));

31999

}

32000

static void *_p_wxPrintDialogTo_p_wxObject(void *x) {

32001

return (void *)((wxObject *) ((wxPrintDialog *) x));

32002

}

32003

static void *_p_wxPageSetupDialogTo_p_wxObject(void *x) {

32004

return (void *)((wxObject *) ((wxPageSetupDialog *) x));

32005

}

32006

static void *_p_wxFontDialogTo_p_wxObject(void *x) {

32007

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));

32008

}

32009

static void *_p_wxDirDialogTo_p_wxObject(void *x) {

32010

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));

32011

}

32012

static void *_p_wxColourDialogTo_p_wxObject(void *x) {

32013

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));

32014

}

32015

static void *_p_wxDialogTo_p_wxObject(void *x) {

32016

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *) ((wxDialog *) x));

32017

}

32018

static void *_p_wxRichTextImageTo_p_wxObject(void *x) {

32019

return (void *)((wxObject *) (wxRichTextObject *) ((wxRichTextImage *) x));

32020

}

32021

static void *_p_wxNotifyEventTo_p_wxObject(void *x) {

32022

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));

32023

}

32024

static void *_p_wxPyEventTo_p_wxObject(void *x) {

32025

return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));

32026

}

32027

static void *_p_wxRichTextXMLHandlerTo_p_wxObject(void *x) {

32028

return (void *)((wxObject *) (wxRichTextFileHandler *) ((wxRichTextXMLHandler *) x));

32029

}

32030

static void *_p_wxRichTextHTMLHandlerTo_p_wxObject(void *x) {

32031

return (void *)((wxObject *) (wxRichTextFileHandler *) ((wxRichTextHTMLHandler *) x));

32032

}

32033

static void *_p_wxRichTextPlainTextHandlerTo_p_wxObject(void *x) {

32034

return (void *)((wxObject *) (wxRichTextFileHandler *) ((wxRichTextPlainTextHandler *) x));

32035

}

32036

static void *_p_wxRichTextFileHandlerTo_p_wxObject(void *x) {

32037

return (void *)((wxObject *) ((wxRichTextFileHandler *) x));

32038

}

32039

static void *_p_wxPyEvtHandlerTo_p_wxObject(void *x) {

32040

return (void *)((wxObject *) (wxEvtHandler *) ((wxPyEvtHandler *) x));

32041

}

32042

static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {

32043

return (void *)((wxObject *) ((wxEvtHandler *) x));

32044

}

32045

static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {

32046

return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));

32047

}

32048

static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {

32049

return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));

32050

}

32051

static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {

32052

return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));

32053

}

32054

static void *_p_wxImageHandlerTo_p_wxObject(void *x) {

32055

return (void *)((wxObject *) ((wxImageHandler *) x));

32056

}

32057

static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {

32058

return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));

32059

}

32060

static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {

32061

return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));

32062

}

32063

static void *_p_wxICOHandlerTo_p_wxObject(void *x) {

32064

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));

32065

}

32066

static void *_p_wxCURHandlerTo_p_wxObject(void *x) {

32067

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));

32068

}

32069

static void *_p_wxANIHandlerTo_p_wxObject(void *x) {

32070

return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));

32071

}

32072

static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {

32073

return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));

32074

}

32075

static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {

32076

return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));

32077

}

32078

static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {

32079

return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));

32080

}

32081

static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {

32082

return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));

32083

}

32084

static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {

32085

return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));

32086

}

32087

static void *_p_wxShowEventTo_p_wxObject(void *x) {

32088

return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));

32089

}

32090

static void *_p_wxPyScrolledWindowTo_p_wxObject(void *x) {

32091

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));

32092

}

32093

static void *_p_wxMDIClientWindowTo_p_wxObject(void *x) {

32094

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMDIClientWindow *) x));

32095

}

32096

static void *_p_wxPyVScrolledWindowTo_p_wxObject(void *x) {

32097

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxPyVScrolledWindow *) x));

32098

}

32099

static void *_p_wxTipWindowTo_p_wxObject(void *x) {

32100

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));

32101

}

32102

static void *_p_wxPyPopupTransientWindowTo_p_wxObject(void *x) {

32103

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPopupWindow *) ((wxPyPopupTransientWindow *) x));

32104

}

32105

static void *_p_wxPopupWindowTo_p_wxObject(void *x) {

32106

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPopupWindow *) x));

32107

}

32108

static void *_p_wxSashLayoutWindowTo_p_wxObject(void *x) {

32109

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxSashWindow *) ((wxSashLayoutWindow *) x));

32110

}

32111

static void *_p_wxSashWindowTo_p_wxObject(void *x) {

32112

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSashWindow *) x));

32113

}

32114

static void *_p_wxSplitterWindowTo_p_wxObject(void *x) {

32115

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplitterWindow *) x));

32116

}

32117

static void *_p_wxSplashScreenWindowTo_p_wxObject(void *x) {

32118

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxSplashScreenWindow *) x));

32119

}

32120

static void *_p_wxTopLevelWindowTo_p_wxObject(void *x) {

32121

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxTopLevelWindow *) x));

32122

}

32123

static void *_p_wxScrolledWindowTo_p_wxObject(void *x) {

32124

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxPanel *) ((wxScrolledWindow *) x));

32125

}

32126

static void *_p_wxWindowTo_p_wxObject(void *x) {

32127

return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));

32128

}

32129

static void *_p_wxRichTextStdRendererTo_p_wxObject(void *x) {

32130

return (void *)((wxObject *) (wxRichTextRenderer *) ((wxRichTextStdRenderer *) x));

32131

}

32132

static void *_p_wxRichTextRendererTo_p_wxObject(void *x) {

32133

return (void *)((wxObject *) ((wxRichTextRenderer *) x));

32134

}

32135

static void *_p_wxRichTextBoxTo_p_wxObject(void *x) {

32136

return (void *)((wxObject *) (wxRichTextObject *)(wxRichTextCompositeObject *) ((wxRichTextBox *) x));

32137

}

32138

static void *_p_wxRichTextParagraphLayoutBoxTo_p_wxObject(void *x) {

32139

return (void *)((wxObject *) (wxRichTextObject *)(wxRichTextCompositeObject *)(wxRichTextBox *) ((wxRichTextParagraphLayoutBox *) x));

32140

}

32141

static void *_p_wxFindReplaceDialogTo_p_wxObject(void *x) {

32142

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));

32143

}

32144

static void *_p_wxProgressDialogTo_p_wxObject(void *x) {

32145

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxProgressDialog *) x));

32146

}

32147

static void *_p_wxMessageDialogTo_p_wxObject(void *x) {

32148

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));

32149

}

32150

static void *_p_wxNumberEntryDialogTo_p_wxObject(void *x) {

32151

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));

32152

}

32153

static void *_p_wxPasswordEntryDialogTo_p_wxObject(void *x) {

32154

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));

32155

}

32156

static void *_p_wxTextEntryDialogTo_p_wxObject(void *x) {

32157

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));

32158

}

32159

static void *_p_wxSingleChoiceDialogTo_p_wxObject(void *x) {

32160

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));

32161

}

32162

static void *_p_wxMultiChoiceDialogTo_p_wxObject(void *x) {

32163

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));

32164

}

32165

static void *_p_wxFileDialogTo_p_wxObject(void *x) {

32166

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));

32167

}

32168

static void *_p_wxPyWindowTo_p_wxObject(void *x) {

32169

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPyWindow *) x));

32170

}

32171

static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {

32172

return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));

32173

}

32174

static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {

32175

return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));

32176

}

32177

static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {

32178

return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));

32179

}

32180

static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {

32181

return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));

32182

}

32183

static void *_p_wxPanelTo_p_wxObject(void *x) {

32184

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxPanel *) x));

32185

}

32186

static void *_p_wxTaskBarIconEventTo_p_wxObject(void *x) {

32187

return (void *)((wxObject *) (wxEvent *) ((wxTaskBarIconEvent *) x));

32188

}

32189

static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {

32190

return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));

32191

}

32192

static void *_p_wxMenuEventTo_p_wxObject(void *x) {

32193

return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));

32194

}

32195

static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {

32196

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));

32197

}

32198

static void *_p_wxCommandEventTo_p_wxObject(void *x) {

32199

return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));

32200

}

32201

static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {

32202

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));

32203

}

32204

static void *_p_wxStatusBarTo_p_wxObject(void *x) {

32205

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxStatusBar *) x));

32206

}

32207

static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {

32208

return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));

32209

}

32210

static void *_p_wxFocusEventTo_p_wxObject(void *x) {

32211

return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));

32212

}

32213

static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {

32214

return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));

32215

}

32216

static void *_p_wxMDIParentFrameTo_p_wxObject(void *x) {

32217

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));

32218

}

32219

static void *_p_wxMenuBarTo_p_wxObject(void *x) {

32220

return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));

32221

}

32222

static void *_p_wxSplashScreenTo_p_wxWindow(void *x) {

32223

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxSplashScreen *) x));

32224

}

32225

static void *_p_wxMiniFrameTo_p_wxWindow(void *x) {

32226

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMiniFrame *) x));

32227

}

32228

static void *_p_wxPyPanelTo_p_wxWindow(void *x) {

32229

return (void *)((wxWindow *) (wxPanel *) ((wxPyPanel *) x));

32230

}

32231

static void *_p_wxMenuBarTo_p_wxWindow(void *x) {

32232

return (void *)((wxWindow *) ((wxMenuBar *) x));

32233

}

32234

static void *_p_wxFindReplaceDialogTo_p_wxWindow(void *x) {

32235

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFindReplaceDialog *) x));

32236

}

32237

static void *_p_wxProgressDialogTo_p_wxWindow(void *x) {

32238

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxProgressDialog *) x));

32239

}

32240

static void *_p_wxMessageDialogTo_p_wxWindow(void *x) {

32241

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMessageDialog *) x));

32242

}

32243

static void *_p_wxNumberEntryDialogTo_p_wxWindow(void *x) {

32244

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxNumberEntryDialog *) x));

32245

}

32246

static void *_p_wxPasswordEntryDialogTo_p_wxWindow(void *x) {

32247

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *)(wxTextEntryDialog *) ((wxPasswordEntryDialog *) x));

32248

}

32249

static void *_p_wxTextEntryDialogTo_p_wxWindow(void *x) {

32250

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxTextEntryDialog *) x));

32251

}

32252

static void *_p_wxSingleChoiceDialogTo_p_wxWindow(void *x) {

32253

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxSingleChoiceDialog *) x));

32254

}

32255

static void *_p_wxMultiChoiceDialogTo_p_wxWindow(void *x) {

32256

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxMultiChoiceDialog *) x));

32257

}

32258

static void *_p_wxFileDialogTo_p_wxWindow(void *x) {

32259

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFileDialog *) x));

32260

}

32261

static void *_p_wxPanelTo_p_wxWindow(void *x) {

32262

return (void *)((wxWindow *) ((wxPanel *) x));

32263

}

32264

static void *_p_wxStatusBarTo_p_wxWindow(void *x) {

32265

return (void *)((wxWindow *) ((wxStatusBar *) x));

32266

}

32267

static void *_p_wxPyVScrolledWindowTo_p_wxWindow(void *x) {

32268

return (void *)((wxWindow *) (wxPanel *) ((wxPyVScrolledWindow *) x));

32269

}

32270

static void *_p_wxTipWindowTo_p_wxWindow(void *x) {

32271

return (void *)((wxWindow *) (wxPopupWindow *)(wxPyPopupTransientWindow *) ((wxTipWindow *) x));

32272

}

32273

static void *_p_wxPyPopupTransientWindowTo_p_wxWindow(void *x) {

32274

return (void *)((wxWindow *) (wxPopupWindow *) ((wxPyPopupTransientWindow *) x));

32275

}

32276

static void *_p_wxPopupWindowTo_p_wxWindow(void *x) {

32277

return (void *)((wxWindow *) ((wxPopupWindow *) x));

32278

}

32279

static void *_p_wxSashLayoutWindowTo_p_wxWindow(void *x) {

32280

return (void *)((wxWindow *) (wxSashWindow *) ((wxSashLayoutWindow *) x));

32281

}

32282

static void *_p_wxScrolledWindowTo_p_wxWindow(void *x) {

32283

return (void *)((wxWindow *) (wxPanel *) ((wxScrolledWindow *) x));

32284

}

32285

static void *_p_wxTopLevelWindowTo_p_wxWindow(void *x) {

32286

return (void *)((wxWindow *) ((wxTopLevelWindow *) x));

32287

}

32288

static void *_p_wxSplashScreenWindowTo_p_wxWindow(void *x) {

32289

return (void *)((wxWindow *) ((wxSplashScreenWindow *) x));

32290

}

32291

static void *_p_wxSplitterWindowTo_p_wxWindow(void *x) {

32292

return (void *)((wxWindow *) ((wxSplitterWindow *) x));

32293

}

32294

static void *_p_wxSashWindowTo_p_wxWindow(void *x) {

32295

return (void *)((wxWindow *) ((wxSashWindow *) x));

32296

}

32297

static void *_p_wxMDIClientWindowTo_p_wxWindow(void *x) {

32298

return (void *)((wxWindow *) ((wxMDIClientWindow *) x));

32299

}

32300

static void *_p_wxPyScrolledWindowTo_p_wxWindow(void *x) {

32301

return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPyScrolledWindow *) x));

32302

}

32303

static void *_p_wxControlTo_p_wxWindow(void *x) {

32304

return (void *)((wxWindow *) ((wxControl *) x));

32305

}

32306

static void *_p_wxPreviewFrameTo_p_wxWindow(void *x) {

32307

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxPreviewFrame *) x));

32308

}

32309

static void *_p_wxPyPreviewFrameTo_p_wxWindow(void *x) {

32310

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *)(wxPreviewFrame *) ((wxPyPreviewFrame *) x));

32311

}

32312

static void *_p_wxMDIChildFrameTo_p_wxWindow(void *x) {

32313

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIChildFrame *) x));

32314

}

32315

static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {

32316

return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));

32317

}

32318

static void *_p_wxPyWindowTo_p_wxWindow(void *x) {

32319

return (void *)((wxWindow *) ((wxPyWindow *) x));

32320

}

32321

static void *_p_wxPreviewCanvasTo_p_wxWindow(void *x) {

32322

return (void *)((wxWindow *) (wxPanel *)(wxScrolledWindow *) ((wxPreviewCanvas *) x));

32323

}

32324

static void *_p_wxSimpleHtmlListBoxTo_p_wxWindow(void *x) {

32325

return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *)(wxPyHtmlListBox *) ((wxSimpleHtmlListBox *) x));

32326

}

32327

static void *_p_wxPyHtmlListBoxTo_p_wxWindow(void *x) {

32328

return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *)(wxPyVListBox *) ((wxPyHtmlListBox *) x));

32329

}

32330

static void *_p_wxPyVListBoxTo_p_wxWindow(void *x) {

32331

return (void *)((wxWindow *) (wxPanel *)(wxPyVScrolledWindow *) ((wxPyVListBox *) x));

32332

}

32333

static void *_p_wxPreviewControlBarTo_p_wxWindow(void *x) {

32334

return (void *)((wxWindow *) (wxPanel *) ((wxPreviewControlBar *) x));

32335

}

32336

static void *_p_wxPyPreviewControlBarTo_p_wxWindow(void *x) {

32337

return (void *)((wxWindow *) (wxPanel *)(wxPreviewControlBar *) ((wxPyPreviewControlBar *) x));

32338

}

32339

static void *_p_wxFrameTo_p_wxWindow(void *x) {

32340

return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxFrame *) x));

32341

}

32342

static void *_p_wxFontDialogTo_p_wxWindow(void *x) {

32343

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxFontDialog *) x));

32344

}

32345

static void *_p_wxDirDialogTo_p_wxWindow(void *x) {

32346

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxDirDialog *) x));

32347

}

32348

static void *_p_wxColourDialogTo_p_wxWindow(void *x) {

32349

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxDialog *) ((wxColourDialog *) x));

32350

}

32351

static void *_p_wxDialogTo_p_wxWindow(void *x) {

32352

return (void *)((wxWindow *) (wxTopLevelWindow *) ((wxDialog *) x));

32353

}

32354

static void *_p_wxMDIParentFrameTo_p_wxWindow(void *x) {

32355

return (void *)((wxWindow *) (wxTopLevelWindow *)(wxFrame *) ((wxMDIParentFrame *) x));

32356

}

32357

static void *_p_wxRichTextCtrlTo_p_wxWindow(void *x) {

32358

return (void *)((wxWindow *) (wxControl *) ((wxRichTextCtrl *) x));

32359

}

32360

static void *_p_wxSashEventTo_p_wxCommandEvent(void *x) {

32361

return (void *)((wxCommandEvent *) ((wxSashEvent *) x));

32362

}

32363

static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {

32364

return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));

32365

}

32366

static void *_p_wxSplitterEventTo_p_wxCommandEvent(void *x) {

32367

return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxSplitterEvent *) x));

32368

}

32369

static void *_p_wxRichTextEventTo_p_wxCommandEvent(void *x) {

32370

return (void *)((wxCommandEvent *) (wxNotifyEvent *) ((wxRichTextEvent *) x));

32371

}

32372

static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {

32373

return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));

32374

}

32375

static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {

32376

return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));

32377

}

32378

static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {

32379

return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));

32380

}

32381

static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {

32382

return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));

32383

}

32384

static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {

32385

return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));

32386

}

32387

static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {

32388

return (void *)((wxCommandEvent *) ((wxDateEvent *) x));

32389

}

32390

static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {

32391

return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));

32392

}

32393

static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {

32394

return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));

32395

}

32396

static void *_p_wxFindDialogEventTo_p_wxCommandEvent(void *x) {

32397

return (void *)((wxCommandEvent *) ((wxFindDialogEvent *) x));

32398

}

32399

static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {

32400

return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));

32401

}

32402

static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {

32403

return (void *)((wxValidator *) ((wxPyValidator *) x));

32404

}

32405

static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};

32406

static swig_type_info _swigt__p_double = {"_p_double", "double *|wxDouble *", 0, 0, (void*)0, 0};

32407

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};

32408

static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};

32409

static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};

32410

static swig_type_info _swigt__p_p_wxRichTextObject = {"_p_p_wxRichTextObject", "wxRichTextObject **", 0, 0, (void*)0, 0};

32411

static swig_type_info _swigt__p_p_wxRichTextBox = {"_p_p_wxRichTextBox", 0, 0, 0, 0, 0};

32412

static swig_type_info _swigt__p_p_wxRichTextParagraphLayoutBox = {"_p_p_wxRichTextParagraphLayoutBox", 0, 0, 0, 0, 0};

32413

static swig_type_info _swigt__p_p_wxRichTextParagraph = {"_p_p_wxRichTextParagraph", 0, 0, 0, 0, 0};

32414

static swig_type_info _swigt__p_p_wxRichTextImage = {"_p_p_wxRichTextImage", 0, 0, 0, 0, 0};

32415

static swig_type_info _swigt__p_p_wxRichTextBuffer = {"_p_p_wxRichTextBuffer", 0, 0, 0, 0, 0};

32416

static swig_type_info _swigt__p_p_wxRichTextPlainText = {"_p_p_wxRichTextPlainText", 0, 0, 0, 0, 0};

32417

static swig_type_info _swigt__p_p_wxRichTextCompositeObject = {"_p_p_wxRichTextCompositeObject", 0, 0, 0, 0, 0};

32418

static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};

32419

static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};

32420

static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};

32421

static swig_type_info _swigt__p_wxArrayInt = {"_p_wxArrayInt", "wxArrayInt *", 0, 0, (void*)0, 0};

32422

static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};

32423

static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};

32424

static swig_type_info _swigt__p_wxChar = {"_p_wxChar", "wxChar *", 0, 0, (void*)0, 0};

32425

static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};

32426

static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};

32427

static swig_type_info _swigt__p_wxSashEvent = {"_p_wxSashEvent", 0, 0, 0, 0, 0};

32428

static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", 0, 0, 0, 0, 0};

32429

static swig_type_info _swigt__p_wxSplitterEvent = {"_p_wxSplitterEvent", 0, 0, 0, 0, 0};

32430

static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", 0, 0, 0, 0, 0};

32431

static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", 0, 0, 0, 0, 0};

32432

static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", 0, 0, 0, 0, 0};

32433

static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", 0, 0, 0, 0, 0};

32434

static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", 0, 0, 0, 0, 0};

32435

static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", 0, 0, 0, 0, 0};

32436

static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", 0, 0, 0, 0, 0};

32437

static swig_type_info _swigt__p_wxFindDialogEvent = {"_p_wxFindDialogEvent", 0, 0, 0, 0, 0};

32438

static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", 0, 0, 0, 0, 0};

32439

static swig_type_info _swigt__p_wxCommandProcessor = {"_p_wxCommandProcessor", "wxCommandProcessor *", 0, 0, (void*)0, 0};

32440

static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};

32441

static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", 0, 0, 0, 0, 0};

32442

static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};

32443

static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};

32444

static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};

32445

static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};

32446

static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", 0, 0, 0, 0, 0};

32447

static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", 0, 0, 0, 0, 0};

32448

static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", 0, 0, 0, 0, 0};

32449

static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", 0, 0, 0, 0, 0};

32450

static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", 0, 0, 0, 0, 0};

32451

static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", 0, 0, 0, 0, 0};

32452

static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", 0, 0, 0, 0, 0};

32453

static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", 0, 0, 0, 0, 0};

32454

static swig_type_info _swigt__p_wxCalculateLayoutEvent = {"_p_wxCalculateLayoutEvent", 0, 0, 0, 0, 0};

32455

static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", 0, 0, 0, 0, 0};

32456

static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", 0, 0, 0, 0, 0};

32457

static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", 0, 0, 0, 0, 0};

32458

static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", 0, 0, 0, 0, 0};

32459

static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", 0, 0, 0, 0, 0};

32460

static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", 0, 0, 0, 0, 0};

32461

static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", 0, 0, 0, 0, 0};

32462

static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", 0, 0, 0, 0, 0};

32463

static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", 0, 0, 0, 0, 0};

32464

static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", 0, 0, 0, 0, 0};

32465

static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", 0, 0, 0, 0, 0};

32466

static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", 0, 0, 0, 0, 0};

32467

static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", 0, 0, 0, 0, 0};

32468

static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", 0, 0, 0, 0, 0};

32469

static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", 0, 0, 0, 0, 0};

32470

static swig_type_info _swigt__p_wxQueryLayoutInfoEvent = {"_p_wxQueryLayoutInfoEvent", 0, 0, 0, 0, 0};

32471

static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", 0, 0, 0, 0, 0};

32472

static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", 0, 0, 0, 0, 0};

32473

static swig_type_info _swigt__p_wxTaskBarIconEvent = {"_p_wxTaskBarIconEvent", 0, 0, 0, 0, 0};

32474

static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};

32475

static swig_type_info _swigt__p_wxSplashScreen = {"_p_wxSplashScreen", 0, 0, 0, 0, 0};

32476

static swig_type_info _swigt__p_wxMiniFrame = {"_p_wxMiniFrame", 0, 0, 0, 0, 0};

32477

static swig_type_info _swigt__p_wxPyPanel = {"_p_wxPyPanel", 0, 0, 0, 0, 0};

32478

static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", 0, 0, 0, 0, 0};

32479

static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", 0, 0, 0, 0, 0};

32480

static swig_type_info _swigt__p_wxNumberEntryDialog = {"_p_wxNumberEntryDialog", 0, 0, 0, 0, 0};

32481

static swig_type_info _swigt__p_wxPasswordEntryDialog = {"_p_wxPasswordEntryDialog", 0, 0, 0, 0, 0};

32482

static swig_type_info _swigt__p_wxFindReplaceDialog = {"_p_wxFindReplaceDialog", 0, 0, 0, 0, 0};

32483

static swig_type_info _swigt__p_wxProgressDialog = {"_p_wxProgressDialog", 0, 0, 0, 0, 0};

32484

static swig_type_info _swigt__p_wxMessageDialog = {"_p_wxMessageDialog", 0, 0, 0, 0, 0};

32485

static swig_type_info _swigt__p_wxSingleChoiceDialog = {"_p_wxSingleChoiceDialog", 0, 0, 0, 0, 0};

32486

static swig_type_info _swigt__p_wxMultiChoiceDialog = {"_p_wxMultiChoiceDialog", 0, 0, 0, 0, 0};

32487

static swig_type_info _swigt__p_wxFileDialog = {"_p_wxFileDialog", 0, 0, 0, 0, 0};

32488

static swig_type_info _swigt__p_wxTextEntryDialog = {"_p_wxTextEntryDialog", 0, 0, 0, 0, 0};

32489

static swig_type_info _swigt__p_wxPanel = {"_p_wxPanel", 0, 0, 0, 0, 0};

32490

static swig_type_info _swigt__p_wxStatusBar = {"_p_wxStatusBar", 0, 0, 0, 0, 0};

32491

static swig_type_info _swigt__p_wxPyVScrolledWindow = {"_p_wxPyVScrolledWindow", 0, 0, 0, 0, 0};

32492

static swig_type_info _swigt__p_wxTipWindow = {"_p_wxTipWindow", 0, 0, 0, 0, 0};

32493

static swig_type_info _swigt__p_wxPyPopupTransientWindow = {"_p_wxPyPopupTransientWindow", 0, 0, 0, 0, 0};

32494

static swig_type_info _swigt__p_wxPopupWindow = {"_p_wxPopupWindow", 0, 0, 0, 0, 0};

32495

static swig_type_info _swigt__p_wxSashLayoutWindow = {"_p_wxSashLayoutWindow", 0, 0, 0, 0, 0};

32496

static swig_type_info _swigt__p_wxSplashScreenWindow = {"_p_wxSplashScreenWindow", 0, 0, 0, 0, 0};

32497

static swig_type_info _swigt__p_wxSplitterWindow = {"_p_wxSplitterWindow", 0, 0, 0, 0, 0};

32498

static swig_type_info _swigt__p_wxSashWindow = {"_p_wxSashWindow", 0, 0, 0, 0, 0};

32499

static swig_type_info _swigt__p_wxScrolledWindow = {"_p_wxScrolledWindow", 0, 0, 0, 0, 0};

32500

static swig_type_info _swigt__p_wxTopLevelWindow = {"_p_wxTopLevelWindow", 0, 0, 0, 0, 0};

32501

static swig_type_info _swigt__p_wxMDIClientWindow = {"_p_wxMDIClientWindow", 0, 0, 0, 0, 0};

32502

static swig_type_info _swigt__p_wxPyScrolledWindow = {"_p_wxPyScrolledWindow", 0, 0, 0, 0, 0};

32503

static swig_type_info _swigt__p_wxPreviewFrame = {"_p_wxPreviewFrame", 0, 0, 0, 0, 0};

32504

static swig_type_info _swigt__p_wxPyPreviewFrame = {"_p_wxPyPreviewFrame", 0, 0, 0, 0, 0};

32505

static swig_type_info _swigt__p_wxMDIChildFrame = {"_p_wxMDIChildFrame", 0, 0, 0, 0, 0};

32506

static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", 0, 0, 0, 0, 0};

32507

static swig_type_info _swigt__p_wxPyEvtHandler = {"_p_wxPyEvtHandler", 0, 0, 0, 0, 0};

32508

static swig_type_info _swigt__p_wxPyWindow = {"_p_wxPyWindow", 0, 0, 0, 0, 0};

32509

static swig_type_info _swigt__p_wxPreviewCanvas = {"_p_wxPreviewCanvas", 0, 0, 0, 0, 0};

32510

static swig_type_info _swigt__p_wxSimpleHtmlListBox = {"_p_wxSimpleHtmlListBox", 0, 0, 0, 0, 0};

32511

static swig_type_info _swigt__p_wxPyHtmlListBox = {"_p_wxPyHtmlListBox", 0, 0, 0, 0, 0};

32512

static swig_type_info _swigt__p_wxPyVListBox = {"_p_wxPyVListBox", 0, 0, 0, 0, 0};

32513

static swig_type_info _swigt__p_wxPreviewControlBar = {"_p_wxPreviewControlBar", 0, 0, 0, 0, 0};

32514

static swig_type_info _swigt__p_wxPyPreviewControlBar = {"_p_wxPyPreviewControlBar", 0, 0, 0, 0, 0};

32515

static swig_type_info _swigt__p_wxPyTaskBarIcon = {"_p_wxPyTaskBarIcon", 0, 0, 0, 0, 0};

32516

static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", 0, 0, 0, 0, 0};

32517

static swig_type_info _swigt__p_wxFontDialog = {"_p_wxFontDialog", 0, 0, 0, 0, 0};

32518

static swig_type_info _swigt__p_wxDirDialog = {"_p_wxDirDialog", 0, 0, 0, 0, 0};

32519

static swig_type_info _swigt__p_wxColourDialog = {"_p_wxColourDialog", 0, 0, 0, 0, 0};

32520

static swig_type_info _swigt__p_wxDialog = {"_p_wxDialog", 0, 0, 0, 0, 0};

32521

static swig_type_info _swigt__p_wxMDIParentFrame = {"_p_wxMDIParentFrame", 0, 0, 0, 0, 0};

32522

static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};

32523

static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};

32524

static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};

32525

static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};

32526

static swig_type_info _swigt__p_wxList = {"_p_wxList", "wxList *", 0, 0, (void*)0, 0};

32527

static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};

32528

static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};

32529

static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};

32530

static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", 0, 0, 0, 0, 0};

32531

static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", 0, 0, 0, 0, 0};

32532

static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", 0, 0, 0, 0, 0};

32533

static swig_type_info _swigt__p_wxLayoutAlgorithm = {"_p_wxLayoutAlgorithm", 0, 0, 0, 0, 0};

32534

static swig_type_info _swigt__p_wxFindReplaceData = {"_p_wxFindReplaceData", 0, 0, 0, 0, 0};

32535

static swig_type_info _swigt__p_wxPrintDialogData = {"_p_wxPrintDialogData", 0, 0, 0, 0, 0};

32536

static swig_type_info _swigt__p_wxPrinter = {"_p_wxPrinter", 0, 0, 0, 0, 0};

32537

static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", 0, 0, 0, 0, 0};

32538

static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", 0, 0, 0, 0, 0};

32539

static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", 0, 0, 0, 0, 0};

32540

static swig_type_info _swigt__p_wxColourData = {"_p_wxColourData", 0, 0, 0, 0, 0};

32541

static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", 0, 0, 0, 0, 0};

32542

static swig_type_info _swigt__p_wxFontData = {"_p_wxFontData", 0, 0, 0, 0, 0};

32543

static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", 0, 0, 0, 0, 0};

32544

static swig_type_info _swigt__p_wxPrintPreview = {"_p_wxPrintPreview", 0, 0, 0, 0, 0};

32545

static swig_type_info _swigt__p_wxPyPrintPreview = {"_p_wxPyPrintPreview", 0, 0, 0, 0, 0};

32546

static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", 0, 0, 0, 0, 0};

32547

static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", 0, 0, 0, 0, 0};

32548

static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", 0, 0, 0, 0, 0};

32549

static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", 0, 0, 0, 0, 0};

32550

static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", 0, 0, 0, 0, 0};

32551

static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", 0, 0, 0, 0, 0};

32552

static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", 0, 0, 0, 0, 0};

32553

static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", 0, 0, 0, 0, 0};

32554

static swig_type_info _swigt__p_wxPrintDialog = {"_p_wxPrintDialog", 0, 0, 0, 0, 0};

32555

static swig_type_info _swigt__p_wxPageSetupDialog = {"_p_wxPageSetupDialog", 0, 0, 0, 0, 0};

32556

static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", 0, 0, 0, 0, 0};

32557

static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", 0, 0, 0, 0, 0};

32558

static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", 0, 0, 0, 0, 0};

32559

static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", 0, 0, 0, 0, 0};

32560

static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", 0, 0, 0, 0, 0};

32561

static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", 0, 0, 0, 0, 0};

32562

static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", 0, 0, 0, 0, 0};

32563

static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", 0, 0, 0, 0, 0};

32564

static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", 0, 0, 0, 0, 0};

32565

static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", 0, 0, 0, 0, 0};

32566

static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", 0, 0, 0, 0, 0};

32567

static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", 0, 0, 0, 0, 0};

32568

static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", 0, 0, 0, 0, 0};

32569

static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", 0, 0, 0, 0, 0};

32570

static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};

32571

static swig_type_info _swigt__p_wxPageSetupData = {"_p_wxPageSetupData", "wxPageSetupData *", 0, 0, (void*)0, 0};

32572

static swig_type_info _swigt__p_wxPageSetupDialogData = {"_p_wxPageSetupDialogData", "wxPageSetupDialogData *", 0, 0, (void*)0, 0};

32573

static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};

32574

static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};

32575

static swig_type_info _swigt__p_wxPrintData = {"_p_wxPrintData", "wxPrintData *", 0, 0, (void*)0, 0};

32576

static swig_type_info _swigt__p_wxPyPrintout = {"_p_wxPyPrintout", "wxPyPrintout *", 0, 0, (void*)0, 0};

32577

static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};

32578

static swig_type_info _swigt__p_wxRichTextAction = {"_p_wxRichTextAction", "wxRichTextAction *", 0, 0, (void*)0, 0};

32579

static swig_type_info _swigt__p_wxRichTextAttr = {"_p_wxRichTextAttr", "wxRichTextAttr *", 0, 0, (void*)0, 0};

32580

static swig_type_info _swigt__p_wxRichTextBox = {"_p_wxRichTextBox", "wxRichTextBox *", 0, 0, (void*)0, 0};

32581

static swig_type_info _swigt__p_wxRichTextBuffer = {"_p_wxRichTextBuffer", "wxRichTextBuffer *", 0, 0, (void*)0, 0};

32582

static swig_type_info _swigt__p_wxRichTextCommand = {"_p_wxRichTextCommand", "wxRichTextCommand *", 0, 0, (void*)0, 0};

32583

static swig_type_info _swigt__p_wxRichTextCompositeObject = {"_p_wxRichTextCompositeObject", "wxRichTextCompositeObject *", 0, 0, (void*)0, 0};

32584

static swig_type_info _swigt__p_wxRichTextCtrl = {"_p_wxRichTextCtrl", "wxRichTextCtrl *", 0, 0, (void*)0, 0};

32585

static swig_type_info _swigt__p_wxRichTextEvent = {"_p_wxRichTextEvent", "wxRichTextEvent *", 0, 0, (void*)0, 0};

32586

static swig_type_info _swigt__p_wxRichTextFileHandler = {"_p_wxRichTextFileHandler", "wxRichTextFileHandler *", 0, 0, (void*)0, 0};

32587

static swig_type_info _swigt__p_wxRichTextFileHandlerList = {"_p_wxRichTextFileHandlerList", "wxRichTextFileHandlerList *", 0, 0, (void*)0, 0};

32588

static swig_type_info _swigt__p_wxRichTextFileHandlerList_iterator = {"_p_wxRichTextFileHandlerList_iterator", "wxRichTextFileHandlerList_iterator *", 0, 0, (void*)0, 0};

32589

static swig_type_info _swigt__p_wxRichTextHTMLHandler = {"_p_wxRichTextHTMLHandler", "wxRichTextHTMLHandler *", 0, 0, (void*)0, 0};

32590

static swig_type_info _swigt__p_wxRichTextHeaderFooterData = {"_p_wxRichTextHeaderFooterData", "wxRichTextHeaderFooterData *", 0, 0, (void*)0, 0};

32591

static swig_type_info _swigt__p_wxRichTextImage = {"_p_wxRichTextImage", "wxRichTextImage *", 0, 0, (void*)0, 0};

32592

static swig_type_info _swigt__p_wxRichTextImageBlock = {"_p_wxRichTextImageBlock", "wxRichTextImageBlock *", 0, 0, (void*)0, 0};

32593

static swig_type_info _swigt__p_wxRichTextLine = {"_p_wxRichTextLine", "wxRichTextLine *", 0, 0, (void*)0, 0};

32594

static swig_type_info _swigt__p_wxRichTextLineList = {"_p_wxRichTextLineList", "wxRichTextLineList *", 0, 0, (void*)0, 0};

32595

static swig_type_info _swigt__p_wxRichTextListStyleDefinition = {"_p_wxRichTextListStyleDefinition", "wxRichTextListStyleDefinition *", 0, 0, (void*)0, 0};

32596

static swig_type_info _swigt__p_wxRichTextObject = {"_p_wxRichTextObject", "wxRichTextObject *", 0, 0, (void*)0, 0};

32597

static swig_type_info _swigt__p_wxRichTextObjectList = {"_p_wxRichTextObjectList", "wxRichTextObjectList *", 0, 0, (void*)0, 0};

32598

static swig_type_info _swigt__p_wxRichTextObjectList_iterator = {"_p_wxRichTextObjectList_iterator", "wxRichTextObjectList_iterator *", 0, 0, (void*)0, 0};

32599

static swig_type_info _swigt__p_wxRichTextParagraph = {"_p_wxRichTextParagraph", "wxRichTextParagraph *", 0, 0, (void*)0, 0};

32600

static swig_type_info _swigt__p_wxRichTextParagraphLayoutBox = {"_p_wxRichTextParagraphLayoutBox", "wxRichTextParagraphLayoutBox *", 0, 0, (void*)0, 0};

32601

static swig_type_info _swigt__p_wxRichTextPlainText = {"_p_wxRichTextPlainText", "wxRichTextPlainText *", 0, 0, (void*)0, 0};

32602

static swig_type_info _swigt__p_wxRichTextPlainTextHandler = {"_p_wxRichTextPlainTextHandler", "wxRichTextPlainTextHandler *", 0, 0, (void*)0, 0};

32603

static swig_type_info _swigt__p_wxRichTextPrinting = {"_p_wxRichTextPrinting", "wxRichTextPrinting *", 0, 0, (void*)0, 0};

32604

static swig_type_info _swigt__p_wxRichTextPrintout = {"_p_wxRichTextPrintout", "wxRichTextPrintout *", 0, 0, (void*)0, 0};

32605

static swig_type_info _swigt__p_wxRichTextRange = {"_p_wxRichTextRange", "wxRichTextRange *", 0, 0, (void*)0, 0};

32606

static swig_type_info _swigt__p_wxRichTextRenderer = {"_p_wxRichTextRenderer", "wxRichTextRenderer *", 0, 0, (void*)0, 0};

32607

static swig_type_info _swigt__p_wxRichTextStdRenderer = {"_p_wxRichTextStdRenderer", "wxRichTextStdRenderer *", 0, 0, (void*)0, 0};

32608

static swig_type_info _swigt__p_wxRichTextStyleDefinition = {"_p_wxRichTextStyleDefinition", "wxRichTextStyleDefinition *", 0, 0, (void*)0, 0};

32609

static swig_type_info _swigt__p_wxRichTextStyleSheet = {"_p_wxRichTextStyleSheet", "wxRichTextStyleSheet *", 0, 0, (void*)0, 0};

32610

static swig_type_info _swigt__p_wxRichTextXMLHandler = {"_p_wxRichTextXMLHandler", "wxRichTextXMLHandler *", 0, 0, (void*)0, 0};

32611

static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};

32612

static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};

32613

static swig_type_info _swigt__p_wxTextAttrEx = {"_p_wxTextAttrEx", "wxTextAttrEx *", 0, 0, (void*)0, 0};

32614

static swig_type_info _swigt__p_wxTextCoord = {"_p_wxTextCoord", "wxTextCoord *", 0, 0, (void*)0, 0};

32615

static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};

32616

static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};

32617

32618

static swig_type_info *swig_type_initial[] = {

32619

&_swigt__p_char,

32620

&_swigt__p_double,

32621

&_swigt__p_form_ops_t,

32622

&_swigt__p_int,

32623

&_swigt__p_long,

32624

&_swigt__p_p_wxRichTextBox,

32625

&_swigt__p_p_wxRichTextBuffer,

32626

&_swigt__p_p_wxRichTextCompositeObject,

32627

&_swigt__p_p_wxRichTextImage,

32628

&_swigt__p_p_wxRichTextObject,

32629

&_swigt__p_p_wxRichTextParagraph,

32630

&_swigt__p_p_wxRichTextParagraphLayoutBox,

32631

&_swigt__p_p_wxRichTextPlainText,

32632

&_swigt__p_unsigned_char,

32633

&_swigt__p_unsigned_int,

32634

&_swigt__p_unsigned_long,

32635

&_swigt__p_wxANIHandler,

32636

&_swigt__p_wxAcceleratorTable,

32637

&_swigt__p_wxActivateEvent,

32638

&_swigt__p_wxArrayInt,

32639

&_swigt__p_wxArrayString,

32640

&_swigt__p_wxBMPHandler,

32641

&_swigt__p_wxBitmap,

32642

&_swigt__p_wxBoxSizer,

32643

&_swigt__p_wxCURHandler,

32644

&_swigt__p_wxCalculateLayoutEvent,

32645

&_swigt__p_wxChar,

32646

&_swigt__p_wxChildFocusEvent,

32647

&_swigt__p_wxClipboardTextEvent,

32648

&_swigt__p_wxCloseEvent,

32649

&_swigt__p_wxColour,

32650

&_swigt__p_wxColourData,

32651

&_swigt__p_wxColourDialog,

32652

&_swigt__p_wxCommandEvent,

32653

&_swigt__p_wxCommandProcessor,

32654

&_swigt__p_wxContextMenuEvent,

32655

&_swigt__p_wxControl,

32656

&_swigt__p_wxControlWithItems,

32657

&_swigt__p_wxCursor,

32658

&_swigt__p_wxDC,

32659

&_swigt__p_wxDateEvent,

32660

&_swigt__p_wxDialog,

32661

&_swigt__p_wxDirDialog,

32662

&_swigt__p_wxDisplayChangedEvent,

32663

&_swigt__p_wxDropFilesEvent,

32664

&_swigt__p_wxDuplexMode,

32665

&_swigt__p_wxEraseEvent,

32666

&_swigt__p_wxEvent,

32667

&_swigt__p_wxEvtHandler,

32668

&_swigt__p_wxFSFile,

32669

&_swigt__p_wxFileDialog,

32670

&_swigt__p_wxFileSystem,

32671

&_swigt__p_wxFindDialogEvent,

32672

&_swigt__p_wxFindReplaceData,

32673

&_swigt__p_wxFindReplaceDialog,

32674

&_swigt__p_wxFlexGridSizer,

32675

&_swigt__p_wxFocusEvent,

32676

&_swigt__p_wxFont,

32677

&_swigt__p_wxFontData,

32678

&_swigt__p_wxFontDialog,

32679

&_swigt__p_wxFrame,

32680

&_swigt__p_wxGBSizerItem,

32681

&_swigt__p_wxGIFHandler,

32682

&_swigt__p_wxGridBagSizer,

32683

&_swigt__p_wxGridSizer,

32684

&_swigt__p_wxICOHandler,

32685

&_swigt__p_wxIconizeEvent,

32686

&_swigt__p_wxIdleEvent,

32687

&_swigt__p_wxImage,

32688

&_swigt__p_wxImageHandler,

32689

&_swigt__p_wxIndividualLayoutConstraint,

32690

&_swigt__p_wxInitDialogEvent,

32691

&_swigt__p_wxInputStream,

32692

&_swigt__p_wxJPEGHandler,

32693

&_swigt__p_wxKeyEvent,

32694

&_swigt__p_wxLayoutAlgorithm,

32695

&_swigt__p_wxLayoutConstraints,

32696

&_swigt__p_wxList,

32697

&_swigt__p_wxMDIChildFrame,

32698

&_swigt__p_wxMDIClientWindow,

32699

&_swigt__p_wxMDIParentFrame,

32700

&_swigt__p_wxMaximizeEvent,

32701

&_swigt__p_wxMenu,

32702

&_swigt__p_wxMenuBar,

32703

&_swigt__p_wxMenuEvent,

32704

&_swigt__p_wxMenuItem,

32705

&_swigt__p_wxMessageDialog,

32706

&_swigt__p_wxMiniFrame,

32707

&_swigt__p_wxMouseCaptureChangedEvent,

32708

&_swigt__p_wxMouseCaptureLostEvent,

32709

&_swigt__p_wxMouseEvent,

32710

&_swigt__p_wxMoveEvent,

32711

&_swigt__p_wxMultiChoiceDialog,

32712

&_swigt__p_wxNavigationKeyEvent,

32713

&_swigt__p_wxNcPaintEvent,

32714

&_swigt__p_wxNotifyEvent,

32715

&_swigt__p_wxNumberEntryDialog,

32716

&_swigt__p_wxObject,

32717

&_swigt__p_wxOutputStream,

32718

&_swigt__p_wxPCXHandler,

32719

&_swigt__p_wxPNGHandler,

32720

&_swigt__p_wxPNMHandler,

32721

&_swigt__p_wxPageSetupData,

32722

&_swigt__p_wxPageSetupDialog,

32723

&_swigt__p_wxPageSetupDialogData,

32724

&_swigt__p_wxPaintEvent,

32725

&_swigt__p_wxPaletteChangedEvent,

32726

&_swigt__p_wxPanel,

32727

&_swigt__p_wxPaperSize,

32728

&_swigt__p_wxPasswordEntryDialog,

32729

&_swigt__p_wxPoint,

32730

&_swigt__p_wxPopupWindow,

32731

&_swigt__p_wxPreviewCanvas,

32732

&_swigt__p_wxPreviewControlBar,

32733

&_swigt__p_wxPreviewFrame,

32734

&_swigt__p_wxPrintData,

32735

&_swigt__p_wxPrintDialog,

32736

&_swigt__p_wxPrintDialogData,

32737

&_swigt__p_wxPrintPreview,

32738

&_swigt__p_wxPrinter,

32739

&_swigt__p_wxProgressDialog,

32740

&_swigt__p_wxPyApp,

32741

&_swigt__p_wxPyCommandEvent,

32742

&_swigt__p_wxPyEvent,

32743

&_swigt__p_wxPyEvtHandler,

32744

&_swigt__p_wxPyHtmlListBox,

32745

&_swigt__p_wxPyImageHandler,

32746

&_swigt__p_wxPyPanel,

32747

&_swigt__p_wxPyPopupTransientWindow,

32748

&_swigt__p_wxPyPreviewControlBar,

32749

&_swigt__p_wxPyPreviewFrame,

32750

&_swigt__p_wxPyPrintPreview,

32751

&_swigt__p_wxPyPrintout,

32752

&_swigt__p_wxPyScrolledWindow,

32753

&_swigt__p_wxPySizer,

32754

&_swigt__p_wxPyTaskBarIcon,

32755

&_swigt__p_wxPyVListBox,

32756

&_swigt__p_wxPyVScrolledWindow,

32757

&_swigt__p_wxPyValidator,

32758

&_swigt__p_wxPyWindow,

32759

&_swigt__p_wxQueryLayoutInfoEvent,

32760

&_swigt__p_wxQueryNewPaletteEvent,

32761

&_swigt__p_wxRect,

32762

&_swigt__p_wxRichTextAction,

32763

&_swigt__p_wxRichTextAttr,

32764

&_swigt__p_wxRichTextBox,

32765

&_swigt__p_wxRichTextBuffer,

32766

&_swigt__p_wxRichTextCommand,

32767

&_swigt__p_wxRichTextCompositeObject,

32768

&_swigt__p_wxRichTextCtrl,

32769

&_swigt__p_wxRichTextEvent,

32770

&_swigt__p_wxRichTextFileHandler,

32771

&_swigt__p_wxRichTextFileHandlerList,

32772

&_swigt__p_wxRichTextFileHandlerList_iterator,

32773

&_swigt__p_wxRichTextHTMLHandler,

32774

&_swigt__p_wxRichTextHeaderFooterData,

32775

&_swigt__p_wxRichTextImage,

32776

&_swigt__p_wxRichTextImageBlock,

32777

&_swigt__p_wxRichTextLine,

32778

&_swigt__p_wxRichTextLineList,

32779

&_swigt__p_wxRichTextListStyleDefinition,

32780

&_swigt__p_wxRichTextObject,

32781

&_swigt__p_wxRichTextObjectList,

32782

&_swigt__p_wxRichTextObjectList_iterator,

32783

&_swigt__p_wxRichTextParagraph,

32784

&_swigt__p_wxRichTextParagraphLayoutBox,

32785

&_swigt__p_wxRichTextPlainText,

32786

&_swigt__p_wxRichTextPlainTextHandler,

32787

&_swigt__p_wxRichTextPrinting,

32788

&_swigt__p_wxRichTextPrintout,

32789

&_swigt__p_wxRichTextRange,

32790

&_swigt__p_wxRichTextRenderer,

32791

&_swigt__p_wxRichTextStdRenderer,

32792

&_swigt__p_wxRichTextStyleDefinition,

32793

&_swigt__p_wxRichTextStyleSheet,

32794

&_swigt__p_wxRichTextXMLHandler,

32795

&_swigt__p_wxSashEvent,

32796

&_swigt__p_wxSashLayoutWindow,

32797

&_swigt__p_wxSashWindow,

32798

&_swigt__p_wxScrollEvent,

32799

&_swigt__p_wxScrollWinEvent,

32800

&_swigt__p_wxScrolledWindow,

32801

&_swigt__p_wxSetCursorEvent,

32802

&_swigt__p_wxShowEvent,

32803

&_swigt__p_wxSimpleHtmlListBox,

32804

&_swigt__p_wxSingleChoiceDialog,

32805

&_swigt__p_wxSize,

32806

&_swigt__p_wxSizeEvent,

32807

&_swigt__p_wxSizer,

32808

&_swigt__p_wxSizerItem,

32809

&_swigt__p_wxSplashScreen,

32810

&_swigt__p_wxSplashScreenWindow,

32811

&_swigt__p_wxSplitterEvent,

32812

&_swigt__p_wxSplitterWindow,

32813

&_swigt__p_wxStaticBoxSizer,

32814

&_swigt__p_wxStatusBar,

32815

&_swigt__p_wxStdDialogButtonSizer,

32816

&_swigt__p_wxSysColourChangedEvent,

32817

&_swigt__p_wxTGAHandler,

32818

&_swigt__p_wxTIFFHandler,

32819

&_swigt__p_wxTaskBarIconEvent,

32820

&_swigt__p_wxTextAttrEx,

32821

&_swigt__p_wxTextCoord,

32822

&_swigt__p_wxTextEntryDialog,

32823

&_swigt__p_wxTipWindow,

32824

&_swigt__p_wxTopLevelWindow,

32825

&_swigt__p_wxUpdateUIEvent,

32826

&_swigt__p_wxValidator,

32827

&_swigt__p_wxWindow,

32828

&_swigt__p_wxWindowCreateEvent,

32829

&_swigt__p_wxWindowDestroyEvent,

32830

&_swigt__p_wxXPMHandler,

32831

};

32832

32833

static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};

32834

static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};

32835

static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};

32836

static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};

32837

static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};

32838

static swig_cast_info _swigc__p_p_wxRichTextBox[] = {{&_swigt__p_p_wxRichTextBox, 0, 0, 0},{0, 0, 0, 0}};

32839

static swig_cast_info _swigc__p_p_wxRichTextParagraphLayoutBox[] = {{&_swigt__p_p_wxRichTextParagraphLayoutBox, 0, 0, 0},{0, 0, 0, 0}};

32840

static swig_cast_info _swigc__p_p_wxRichTextParagraph[] = {{&_swigt__p_p_wxRichTextParagraph, 0, 0, 0},{0, 0, 0, 0}};

32841

static swig_cast_info _swigc__p_p_wxRichTextImage[] = {{&_swigt__p_p_wxRichTextImage, 0, 0, 0},{0, 0, 0, 0}};

32842

static swig_cast_info _swigc__p_p_wxRichTextBuffer[] = {{&_swigt__p_p_wxRichTextBuffer, 0, 0, 0},{0, 0, 0, 0}};

32843

static swig_cast_info _swigc__p_p_wxRichTextPlainText[] = {{&_swigt__p_p_wxRichTextPlainText, 0, 0, 0},{0, 0, 0, 0}};

32844

static swig_cast_info _swigc__p_p_wxRichTextCompositeObject[] = {{&_swigt__p_p_wxRichTextCompositeObject, 0, 0, 0},{0, 0, 0, 0}};

32845

static swig_cast_info _swigc__p_p_wxRichTextObject[] = { {&_swigt__p_p_wxRichTextBox, _p_p_wxRichTextBoxTo_p_p_wxRichTextObject, 0, 0}, {&_swigt__p_p_wxRichTextParagraphLayoutBox, _p_p_wxRichTextParagraphLayoutBoxTo_p_p_wxRichTextObject, 0, 0}, {&_swigt__p_p_wxRichTextParagraph, _p_p_wxRichTextParagraphTo_p_p_wxRichTextObject, 0, 0}, {&_swigt__p_p_wxRichTextImage, _p_p_wxRichTextImageTo_p_p_wxRichTextObject, 0, 0}, {&_swigt__p_p_wxRichTextBuffer, _p_p_wxRichTextBufferTo_p_p_wxRichTextObject, 0, 0}, {&_swigt__p_p_wxRichTextObject, 0, 0, 0}, {&_swigt__p_p_wxRichTextPlainText, _p_p_wxRichTextPlainTextTo_p_p_wxRichTextObject, 0, 0}, {&_swigt__p_p_wxRichTextCompositeObject, _p_p_wxRichTextCompositeObjectTo_p_p_wxRichTextObject, 0, 0},{0, 0, 0, 0}};

32846

static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};

32847

static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};

32848

static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};

32849

static swig_cast_info _swigc__p_wxArrayInt[] = { {&_swigt__p_wxArrayInt, 0, 0, 0},{0, 0, 0, 0}};

32850

static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};

32851

static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};

32852

static swig_cast_info _swigc__p_wxChar[] = { {&_swigt__p_wxChar, 0, 0, 0},{0, 0, 0, 0}};

32853

static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};

32854

static swig_cast_info _swigc__p_wxSashEvent[] = {{&_swigt__p_wxSashEvent, 0, 0, 0},{0, 0, 0, 0}};

32855

static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = {{&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};

32856

static swig_cast_info _swigc__p_wxSplitterEvent[] = {{&_swigt__p_wxSplitterEvent, 0, 0, 0},{0, 0, 0, 0}};

32857

static swig_cast_info _swigc__p_wxClipboardTextEvent[] = {{&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};

32858

static swig_cast_info _swigc__p_wxScrollEvent[] = {{&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};

32859

static swig_cast_info _swigc__p_wxPyCommandEvent[] = {{&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};

32860

static swig_cast_info _swigc__p_wxContextMenuEvent[] = {{&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

32861

static swig_cast_info _swigc__p_wxChildFocusEvent[] = {{&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

32862

static swig_cast_info _swigc__p_wxDateEvent[] = {{&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};

32863

static swig_cast_info _swigc__p_wxWindowCreateEvent[] = {{&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};

32864

static swig_cast_info _swigc__p_wxFindDialogEvent[] = {{&_swigt__p_wxFindDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

32865

static swig_cast_info _swigc__p_wxUpdateUIEvent[] = {{&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};

32866

static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxRichTextEvent, _p_wxRichTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};

32867

static swig_cast_info _swigc__p_wxCommandProcessor[] = { {&_swigt__p_wxCommandProcessor, 0, 0, 0},{0, 0, 0, 0}};

32868

static swig_cast_info _swigc__p_wxControlWithItems[] = {{&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};

32869

static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0}, {&_swigt__p_wxRichTextCtrl, _p_wxRichTextCtrlTo_p_wxControl, 0, 0},{0, 0, 0, 0}};

32870

static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};

32871

static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};

32872

static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};

32873

static swig_cast_info _swigc__p_wxMenuEvent[] = {{&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};

32874

static swig_cast_info _swigc__p_wxCloseEvent[] = {{&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};

32875

static swig_cast_info _swigc__p_wxMouseEvent[] = {{&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};

32876

static swig_cast_info _swigc__p_wxEraseEvent[] = {{&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};

32877

static swig_cast_info _swigc__p_wxSetCursorEvent[] = {{&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};

32878

static swig_cast_info _swigc__p_wxInitDialogEvent[] = {{&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};

32879

static swig_cast_info _swigc__p_wxPyEvent[] = {{&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};

32880

static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = {{&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};

32881

static swig_cast_info _swigc__p_wxCalculateLayoutEvent[] = {{&_swigt__p_wxCalculateLayoutEvent, 0, 0, 0},{0, 0, 0, 0}};

32882

static swig_cast_info _swigc__p_wxIdleEvent[] = {{&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};

32883

static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = {{&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};

32884

static swig_cast_info _swigc__p_wxMaximizeEvent[] = {{&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};

32885

static swig_cast_info _swigc__p_wxIconizeEvent[] = {{&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};

32886

static swig_cast_info _swigc__p_wxActivateEvent[] = {{&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};

32887

static swig_cast_info _swigc__p_wxSizeEvent[] = {{&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};

32888

static swig_cast_info _swigc__p_wxMoveEvent[] = {{&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};

32889

static swig_cast_info _swigc__p_wxPaintEvent[] = {{&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

32890

static swig_cast_info _swigc__p_wxNcPaintEvent[] = {{&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};

32891

static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = {{&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

32892

static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = {{&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

32893

static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = {{&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

32894

static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = {{&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};

32895

static swig_cast_info _swigc__p_wxDropFilesEvent[] = {{&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};

32896

static swig_cast_info _swigc__p_wxFocusEvent[] = {{&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};

32897

static swig_cast_info _swigc__p_wxQueryLayoutInfoEvent[] = {{&_swigt__p_wxQueryLayoutInfoEvent, 0, 0, 0},{0, 0, 0, 0}};

32898

static swig_cast_info _swigc__p_wxShowEvent[] = {{&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};

32899

static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = {{&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

32900

static swig_cast_info _swigc__p_wxTaskBarIconEvent[] = {{&_swigt__p_wxTaskBarIconEvent, 0, 0, 0},{0, 0, 0, 0}};

32901

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_wxSplitterEvent, _p_wxSplitterEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_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_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_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_wxRichTextEvent, _p_wxRichTextEventTo_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_wxSashEvent, _p_wxSashEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_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}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};

32902

static swig_cast_info _swigc__p_wxSplashScreen[] = {{&_swigt__p_wxSplashScreen, 0, 0, 0},{0, 0, 0, 0}};

32903

static swig_cast_info _swigc__p_wxMiniFrame[] = {{&_swigt__p_wxMiniFrame, 0, 0, 0},{0, 0, 0, 0}};

32904

static swig_cast_info _swigc__p_wxPyPanel[] = {{&_swigt__p_wxPyPanel, 0, 0, 0},{0, 0, 0, 0}};

32905

static swig_cast_info _swigc__p_wxMenuBar[] = {{&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};

32906

static swig_cast_info _swigc__p_wxPyValidator[] = {{&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};

32907

static swig_cast_info _swigc__p_wxNumberEntryDialog[] = {{&_swigt__p_wxNumberEntryDialog, 0, 0, 0},{0, 0, 0, 0}};

32908

static swig_cast_info _swigc__p_wxPasswordEntryDialog[] = {{&_swigt__p_wxPasswordEntryDialog, 0, 0, 0},{0, 0, 0, 0}};

32909

static swig_cast_info _swigc__p_wxFindReplaceDialog[] = {{&_swigt__p_wxFindReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};

32910

static swig_cast_info _swigc__p_wxProgressDialog[] = {{&_swigt__p_wxProgressDialog, 0, 0, 0},{0, 0, 0, 0}};

32911

static swig_cast_info _swigc__p_wxMessageDialog[] = {{&_swigt__p_wxMessageDialog, 0, 0, 0},{0, 0, 0, 0}};

32912

static swig_cast_info _swigc__p_wxSingleChoiceDialog[] = {{&_swigt__p_wxSingleChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};

32913

static swig_cast_info _swigc__p_wxMultiChoiceDialog[] = {{&_swigt__p_wxMultiChoiceDialog, 0, 0, 0},{0, 0, 0, 0}};

32914

static swig_cast_info _swigc__p_wxFileDialog[] = {{&_swigt__p_wxFileDialog, 0, 0, 0},{0, 0, 0, 0}};

32915

static swig_cast_info _swigc__p_wxTextEntryDialog[] = {{&_swigt__p_wxTextEntryDialog, 0, 0, 0},{0, 0, 0, 0}};

32916

static swig_cast_info _swigc__p_wxPanel[] = {{&_swigt__p_wxPanel, 0, 0, 0},{0, 0, 0, 0}};

32917

static swig_cast_info _swigc__p_wxStatusBar[] = {{&_swigt__p_wxStatusBar, 0, 0, 0},{0, 0, 0, 0}};

32918

static swig_cast_info _swigc__p_wxPyVScrolledWindow[] = {{&_swigt__p_wxPyVScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};

32919

static swig_cast_info _swigc__p_wxTipWindow[] = {{&_swigt__p_wxTipWindow, 0, 0, 0},{0, 0, 0, 0}};

32920

static swig_cast_info _swigc__p_wxPyPopupTransientWindow[] = {{&_swigt__p_wxPyPopupTransientWindow, 0, 0, 0},{0, 0, 0, 0}};

32921

static swig_cast_info _swigc__p_wxPopupWindow[] = {{&_swigt__p_wxPopupWindow, 0, 0, 0},{0, 0, 0, 0}};

32922

static swig_cast_info _swigc__p_wxSashLayoutWindow[] = {{&_swigt__p_wxSashLayoutWindow, 0, 0, 0},{0, 0, 0, 0}};

32923

static swig_cast_info _swigc__p_wxSplashScreenWindow[] = {{&_swigt__p_wxSplashScreenWindow, 0, 0, 0},{0, 0, 0, 0}};

32924

static swig_cast_info _swigc__p_wxSplitterWindow[] = {{&_swigt__p_wxSplitterWindow, 0, 0, 0},{0, 0, 0, 0}};

32925

static swig_cast_info _swigc__p_wxSashWindow[] = {{&_swigt__p_wxSashWindow, 0, 0, 0},{0, 0, 0, 0}};

32926

static swig_cast_info _swigc__p_wxScrolledWindow[] = {{&_swigt__p_wxScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};

32927

static swig_cast_info _swigc__p_wxTopLevelWindow[] = {{&_swigt__p_wxTopLevelWindow, 0, 0, 0},{0, 0, 0, 0}};

32928

static swig_cast_info _swigc__p_wxMDIClientWindow[] = {{&_swigt__p_wxMDIClientWindow, 0, 0, 0},{0, 0, 0, 0}};

32929

static swig_cast_info _swigc__p_wxPyScrolledWindow[] = {{&_swigt__p_wxPyScrolledWindow, 0, 0, 0},{0, 0, 0, 0}};

32930

static swig_cast_info _swigc__p_wxPreviewFrame[] = {{&_swigt__p_wxPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};

32931

static swig_cast_info _swigc__p_wxPyPreviewFrame[] = {{&_swigt__p_wxPyPreviewFrame, 0, 0, 0},{0, 0, 0, 0}};

32932

static swig_cast_info _swigc__p_wxMDIChildFrame[] = {{&_swigt__p_wxMDIChildFrame, 0, 0, 0},{0, 0, 0, 0}};

32933

static swig_cast_info _swigc__p_wxPyApp[] = {{&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};

32934

static swig_cast_info _swigc__p_wxPyEvtHandler[] = {{&_swigt__p_wxPyEvtHandler, 0, 0, 0},{0, 0, 0, 0}};

32935

static swig_cast_info _swigc__p_wxPyWindow[] = {{&_swigt__p_wxPyWindow, 0, 0, 0},{0, 0, 0, 0}};

32936

static swig_cast_info _swigc__p_wxPreviewCanvas[] = {{&_swigt__p_wxPreviewCanvas, 0, 0, 0},{0, 0, 0, 0}};

32937

static swig_cast_info _swigc__p_wxSimpleHtmlListBox[] = {{&_swigt__p_wxSimpleHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};

32938

static swig_cast_info _swigc__p_wxPyHtmlListBox[] = {{&_swigt__p_wxPyHtmlListBox, 0, 0, 0},{0, 0, 0, 0}};

32939

static swig_cast_info _swigc__p_wxPyVListBox[] = {{&_swigt__p_wxPyVListBox, 0, 0, 0},{0, 0, 0, 0}};

32940

static swig_cast_info _swigc__p_wxPreviewControlBar[] = {{&_swigt__p_wxPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};

32941

static swig_cast_info _swigc__p_wxPyPreviewControlBar[] = {{&_swigt__p_wxPyPreviewControlBar, 0, 0, 0},{0, 0, 0, 0}};

32942

static swig_cast_info _swigc__p_wxPyTaskBarIcon[] = {{&_swigt__p_wxPyTaskBarIcon, 0, 0, 0},{0, 0, 0, 0}};

32943

static swig_cast_info _swigc__p_wxFrame[] = {{&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};

32944

static swig_cast_info _swigc__p_wxFontDialog[] = {{&_swigt__p_wxFontDialog, 0, 0, 0},{0, 0, 0, 0}};

32945

static swig_cast_info _swigc__p_wxDirDialog[] = {{&_swigt__p_wxDirDialog, 0, 0, 0},{0, 0, 0, 0}};

32946

static swig_cast_info _swigc__p_wxColourDialog[] = {{&_swigt__p_wxColourDialog, 0, 0, 0},{0, 0, 0, 0}};

32947

static swig_cast_info _swigc__p_wxDialog[] = {{&_swigt__p_wxDialog, 0, 0, 0},{0, 0, 0, 0}};

32948

static swig_cast_info _swigc__p_wxMDIParentFrame[] = {{&_swigt__p_wxMDIParentFrame, 0, 0, 0},{0, 0, 0, 0}};

32949

static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxRichTextCtrl, _p_wxRichTextCtrlTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};

32950

static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};

32951

static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};

32952

static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};

32953

static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};

32954

static swig_cast_info _swigc__p_wxList[] = { {&_swigt__p_wxList, 0, 0, 0},{0, 0, 0, 0}};

32955

static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};

32956

static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxRichTextEvent, _p_wxRichTextEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxNotifyEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};

32957

static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = {{&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};

32958

static swig_cast_info _swigc__p_wxMenuItem[] = {{&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};

32959

static swig_cast_info _swigc__p_wxPySizer[] = {{&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};

32960

static swig_cast_info _swigc__p_wxLayoutAlgorithm[] = {{&_swigt__p_wxLayoutAlgorithm, 0, 0, 0},{0, 0, 0, 0}};

32961

static swig_cast_info _swigc__p_wxFindReplaceData[] = {{&_swigt__p_wxFindReplaceData, 0, 0, 0},{0, 0, 0, 0}};

32962

static swig_cast_info _swigc__p_wxPrintDialogData[] = {{&_swigt__p_wxPrintDialogData, 0, 0, 0},{0, 0, 0, 0}};

32963

static swig_cast_info _swigc__p_wxPrinter[] = {{&_swigt__p_wxPrinter, 0, 0, 0},{0, 0, 0, 0}};

32964

static swig_cast_info _swigc__p_wxGridSizer[] = {{&_swigt__p_wxGridSizer, 0, 0, 0},{0, 0, 0, 0}};

32965

static swig_cast_info _swigc__p_wxFlexGridSizer[] = {{&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};

32966

static swig_cast_info _swigc__p_wxAcceleratorTable[] = {{&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};

32967

static swig_cast_info _swigc__p_wxColourData[] = {{&_swigt__p_wxColourData, 0, 0, 0},{0, 0, 0, 0}};

32968

static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = {{&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};

32969

static swig_cast_info _swigc__p_wxFontData[] = {{&_swigt__p_wxFontData, 0, 0, 0},{0, 0, 0, 0}};

32970

static swig_cast_info _swigc__p_wxFileSystem[] = {{&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};

32971

static swig_cast_info _swigc__p_wxPrintPreview[] = {{&_swigt__p_wxPrintPreview, 0, 0, 0},{0, 0, 0, 0}};

32972

static swig_cast_info _swigc__p_wxPyPrintPreview[] = {{&_swigt__p_wxPyPrintPreview, 0, 0, 0},{0, 0, 0, 0}};

32973

static swig_cast_info _swigc__p_wxLayoutConstraints[] = {{&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};

32974

static swig_cast_info _swigc__p_wxBoxSizer[] = {{&_swigt__p_wxBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

32975

static swig_cast_info _swigc__p_wxSizer[] = {{&_swigt__p_wxSizer, 0, 0, 0},{0, 0, 0, 0}};

32976

static swig_cast_info _swigc__p_wxStaticBoxSizer[] = {{&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};

32977

static swig_cast_info _swigc__p_wxGridBagSizer[] = {{&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};

32978

static swig_cast_info _swigc__p_wxFSFile[] = {{&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};

32979

static swig_cast_info _swigc__p_wxGBSizerItem[] = {{&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};

32980

static swig_cast_info _swigc__p_wxSizerItem[] = {{&_swigt__p_wxSizerItem, 0, 0, 0},{0, 0, 0, 0}};

32981

static swig_cast_info _swigc__p_wxPrintDialog[] = {{&_swigt__p_wxPrintDialog, 0, 0, 0},{0, 0, 0, 0}};

32982

static swig_cast_info _swigc__p_wxPageSetupDialog[] = {{&_swigt__p_wxPageSetupDialog, 0, 0, 0},{0, 0, 0, 0}};

32983

static swig_cast_info _swigc__p_wxTGAHandler[] = {{&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};

32984

static swig_cast_info _swigc__p_wxTIFFHandler[] = {{&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};

32985

static swig_cast_info _swigc__p_wxXPMHandler[] = {{&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};

32986

static swig_cast_info _swigc__p_wxImageHandler[] = {{&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};

32987

static swig_cast_info _swigc__p_wxPyImageHandler[] = {{&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};

32988

static swig_cast_info _swigc__p_wxBMPHandler[] = {{&_swigt__p_wxBMPHandler, 0, 0, 0},{0, 0, 0, 0}};

32989

static swig_cast_info _swigc__p_wxICOHandler[] = {{&_swigt__p_wxICOHandler, 0, 0, 0},{0, 0, 0, 0}};

32990

static swig_cast_info _swigc__p_wxCURHandler[] = {{&_swigt__p_wxCURHandler, 0, 0, 0},{0, 0, 0, 0}};

32991

static swig_cast_info _swigc__p_wxANIHandler[] = {{&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};

32992

static swig_cast_info _swigc__p_wxPNGHandler[] = {{&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};

32993

static swig_cast_info _swigc__p_wxGIFHandler[] = {{&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};

32994

static swig_cast_info _swigc__p_wxPCXHandler[] = {{&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};

32995

static swig_cast_info _swigc__p_wxJPEGHandler[] = {{&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};

32996

static swig_cast_info _swigc__p_wxPNMHandler[] = {{&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};

32997

static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextPlainText, _p_wxRichTextPlainTextTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindDialogEvent, _p_wxFindDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutAlgorithm, _p_wxLayoutAlgorithmTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyTaskBarIcon, _p_wxPyTaskBarIconTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextBuffer, _p_wxRichTextBufferTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextParagraph, _p_wxRichTextParagraphTo_p_wxObject, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceData, _p_wxFindReplaceDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_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_wxRichTextPrinting, _p_wxRichTextPrintingTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialogData, _p_wxPageSetupDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialogData, _p_wxPrintDialogDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrinter, _p_wxPrinterTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxRichTextObject, _p_wxRichTextObjectTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourData, _p_wxColourDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCalculateLayoutEvent, _p_wxCalculateLayoutEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextPrintout, _p_wxRichTextPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintout, _p_wxPyPrintoutTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextCompositeObject, _p_wxRichTextCompositeObjectTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashEvent, _p_wxSashEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontData, _p_wxFontDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintData, _p_wxPrintDataTo_p_wxObject, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryLayoutInfoEvent, _p_wxQueryLayoutInfoEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintPreview, _p_wxPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPrintPreview, _p_wxPyPrintPreviewTo_p_wxObject, 0, 0}, {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_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_wxRichTextEvent, _p_wxRichTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterEvent, _p_wxSplitterEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextCtrl, _p_wxRichTextCtrlTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxPrintDialog, _p_wxPrintDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPageSetupDialog, _p_wxPageSetupDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextImage, _p_wxRichTextImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextHTMLHandler, _p_wxRichTextHTMLHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextPlainTextHandler, _p_wxRichTextPlainTextHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextFileHandler, _p_wxRichTextFileHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvtHandler, _p_wxPyEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_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_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextXMLHandler, _p_wxRichTextXMLHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextBox, _p_wxRichTextBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextRenderer, _p_wxRichTextRendererTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextStdRenderer, _p_wxRichTextStdRendererTo_p_wxObject, 0, 0}, {&_swigt__p_wxRichTextParagraphLayoutBox, _p_wxRichTextParagraphLayoutBoxTo_p_wxObject, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxTaskBarIconEvent, _p_wxTaskBarIconEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0},{0, 0, 0, 0}};

32998

static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};

32999

static swig_cast_info _swigc__p_wxPageSetupData[] = { {&_swigt__p_wxPageSetupData, 0, 0, 0},{0, 0, 0, 0}};

33000

static swig_cast_info _swigc__p_wxPageSetupDialogData[] = { {&_swigt__p_wxPageSetupDialogData, 0, 0, 0},{0, 0, 0, 0}};

33001

static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};

33002

static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};

33003

static swig_cast_info _swigc__p_wxPrintData[] = { {&_swigt__p_wxPrintData, 0, 0, 0},{0, 0, 0, 0}};

33004

static swig_cast_info _swigc__p_wxPyPrintout[] = { {&_swigt__p_wxPyPrintout, 0, 0, 0}, {&_swigt__p_wxRichTextPrintout, _p_wxRichTextPrintoutTo_p_wxPyPrintout, 0, 0},{0, 0, 0, 0}};

33005

static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};

33006

static swig_cast_info _swigc__p_wxRichTextAction[] = { {&_swigt__p_wxRichTextAction, 0, 0, 0},{0, 0, 0, 0}};

33007

static swig_cast_info _swigc__p_wxRichTextAttr[] = { {&_swigt__p_wxRichTextAttr, 0, 0, 0},{0, 0, 0, 0}};

33008

static swig_cast_info _swigc__p_wxRichTextBox[] = { {&_swigt__p_wxRichTextBox, 0, 0, 0}, {&_swigt__p_wxRichTextParagraphLayoutBox, _p_wxRichTextParagraphLayoutBoxTo_p_wxRichTextBox, 0, 0}, {&_swigt__p_wxRichTextBuffer, _p_wxRichTextBufferTo_p_wxRichTextBox, 0, 0}, {&_swigt__p_wxRichTextParagraph, _p_wxRichTextParagraphTo_p_wxRichTextBox, 0, 0},{0, 0, 0, 0}};

33009

static swig_cast_info _swigc__p_wxRichTextBuffer[] = { {&_swigt__p_wxRichTextBuffer, 0, 0, 0},{0, 0, 0, 0}};

33010

static swig_cast_info _swigc__p_wxRichTextCommand[] = { {&_swigt__p_wxRichTextCommand, 0, 0, 0},{0, 0, 0, 0}};

33011

static swig_cast_info _swigc__p_wxRichTextCompositeObject[] = { {&_swigt__p_wxRichTextBox, _p_wxRichTextBoxTo_p_wxRichTextCompositeObject, 0, 0}, {&_swigt__p_wxRichTextParagraphLayoutBox, _p_wxRichTextParagraphLayoutBoxTo_p_wxRichTextCompositeObject, 0, 0}, {&_swigt__p_wxRichTextBuffer, _p_wxRichTextBufferTo_p_wxRichTextCompositeObject, 0, 0}, {&_swigt__p_wxRichTextParagraph, _p_wxRichTextParagraphTo_p_wxRichTextCompositeObject, 0, 0}, {&_swigt__p_wxRichTextCompositeObject, 0, 0, 0},{0, 0, 0, 0}};

33012

static swig_cast_info _swigc__p_wxRichTextCtrl[] = { {&_swigt__p_wxRichTextCtrl, 0, 0, 0},{0, 0, 0, 0}};

33013

static swig_cast_info _swigc__p_wxRichTextEvent[] = { {&_swigt__p_wxRichTextEvent, 0, 0, 0},{0, 0, 0, 0}};

33014

static swig_cast_info _swigc__p_wxRichTextFileHandler[] = { {&_swigt__p_wxRichTextFileHandler, 0, 0, 0}, {&_swigt__p_wxRichTextPlainTextHandler, _p_wxRichTextPlainTextHandlerTo_p_wxRichTextFileHandler, 0, 0}, {&_swigt__p_wxRichTextHTMLHandler, _p_wxRichTextHTMLHandlerTo_p_wxRichTextFileHandler, 0, 0}, {&_swigt__p_wxRichTextXMLHandler, _p_wxRichTextXMLHandlerTo_p_wxRichTextFileHandler, 0, 0},{0, 0, 0, 0}};

33015

static swig_cast_info _swigc__p_wxRichTextFileHandlerList[] = { {&_swigt__p_wxRichTextFileHandlerList, 0, 0, 0},{0, 0, 0, 0}};

33016

static swig_cast_info _swigc__p_wxRichTextFileHandlerList_iterator[] = { {&_swigt__p_wxRichTextFileHandlerList_iterator, 0, 0, 0},{0, 0, 0, 0}};

33017

static swig_cast_info _swigc__p_wxRichTextHTMLHandler[] = { {&_swigt__p_wxRichTextHTMLHandler, 0, 0, 0},{0, 0, 0, 0}};

33018

static swig_cast_info _swigc__p_wxRichTextHeaderFooterData[] = { {&_swigt__p_wxRichTextHeaderFooterData, 0, 0, 0},{0, 0, 0, 0}};

33019

static swig_cast_info _swigc__p_wxRichTextImage[] = { {&_swigt__p_wxRichTextImage, 0, 0, 0},{0, 0, 0, 0}};

33020

static swig_cast_info _swigc__p_wxRichTextImageBlock[] = { {&_swigt__p_wxRichTextImageBlock, 0, 0, 0},{0, 0, 0, 0}};

33021

static swig_cast_info _swigc__p_wxRichTextLine[] = { {&_swigt__p_wxRichTextLine, 0, 0, 0},{0, 0, 0, 0}};

33022

static swig_cast_info _swigc__p_wxRichTextLineList[] = { {&_swigt__p_wxRichTextLineList, 0, 0, 0},{0, 0, 0, 0}};

33023

static swig_cast_info _swigc__p_wxRichTextListStyleDefinition[] = { {&_swigt__p_wxRichTextListStyleDefinition, 0, 0, 0},{0, 0, 0, 0}};

33024

static swig_cast_info _swigc__p_wxRichTextObject[] = { {&_swigt__p_wxRichTextBox, _p_wxRichTextBoxTo_p_wxRichTextObject, 0, 0}, {&_swigt__p_wxRichTextParagraphLayoutBox, _p_wxRichTextParagraphLayoutBoxTo_p_wxRichTextObject, 0, 0}, {&_swigt__p_wxRichTextBuffer, _p_wxRichTextBufferTo_p_wxRichTextObject, 0, 0}, {&_swigt__p_wxRichTextParagraph, _p_wxRichTextParagraphTo_p_wxRichTextObject, 0, 0}, {&_swigt__p_wxRichTextImage, _p_wxRichTextImageTo_p_wxRichTextObject, 0, 0}, {&_swigt__p_wxRichTextObject, 0, 0, 0}, {&_swigt__p_wxRichTextPlainText, _p_wxRichTextPlainTextTo_p_wxRichTextObject, 0, 0}, {&_swigt__p_wxRichTextCompositeObject, _p_wxRichTextCompositeObjectTo_p_wxRichTextObject, 0, 0},{0, 0, 0, 0}};

33025

static swig_cast_info _swigc__p_wxRichTextObjectList[] = { {&_swigt__p_wxRichTextObjectList, 0, 0, 0},{0, 0, 0, 0}};

33026

static swig_cast_info _swigc__p_wxRichTextObjectList_iterator[] = { {&_swigt__p_wxRichTextObjectList_iterator, 0, 0, 0},{0, 0, 0, 0}};

33027

static swig_cast_info _swigc__p_wxRichTextParagraph[] = { {&_swigt__p_wxRichTextParagraph, 0, 0, 0},{0, 0, 0, 0}};

33028

static swig_cast_info _swigc__p_wxRichTextParagraphLayoutBox[] = { {&_swigt__p_wxRichTextParagraphLayoutBox, 0, 0, 0}, {&_swigt__p_wxRichTextBuffer, _p_wxRichTextBufferTo_p_wxRichTextParagraphLayoutBox, 0, 0},{0, 0, 0, 0}};

33029

static swig_cast_info _swigc__p_wxRichTextPlainText[] = { {&_swigt__p_wxRichTextPlainText, 0, 0, 0},{0, 0, 0, 0}};

33030

static swig_cast_info _swigc__p_wxRichTextPlainTextHandler[] = { {&_swigt__p_wxRichTextPlainTextHandler, 0, 0, 0},{0, 0, 0, 0}};

33031

static swig_cast_info _swigc__p_wxRichTextPrinting[] = { {&_swigt__p_wxRichTextPrinting, 0, 0, 0},{0, 0, 0, 0}};

33032

static swig_cast_info _swigc__p_wxRichTextPrintout[] = { {&_swigt__p_wxRichTextPrintout, 0, 0, 0},{0, 0, 0, 0}};

33033

static swig_cast_info _swigc__p_wxRichTextRange[] = { {&_swigt__p_wxRichTextRange, 0, 0, 0},{0, 0, 0, 0}};

33034

static swig_cast_info _swigc__p_wxRichTextRenderer[] = { {&_swigt__p_wxRichTextRenderer, 0, 0, 0}, {&_swigt__p_wxRichTextStdRenderer, _p_wxRichTextStdRendererTo_p_wxRichTextRenderer, 0, 0},{0, 0, 0, 0}};

33035

static swig_cast_info _swigc__p_wxRichTextStdRenderer[] = { {&_swigt__p_wxRichTextStdRenderer, 0, 0, 0},{0, 0, 0, 0}};

33036

static swig_cast_info _swigc__p_wxRichTextStyleDefinition[] = { {&_swigt__p_wxRichTextStyleDefinition, 0, 0, 0},{0, 0, 0, 0}};

33037

static swig_cast_info _swigc__p_wxRichTextStyleSheet[] = { {&_swigt__p_wxRichTextStyleSheet, 0, 0, 0},{0, 0, 0, 0}};

33038

static swig_cast_info _swigc__p_wxRichTextXMLHandler[] = { {&_swigt__p_wxRichTextXMLHandler, 0, 0, 0},{0, 0, 0, 0}};

33039

static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};

33040

static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};

33041

static swig_cast_info _swigc__p_wxTextAttrEx[] = { {&_swigt__p_wxTextAttrEx, 0, 0, 0},{0, 0, 0, 0}};

33042

static swig_cast_info _swigc__p_wxTextCoord[] = { {&_swigt__p_wxTextCoord, 0, 0, 0},{0, 0, 0, 0}};

33043

static swig_cast_info _swigc__p_wxValidator[] = { {&_swigt__p_wxValidator, 0, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxValidator, 0, 0},{0, 0, 0, 0}};

33044

static swig_cast_info _swigc__p_wxWindow[] = { {&_swigt__p_wxSplashScreen, _p_wxSplashScreenTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMiniFrame, _p_wxMiniFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPanel, _p_wxPyPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFindReplaceDialog, _p_wxFindReplaceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxProgressDialog, _p_wxProgressDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMessageDialog, _p_wxMessageDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxNumberEntryDialog, _p_wxNumberEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPasswordEntryDialog, _p_wxPasswordEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTextEntryDialog, _p_wxTextEntryDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSingleChoiceDialog, _p_wxSingleChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMultiChoiceDialog, _p_wxMultiChoiceDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFileDialog, _p_wxFileDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPanel, _p_wxPanelTo_p_wxWindow, 0, 0}, {&_swigt__p_wxStatusBar, _p_wxStatusBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVScrolledWindow, _p_wxPyVScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTipWindow, _p_wxTipWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPopupTransientWindow, _p_wxPyPopupTransientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPopupWindow, _p_wxPopupWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashLayoutWindow, _p_wxSashLayoutWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxScrolledWindow, _p_wxScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxTopLevelWindow, _p_wxTopLevelWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplashScreenWindow, _p_wxSplashScreenWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSplitterWindow, _p_wxSplitterWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSashWindow, _p_wxSashWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIClientWindow, _p_wxMDIClientWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyScrolledWindow, _p_wxPyScrolledWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxWindow, 0, 0, 0}, {&_swigt__p_wxPreviewFrame, _p_wxPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewFrame, _p_wxPyPreviewFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIChildFrame, _p_wxMDIChildFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyWindow, _p_wxPyWindowTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewCanvas, _p_wxPreviewCanvasTo_p_wxWindow, 0, 0}, {&_swigt__p_wxSimpleHtmlListBox, _p_wxSimpleHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyHtmlListBox, _p_wxPyHtmlListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyVListBox, _p_wxPyVListBoxTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPreviewControlBar, _p_wxPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxPyPreviewControlBar, _p_wxPyPreviewControlBarTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFrame, _p_wxFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxFontDialog, _p_wxFontDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDirDialog, _p_wxDirDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxColourDialog, _p_wxColourDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxDialog, _p_wxDialogTo_p_wxWindow, 0, 0}, {&_swigt__p_wxMDIParentFrame, _p_wxMDIParentFrameTo_p_wxWindow, 0, 0}, {&_swigt__p_wxRichTextCtrl, _p_wxRichTextCtrlTo_p_wxWindow, 0, 0},{0, 0, 0, 0}};

33045

33046

static swig_cast_info *swig_cast_initial[] = {

33047

_swigc__p_char,

33048

_swigc__p_double,

33049

_swigc__p_form_ops_t,

33050

_swigc__p_int,

33051

_swigc__p_long,

33052

_swigc__p_p_wxRichTextBox,

33053

_swigc__p_p_wxRichTextBuffer,

33054

_swigc__p_p_wxRichTextCompositeObject,

33055

_swigc__p_p_wxRichTextImage,

33056

_swigc__p_p_wxRichTextObject,

33057

_swigc__p_p_wxRichTextParagraph,

33058

_swigc__p_p_wxRichTextParagraphLayoutBox,

33059

_swigc__p_p_wxRichTextPlainText,

33060

_swigc__p_unsigned_char,

33061

_swigc__p_unsigned_int,

33062

_swigc__p_unsigned_long,

33063

_swigc__p_wxANIHandler,

33064

_swigc__p_wxAcceleratorTable,

33065

_swigc__p_wxActivateEvent,

33066

_swigc__p_wxArrayInt,

33067

_swigc__p_wxArrayString,

33068

_swigc__p_wxBMPHandler,

33069

_swigc__p_wxBitmap,

33070

_swigc__p_wxBoxSizer,

33071

_swigc__p_wxCURHandler,

33072

_swigc__p_wxCalculateLayoutEvent,

33073

_swigc__p_wxChar,

33074

_swigc__p_wxChildFocusEvent,

33075

_swigc__p_wxClipboardTextEvent,

33076

_swigc__p_wxCloseEvent,

33077

_swigc__p_wxColour,

33078

_swigc__p_wxColourData,

33079

_swigc__p_wxColourDialog,

33080

_swigc__p_wxCommandEvent,

33081

_swigc__p_wxCommandProcessor,

33082

_swigc__p_wxContextMenuEvent,

33083

_swigc__p_wxControl,

33084

_swigc__p_wxControlWithItems,

33085

_swigc__p_wxCursor,

33086

_swigc__p_wxDC,

33087

_swigc__p_wxDateEvent,

33088

_swigc__p_wxDialog,

33089

_swigc__p_wxDirDialog,

33090

_swigc__p_wxDisplayChangedEvent,

33091

_swigc__p_wxDropFilesEvent,

33092

_swigc__p_wxDuplexMode,

33093

_swigc__p_wxEraseEvent,

33094

_swigc__p_wxEvent,

33095

_swigc__p_wxEvtHandler,

33096

_swigc__p_wxFSFile,

33097

_swigc__p_wxFileDialog,

33098

_swigc__p_wxFileSystem,

33099

_swigc__p_wxFindDialogEvent,

33100

_swigc__p_wxFindReplaceData,

33101

_swigc__p_wxFindReplaceDialog,

33102

_swigc__p_wxFlexGridSizer,

33103

_swigc__p_wxFocusEvent,

33104

_swigc__p_wxFont,

33105

_swigc__p_wxFontData,

33106

_swigc__p_wxFontDialog,

33107

_swigc__p_wxFrame,

33108

_swigc__p_wxGBSizerItem,

33109

_swigc__p_wxGIFHandler,

33110

_swigc__p_wxGridBagSizer,

33111

_swigc__p_wxGridSizer,

33112

_swigc__p_wxICOHandler,

33113

_swigc__p_wxIconizeEvent,

33114

_swigc__p_wxIdleEvent,

33115

_swigc__p_wxImage,

33116

_swigc__p_wxImageHandler,

33117

_swigc__p_wxIndividualLayoutConstraint,

33118

_swigc__p_wxInitDialogEvent,

33119

_swigc__p_wxInputStream,

33120

_swigc__p_wxJPEGHandler,

33121

_swigc__p_wxKeyEvent,

33122

_swigc__p_wxLayoutAlgorithm,

33123

_swigc__p_wxLayoutConstraints,

33124

_swigc__p_wxList,

33125

_swigc__p_wxMDIChildFrame,

33126

_swigc__p_wxMDIClientWindow,

33127

_swigc__p_wxMDIParentFrame,

33128

_swigc__p_wxMaximizeEvent,

33129

_swigc__p_wxMenu,

33130

_swigc__p_wxMenuBar,

33131

_swigc__p_wxMenuEvent,

33132

_swigc__p_wxMenuItem,

33133

_swigc__p_wxMessageDialog,

33134

_swigc__p_wxMiniFrame,

33135

_swigc__p_wxMouseCaptureChangedEvent,

33136

_swigc__p_wxMouseCaptureLostEvent,

33137

_swigc__p_wxMouseEvent,

33138

_swigc__p_wxMoveEvent,

33139

_swigc__p_wxMultiChoiceDialog,

33140

_swigc__p_wxNavigationKeyEvent,

33141

_swigc__p_wxNcPaintEvent,

33142

_swigc__p_wxNotifyEvent,

33143

_swigc__p_wxNumberEntryDialog,

33144

_swigc__p_wxObject,

33145

_swigc__p_wxOutputStream,

33146

_swigc__p_wxPCXHandler,

33147

_swigc__p_wxPNGHandler,

33148

_swigc__p_wxPNMHandler,

33149

_swigc__p_wxPageSetupData,

33150

_swigc__p_wxPageSetupDialog,

33151

_swigc__p_wxPageSetupDialogData,

33152

_swigc__p_wxPaintEvent,

33153

_swigc__p_wxPaletteChangedEvent,

33154

_swigc__p_wxPanel,

33155

_swigc__p_wxPaperSize,

33156

_swigc__p_wxPasswordEntryDialog,

33157

_swigc__p_wxPoint,

33158

_swigc__p_wxPopupWindow,

33159

_swigc__p_wxPreviewCanvas,

33160

_swigc__p_wxPreviewControlBar,

33161

_swigc__p_wxPreviewFrame,

33162

_swigc__p_wxPrintData,

33163

_swigc__p_wxPrintDialog,

33164

_swigc__p_wxPrintDialogData,

33165

_swigc__p_wxPrintPreview,

33166

_swigc__p_wxPrinter,

33167

_swigc__p_wxProgressDialog,

33168

_swigc__p_wxPyApp,

33169

_swigc__p_wxPyCommandEvent,

33170

_swigc__p_wxPyEvent,

33171

_swigc__p_wxPyEvtHandler,

33172

_swigc__p_wxPyHtmlListBox,

33173

_swigc__p_wxPyImageHandler,

33174

_swigc__p_wxPyPanel,

33175

_swigc__p_wxPyPopupTransientWindow,

33176

_swigc__p_wxPyPreviewControlBar,

33177

_swigc__p_wxPyPreviewFrame,

33178

_swigc__p_wxPyPrintPreview,

33179

_swigc__p_wxPyPrintout,

33180

_swigc__p_wxPyScrolledWindow,

33181

_swigc__p_wxPySizer,

33182

_swigc__p_wxPyTaskBarIcon,

33183

_swigc__p_wxPyVListBox,

33184

_swigc__p_wxPyVScrolledWindow,

33185

_swigc__p_wxPyValidator,

33186

_swigc__p_wxPyWindow,

33187

_swigc__p_wxQueryLayoutInfoEvent,

33188

_swigc__p_wxQueryNewPaletteEvent,

33189

_swigc__p_wxRect,

33190

_swigc__p_wxRichTextAction,

33191

_swigc__p_wxRichTextAttr,

33192

_swigc__p_wxRichTextBox,

33193

_swigc__p_wxRichTextBuffer,

33194

_swigc__p_wxRichTextCommand,

33195

_swigc__p_wxRichTextCompositeObject,

33196

_swigc__p_wxRichTextCtrl,

33197

_swigc__p_wxRichTextEvent,

33198

_swigc__p_wxRichTextFileHandler,

33199

_swigc__p_wxRichTextFileHandlerList,

33200

_swigc__p_wxRichTextFileHandlerList_iterator,

33201

_swigc__p_wxRichTextHTMLHandler,

33202

_swigc__p_wxRichTextHeaderFooterData,

33203

_swigc__p_wxRichTextImage,

33204

_swigc__p_wxRichTextImageBlock,

33205

_swigc__p_wxRichTextLine,

33206

_swigc__p_wxRichTextLineList,

33207

_swigc__p_wxRichTextListStyleDefinition,

33208

_swigc__p_wxRichTextObject,

33209

_swigc__p_wxRichTextObjectList,

33210

_swigc__p_wxRichTextObjectList_iterator,

33211

_swigc__p_wxRichTextParagraph,

33212

_swigc__p_wxRichTextParagraphLayoutBox,

33213

_swigc__p_wxRichTextPlainText,

33214

_swigc__p_wxRichTextPlainTextHandler,

33215

_swigc__p_wxRichTextPrinting,

33216

_swigc__p_wxRichTextPrintout,

33217

_swigc__p_wxRichTextRange,

33218

_swigc__p_wxRichTextRenderer,

33219

_swigc__p_wxRichTextStdRenderer,

33220

_swigc__p_wxRichTextStyleDefinition,

33221

_swigc__p_wxRichTextStyleSheet,

33222

_swigc__p_wxRichTextXMLHandler,

33223

_swigc__p_wxSashEvent,

33224

_swigc__p_wxSashLayoutWindow,

33225

_swigc__p_wxSashWindow,

33226

_swigc__p_wxScrollEvent,

33227

_swigc__p_wxScrollWinEvent,

33228

_swigc__p_wxScrolledWindow,

33229

_swigc__p_wxSetCursorEvent,

33230

_swigc__p_wxShowEvent,

33231

_swigc__p_wxSimpleHtmlListBox,

33232

_swigc__p_wxSingleChoiceDialog,

33233

_swigc__p_wxSize,

33234

_swigc__p_wxSizeEvent,

33235

_swigc__p_wxSizer,

33236

_swigc__p_wxSizerItem,

33237

_swigc__p_wxSplashScreen,

33238

_swigc__p_wxSplashScreenWindow,

33239

_swigc__p_wxSplitterEvent,

33240

_swigc__p_wxSplitterWindow,

33241

_swigc__p_wxStaticBoxSizer,

33242

_swigc__p_wxStatusBar,

33243

_swigc__p_wxStdDialogButtonSizer,

33244

_swigc__p_wxSysColourChangedEvent,

33245

_swigc__p_wxTGAHandler,

33246

_swigc__p_wxTIFFHandler,

33247

_swigc__p_wxTaskBarIconEvent,

33248

_swigc__p_wxTextAttrEx,

33249

_swigc__p_wxTextCoord,

33250

_swigc__p_wxTextEntryDialog,

33251

_swigc__p_wxTipWindow,

33252

_swigc__p_wxTopLevelWindow,

33253

_swigc__p_wxUpdateUIEvent,

33254

_swigc__p_wxValidator,

33255

_swigc__p_wxWindow,

33256

_swigc__p_wxWindowCreateEvent,

33257

_swigc__p_wxWindowDestroyEvent,

33258

_swigc__p_wxXPMHandler,

33259

};

33260

33261

33262

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

33263

33264

static swig_const_info swig_const_table[] = {

33265

{0, 0, 0, 0.0, 0, 0}};

33266

33267

#ifdef __cplusplus

33268

}

33269

#endif

33270

/* -----------------------------------------------------------------------------

33271

* Type initialization:

33272

* This problem is tough by the requirement that no dynamic

33273

* memory is used. Also, since swig_type_info structures store pointers to

33274

* swig_cast_info structures and swig_cast_info structures store pointers back

33275

* to swig_type_info structures, we need some lookup code at initialization.

33276

* The idea is that swig generates all the structures that are needed.

33277

* The runtime then collects these partially filled structures.

33278

* The SWIG_InitializeModule function takes these initial arrays out of

33279

* swig_module, and does all the lookup, filling in the swig_module.types

33280

* array with the correct data and linking the correct swig_cast_info

33281

* structures together.

33282

*

33283

* The generated swig_type_info structures are assigned staticly to an initial

33284

* array. We just loop though that array, and handle each type individually.

33285

* First we lookup if this type has been already loaded, and if so, use the

33286

* loaded structure instead of the generated one. Then we have to fill in the

33287

* cast linked list. The cast data is initially stored in something like a

33288

* two-dimensional array. Each row corresponds to a type (there are the same

33289

* number of rows as there are in the swig_type_initial array). Each entry in

33290

* a column is one of the swig_cast_info structures for that type.

33291

* The cast_initial array is actually an array of arrays, because each row has

33292

* a variable number of columns. So to actually build the cast linked list,

33293

* we find the array of casts associated with the type, and loop through it

33294

* adding the casts to the list. The one last trick we need to do is making

33295

* sure the type pointer in the swig_cast_info struct is correct.

33296

*

33297

* First off, we lookup the cast->type name to see if it is already loaded.

33298

* There are three cases to handle:

33299

* 1) If the cast->type has already been loaded AND the type we are adding

33300

* casting info to has not been loaded (it is in this module), THEN we

33301

* replace the cast->type pointer with the type pointer that has already

33302

* been loaded.

33303

* 2) If BOTH types (the one we are adding casting info to, and the

33304

* cast->type) are loaded, THEN the cast info has already been loaded by

33305

* the previous module so we just ignore it.

33306

* 3) Finally, if cast->type has not already been loaded, then we add that

33307

* swig_cast_info to the linked list (because the cast->type) pointer will

33308

* be correct.

33309

* ----------------------------------------------------------------------------- */

33310

33311

#ifdef __cplusplus

33312

extern "C" {

33313

#if 0

33314

} /* c-mode */

33315

#endif

33316

#endif

33317

33318

#if 0

33319

#define SWIGRUNTIME_DEBUG

33320

#endif

33321

33322

SWIGRUNTIME void

33323

SWIG_InitializeModule(void *clientdata) {

33324

size_t i;

33325

swig_module_info *module_head;

33326

static int init_run = 0;

33327

33328

clientdata = clientdata;

33329

33330

if (init_run) return;

33331

init_run = 1;

33332

33333

/* Initialize the swig_module */

33334

swig_module.type_initial = swig_type_initial;

33335

swig_module.cast_initial = swig_cast_initial;

33336

33337

/* Try and load any already created modules */

33338

module_head = SWIG_GetModule(clientdata);

33339

if (module_head) {

33340

swig_module.next = module_head->next;

33341

module_head->next = &swig_module;

33342

} else {

33343

/* This is the first module loaded */

33344

swig_module.next = &swig_module;

33345

SWIG_SetModule(clientdata, &swig_module);

33346

}

33347

33348

/* Now work on filling in swig_module.types */

33349

#ifdef SWIGRUNTIME_DEBUG

33350

printf("SWIG_InitializeModule: size %d\n", swig_module.size);

33351

#endif

33352

for (i = 0; i < swig_module.size; ++i) {

33353

swig_type_info *type = 0;

33354

swig_type_info *ret;

33355

swig_cast_info *cast;

33356

33357

#ifdef SWIGRUNTIME_DEBUG

33358

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

33359

#endif

33360

33361

/* if there is another module already loaded */

33362

if (swig_module.next != &swig_module) {

33363

type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);

33364

}

33365

if (type) {

33366

/* Overwrite clientdata field */

33367

#ifdef SWIGRUNTIME_DEBUG

33368

printf("SWIG_InitializeModule: found type %s\n", type->name);

33369

#endif

33370

if (swig_module.type_initial[i]->clientdata) {

33371

type->clientdata = swig_module.type_initial[i]->clientdata;

33372

#ifdef SWIGRUNTIME_DEBUG

33373

printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);

33374

#endif

33375

}

33376

} else {

33377

type = swig_module.type_initial[i];

33378

}

33379

33380

/* Insert casting types */

33381

cast = swig_module.cast_initial[i];

33382

while (cast->type) {

33383

/* Don't need to add information already in the list */

33384

ret = 0;

33385

#ifdef SWIGRUNTIME_DEBUG

33386

printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);

33387

#endif

33388

if (swig_module.next != &swig_module) {

33389

ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);

33390

#ifdef SWIGRUNTIME_DEBUG

33391

if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);

33392

#endif

33393

}

33394

if (ret) {

33395

if (type == swig_module.type_initial[i]) {

33396

#ifdef SWIGRUNTIME_DEBUG

33397

printf("SWIG_InitializeModule: skip old type %s\n", ret->name);

33398

#endif

33399

cast->type = ret;

33400

ret = 0;

33401

} else {

33402

/* Check for casting already in the list */

33403

swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);

33404

#ifdef SWIGRUNTIME_DEBUG

33405

if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);

33406

#endif

33407

if (!ocast) ret = 0;

33408

}

33409

}

33410

33411

if (!ret) {

33412

#ifdef SWIGRUNTIME_DEBUG

33413

printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);

33414

#endif

33415

if (type->cast) {

33416

type->cast->prev = cast;

33417

cast->next = type->cast;

33418

}

33419

type->cast = cast;

33420

}

33421

cast++;

33422

}

33423

/* Set entry in modules->types array equal to the type */

33424

swig_module.types[i] = type;

33425

}

33426

swig_module.types[i] = 0;

33427

33428

#ifdef SWIGRUNTIME_DEBUG

33429

printf("**** SWIG_InitializeModule: Cast List ******\n");

33430

for (i = 0; i < swig_module.size; ++i) {

33431

int j = 0;

33432

swig_cast_info *cast = swig_module.cast_initial[i];

33433

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

33434

while (cast->type) {

33435

printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);

33436

cast++;

33437

++j;

33438

}

33439

printf("---- Total casts: %d\n",j);

33440

}

33441

printf("**** SWIG_InitializeModule: Cast List ******\n");

33442

#endif

33443

}

33444

33445

/* This function will propagate the clientdata field of type to

33446

* any new swig_type_info structures that have been added into the list

33447

* of equivalent types. It is like calling

33448

* SWIG_TypeClientData(type, clientdata) a second time.

33449

*/

33450

SWIGRUNTIME void

33451

SWIG_PropagateClientData(void) {

33452

size_t i;

33453

swig_cast_info *equiv;

33454

static int init_run = 0;

33455

33456

if (init_run) return;

33457

init_run = 1;

33458

33459

for (i = 0; i < swig_module.size; i++) {

33460

if (swig_module.types[i]->clientdata) {

33461

equiv = swig_module.types[i]->cast;

33462

while (equiv) {

33463

if (!equiv->converter) {

33464

if (equiv->type && !equiv->type->clientdata)

33465

SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);

33466

}

33467

equiv = equiv->next;

33468

}

33469

}

33470

}

33471

}

33472

33473

#ifdef __cplusplus

33474

#if 0

33475

{

33476

/* c-mode */

33477

#endif

33478

}

33479

#endif

33480

33481

33482

33483

#ifdef __cplusplus

33484

extern "C" {

33485

#endif

33486

33487

/* Python-specific SWIG API */

33488

#define SWIG_newvarlink() SWIG_Python_newvarlink()

33489

#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)

33490

#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)

33491

33492

/* -----------------------------------------------------------------------------

33493

* global variable support code.

33494

* ----------------------------------------------------------------------------- */

33495

33496

typedef struct swig_globalvar {

33497

char *name; /* Name of global variable */

33498

PyObject *(*get_attr)(void); /* Return the current value */

33499

int (*set_attr)(PyObject *); /* Set the value */

33500

struct swig_globalvar *next;

33501

} swig_globalvar;

33502

33503

typedef struct swig_varlinkobject {

33504

PyObject_HEAD

33505

swig_globalvar *vars;

33506

} swig_varlinkobject;

33507

33508

SWIGINTERN PyObject *

33509

swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {

33510

return PyString_FromString("<Swig global variables>");

33511

}

33512

33513

SWIGINTERN PyObject *

33514

swig_varlink_str(swig_varlinkobject *v) {

33515

PyObject *str = PyString_FromString("(");

33516

swig_globalvar *var;

33517

for (var = v->vars; var; var=var->next) {

33518

PyString_ConcatAndDel(&str,PyString_FromString(var->name));

33519

if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));

33520

}

33521

PyString_ConcatAndDel(&str,PyString_FromString(")"));

33522

return str;

33523

}

33524

33525

SWIGINTERN int

33526

swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {

33527

PyObject *str = swig_varlink_str(v);

33528

fprintf(fp,"Swig global variables ");

33529

fprintf(fp,"%s\n", PyString_AsString(str));

33530

Py_DECREF(str);

33531

return 0;

33532

}

33533

33534

SWIGINTERN void

33535

swig_varlink_dealloc(swig_varlinkobject *v) {

33536

swig_globalvar *var = v->vars;

33537

while (var) {

33538

swig_globalvar *n = var->next;

33539

free(var->name);

33540

free(var);

33541

var = n;

33542

}

33543

}

33544

33545

SWIGINTERN PyObject *

33546

swig_varlink_getattr(swig_varlinkobject *v, char *n) {

33547

PyObject *res = NULL;

33548

swig_globalvar *var = v->vars;

33549

while (var) {

33550

if (strcmp(var->name,n) == 0) {

33551

res = (*var->get_attr)();

33552

break;

33553

}

33554

var = var->next;

33555

}

33556

if (res == NULL && !PyErr_Occurred()) {

33557

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

33558

}

33559

return res;

33560

}

33561

33562

SWIGINTERN int

33563

swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {

33564

int res = 1;

33565

swig_globalvar *var = v->vars;

33566

while (var) {

33567

if (strcmp(var->name,n) == 0) {

33568

res = (*var->set_attr)(p);

33569

break;

33570

}

33571

var = var->next;

33572

}

33573

if (res == 1 && !PyErr_Occurred()) {

33574

PyErr_SetString(PyExc_NameError,"Unknown C global variable");

33575

}

33576

return res;

33577

}

33578

33579

SWIGINTERN PyTypeObject*

33580

swig_varlink_type(void) {

33581

static char varlink__doc__[] = "Swig var link object";

33582

static PyTypeObject varlink_type;

33583

static int type_init = 0;

33584

if (!type_init) {

33585

const PyTypeObject tmp

33586

= {

33587

PyObject_HEAD_INIT(NULL)

33588

0, /* Number of items in variable part (ob_size) */

33589

(char *)"swigvarlink", /* Type name (tp_name) */

33590

sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */

33591

0, /* Itemsize (tp_itemsize) */

33592

(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */

33593

(printfunc) swig_varlink_print, /* Print (tp_print) */

33594

(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */

33595

(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */

33596

0, /* tp_compare */

33597

(reprfunc) swig_varlink_repr, /* tp_repr */

33598

0, /* tp_as_number */

33599

0, /* tp_as_sequence */

33600

0, /* tp_as_mapping */

33601

0, /* tp_hash */

33602

0, /* tp_call */

33603

(reprfunc)swig_varlink_str, /* tp_str */

33604

0, /* tp_getattro */

33605

0, /* tp_setattro */

33606

0, /* tp_as_buffer */

33607

0, /* tp_flags */

33608

varlink__doc__, /* tp_doc */

33609

0, /* tp_traverse */

33610

0, /* tp_clear */

33611

0, /* tp_richcompare */

33612

0, /* tp_weaklistoffset */

33613

#if PY_VERSION_HEX >= 0x02020000

33614

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */

33615

#endif

33616

#if PY_VERSION_HEX >= 0x02030000

33617

0, /* tp_del */

33618

#endif

33619

#ifdef COUNT_ALLOCS

33620

0,0,0,0 /* tp_alloc -> tp_next */

33621

#endif

33622

};

33623

varlink_type = tmp;

33624

varlink_type.ob_type = &PyType_Type;

33625

type_init = 1;

33626

}

33627

return &varlink_type;

33628

}

33629

33630

/* Create a variable linking object for use later */

33631

SWIGINTERN PyObject *

33632

SWIG_Python_newvarlink(void) {

33633

swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());

33634

if (result) {

33635

result->vars = 0;

33636

}

33637

return ((PyObject*) result);

33638

}

33639

33640

SWIGINTERN void

33641

SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {

33642

swig_varlinkobject *v = (swig_varlinkobject *) p;

33643

swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));

33644

if (gv) {

33645

size_t size = strlen(name)+1;

33646

gv->name = (char *)malloc(size);

33647

if (gv->name) {

33648

strncpy(gv->name,name,size);

33649

gv->get_attr = get_attr;

33650

gv->set_attr = set_attr;

33651

gv->next = v->vars;

33652

}

33653

}

33654

v->vars = gv;

33655

}

33656

33657

SWIGINTERN PyObject *

33658

SWIG_globals() {

33659

static PyObject *_SWIG_globals = 0;

33660

if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();

33661

return _SWIG_globals;

33662

}

33663

33664

/* -----------------------------------------------------------------------------

33665

* constants/methods manipulation

33666

* ----------------------------------------------------------------------------- */

33667

33668

/* Install Constants */

33669

SWIGINTERN void

33670

SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {

33671

PyObject *obj = 0;

33672

size_t i;

33673

for (i = 0; constants[i].type; ++i) {

33674

switch(constants[i].type) {

33675

case SWIG_PY_POINTER:

33676

obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);

33677

break;

33678

case SWIG_PY_BINARY:

33679

obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));

33680

break;

33681

default:

33682

obj = 0;

33683

break;

33684

}

33685

if (obj) {

33686

PyDict_SetItemString(d, constants[i].name, obj);

33687

Py_DECREF(obj);

33688

}

33689

}

33690

}

33691

33692

/* -----------------------------------------------------------------------------*/

33693

/* Fix SwigMethods to carry the callback ptrs when needed */

33694

/* -----------------------------------------------------------------------------*/

33695

33696

SWIGINTERN void

33697

SWIG_Python_FixMethods(PyMethodDef *methods,

33698

swig_const_info *const_table,

33699

swig_type_info **types,

33700

swig_type_info **types_initial) {

33701

size_t i;

33702

for (i = 0; methods[i].ml_name; ++i) {

33703

const char *c = methods[i].ml_doc;

33704

if (c && (c = strstr(c, "swig_ptr: "))) {

33705

int j;

33706

swig_const_info *ci = 0;

33707

const char *name = c + 10;

33708

for (j = 0; const_table[j].type; ++j) {

33709

if (strncmp(const_table[j].name, name,

33710

strlen(const_table[j].name)) == 0) {

33711

ci = &(const_table[j]);

33712

break;

33713

}

33714

}

33715

if (ci) {

33716

size_t shift = (ci->ptype) - types;

33717

swig_type_info *ty = types_initial[shift];

33718

size_t ldoc = (c - methods[i].ml_doc);

33719

size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;

33720

char *ndoc = (char*)malloc(ldoc + lptr + 10);

33721

if (ndoc) {

33722

char *buff = ndoc;

33723

void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;

33724

if (ptr) {

33725

strncpy(buff, methods[i].ml_doc, ldoc);

33726

buff += ldoc;

33727

strncpy(buff, "swig_ptr: ", 10);

33728

buff += 10;

33729

SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);

33730

methods[i].ml_doc = ndoc;

33731

}

33732

}

33733

}

33734

}

33735

}

33736

}

33737

33738

#ifdef __cplusplus

33739

}

33740

#endif

33741

33742

/* -----------------------------------------------------------------------------*

33743

* Partial Init method

33744

* -----------------------------------------------------------------------------*/

33745

33746

#ifdef __cplusplus

33747

extern "C"

33748

#endif

33749

SWIGEXPORT void SWIG_init(void) {

33750

PyObject *m, *d;

33751

33752

/* Fix SwigMethods to carry the callback ptrs when needed */

33753

SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);

33754

33755

m = Py_InitModule((char *) SWIG_name, SwigMethods);

33756

d = PyModule_GetDict(m);

33757

33758

SWIG_InitializeModule(0);

33759

SWIG_InstallConstants(d,swig_const_table);

33760

33761

33762

SWIG_Python_SetConstant(d, "USE_TEXTATTREX",SWIG_From_int(static_cast< int >(0)));

33763

SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_DEFAULT",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_DEFAULT)));

33764

SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_LEFT",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_LEFT)));

33765

SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_CENTRE",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_CENTRE)));

33766

SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_CENTER",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_CENTER)));

33767

SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_RIGHT",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_RIGHT)));

33768

SWIG_Python_SetConstant(d, "TEXT_ALIGNMENT_JUSTIFIED",SWIG_From_int(static_cast< int >(wxTEXT_ALIGNMENT_JUSTIFIED)));

33769

SWIG_Python_SetConstant(d, "RICHTEXT_TYPE_ANY",SWIG_From_int(static_cast< int >(wxRICHTEXT_TYPE_ANY)));

33770

SWIG_Python_SetConstant(d, "RICHTEXT_TYPE_TEXT",SWIG_From_int(static_cast< int >(wxRICHTEXT_TYPE_TEXT)));

33771

SWIG_Python_SetConstant(d, "RICHTEXT_TYPE_XML",SWIG_From_int(static_cast< int >(wxRICHTEXT_TYPE_XML)));

33772

SWIG_Python_SetConstant(d, "RICHTEXT_TYPE_HTML",SWIG_From_int(static_cast< int >(wxRICHTEXT_TYPE_HTML)));

33773

SWIG_Python_SetConstant(d, "RICHTEXT_TYPE_RTF",SWIG_From_int(static_cast< int >(wxRICHTEXT_TYPE_RTF)));

33774

SWIG_Python_SetConstant(d, "RICHTEXT_TYPE_PDF",SWIG_From_int(static_cast< int >(wxRICHTEXT_TYPE_PDF)));

33775

SWIG_Python_SetConstant(d, "RICHTEXT_FIXED_WIDTH",SWIG_From_int(static_cast< int >(wxRICHTEXT_FIXED_WIDTH)));

33776

SWIG_Python_SetConstant(d, "RICHTEXT_FIXED_HEIGHT",SWIG_From_int(static_cast< int >(wxRICHTEXT_FIXED_HEIGHT)));

33777

SWIG_Python_SetConstant(d, "RICHTEXT_VARIABLE_WIDTH",SWIG_From_int(static_cast< int >(wxRICHTEXT_VARIABLE_WIDTH)));

33778

SWIG_Python_SetConstant(d, "RICHTEXT_VARIABLE_HEIGHT",SWIG_From_int(static_cast< int >(wxRICHTEXT_VARIABLE_HEIGHT)));

33779

SWIG_Python_SetConstant(d, "RICHTEXT_LAYOUT_SPECIFIED_RECT",SWIG_From_int(static_cast< int >(wxRICHTEXT_LAYOUT_SPECIFIED_RECT)));

33780

SWIG_Python_SetConstant(d, "RICHTEXT_DRAW_IGNORE_CACHE",SWIG_From_int(static_cast< int >(wxRICHTEXT_DRAW_IGNORE_CACHE)));

33781

SWIG_Python_SetConstant(d, "RICHTEXT_HITTEST_NONE",SWIG_From_int(static_cast< int >(wxRICHTEXT_HITTEST_NONE)));

33782

SWIG_Python_SetConstant(d, "RICHTEXT_HITTEST_BEFORE",SWIG_From_int(static_cast< int >(wxRICHTEXT_HITTEST_BEFORE)));

33783

SWIG_Python_SetConstant(d, "RICHTEXT_HITTEST_AFTER",SWIG_From_int(static_cast< int >(wxRICHTEXT_HITTEST_AFTER)));

33784

SWIG_Python_SetConstant(d, "RICHTEXT_HITTEST_ON",SWIG_From_int(static_cast< int >(wxRICHTEXT_HITTEST_ON)));

33785

SWIG_Python_SetConstant(d, "RICHTEXT_HITTEST_OUTSIDE",SWIG_From_int(static_cast< int >(wxRICHTEXT_HITTEST_OUTSIDE)));

33786

SWIG_Python_SetConstant(d, "RICHTEXT_FORMATTED",SWIG_From_int(static_cast< int >(wxRICHTEXT_FORMATTED)));

33787

SWIG_Python_SetConstant(d, "RICHTEXT_UNFORMATTED",SWIG_From_int(static_cast< int >(wxRICHTEXT_UNFORMATTED)));

33788

SWIG_Python_SetConstant(d, "RICHTEXT_CACHE_SIZE",SWIG_From_int(static_cast< int >(wxRICHTEXT_CACHE_SIZE)));

33789

SWIG_Python_SetConstant(d, "RICHTEXT_HEIGHT_ONLY",SWIG_From_int(static_cast< int >(wxRICHTEXT_HEIGHT_ONLY)));

33790

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_NONE",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_NONE)));

33791

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_WITH_UNDO",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_WITH_UNDO)));

33792

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_OPTIMIZE",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_OPTIMIZE)));

33793

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_PARAGRAPHS_ONLY",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_PARAGRAPHS_ONLY)));

33794

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_CHARACTERS_ONLY",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY)));

33795

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_RENUMBER",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_RENUMBER)));

33796

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_SPECIFY_LEVEL",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL)));

33797

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_RESET",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_RESET)));

33798

SWIG_Python_SetConstant(d, "RICHTEXT_SETSTYLE_REMOVE",SWIG_From_int(static_cast< int >(wxRICHTEXT_SETSTYLE_REMOVE)));

33799

SWIG_Python_SetConstant(d, "RICHTEXT_INSERT_NONE",SWIG_From_int(static_cast< int >(wxRICHTEXT_INSERT_NONE)));

33800

SWIG_Python_SetConstant(d, "RICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE",SWIG_From_int(static_cast< int >(wxRICHTEXT_INSERT_WITH_PREVIOUS_PARAGRAPH_STYLE)));

33801

SWIG_Python_SetConstant(d, "RICHTEXT_INSERT_INTERACTIVE",SWIG_From_int(static_cast< int >(wxRICHTEXT_INSERT_INTERACTIVE)));

33802

SWIG_Python_SetConstant(d, "TEXT_ATTR_TEXT_COLOUR",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_TEXT_COLOUR)));

33803

SWIG_Python_SetConstant(d, "TEXT_ATTR_BACKGROUND_COLOUR",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BACKGROUND_COLOUR)));

33804

SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_FACE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_FACE)));

33805

SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_SIZE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_SIZE)));

33806

SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_WEIGHT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_WEIGHT)));

33807

SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_ITALIC",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_ITALIC)));

33808

SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT_UNDERLINE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT_UNDERLINE)));

33809

SWIG_Python_SetConstant(d, "TEXT_ATTR_FONT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_FONT)));

33810

SWIG_Python_SetConstant(d, "TEXT_ATTR_ALIGNMENT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_ALIGNMENT)));

33811

SWIG_Python_SetConstant(d, "TEXT_ATTR_LEFT_INDENT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LEFT_INDENT)));

33812

SWIG_Python_SetConstant(d, "TEXT_ATTR_RIGHT_INDENT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_RIGHT_INDENT)));

33813

SWIG_Python_SetConstant(d, "TEXT_ATTR_TABS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_TABS)));

33814

SWIG_Python_SetConstant(d, "TEXT_ATTR_PARA_SPACING_AFTER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARA_SPACING_AFTER)));

33815

SWIG_Python_SetConstant(d, "TEXT_ATTR_PARA_SPACING_BEFORE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARA_SPACING_BEFORE)));

33816

SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING)));

33817

SWIG_Python_SetConstant(d, "TEXT_ATTR_CHARACTER_STYLE_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_CHARACTER_STYLE_NAME)));

33818

SWIG_Python_SetConstant(d, "TEXT_ATTR_PARAGRAPH_STYLE_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME)));

33819

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE)));

33820

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_NUMBER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_NUMBER)));

33821

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_TEXT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_TEXT)));

33822

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_NAME)));

33823

SWIG_Python_SetConstant(d, "TEXT_ATTR_URL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_URL)));

33824

SWIG_Python_SetConstant(d, "TEXT_ATTR_PAGE_BREAK",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PAGE_BREAK)));

33825

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECTS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECTS)));

33826

SWIG_Python_SetConstant(d, "TEXT_ATTR_OUTLINE_LEVEL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_OUTLINE_LEVEL)));

33827

SWIG_Python_SetConstant(d, "TEXT_ATTR_KEEP_FIRST_PARA_STYLE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_KEEP_FIRST_PARA_STYLE)));

33828

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_NONE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_NONE)));

33829

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ARABIC",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ARABIC)));

33830

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_LETTERS_UPPER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)));

33831

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_LETTERS_LOWER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_LETTERS_LOWER)));

33832

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ROMAN_UPPER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ROMAN_UPPER)));

33833

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ROMAN_LOWER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ROMAN_LOWER)));

33834

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_SYMBOL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_SYMBOL)));

33835

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_BITMAP",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_BITMAP)));

33836

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_PARENTHESES",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_PARENTHESES)));

33837

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_PERIOD",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_PERIOD)));

33838

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_STANDARD",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_STANDARD)));

33839

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_RIGHT_PARENTHESIS)));

33840

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_OUTLINE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_OUTLINE)));

33841

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ALIGN_LEFT)));

33842

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ALIGN_RIGHT)));

33843

SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ALIGN_CENTRE)));

33844

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_NONE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_NONE)));

33845

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_CAPITALS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_CAPITALS)));

33846

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SMALL_CAPITALS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SMALL_CAPITALS)));

33847

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_STRIKETHROUGH)));

33848

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_DOUBLE_STRIKETHROUGH)));

33849

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SHADOW",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SHADOW)));

33850

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_EMBOSS",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_EMBOSS)));

33851

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_OUTLINE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_OUTLINE)));

33852

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_ENGRAVE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_ENGRAVE)));

33853

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SUPERSCRIPT)));

33854

SWIG_Python_SetConstant(d, "TEXT_ATTR_EFFECT_SUBSCRIPT",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_EFFECT_SUBSCRIPT)));

33855

SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING_NORMAL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING_NORMAL)));

33856

SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING_HALF",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING_HALF)));

33857

SWIG_Python_SetConstant(d, "TEXT_ATTR_LINE_SPACING_TWICE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_LINE_SPACING_TWICE)));

33858

SWIG_Python_SetConstant(d, "TEXT_ATTR_CHARACTER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_CHARACTER)));

33859

SWIG_Python_SetConstant(d, "TEXT_ATTR_PARAGRAPH",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARAGRAPH)));

33860

SWIG_Python_SetConstant(d, "TEXT_ATTR_ALL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_ALL)));

33861

PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());

33862

SWIG_addvarlink(SWIG_globals(),(char*)"RICHTEXT_ALL",RICHTEXT_ALL_get, RICHTEXT_ALL_set);

33863

SWIG_addvarlink(SWIG_globals(),(char*)"RICHTEXT_NONE",RICHTEXT_NONE_get, RICHTEXT_NONE_set);

33864

SWIG_Python_SetConstant(d, "RICHTEXT_HANDLER_INCLUDE_STYLESHEET",SWIG_From_int(static_cast< int >(wxRICHTEXT_HANDLER_INCLUDE_STYLESHEET)));

33865

SWIG_Python_SetConstant(d, "RICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY",SWIG_From_int(static_cast< int >(wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_MEMORY)));

33866

SWIG_Python_SetConstant(d, "RICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES",SWIG_From_int(static_cast< int >(wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_FILES)));

33867

SWIG_Python_SetConstant(d, "RICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64",SWIG_From_int(static_cast< int >(wxRICHTEXT_HANDLER_SAVE_IMAGES_TO_BASE64)));

33868

SWIG_Python_SetConstant(d, "RICHTEXT_HANDLER_NO_HEADER_FOOTER",SWIG_From_int(static_cast< int >(wxRICHTEXT_HANDLER_NO_HEADER_FOOTER)));

33869

SWIG_Python_SetConstant(d, "RICHTEXT_HANDLER_CONVERT_FACENAMES",SWIG_From_int(static_cast< int >(wxRICHTEXT_HANDLER_CONVERT_FACENAMES)));

33870

SWIG_addvarlink(SWIG_globals(),(char*)"TextName",TextName_get, TextName_set);

33871

SWIG_addvarlink(SWIG_globals(),(char*)"TextExt",TextExt_get, TextExt_set);

33872

SWIG_Python_SetConstant(d, "RE_READONLY",SWIG_From_int(static_cast< int >(wxRE_READONLY)));

33873

SWIG_Python_SetConstant(d, "RE_MULTILINE",SWIG_From_int(static_cast< int >(wxRE_MULTILINE)));

33874

SWIG_Python_SetConstant(d, "RE_CENTER_CARET",SWIG_From_int(static_cast< int >(wxRE_CENTER_CARET)));

33875

SWIG_Python_SetConstant(d, "RE_CENTRE_CARET",SWIG_From_int(static_cast< int >(wxRE_CENTRE_CARET)));

33876

SWIG_Python_SetConstant(d, "RICHTEXT_SHIFT_DOWN",SWIG_From_int(static_cast< int >(wxRICHTEXT_SHIFT_DOWN)));

33877

SWIG_Python_SetConstant(d, "RICHTEXT_CTRL_DOWN",SWIG_From_int(static_cast< int >(wxRICHTEXT_CTRL_DOWN)));

33878

SWIG_Python_SetConstant(d, "RICHTEXT_ALT_DOWN",SWIG_From_int(static_cast< int >(wxRICHTEXT_ALT_DOWN)));

33879

SWIG_Python_SetConstant(d, "RICHTEXT_SELECTED",SWIG_From_int(static_cast< int >(wxRICHTEXT_SELECTED)));

33880

SWIG_Python_SetConstant(d, "RICHTEXT_TAGGED",SWIG_From_int(static_cast< int >(wxRICHTEXT_TAGGED)));

33881

SWIG_Python_SetConstant(d, "RICHTEXT_FOCUSSED",SWIG_From_int(static_cast< int >(wxRICHTEXT_FOCUSSED)));

33882

SWIG_Python_SetConstant(d, "RICHTEXT_IS_FOCUS",SWIG_From_int(static_cast< int >(wxRICHTEXT_IS_FOCUS)));

33883

SWIG_addvarlink(SWIG_globals(),(char*)"RichTextCtrlNameStr",RichTextCtrlNameStr_get, RichTextCtrlNameStr_set);

33884

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_LEFT_CLICK));

33885

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK));

33886

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK));

33887

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK));

33888

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_RETURN", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_RETURN));

33889

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_CHARACTER", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_CHARACTER));

33890

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_DELETE", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_DELETE));

33891

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING));

33892

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED));

33893

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING));

33894

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED));

33895

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_CONTENT_INSERTED));

33896

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_CONTENT_DELETED));

33897

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLE_CHANGED));

33898

PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_SELECTION_CHANGED));

33899

SWIG_addvarlink(SWIG_globals(),(char*)"HtmlName",HtmlName_get, HtmlName_set);

33900

SWIG_addvarlink(SWIG_globals(),(char*)"HtmlExt",HtmlExt_get, HtmlExt_set);

33901

SWIG_addvarlink(SWIG_globals(),(char*)"XmlName",XmlName_get, XmlName_set);

33902

SWIG_addvarlink(SWIG_globals(),(char*)"XmlExt",XmlExt_get, XmlExt_set);

33903

SWIG_Python_SetConstant(d, "RICHTEXT_PRINT_MAX_PAGES",SWIG_From_int(static_cast< int >(wxRICHTEXT_PRINT_MAX_PAGES)));

33904

SWIG_Python_SetConstant(d, "RICHTEXT_PAGE_ODD",SWIG_From_int(static_cast< int >(wxRICHTEXT_PAGE_ODD)));

33905

SWIG_Python_SetConstant(d, "RICHTEXT_PAGE_EVEN",SWIG_From_int(static_cast< int >(wxRICHTEXT_PAGE_EVEN)));

33906

SWIG_Python_SetConstant(d, "RICHTEXT_PAGE_ALL",SWIG_From_int(static_cast< int >(wxRICHTEXT_PAGE_ALL)));

33907

SWIG_Python_SetConstant(d, "RICHTEXT_PAGE_LEFT",SWIG_From_int(static_cast< int >(wxRICHTEXT_PAGE_LEFT)));

33908

SWIG_Python_SetConstant(d, "RICHTEXT_PAGE_CENTRE",SWIG_From_int(static_cast< int >(wxRICHTEXT_PAGE_CENTRE)));

33909

SWIG_Python_SetConstant(d, "RICHTEXT_PAGE_RIGHT",SWIG_From_int(static_cast< int >(wxRICHTEXT_PAGE_RIGHT)));

33910

33911

wxRichTextModuleInit();

33912

33913

}

33914