~ubuntu-branches/ubuntu/breezy/koffice/breezy : revision 3

kpresenter/ktextedit.h

/* This file is part of the KDE project

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Library General Public

License as published by the Free Software Foundation; either

version 2 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Library General Public License for more details.

You should have received a copy of the GNU Library General Public License

along with this library; see the file COPYING.LIB. If not, write to

the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

Boston, MA 02111-1307, USA.

#ifndef QTEXTEDIT_H

#define QTEXTEDIT_H

#include <qwidget.h>

#include <qstring.h>

#include <qlist.h>

#include <qrect.h>

#include <qfontmetrics.h>

#include <qintdict.h>

#include <qmap.h>

#include <qstringlist.h>

#include <qfont.h>

#include <qcolor.h>

#include <qsize.h>

#include <qvaluelist.h>

#include <qvaluestack.h>

#include <qdict.h>

#include <qtextstream.h>

#include <qpainter.h>

#include <limits.h>

#include <qptrdict.h>

class QPainter;

class QPaintEvent;

class QKeyEvent;

class QResizeEvent;

class QMouseEvent;

class QTimer;

class QVBox;

class QListBox;

class QFont;

class QColor;

class KTextEditDocument;

class KTextEditCommand;

class KTextEdit;

class KTextEditString;

class KTextEditCommandHistory;

class KTextEditFormat;

class KTextEditCursor;

class KTextEditParag;

class KTextEditFormatter;

class KTextEditFormat;

class KTextEditFormatCollection;

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//#define DEBUG_COLLECTION 1

class KTextEditCursor

{

public:

KTextEditCursor( KTextEditDocument *d );

KTextEditParag *parag() const;

int index() const;

void setParag( KTextEditParag *s );

void gotoLeft();

void gotoRight();

void gotoUp();

void gotoDown();

void gotoLineEnd();

void gotoLineStart();

void gotoHome();

void gotoEnd();

void gotoPageUp( KTextEdit *view );

void gotoPageDown( KTextEdit *view );

void gotoWordLeft();

void gotoWordRight();

void insert( const QString &s, bool checkNewLine );

void splitAndInsertEmtyParag( bool ind = TRUE, bool updateIds = TRUE );

bool remove();

void indent();

bool atParagStart();

bool atParagEnd();

void setIndex( int i );

void checkIndex();

100

101

private:

102

KTextEditParag *string;

103

KTextEditDocument *doc;

104

int idx, tmpIndex;

105

106

};

107

108

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

109

class KPresenterDoc;

110

class KPTextObject;

111

class KTextEditCommandHistory

112

{

113

public:

114

KTextEditCommandHistory( int s, KPresenterDoc *doc, KPTextObject *txtobj ) :

115

document(doc), kptextobject(txtobj), current( -1 ), steps( s ) { history.setAutoDelete( TRUE ); }

116

117

void addCommand( KTextEditCommand *cmd );

118

KTextEditCursor *undo( KTextEditCursor *c );

119

KTextEditCursor *redo( KTextEditCursor *c );

120

121

private:

122

QList<KTextEditCommand> history;

123

KPresenterDoc *document;

124

KPTextObject *kptextobject;

125

int current, steps;

126

127

};

128

129

class KTextEditCommand

130

{

131

public:

132

enum Commands { Invalid, Insert, Delete, Format };

133

KTextEditCommand( KTextEditDocument *d ) : doc( d ), cursor( d ) {}

134

virtual ~KTextEditCommand() {}

135

virtual Commands type() const { return Invalid; };

136

137

virtual KTextEditCursor *execute( KTextEditCursor *c ) = 0;

138

virtual KTextEditCursor *unexecute( KTextEditCursor *c ) = 0;

139

140

protected:

141

KTextEditDocument *doc;

142

KTextEditCursor cursor;

143

144

};

145

146

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

147

148

class KTextEditDeleteCommand : public KTextEditCommand

149

{

150

public:

151

KTextEditDeleteCommand( KTextEditDocument *d, int i, int idx, const QString &str )

152

: KTextEditCommand( d ), id( i ), index( idx ), text( str ) {}

153

virtual Commands type() const { return Delete; };

154

155

virtual KTextEditCursor *execute( KTextEditCursor *c );

156

virtual KTextEditCursor *unexecute( KTextEditCursor *c );

157

158

protected:

159

int id, index;

160

QString text;

161

162

};

163

164

class KTextEditInsertCommand : public KTextEditDeleteCommand

165

{

166

public:

167

KTextEditInsertCommand( KTextEditDocument *d, int i, int idx, const QString &str )

168

: KTextEditDeleteCommand( d, i, idx, str ) {}

169

Commands type() const { return Insert; };

170

171

virtual KTextEditCursor *execute( KTextEditCursor *c ) { return KTextEditDeleteCommand::unexecute( c ); }

172

virtual KTextEditCursor *unexecute( KTextEditCursor *c ) { return KTextEditDeleteCommand::execute( c ); }

173

174

};

175

176

class KTextEditFormatCommand : public KTextEditCommand

177

{

178

public:

179

KTextEditFormatCommand( KTextEditDocument *d, int selId, KTextEditFormat *f, int flags );

180

~KTextEditFormatCommand();

181

Commands type() const { return Format; }

182

183

virtual KTextEditCursor *execute( KTextEditCursor *c );

184

virtual KTextEditCursor *unexecute( KTextEditCursor *c );

185

186

protected:

187

int selection;

188

KTextEditFormat *format;

189

int flags;

190

191

};

192

193

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

194

class KTextEditDocument

195

{

196

public:

197

enum SelectionIds {

198

Standard = 0,

199

Search,

200

Temp // This selection must not be drawn, it's used e.g. by undo/redo to

201

// remove multiple lines with removeSelectedText()

202

};

203

204

static const int numSelections;

205

206

enum Bullet {

207

FilledCircle,

208

FilledSquare,

209

OutlinedCircle,

210

OutlinedSquare

211

};

212

213

KTextEditDocument( KPresenterDoc *doc, KPTextObject *txtobj );

214

215

void clear();

216

217

void setText( const QString &text );

218

QString text( KTextEditParag *p = 0 ) const;

219

220

int x() const;

221

int y() const;

222

int width() const;

223

int height() const;

224

void setWidth( int w );

225

226

KTextEditParag *firstParag() const;

227

KTextEditParag *lastParag() const;

228

void setFirstParag( KTextEditParag *p );

229

void setLastParag( KTextEditParag *p );

230

231

void invalidate();

232

233

void setFormatter( KTextEditFormatter *f );

234

KTextEditFormatter *formatter() const;

235

236

QColor selectionColor( int id ) const;

237

bool invertSelectionText( int id ) const;

238

bool hasSelection( int id ) const;

239

void setSelectionStart( int id, KTextEditCursor *cursor );

240

bool setSelectionEnd( int id, KTextEditCursor *cursor );

241

bool removeSelection( int id );

242

void selectionStart( int id, int &paragId, int &index );

243

void selectionEnd( int id, int &paragId, int &index );

244

void setFormat( int id, KTextEditFormat *f, int flags );

245

KTextEditParag *selectionStart( int id );

246

KTextEditParag *selectionEnd( int id );

247

248

QString selectedText( int id ) const;

249

void copySelectedText( int id );

250

void removeSelectedText( int id, KTextEditCursor *cursor );

251

void indentSelection( int id );

252

253

KTextEditParag *paragAt( int i ) const;

254

255

void addCommand( KTextEditCommand *cmd );

256

KTextEditCursor *undo( KTextEditCursor *c = 0 );

257

KTextEditCursor *redo( KTextEditCursor *c = 0 );

258

259

KTextEditFormatCollection *formatCollection() const;

260

261

int listIndent( int depth ) const;

262

Bullet bullet( int depth ) const;

263

QColor bulletColor( int depth ) const;

264

265

bool find( const QString &expr, bool cs, bool wo, bool forward, int *parag, int *index, KTextEditCursor *cursor );

266

267

void setParagSpacing( int s );

268

void setLineSpacing( int s );

269

void setMargin( int m );

270

int paragSpacing( KTextEditParag *p = 0 ) const;

271

int lineSpacing() const;

272

int margin() const { return marg; }

273

274

bool inSelection( int selId, const QPoint &pos ) const;

275

276

void draw( QPainter *p, const QColorGroup &cg );

277

void zoom( float f );

278

void unzoom();

279

280

void enableDrawAllInOneColor( const QColor &c ) { allColor = c; allInOne = TRUE; }

281

void disableDrawAllInOneColor() { allInOne = FALSE; }

282

283

bool drawAllInOneColor() const { return allInOne; }

284

QColor allInOneColor() const { return allColor; }

285

286

void setAlignmentToAll( int a );

287

void setFontToAll( const QFont &f );

288

void setColorToAll( const QColor &c );

289

void setBoldToAll( bool b );

290

void setItalicToAll( bool b );

291

void setUnderlineToAll( bool b );

292

void setPointSizeToAll( int s );

293

void setFamilyToAll( const QString &f );

294

295

struct TextSettings

296

{

297

TextSettings() {

298

bulletType[0] = KTextEditDocument::FilledCircle;

299

bulletType[1] = KTextEditDocument::FilledSquare;

300

bulletType[2] = KTextEditDocument::OutlinedCircle;

301

bulletType[3] = KTextEditDocument::OutlinedSquare;

302

bulletColor[0] = bulletColor[1] = bulletColor[2] = bulletColor[3] = Qt::black;

303

lineSpacing = paragSpacing = margin = 0;

304

}

305

306

KTextEditDocument::Bullet bulletType[4];

307

QColor bulletColor[4];

308

int lineSpacing, paragSpacing, margin;

309

};

310

311

TextSettings textSettings() const { return txtSettings; }

312

void setTextSettings( TextSettings s );

313

314

private:

315

struct Selection {

316

KTextEditParag *startParag, *endParag;

317

int startIndex;

318

};

319

320

int cx, cy, cw;

321

KTextEditParag *fParag, *lParag;

322

QMap<int, QColor> selectionColors;

323

QMap<int, Selection> selections;

324

QMap<int, bool> selectionText;

325

KTextEditCommandHistory *commandHistory;

326

KTextEditFormatter *pFormatter;

327

int ls, ps;

328

QColor allColor;

329

bool allInOne;

330

int listMult;

331

int oldListMult;

332

int oldLineSpacing, oldParagSpacing;

333

TextSettings txtSettings;

334

int marg;

335

KPresenterDoc *kpr_doc;

336

337

};

338

339

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

340

341

class KTextEditString

342

{

343

public:

344

struct Char {

345

public:

346

Char() : format( 0 ), lineStart( 0 ) {}

347

~Char() { format = 0; }

348

QChar c;

349

ushort x;

350

KTextEditFormat *format;

351

uint lineStart : 1;

352

private:

353

Char &operator=( const Char & ) {

354

return *this;

355

}

356

357

};

358

359

KTextEditString();

360

361

QString toString() const;

362

363

Char &at( int i ) const;

364

int length() const;

365

366

void insert( int index, const QString &s, KTextEditFormat *f );

367

void truncate( int index );

368

void remove( int index, int len );

369

370

void setFormat( int index, KTextEditFormat *f, bool useCollection );

371

372

private:

373

QArray<Char> data;

374

QString cache;

375

376

};

377

378

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

379

380

class KTextEditParag

381

{

382

public:

383

struct LineStart {

384

LineStart() : y( 0 ), baseLine( 0 ), h( 0 ) {}

385

LineStart( ushort y_, ushort bl, ushort h_ ) : y( y_ ), baseLine( bl ), h( h_ ) {}

386

ushort y, baseLine, h;

387

};

388

389

enum Type {

390

Normal = 0,

391

BulletList,

392

EnumList

393

};

394

395

KTextEditParag( KTextEditDocument *d, KTextEditParag *pr, KTextEditParag *nx, bool updateIds = TRUE );

396

virtual ~KTextEditParag() {}

397

398

Type type() const;

399

void setType( Type t );

400

401

KTextEditString *string() const;

402

KTextEditString::Char *at( int i ) const; // maybe remove later

403

int length() const; // maybe remove later

404

405

KTextEditDocument *document() const;

406

407

QRect rect() const;

408

409

KTextEditParag *prev() const;

410

KTextEditParag *next() const;

411

void setPrev( KTextEditParag *s );

412

void setNext( KTextEditParag *s );

413

414

void insert( int index, const QString &s );

415

void append( const QString &s );

416

void truncate( int index );

417

void remove( int index, int len );

418

void join( KTextEditParag *s );

419

420

void invalidate( int chr );

421

422

void move( int dy );

423

void format( int start = -1, bool doMove = TRUE );

424

425

bool isValid() const;

426

bool hasChanged() const;

427

void setChanged( bool b );

428

429

int lineHeightOfChar( int i, int *bl = 0, int *y = 0 ) const;

430

KTextEditString::Char *lineStartOfChar( int i, int *index = 0, int *line = 0 ) const;

431

int lines() const;

432

KTextEditString::Char *lineStartOfLine( int line, int *index = 0 ) const;

433

int lineY( int l ) const;

434

int lineBaseLine( int l ) const;

435

int lineHeight( int l ) const;

436

void lineInfo( int l, int &y, int &h, int &bl ) const;

437

438

void setSelection( int id, int start, int end );

439

void removeSelection( int id );

440

int selectionStart( int id ) const;

441

int selectionEnd( int id ) const;

442

bool hasSelection( int id ) const;

443

bool hasAnySelection() const;

444

bool fullSelected( int id ) const;

445

446

void setParagId( int i );

447

int paragId() const;

448

449

void indent( int *oldIndent = 0, int *newIndent = 0 );

450

451

QMap<int, LineStart*> &lineStartList();

452

453

void setFormat( int index, int len, KTextEditFormat *f, bool useCollection, int flags = -1 );

454

455

int leftIndent() const;

456

int listDepth() const;

457

void setListDepth( int d );

458

459

void setAlignment( int a );

460

int alignment() const;

461

462

virtual void paint( QPainter &painter, const QColorGroup &cg,

463

KTextEditCursor *cusror = 0, bool drawSelections = FALSE );

464

465

private:

466

void drawParagBuffer( QPainter &painter, const QString &buffer, int startX,

467

int lastY, int baseLine, int bw, int h, bool drawSelections,

468

KTextEditFormat *lastFormat, int i, int *selectionStarts,

469

int *selectionEnds, const QColorGroup &cg );

470

471

private:

472

struct Selection {

473

int start, end;

474

};

475

476

QMap<int, LineStart*> lineStarts;

477

int invalid;

478

QRect r;

479

KTextEditParag *p, *n;

480

KTextEditDocument *doc;

481

bool changed;

482

bool firstFormat;

483

QMap<int, Selection> selections;

484

int id;

485

KTextEditString *str;

486

Type typ;

487

int left;

488

int depth;

489

int align;

490

491

};

492

493

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

494

495

class KTextEditFormatter

496

{

497

public:

498

KTextEditFormatter( KTextEditDocument *d );

499

virtual ~KTextEditFormatter() {}

500

virtual int format( KTextEditParag *parag, int start ) = 0;

501

502

protected:

503

KTextEditDocument *doc;

504

505

};

506

507

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

508

509

class KTextEditFormatterBreakWords : public KTextEditFormatter

510

{

511

public:

512

KTextEditFormatterBreakWords( KTextEditDocument *d );

513

int format( KTextEditParag *parag, int start );

514

515

};

516

517

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

518

519

class KTextEditFormat

520

{

521

friend class KTextEditFormatCollection;

522

523

public:

524

enum Flags {

525

Bold = 1,

526

Italic = 2,

527

Underline = 4,

528

Family = 8,

529

Size = 16,

530

Color = 32,

531

Font = Bold | Italic | Underline | Family | Size,

532

Format = Font | Color

533

};

534

535

KTextEditFormat( const QFont &f, const QColor &c );

536

KTextEditFormat( const KTextEditFormat &fm );

537

QColor color() const;

538

QFont font() const;

539

int minLeftBearing() const;

540

int minRightBearing() const;

541

int width( const QChar &c ) const;

542

int height() const;

543

int ascent() const;

544

int descent() const;

545

546

void setBold( bool b );

547

void setItalic( bool b );

548

void setUnderline( bool b );

549

void setFamily( const QString &f );

550

void setPointSize( int s );

551

void setFont( const QFont &f );

552

void setColor( const QColor &c );

553

554

bool operator==( const KTextEditFormat &f ) const;

555

KTextEditFormatCollection *parent() const;

556

QString key() const;

557

558

static QString getKey( const QFont &f, const QColor &c );

559

560

void addRef();

561

void removeRef();

562

563

private:

564

void update();

565

void generateKey();

566

const QFontMetrics *fontMetrics() const;

567

KTextEditFormat() {}

568

569

private:

570

QFont fn;

571

QColor col;

572

QFontMetrics *fm;

573

int leftBearing, rightBearing;

574

int widths[ 256 ];

575

int hei, asc, dsc;

576

KTextEditFormatCollection *collection;

577

int ref;

578

QString k;

579

580

};

581

582

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

583

584

class KTextEditFormatCollection

585

{

586

public:

587

KTextEditFormatCollection();

588

~KTextEditFormatCollection();

589

590

591

void setDefaultFormat( KTextEditFormat *f );

592

KTextEditFormat *defaultFormat() const;

593

KTextEditFormat *format( KTextEditFormat *f );

594

KTextEditFormat *format( KTextEditFormat *of, KTextEditFormat *nf, int flags );

595

KTextEditFormat *format( const QFont &f, const QColor &c );

596

void remove( KTextEditFormat *f );

597

598

void debug();

599

600

void zoom( float f );

601

void unzoom();

602

603

private:

604

KTextEditFormat *defFormat, *lastFormat, *cachedFormat;

605

QDict<KTextEditFormat> cKey;

606

QPtrDict<int> orig;

607

KTextEditFormat *cres;

608

QFont cfont;

609

QColor ccol;

610

QString kof, knf;

611

int cflags;

612

float zoomFakt;

613

614

};

615

616

class KTextEdit : public QWidget

617

{

618

Q_OBJECT

619

620

public:

621

enum ParagType {

622

Normal = 0,

623

BulletList,

624

EnumList

625

};

626

627

KTextEdit( KPresenterDoc *doc, KPTextObject *txtobj, QWidget *parent, const QString &fn, bool tabify = FALSE );

628

KTextEdit( KPresenterDoc *doc, KPTextObject *txtobj, QWidget *parent = 0, const char *name = 0 );

629

virtual ~KTextEdit();

630

631

void clear();

632

633

KTextEditDocument *document() const;

634

635

QString text() const;

636

void setText( const QString &txt );

637

638

void cursorPosition( int &parag, int &index );

639

void selection( int &parag_from, int &index_from,

640

int &parag_to, int &index_to );

641

virtual bool find( const QString &expr, bool cs, bool wo, bool forward = TRUE,

642

int *parag = 0, int *index = 0 );

643

void insert( const QString &text, bool checkNewLine = FALSE );

644

645

int paragraphs() const;

646

int lines() const;

647

int linesOfParagraph( int parag ) const;

648

int lineOfChar( int parag, int chr );

649

650

bool isReadOnly() const;

651

bool isModified() const;

652

653

bool italic() const;

654

bool bold() const;

655

bool underline() const;

656

QString family() const;

657

int pointSize() const;

658

QColor color() const;

659

QFont font() const;

660

ParagType paragType() const;

661

int alignment() const;

662

int maxLines() const;

663

664

void zoom( float f );

665

void unzoom();

666

667

KTextEditParag *currentParagraph() { return cursor->parag(); }

668

void extendContents2Height();

669

void updateCurrentFormat();

670

671

public slots:

672

virtual void undo();

673

virtual void redo();

674

675

virtual void cut();

676

virtual void copy();

677

virtual void paste();

678

679

virtual void indent();

680

681

virtual void setItalic( bool b );

682

virtual void setBold( bool b );

683

virtual void setUnderline( bool b );

684

virtual void setFamily( const QString &f );

685

virtual void setPointSize( int s );

686

virtual void setColor( const QColor &c );

687

virtual void setFont( const QFont &f );

688

689

virtual void setParagType( ParagType t );

690

virtual void setAlignment( int );

691

virtual void setListDepth( int diff );

692

693

virtual void setCursorPosition( int parag, int index );

694

virtual void setSelection( int parag_from, int index_from,

695

int parag_to, int index_to );

696

697

virtual void setReadOnly( bool ro );

698

virtual void setModified( bool m );

699

virtual void selectAll( bool select );

700

701

virtual void setMaxLines( int l );

702

virtual void resetFormat();

703

704

QSize neededSize() const { return QSize( doc->width(), doc->lastParag()->rect().bottom() + 1 ); }

705

706

signals:

707

void currentFontChanged( const QFont &f );

708

void currentColorChanged( const QColor &c );

709

void currentAlignmentChanged( int );

710

void currentParagTypeChanged( KTextEdit::ParagType );

711

void textChanged();

712

void exitEditMode();

713

714

protected:

715

void setFormat( KTextEditFormat *f, int flags );

716

void drawContents( QPainter *p, int cx, int cy, int cw, int ch );

717

void keyPressEvent( QKeyEvent *e );

718

void resizeEvent( QResizeEvent *e );

719

void paintEvent( QPaintEvent *e );

720

void mousePressEvent( QMouseEvent *e );

721

void mouseMoveEvent( QMouseEvent *e );

722

void mouseReleaseEvent( QMouseEvent *e );

723

void mouseDoubleClickEvent( QMouseEvent *e );

724

void dragEnterEvent( QDragEnterEvent *e );

725

void dragMoveEvent( QDragMoveEvent *e );

726

void dragLeaveEvent( QDragLeaveEvent *e );

727

void dropEvent( QDropEvent *e );

728

bool event( QEvent * e );

729

bool eventFilter( QObject *o, QEvent *e );

730

bool focusNextPrevChild( bool next );

731

732

private slots:

733

void formatMore();

734

void doResize();

735

void doChangeInterval();

736

void blinkCursor();

737

void setModified();

738

void startDrag();

739

740

private:

741

enum MoveDirection {

742

MoveLeft,

743

MoveRight,

744

MoveUp,

745

MoveDown,

746

MoveHome,

747

MoveEnd,

748

MovePgUp,

749

MovePgDown

750

};

751

enum KeyboardAction {

752

ActionBackspace,

753

ActionDelete,

754

ActionReturn

755

};

756

757

struct UndoRedoInfo {

758

enum Type { Invalid, Insert, Delete, Backspace, Return, RemoveSelected };

759

UndoRedoInfo( KTextEditDocument *d ) : type( Invalid ), doc( d )

760

{ text = QString::null; id = -1; index = -1; }

761

void clear();

762

inline bool valid() const { return !text.isEmpty() && id >= 0&& index >= 0; }

763

764

QString text;

765

int id;

766

int index;

767

Type type;

768

KTextEditDocument *doc;

769

};

770

771

private:

772

QPixmap *bufferPixmap( const QSize &s );

773

void init();

774

void drawCursor( bool visible );

775

void placeCursor( const QPoint &pos, KTextEditCursor *c = 0 );

776

void moveCursor( int direction, bool shift, bool control );

777

void moveCursor( int direction, bool control );

778

void removeSelectedText();

779

void doKeyboardAction( int action );

780

void checkUndoRedoInfo( UndoRedoInfo::Type t );

781

void repaintChanged();

782

QColor getColorTextBack();

783

784

private:

785

KTextEditDocument *doc;

786

KTextEditCursor *cursor;

787

bool drawAll;

788

bool mousePressed;

789

QTimer *formatTimer, *changeIntervalTimer, *blinkTimer, *dragStartTimer;

790

KTextEditParag *lastFormatted;

791

int interval;

792

UndoRedoInfo undoRedoInfo;

793

KTextEditFormat *currentFormat;

794

QPainter painter;

795

QPixmap *doubleBuffer;

796

int currentAlignment;

797

ParagType currentParagType;

798

bool inDoubleClick;

799

QPoint oldMousePos, mousePos;

800

QPixmap *buf_pixmap;

801

bool cursorVisible, blinkCursorVisible;

802

bool readOnly, modified, mightStartDrag;

803

QPoint dragStartPos;

804

int mLines;

805

KPresenterDoc *kp_doc;

806

807

};

808

809

810

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

811

812

inline KTextEditParag *KTextEditCursor::parag() const

813

{

814

return string;

815

}

816

817

inline int KTextEditCursor::index() const

818

{

819

return idx;

820

}

821

822

inline void KTextEditCursor::setIndex( int i )

823

{

824

tmpIndex = -1;

825

idx = i;

826

}

827

828

inline void KTextEditCursor::setParag( KTextEditParag *s )

829

{

830

idx = 0;

831

string = s;

832

tmpIndex = -1;

833

}

834

835

inline void KTextEditCursor::checkIndex()

836

{

837

if ( idx >= string->length() )

838

idx = string->length() - 1;

839

}

840

841

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

842

843

inline int KTextEditDocument::x() const

844

{

845

return cx;

846

}

847

848

inline int KTextEditDocument::y() const

849

{

850

return cy + marg;

851

}

852

853

inline int KTextEditDocument::width() const

854

{

855

return cw - 2 * marg;

856

}

857

858

inline int KTextEditDocument::height() const

859

{

860

if ( !lParag )

861

return 0;

862

return lParag->rect().bottom() + 1;

863

}

864

865

inline KTextEditParag *KTextEditDocument::firstParag() const

866

{

867

return fParag;

868

}

869

870

inline KTextEditParag *KTextEditDocument::lastParag() const

871

{

872

return lParag;

873

}

874

875

inline void KTextEditDocument::setFirstParag( KTextEditParag *p )

876

{

877

fParag = p;

878

}

879

880

inline void KTextEditDocument::setLastParag( KTextEditParag *p )

881

{

882

lParag = p;

883

}

884

885

inline void KTextEditDocument::setWidth( int w )

886

{

887

cw = w;

888

}

889

890

inline void KTextEditDocument::setFormatter( KTextEditFormatter *f )

891

{

892

pFormatter = f;

893

}

894

895

inline KTextEditFormatter *KTextEditDocument::formatter() const

896

{

897

return pFormatter;

898

}

899

900

inline QColor KTextEditDocument::selectionColor( int id ) const

901

{

902

return selectionColors[ id ];

903

}

904

905

inline bool KTextEditDocument::invertSelectionText( int id ) const

906

{

907

return selectionText[ id ];

908

}

909

910

inline bool KTextEditDocument::hasSelection( int id ) const

911

{

912

return selections.find( id ) != selections.end();

913

}

914

915

inline void KTextEditDocument::setSelectionStart( int id, KTextEditCursor *cursor )

916

{

917

Selection sel;

918

sel.startParag = cursor->parag();

919

sel.endParag = cursor->parag();

920

sel.startParag->setSelection( id, cursor->index(), cursor->index() );

921

sel.startIndex = cursor->index();

922

selections[ id ] = sel;

923

}

924

925

inline KTextEditParag *KTextEditDocument::paragAt( int i ) const

926

{

927

KTextEditParag *s = fParag;

928

while ( s ) {

929

if ( s->paragId() == i )

930

return s;

931

s = s->next();

932

}

933

return 0;

934

}

935

936

inline int KTextEditDocument::listIndent( int depth ) const

937

{

938

// #######

939

return ( depth + 1 ) * listMult;

940

}

941

942

inline KTextEditDocument::Bullet KTextEditDocument::bullet( int depth ) const

943

{

944

if ( depth == 0 )

945

return txtSettings.bulletType[ 0 ];

946

else if ( depth == 1 )

947

return txtSettings.bulletType[ 1 ];

948

else if ( depth == 2 )

949

return txtSettings.bulletType[ 2 ];

950

else if ( depth == 3 )

951

return txtSettings.bulletType[ 3 ];

952

else

953

return txtSettings.bulletType[ 0 ];

954

}

955

956

inline QColor KTextEditDocument::bulletColor( int depth ) const

957

{

958

if ( depth == 0 )

959

return txtSettings.bulletColor[ 0 ];

960

else if ( depth == 1 )

961

return txtSettings.bulletColor[ 1 ];

962

else if ( depth == 2 )

963

return txtSettings.bulletColor[ 2 ];

964

else if ( depth == 3 )

965

return txtSettings.bulletColor[ 3 ];

966

else

967

return txtSettings.bulletColor[ 0 ];

968

}

969

970

inline int KTextEditDocument::paragSpacing( KTextEditParag * ) const

971

{

972

return ps;

973

}

974

975

inline int KTextEditDocument::lineSpacing() const

976

{

977

return ls;

978

}

979

980

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

981

982

inline KTextEditFormat::KTextEditFormat( const QFont &f, const QColor &c )

983

: fn( f ), col( c ), fm( new QFontMetrics( f ) ), collection( 0L )

984

{

985

leftBearing = fm->minLeftBearing();

986

rightBearing = fm->minRightBearing();

987

hei = fm->height();

988

asc = fm->ascent();

989

dsc = fm->descent();

990

for ( int i = 0; i < 256; ++i )

991

widths[ i ] = 0;

992

generateKey();

993

addRef();

994

}

995

996

inline KTextEditFormat::KTextEditFormat( const KTextEditFormat &f ) : collection( 0L )

997

{

998

//qDebug("constructing a format from another one");

999

fn = f.fn;

1000

col = f.col;

1001

fm = new QFontMetrics( fn );

1002

leftBearing = f.leftBearing;

1003

rightBearing = f.rightBearing;

1004

for ( int i = 0; i < 256; ++i )

1005

widths[ i ] = f.widths[ i ];

1006

hei = f.hei;

1007

asc = f.asc;

1008

dsc = f.dsc;

1009

generateKey();

1010

addRef();

1011

}

1012

1013

inline void KTextEditFormat::update()

1014

{

1015

*fm = QFontMetrics( fn );

1016

leftBearing = fm->minLeftBearing();

1017

rightBearing = fm->minRightBearing();

1018

hei = fm->height();

1019

asc = fm->ascent();

1020

dsc = fm->descent();

1021

for ( int i = 0; i < 256; ++i )

1022

widths[ i ] = 0;

1023

generateKey();

1024

}

1025

1026

inline const QFontMetrics *KTextEditFormat::fontMetrics() const

1027

{

1028

return fm;

1029

}

1030

1031

inline QColor KTextEditFormat::color() const

1032

{

1033

return col;

1034

}

1035

1036

inline QFont KTextEditFormat::font() const

1037

{

1038

return fn;

1039

}

1040

1041

inline int KTextEditFormat::minLeftBearing() const

1042

{

1043

return leftBearing;

1044

}

1045

1046

inline int KTextEditFormat::minRightBearing() const

1047

{

1048

return rightBearing;

1049

}

1050

1051

inline int KTextEditFormat::width( const QChar &c ) const

1052

{

1053

if ( c == '\t' )

1054

return 30;

1055

int w = 0;

1056

if ( c.unicode() < 256 )

1057

w = widths[ c.unicode() ];

1058

if ( w == 0 ) {

1059

w = fm->width( c );

1060

if ( c.unicode() < 256 )

1061

( (KTextEditFormat*)this )->widths[ c.unicode() ] = w;

1062

}

1063

return w;

1064

}

1065

1066

inline int KTextEditFormat::height() const

1067

{

1068

return hei;

1069

}

1070

1071

inline int KTextEditFormat::ascent() const

1072

{

1073

return asc;

1074

}

1075

1076

inline int KTextEditFormat::descent() const

1077

{

1078

return dsc;

1079

}

1080

1081

inline bool KTextEditFormat::operator==( const KTextEditFormat &f ) const

1082

{

1083

return k == f.k;

1084

}

1085

1086

inline KTextEditFormatCollection *KTextEditFormat::parent() const

1087

{

1088

return collection;

1089

}

1090

1091

inline void KTextEditFormat::addRef()

1092

{

1093

ref++;

1094

#ifdef DEBUG_COLLECTION

1095

qDebug( "add ref of '%s' to %d (%p)", k.latin1(), ref, this );

1096

#endif

1097

}

1098

1099

inline void KTextEditFormat::removeRef()

1100

{

1101

ref--;

1102

if ( !collection )

1103

return;

1104

#ifdef DEBUG_COLLECTION

1105

qDebug( "remove ref of '%s' to %d (%p)", k.latin1(), ref, this );

1106

#endif

1107

if ( ref == 0 )

1108

collection->remove( this );

1109

}

1110

1111

inline QString KTextEditFormat::key() const

1112

{

1113

return k;

1114

}

1115

1116

inline void KTextEditFormat::generateKey()

1117

{

1118

QTextOStream ts( &k );

1119

ts << fn.pointSize()

1120

<< fn.weight()

1121

<< (int)fn.underline()

1122

<< (int)fn.italic()

1123

<< col.rgb()

1124

<< fn.family();

1125

}

1126

1127

inline QString KTextEditFormat::getKey( const QFont &fn, const QColor &col )

1128

{

1129

QString k;

1130

QTextOStream ts( &k );

1131

ts << fn.pointSize()

1132

<< fn.weight()

1133

<< (int)fn.underline()

1134

<< (int)fn.italic()

1135

<< col.rgb()

1136

<< fn.family();

1137

return k;

1138

}

1139

1140

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1141

1142

inline KTextEditString::Char &KTextEditString::at( int i ) const

1143

{

1144

return data[ i ];

1145

}

1146

1147

inline QString KTextEditString::toString() const

1148

{

1149

return cache;

1150

}

1151

1152

inline int KTextEditString::length() const

1153

{

1154

return data.size();

1155

}

1156

1157

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1158

1159

inline KTextEditString::Char *KTextEditParag::at( int i ) const

1160

{

1161

return &str->at( i );

1162

}

1163

1164

inline int KTextEditParag::length() const

1165

{

1166

return str->length();

1167

}

1168

1169

inline bool KTextEditParag::isValid() const

1170

{

1171

return invalid == -1;

1172

}

1173

1174

inline bool KTextEditParag::hasChanged() const

1175

{

1176

return changed;

1177

}

1178

1179

inline void KTextEditParag::setChanged( bool b )

1180

{

1181

changed = b;

1182

}

1183

1184

inline void KTextEditParag::append( const QString &s )

1185

{

1186

insert( str->length(), s );

1187

}

1188

1189

inline QRect KTextEditParag::rect() const

1190

{

1191

return r;

1192

}

1193

1194

inline KTextEditParag *KTextEditParag::prev() const

1195

{

1196

return p;

1197

}

1198

1199

inline KTextEditParag *KTextEditParag::next() const

1200

{

1201

return n;

1202

}

1203

1204

inline void KTextEditParag::setSelection( int id, int start, int end )

1205

{

1206

QMap<int, Selection>::ConstIterator it = selections.find( id );

1207

if ( it != selections.end() ) {

1208

if ( start == ( *it ).start && end == ( *it ).end )

1209

return;

1210

}

1211

1212

Selection sel;

1213

sel.start = start;

1214

sel.end = end;

1215

selections[ id ] = sel;

1216

changed = TRUE;

1217

}

1218

1219

inline void KTextEditParag::removeSelection( int id )

1220

{

1221

selections.remove( id );

1222

changed = TRUE;

1223

}

1224

1225

inline int KTextEditParag::selectionStart( int id ) const

1226

{

1227

QMap<int, Selection>::ConstIterator it = selections.find( id );

1228

if ( it == selections.end() )

1229

return -1;

1230

return ( *it ).start;

1231

}

1232

1233

inline int KTextEditParag::selectionEnd( int id ) const

1234

{

1235

QMap<int, Selection>::ConstIterator it = selections.find( id );

1236

if ( it == selections.end() )

1237

return -1;

1238

return ( *it ).end;

1239

}

1240

1241

inline bool KTextEditParag::hasSelection( int id ) const

1242

{

1243

QMap<int, Selection>::ConstIterator it = selections.find( id );

1244

if ( it == selections.end() )

1245

return FALSE;

1246

return ( *it ).start != ( *it ).end || length() == 1;

1247

}

1248

1249

inline bool KTextEditParag::hasAnySelection() const

1250

{

1251

return !selections.isEmpty();

1252

}

1253

1254

inline bool KTextEditParag::fullSelected( int id ) const

1255

{

1256

QMap<int, Selection>::ConstIterator it = selections.find( id );

1257

if ( it == selections.end() )

1258

return FALSE;

1259

return ( *it ).start == 0 && ( *it ).end == str->length() - 1;

1260

}

1261

1262

inline void KTextEditParag::setParagId( int i )

1263

{

1264

id = i;

1265

}

1266

1267

inline int KTextEditParag::paragId() const

1268

{

1269

if ( id == -1 )

1270

qWarning( "invalid parag id!!!!!!!! (%p)", this );

1271

return id;

1272

}

1273

1274

inline QMap<int, KTextEditParag::LineStart*> &KTextEditParag::lineStartList()

1275

{

1276

return lineStarts;

1277

}

1278

1279

inline int KTextEditParag::lineY( int l ) const

1280

{

1281

if ( l > (int)lineStarts.count() - 1 ) {

1282

qWarning( "KTextEditParag::lineY: line %d out of range!", l );

1283

return 0;

1284

}

1285

1286

if ( !isValid() )

1287

( (KTextEditParag*)this )->format();

1288

1289

QMap<int, LineStart*>::ConstIterator it = lineStarts.begin();

1290

while ( l-- > 0 )

1291

++it;

1292

return ( *it )->y;

1293

}

1294

1295

1296

inline int KTextEditParag::lineBaseLine( int l ) const

1297

{

1298

if ( l > (int)lineStarts.count() - 1 ) {

1299

qWarning( "KTextEditParag::lineBaseLine: line %d out of range!", l );

1300

return 10;

1301

}

1302

1303

if ( !isValid() )

1304

( (KTextEditParag*)this )->format();

1305

1306

QMap<int, LineStart*>::ConstIterator it = lineStarts.begin();

1307

while ( l-- > 0 )

1308

++it;

1309

return ( *it )->baseLine;

1310

}

1311

1312

inline int KTextEditParag::lineHeight( int l ) const

1313

{

1314

if ( l > (int)lineStarts.count() - 1 ) {

1315

qWarning( "KTextEditParag::lineHeight: line %d out of range!", l );

1316

return 15;

1317

}

1318

1319

if ( !isValid() )

1320

( (KTextEditParag*)this )->format();

1321

1322

QMap<int, LineStart*>::ConstIterator it = lineStarts.begin();

1323

while ( l-- > 0 )

1324

++it;

1325

return ( *it )->h;

1326

}

1327

1328

inline void KTextEditParag::lineInfo( int l, int &y, int &h, int &bl ) const

1329

{

1330

if ( l > (int)lineStarts.count() - 1 ) {

1331

qWarning( "KTextEditParag::lineInfo: line %d out of range!", l );

1332

qDebug( "%d %d", lineStarts.count() - 1, l );

1333

y = 0;

1334

h = 15;

1335

bl = 10;

1336

return;

1337

}

1338

1339

if ( !isValid() )

1340

( (KTextEditParag*)this )->format();

1341

1342

QMap<int, LineStart*>::ConstIterator it = lineStarts.begin();

1343

while ( l-- > 0 )

1344

++it;

1345

y = ( *it )->y;

1346

h = ( *it )->h;

1347

bl = ( *it )->baseLine;

1348

}

1349

1350

inline KTextEditString *KTextEditParag::string() const

1351

{

1352

return str;

1353

}

1354

1355

inline KTextEditDocument *KTextEditParag::document() const

1356

{

1357

return doc;

1358

}

1359

1360

inline KTextEditParag::Type KTextEditParag::type() const

1361

{

1362

return typ;

1363

}

1364

1365

inline void KTextEditParag::setType( Type t )

1366

{

1367

if ( t != typ ) {

1368

invalidate( 0 );

1369

if ( p && p->type() == typ )

1370

p->invalidate( 0 );

1371

}

1372

typ = t;

1373

if ( t == Normal )

1374

left = 0;

1375

}

1376

1377

inline int KTextEditParag::leftIndent() const

1378

{

1379

return left;

1380

}

1381

1382

inline int KTextEditParag::listDepth() const

1383

{

1384

return depth;

1385

}

1386

1387

inline void KTextEditParag::setAlignment( int a )

1388

{

1389

if ( a == align )

1390

return;

1391

align = a;

1392

invalidate( 0 );

1393

}

1394

1395

inline int KTextEditParag::alignment() const

1396

{

1397

return align;

1398

}

1399

1400

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1401

1402

inline void KTextEditFormatCollection::setDefaultFormat( KTextEditFormat *f )

1403

{

1404

defFormat = f;

1405

}

1406

1407

inline KTextEditFormat *KTextEditFormatCollection::defaultFormat() const

1408

{

1409

return defFormat;

1410

}

1411

1412

inline KTextEditDocument *KTextEdit::document() const

1413

{

1414

return doc;

1415

}

1416

1417

#endif

Older »