~oif-team/ubuntu/natty/qt4-x11/xi2.1

qWarning("Q3TextEdit::optimParseTags: mismatching %s-tag for '<%s>' in line %d.", cur->tag[0] == '/' ? "left" : "right", cur->tag.latin1(), cur->line + 1);

6158

return; // something is amiss - give up

6159

}

6160

}

6161

}

6162

cur = cur->prev;

6163

}

6164

} else {

6165

tag->bold = bold > 0;

6166

tag->italic = italic > 0;

6167

tag->underline = underline > 0;

6168

tmp = tag->prev;

6169

while (tmp && tmp->leftTag) {

6170

tmp = tmp->leftTag->parent;

6171

}

6172

if (tmp) {

6173

tag->bold |= tmp->bold;

6174

tag->italic |= tmp->italic;

6175

tag->underline |= tmp->underline;

6176

}

6177

}

6178

}

6179

if (startIndex != -1) {

6180

int l = (endIndex == -1) ?

6181

line->length() - startIndex : endIndex - startIndex;

6182

line->remove(startIndex, l+1);

6183

len = line->length();

6184

i -= l+1;

6185

}

6186

tagStr = "";

6187

continue;

6188

}

6189

6190

if (state == 1) {

6191

tagStr += (*line)[i];

6192

}

6193

}

6194

}

6195

6196

// calculate the width of a string in pixels inc. tabs

6197

static int qStrWidth(const QString& str, int tabWidth, const QFontMetrics& fm)

6198

{

6199

int tabs = str.count('\t');

6200

6201

if (!tabs)

6202

return fm.width(str);

6203

6204

int newIdx = 0;

6205

int lastIdx = 0;

6206

int strWidth = 0;

6207

int tn;

6208

for (tn = 1; tn <= tabs; ++tn) {

6209

newIdx = str.indexOf('\t', newIdx);

6210

strWidth += fm.width(str.mid(lastIdx, newIdx - lastIdx));

6211

if (strWidth >= tn * tabWidth) {

6212

int u = tn;

6213

while (strWidth >= u * tabWidth)

6214

++u;

6215

strWidth = u * tabWidth;

6216

} else {

6217

strWidth = tn * tabWidth;

6218

}

6219

lastIdx = ++newIdx;

6220

}

6221

if ((int)str.length() > newIdx)

6222

strWidth += fm.width(str.mid(newIdx));

6223

return strWidth;

6224

}

6225

6226

bool Q3TextEdit::optimHasBoldMetrics(int line)

6227

{

6228

Q3TextEditOptimPrivate::Tag *t;

6229

QMap<int,Q3TextEditOptimPrivate::Tag *>::ConstIterator it;

6230

if ((it = d->od->tagIndex.find(line)) != d->od->tagIndex.end()) {

6231

t = *it;

6232

while (t && t->line == line) {

6233

if (t->bold)

6234

return true;

6235

t = t->next;

6236

}

6237

} else if ((t = optimPreviousLeftTag(line)) && t->bold) {

6238

return true;

6239

}

6240

return false;

6241

}

6242

6243

/*! \internal

6244

6245

Append \a str to the current text buffer. Parses each line to find

6246

formatting tags.

6247

6248

void Q3TextEdit::optimAppend(const QString &str)

6249

{

6250

if (str.isEmpty() || str.isNull() || d->maxLogLines == 0)

6251

return;

6252

6253

QStringList strl = str.split('\n');

6254

QStringList::Iterator it = strl.begin();

6255

6256

QFontMetrics fm(Q3ScrollView::font());

6257

int lWidth = 0;

6258

for (; it != strl.end(); ++it) {

6259

optimParseTags(&*it);

6260

optimCheckLimit(*it);

6261

if (optimHasBoldMetrics(d->od->numLines-1)) {

6262

QFont fnt = Q3ScrollView::font();

6263

fnt.setBold(true);

6264

fm = QFontMetrics(fnt);

6265

}

6266

lWidth = qStrWidth(*it, tabStopWidth(), fm) + 4;

6267

if (lWidth > d->od->maxLineWidth)

6268

d->od->maxLineWidth = lWidth;

6269

}

6270

bool scrollToEnd = contentsY() >= contentsHeight() - visibleHeight();

6271

resizeContents(d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1);

6272

if (scrollToEnd) {

6273

updateScrollBars();

6274

ensureVisible(contentsX(), contentsHeight(), 0, 0);

6275

}

6276

// when a max log size is set, the text may not be redrawn because

6277

// the size of the viewport may not have changed

6278

if (d->maxLogLines > -1)

6279

viewport()->update();

6280

emit textChanged();

6281

}

6282

6283

static void qStripTags(QString *line)

6284

{

6285

int len = line->length();

6286

int i, startIndex = -1, endIndex = -1, escIndex = -1;

6287

int state = 0; // 0 = outside tag, 1 = inside tag

6288

bool tagOpen, tagClose;

6289

6290

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

6291

tagOpen = (*line)[i] == '<';

6292

tagClose = (*line)[i] == '>';

6293

6294

// handle '<' and '>' and '&'

6295

if ((*line)[i] == '&') {

6296

escIndex = i;

6297

continue;

6298

} else if (escIndex != -1 && (*line)[i] == ';') {

6299

QString esc = line->mid(escIndex, i - escIndex + 1);

6300

QString c;

6301

if (esc == "<")

6302

c = '<';

6303

else if (esc == ">")

6304

c = '>';

6305

else if (esc == "&")

6306

c = '&';

6307

line->replace(escIndex, i - escIndex + 1, c);

6308

len = line->length();

6309

i -= i-escIndex;

6310

escIndex = -1;

6311

continue;

6312

}

6313

6314

if (state == 0 && tagOpen) {

6315

state = 1;

6316

startIndex = i;

6317

continue;

6318

}

6319

if (state == 1 && tagClose) {

6320

state = 0;

6321

endIndex = i;

6322

if (startIndex != -1) {

6323

int l = (endIndex == -1) ?

6324

line->length() - startIndex : endIndex - startIndex;

6325

line->remove(startIndex, l+1);

6326

len = line->length();

6327

i -= l+1;

6328

}

6329

continue;

6330

}

6331

}

6332

}

6333

6334

/*! \internal

6335

6336

Inserts the text into \a line at index \a index.

6337

6338

6339

void Q3TextEdit::optimInsert(const QString& text, int line, int index)

6340

{

6341

if (text.isEmpty() || d->maxLogLines == 0)

6342

return;

6343

if (line < 0)

6344

line = 0;

6345

if (line > d->od->numLines-1)

6346

line = d->od->numLines-1;

6347

if (index < 0)

6348

index = 0;

6349

if (index > d->od->lines[line].length())

6350

index = d->od->lines[line].length();

6351

6352

QStringList strl = text.split('\n');

6353

int numNewLines = strl.count() - 1;

6354

Q3TextEditOptimPrivate::Tag *tag = 0;

6355

QMap<int,Q3TextEditOptimPrivate::Tag *>::ConstIterator ii;

6356

int x;

6357

6358

if (numNewLines == 0) {

6359

// Case 1. Fast single line case - just inject it!

6360

QString stripped = text;

6361

qStripTags(&stripped);

6362

d->od->lines[LOGOFFSET(line)].insert(index, stripped);

6363

// move the tag indices following the insertion pt.

6364

if ((ii = d->od->tagIndex.find(LOGOFFSET(line))) != d->od->tagIndex.end()) {

6365

tag = *ii;

6366

while (tag && (LOGOFFSET(tag->line) == line && tag->index < index))

6367

tag = tag->next;

6368

while (tag && (LOGOFFSET(tag->line) == line)) {

6369

tag->index += stripped.length();

6370

tag = tag->next;

6371

}

6372

}

6373

stripped = text;

6374

optimParseTags(&stripped, line, index);

6375

} else if (numNewLines > 0) {

6376

// Case 2. We have at least 1 newline char - split at

6377

// insertion pt. and make room for new lines - complex and slow!

6378

QString left = d->od->lines[LOGOFFSET(line)].left(index);

6379

QString right = d->od->lines[LOGOFFSET(line)].mid(index);

6380

6381

// rearrange lines for insertion

6382

for (x = d->od->numLines - 1; x > line; x--)

6383

d->od->lines[x + numNewLines] = d->od->lines[x];

6384

d->od->numLines += numNewLines;

6385

6386

// fix the tag index and the tag line/index numbers - this

6387

// might take a while..

6388

for (x = line; x < d->od->numLines; x++) {

6389

if ((ii = d->od->tagIndex.find(LOGOFFSET(line))) != d->od->tagIndex.end()) {

6390

tag = ii.value();

6391

if (LOGOFFSET(tag->line) == line)

6392

while (tag && (LOGOFFSET(tag->line) == line && tag->index < index))

6393

tag = tag->next;

6394

}

6395

}

6396

6397

// relabel affected tags with new line numbers and new index

6398

// positions

6399

while (tag) {

6400

if (LOGOFFSET(tag->line) == line)

6401

tag->index -= index;

6402

tag->line += numNewLines;

6403

tag = tag->next;

6404

}

6405

6406

// generate a new tag index

6407

d->od->tagIndex.clear();

6408

tag = d->od->tags;

6409

while (tag) {

6410

if (!((ii = d->od->tagIndex.find(LOGOFFSET(tag->line))) != d->od->tagIndex.end()))

6411

d->od->tagIndex[LOGOFFSET(tag->line)] = tag;

6412

tag = tag->next;

6413

}

6414

6415

// update the tag indices on the spliced line - needs to be done before new tags are added

6416

QString stripped = strl[strl.count() - 1];

6417

qStripTags(&stripped);

6418

if ((ii = d->od->tagIndex.find(LOGOFFSET(line + numNewLines))) != d->od->tagIndex.end()) {

6419

tag = *ii;

6420

while (tag && (LOGOFFSET(tag->line) == line + numNewLines)) {

6421

tag->index += stripped.length();

6422

tag = tag->next;

6423

}

6424

}

6425

6426

// inject the new lines

6427

QStringList::Iterator it = strl.begin();

6428

x = line;

6429

int idx;

6430

for (; it != strl.end(); ++it) {

6431

stripped = *it;

6432

qStripTags(&stripped);

6433

if (x == line) {

6434

stripped = left + stripped;

6435

idx = index;

6436

} else {

6437

idx = 0;

6438

}

6439

d->od->lines[LOGOFFSET(x)] = stripped;

6440

optimParseTags(&*it, x++, idx);

6441

}

6442

d->od->lines[LOGOFFSET(x - 1)] += right;

6443

}

6444

// recalculate the pixel width of the longest injected line -

6445

QFontMetrics fm(Q3ScrollView::font());

6446

int lWidth = 0;

6447

for (x = line; x < line + numNewLines; x++) {

6448

if (optimHasBoldMetrics(x)) {

6449

QFont fnt = Q3ScrollView::font();

6450

fnt.setBold(true);

6451

fm = QFontMetrics(fnt);

6452

}

6453

lWidth = fm.width(d->od->lines[x]) + 4;

6454

if (lWidth > d->od->maxLineWidth)

6455

d->od->maxLineWidth = lWidth;

6456

}

6457

resizeContents(d->od->maxLineWidth + 4, d->od->numLines * fm.lineSpacing() + 1);

6458

repaintContents();

6459

emit textChanged();

6460

}

6461

6462

6463

/*! \internal

6464

6465

Returns the first open left-tag appearing before line \a line.

6466

6467

Q3TextEditOptimPrivate::Tag * Q3TextEdit::optimPreviousLeftTag(int line)

6468

{

6469

Q3TextEditOptimPrivate::Tag * ftag = 0;

6470

QMap<int,Q3TextEditOptimPrivate::Tag *>::ConstIterator it;

6471

if ((it = d->od->tagIndex.find(LOGOFFSET(line))) != d->od->tagIndex.end())

6472

ftag = it.value();

6473

if (!ftag) {

6474

// start searching for an open tag

6475

ftag = d->od->tags;

6476

while (ftag) {

6477

if (ftag->line > line || ftag->next == 0) {

6478

if (ftag->line > line)

6479

ftag = ftag->prev;

6480

break;

6481

}

6482

ftag = ftag->next;

6483

}

6484

} else {

6485

ftag = ftag->prev;

6486

}

6487

6488

if (ftag) {

6489

if (ftag && ftag->parent) // use the open parent tag

6490

ftag = ftag->parent;

6491

else if (ftag && ftag->leftTag) // this is a right-tag with no parent

6492

ftag = 0;

6493

}

6494

return ftag;

6495

}

6496

6497

/*! \internal

6498

6499

Set the format for the string starting at index \a start and ending

6500

at \a end according to \a tag. If \a tag is a Format tag, find the

6501

first open color tag appearing before \a tag and use that tag to

6502

color the string.

6503

6504

void Q3TextEdit::optimSetTextFormat(Q3TextDocument * td, Q3TextCursor * cur,

6505

Q3TextFormat * f, int start, int end,

6506

Q3TextEditOptimPrivate::Tag * tag)

6507

{

6508

int formatFlags = Q3TextFormat::Bold | Q3TextFormat::Italic |

6509

Q3TextFormat::Underline;

6510

cur->setIndex(start);

6511

td->setSelectionStart(0, *cur);

6512

cur->setIndex(end);

6513

td->setSelectionEnd(0, *cur);

6514

Q3StyleSheetItem * ssItem = styleSheet()->item(tag->tag);

6515

if (!ssItem || tag->type == Q3TextEditOptimPrivate::Format) {

6516

f->setBold(tag->bold);

6517

f->setItalic(tag->italic);

6518

f->setUnderline(tag->underline);

6519

if (tag->type == Q3TextEditOptimPrivate::Format) {

6520

// check to see if there are any open color tags prior to

6521

// this format tag

6522

tag = tag->prev;

6523

while (tag && (tag->type == Q3TextEditOptimPrivate::Format ||

6524

tag->leftTag)) {

6525

tag = tag->leftTag ? tag->parent : tag->prev;

6526

}

6527

}

6528

if (tag) {

6529

QString col = tag->tag.simplified();

6530

if (col.left(10) == "font color") {

6531

int i = col.indexOf('=', 10);

6532

col = col.mid(i + 1).simplified();

6533

if (col[0] == '\"')

6534

col = col.mid(1, col.length() - 2);

6535

}

6536

QColor color = QColor(col);

6537

if (color.isValid()) {

6538

formatFlags |= Q3TextFormat::Color;

6539

f->setColor(color);

6540

}

6541

}

6542

} else { // use the stylesheet tag definition

6543

if (ssItem->color().isValid()) {

6544

formatFlags |= Q3TextFormat::Color;

6545

f->setColor(ssItem->color());

6546

}

6547

f->setBold(ssItem->fontWeight() == QFont::Bold);

6548

f->setItalic(ssItem->fontItalic());

6549

f->setUnderline(ssItem->fontUnderline());

6550

}

6551

td->setFormat(0, f, formatFlags);

6552

td->removeSelection(0);

6553

}

6554

6555

/*! \internal */

6556

void Q3TextEdit::optimDrawContents(QPainter * p, int clipx, int clipy,

6557

int clipw, int cliph)

6558

{

6559

QFontMetrics fm(Q3ScrollView::font());

6560

int startLine = clipy / fm.lineSpacing();

6561

6562

// we always have to fetch at least two lines for drawing because the

6563

// painter may be translated so that parts of two lines cover the area

6564

// of a single line

6565

int nLines = (cliph / fm.lineSpacing()) + 2;

6566

int endLine = startLine + nLines;

6567

6568

if (startLine >= d->od->numLines)

6569

return;

6570

if ((startLine + nLines) > d->od->numLines)

6571

nLines = d->od->numLines - startLine;

6572

6573

int i = 0;

6574

QString str;

6575

for (i = startLine; i < (startLine + nLines); i++)

6576

str.append(d->od->lines[LOGOFFSET(i)] + "\n");

6577

6578

Q3TextDocument * td = new Q3TextDocument(0);

6579

td->setDefaultFormat(Q3ScrollView::font(), QColor());

6580

td->setPlainText(str);

6581

td->setFormatter(new Q3TextFormatterBreakWords); // deleted by QTextDoc

6582

td->formatter()->setWrapEnabled(false);

6583

td->setTabStops(doc->tabStopWidth());

6584

6585

// get the current text color from the current format

6586

td->selectAll(Q3TextDocument::Standard);

6587

Q3TextFormat f;

6588

f.setColor(palette().text().color());

6589

f.setFont(Q3ScrollView::font());

6590

td->setFormat(Q3TextDocument::Standard, &f,

6591

Q3TextFormat::Color | Q3TextFormat::Font);

6592

td->removeSelection(Q3TextDocument::Standard);

6593

6594

// add tag formatting

6595

if (d->od->tags) {

6596

int i = startLine;

6597

QMap<int,Q3TextEditOptimPrivate::Tag *>::ConstIterator it;

6598

Q3TextEditOptimPrivate::Tag * tag = 0, * tmp = 0;

6599

Q3TextCursor cur(td);

6600

// Step 1 - find previous left-tag

6601

tmp = optimPreviousLeftTag(i);

6602

for (; i < startLine + nLines; i++) {

6603

if ((it = d->od->tagIndex.find(LOGOFFSET(i))) != d->od->tagIndex.end())

6604

tag = it.value();

6605

// Step 2 - iterate over tags on the current line

6606

int lastIndex = 0;

6607

while (tag && tag->line == i) {

6608

tmp = 0;

6609

if (tag->prev && !tag->prev->leftTag) {

6610

tmp = tag->prev;

6611

} else if (tag->prev && tag->prev->parent) {

6612

tmp = tag->prev->parent;

6613

}

6614

if ((tag->index - lastIndex) > 0 && tmp) {

6615

optimSetTextFormat(td, &cur, &f, lastIndex, tag->index, tmp);

6616

}

6617

lastIndex = tag->index;

6618

tmp = tag;

6619

tag = tag->next;

6620

}

6621

// Step 3 - color last part of the line - if necessary

6622

if (tmp && tmp->parent)

6623

tmp = tmp->parent;

6624

if ((cur.paragraph()->length()-1 - lastIndex) > 0 && tmp && !tmp->leftTag) {

6625

optimSetTextFormat(td, &cur, &f, lastIndex,

6626

cur.paragraph()->length() - 1, tmp);

6627

}

6628

cur.setParagraph(cur.paragraph()->next());

6629

}

6630

// useful debug info

6631

6632

// tag = d->od->tags;

6633

// qWarning("###");

6634

// while (tag) {

6635

// qWarning("Tag: %p, parent: %09p, leftTag: %09p, Name: %-15s, ParentName: %s, %d%d%d", tag,

6636

// tag->parent, tag->leftTag, tag->tag.latin1(), tag->parent ? tag->parent->tag.latin1():"<none>",

6637

// tag->bold, tag->italic, tag->underline);

6638

// tag = tag->next;

6639

// }

6640

}

6641

6642

// if there is a selection, make sure that the selection in the

6643

// part we need to redraw is set correctly

6644

if (optimHasSelection()) {

6645

Q3TextCursor c1(td);

6646

Q3TextCursor c2(td);

6647

int selStart = d->od->selStart.line;

6648

int idxStart = d->od->selStart.index;

6649

int selEnd = d->od->selEnd.line;

6650

int idxEnd = d->od->selEnd.index;

6651

if (selEnd < selStart) {

6652

qSwap(&selStart, &selEnd);

6653

qSwap(&idxStart, &idxEnd);

6654

}

6655

if (selEnd > d->od->numLines-1) {

6656

selEnd = d->od->numLines-1;

6657

}

6658

if (startLine <= selStart && endLine >= selEnd) {

6659

// case 1: area to paint covers entire selection

6660

int paragS = selStart - startLine;

6661

int paragE = paragS + (selEnd - selStart);

6662

Q3TextParagraph * parag = td->paragAt(paragS);

6663

if (parag) {

6664

c1.setParagraph(parag);

6665

if (td->text(paragS).length() >= idxStart)

6666

c1.setIndex(idxStart);

6667

}

6668

parag = td->paragAt(paragE);

6669

if (parag) {

6670

c2.setParagraph(parag);

6671

if (td->text(paragE).length() >= idxEnd)

6672

c2.setIndex(idxEnd);

6673

}

6674

} else if (startLine > selStart && endLine < selEnd) {

6675

// case 2: area to paint is all part of the selection

6676

td->selectAll(Q3TextDocument::Standard);

6677

} else if (startLine > selStart && endLine >= selEnd &&

6678

startLine <= selEnd) {

6679

// case 3: area to paint starts inside a selection, ends past it

6680

c1.setParagraph(td->firstParagraph());

6681

c1.setIndex(0);

6682

int paragE = selEnd - startLine;

6683

Q3TextParagraph * parag = td->paragAt(paragE);

6684

if (parag) {

6685

c2.setParagraph(parag);

6686

if (td->text(paragE).length() >= idxEnd)

6687

c2.setIndex(idxEnd);

6688

}

6689

} else if (startLine <= selStart && endLine < selEnd &&

6690

endLine > selStart) {

6691

// case 4: area to paint starts before a selection, ends inside it

6692

int paragS = selStart - startLine;

6693

Q3TextParagraph * parag = td->paragAt(paragS);

6694

if (parag) {

6695

c1.setParagraph(parag);

6696

c1.setIndex(idxStart);

6697

}

6698

c2.setParagraph(td->lastParagraph());

6699

c2.setIndex(td->lastParagraph()->string()->toString().length() - 1);

6700

6701

}

6702

// previously selected?

6703

if (!td->hasSelection(Q3TextDocument::Standard)) {

6704

td->setSelectionStart(Q3TextDocument::Standard, c1);

6705

td->setSelectionEnd(Q3TextDocument::Standard, c2);

6706

}

6707

}

6708

td->doLayout(p, contentsWidth());

6709

6710

// have to align the painter so that partly visible lines are

6711

// drawn at the correct position within the area that needs to be

6712

// painted

6713

int offset = clipy % fm.lineSpacing() + 2;

6714

QRect r(clipx, 0, clipw, cliph + offset);

6715

p->translate(0, clipy - offset);

6716

td->draw(p, r.x(), r.y(), r.width(), r.height(), palette());

6717

p->translate(0, -(clipy - offset));

6718

delete td;

6719

}

6720

6721

/*! \internal */

6722

void Q3TextEdit::optimMousePressEvent(QMouseEvent * e)

6723

{

6724

if (e->button() != Qt::LeftButton)

6725

return;

6726

6727

QFontMetrics fm(Q3ScrollView::font());

6728

mousePressed = true;

6729

mousePos = e->pos();

6730

d->od->selStart.line = e->y() / fm.lineSpacing();

6731

if (d->od->selStart.line > d->od->numLines-1) {

6732

d->od->selStart.line = d->od->numLines-1;

6733

d->od->selStart.index = d->od->lines[LOGOFFSET(d->od->numLines-1)].length();

6734

} else {

6735

QString str = d->od->lines[LOGOFFSET(d->od->selStart.line)];

6736

d->od->selStart.index = optimCharIndex(str, mousePos.x());

6737

}

6738

d->od->selEnd.line = d->od->selStart.line;

6739

d->od->selEnd.index = d->od->selStart.index;

6740

oldMousePos = e->pos();

6741

repaintContents();

6742

}

6743

6744

/*! \internal */

6745

void Q3TextEdit::optimMouseReleaseEvent(QMouseEvent * e)

6746

{

6747

if (e->button() != Qt::LeftButton)

6748

return;

6749

6750

if (scrollTimer->isActive())

6751

scrollTimer->stop();

6752

if (!inDoubleClick) {

6753

QFontMetrics fm(Q3ScrollView::font());

6754

d->od->selEnd.line = e->y() / fm.lineSpacing();

6755

if (d->od->selEnd.line > d->od->numLines-1) {

6756

d->od->selEnd.line = d->od->numLines-1;

6757

}

6758

QString str = d->od->lines[LOGOFFSET(d->od->selEnd.line)];

6759

mousePos = e->pos();

6760

d->od->selEnd.index = optimCharIndex(str, mousePos.x());

6761

if (d->od->selEnd.line < d->od->selStart.line) {

6762

qSwap(&d->od->selStart.line, &d->od->selEnd.line);

6763

qSwap(&d->od->selStart.index, &d->od->selEnd.index);

6764

} else if (d->od->selStart.line == d->od->selEnd.line &&

6765

d->od->selStart.index > d->od->selEnd.index) {

6766

qSwap(&d->od->selStart.index, &d->od->selEnd.index);

6767

}

6768

oldMousePos = e->pos();

6769

repaintContents();

6770

}

6771

if (mousePressed) {

6772

mousePressed = false;

6773

copyToClipboard();

6774

}

6775

6776

inDoubleClick = false;

6777

emit copyAvailable(optimHasSelection());

6778

emit selectionChanged();

6779

}

6780

6781

/*! \internal */

6782

void Q3TextEdit::optimMouseMoveEvent(QMouseEvent * e)

6783

{

6784

mousePos = e->pos();

6785

optimDoAutoScroll();

6786

oldMousePos = mousePos;

6787

}

6788

6789

/*! \internal */

6790

void Q3TextEdit::optimDoAutoScroll()

6791

{

6792

if (!mousePressed)

6793

return;

6794

6795

QFontMetrics fm(Q3ScrollView::font());

6796

QPoint pos(mapFromGlobal(QCursor::pos()));

6797

bool doScroll = false;

6798

int xx = contentsX() + pos.x();

6799

int yy = contentsY() + pos.y();

6800

6801

// find out how much we have to scroll in either dir.

6802

if (pos.x() < 0 || pos.x() > viewport()->width() ||

6803

pos.y() < 0 || pos.y() > viewport()->height()) {

6804

int my = yy;

6805

if (pos.x() < 0)

6806

xx = contentsX() - fm.width('w');

6807

else if (pos.x() > viewport()->width())

6808

xx = contentsX() + viewport()->width() + fm.width('w');

6809

6810

if (pos.y() < 0) {

6811

my = contentsY() - 1;

6812

yy = (my / fm.lineSpacing()) * fm.lineSpacing() + 1;

6813

} else if (pos.y() > viewport()->height()) {

6814

my = contentsY() + viewport()->height() + 1;

6815

yy = (my / fm.lineSpacing() + 1) * fm.lineSpacing() - 1;

6816

}

6817

d->od->selEnd.line = my / fm.lineSpacing();

6818

mousePos.setX(xx);

6819

mousePos.setY(my);

6820

doScroll = true;

6821

} else {

6822

d->od->selEnd.line = mousePos.y() / fm.lineSpacing();

6823

}

6824

6825

if (d->od->selEnd.line < 0) {

6826

d->od->selEnd.line = 0;

6827

} else if (d->od->selEnd.line > d->od->numLines-1) {

6828

d->od->selEnd.line = d->od->numLines-1;

6829

}

6830

6831

QString str = d->od->lines[LOGOFFSET(d->od->selEnd.line)];

6832

d->od->selEnd.index = optimCharIndex(str, mousePos.x());

6833

6834

// have to have a valid index before generating a paint event

6835

if (doScroll)

6836

ensureVisible(xx, yy, 1, 1);

6837

6838

// if the text document is smaller than the height of the viewport

6839

// - redraw the whole thing otherwise calculate the rect that

6840

// needs drawing.

6841

if (d->od->numLines * fm.lineSpacing() < viewport()->height()) {

6842

repaintContents(contentsX(), contentsY(), width(), height());

6843

} else {

6844

int h = QABS(mousePos.y() - oldMousePos.y()) + fm.lineSpacing() * 2;

6845

int y;

6846

if (oldMousePos.y() < mousePos.y()) {

6847

y = oldMousePos.y() - fm.lineSpacing();

6848

} else {

6849

// expand paint area for a fully selected line

6850

h += fm.lineSpacing();

6851

y = mousePos.y() - fm.lineSpacing()*2;

6852

}

6853

if (y < 0)

6854

y = 0;

6855

repaintContents(contentsX(), y, width(), h);

6856

}

6857

6858

if (!scrollTimer->isActive() && pos.y() < 0 || pos.y() > height())

6859

scrollTimer->start(100, false);

6860

else if (scrollTimer->isActive() && pos.y() >= 0 && pos.y() <= height())

6861

scrollTimer->stop();

6862

}

6863

6864

/*! \internal

6865

6866

Returns the index of the character in the string \a str that is

6867

currently under the mouse pointer.

6868

6869

int Q3TextEdit::optimCharIndex(const QString &str, int mx) const

6870

{

6871

QFontMetrics fm(Q3ScrollView::font());

6872

int i = 0;

6873

int dd, dist = 10000000;

6874

int curpos = 0;

6875

int strWidth;

6876

mx = mx - 4; // ### get the real margin from somewhere

6877

6878

if (!str.contains('\t') && mx > fm.width(str))

6879

return str.length();

6880

6881

while (i < str.length()) {

6882

strWidth = qStrWidth(str.left(i), tabStopWidth(), fm);

6883

dd = strWidth - mx;

6884

if (QABS(dd) <= dist) {

6885

dist = QABS(dd);

6886

if (mx >= strWidth)

6887

curpos = i;

6888

}

6889

++i;

6890

}

6891

return curpos;

6892

}

6893

6894

/*! \internal */

6895

void Q3TextEdit::optimSelectAll()

6896

{

6897

d->od->selStart.line = d->od->selStart.index = 0;

6898

d->od->selEnd.line = d->od->numLines - 1;

6899

d->od->selEnd.index = d->od->lines[LOGOFFSET(d->od->selEnd.line)].length();

6900

6901

repaintContents();

6902

emit copyAvailable(optimHasSelection());

6903

emit selectionChanged();

6904

}

6905

6906

/*! \internal */

6907

void Q3TextEdit::optimRemoveSelection()

6908

{

6909

d->od->selStart.line = d->od->selEnd.line = -1;

6910

d->od->selStart.index = d->od->selEnd.index = -1;

6911

repaintContents();

6912

}

6913

6914

/*! \internal */

6915

void Q3TextEdit::optimSetSelection(int startLine, int startIdx,

6916

int endLine, int endIdx)

6917

{

6918

d->od->selStart.line = startLine;

6919

d->od->selEnd.line = endLine;

6920

d->od->selStart.index = startIdx;

6921

d->od->selEnd.index = endIdx;

6922

}

6923

6924

/*! \internal */

6925

bool Q3TextEdit::optimHasSelection() const

6926

{

6927

if (d->od->selStart.line != d->od->selEnd.line ||

6928

d->od->selStart.index != d->od->selEnd.index)

6929

return true;

6930

return false;

6931

}

6932

6933

/*! \internal */

6934

QString Q3TextEdit::optimSelectedText() const

6935

{

6936

QString str;

6937

6938

if (!optimHasSelection())

6939

return str;

6940

6941

// concatenate all strings

6942

if (d->od->selStart.line == d->od->selEnd.line) {

6943

str = d->od->lines[LOGOFFSET(d->od->selEnd.line)].mid(d->od->selStart.index,

6944

d->od->selEnd.index - d->od->selStart.index);

6945

} else {

6946

int i = d->od->selStart.line;

6947

str = d->od->lines[LOGOFFSET(i)].right(d->od->lines[LOGOFFSET(i)].length() -

6948

d->od->selStart.index) + "\n";

6949

i++;

6950

for (; i < d->od->selEnd.line; i++) {

6951

if (d->od->lines[LOGOFFSET(i)].isEmpty()) // CR lines are empty

6952

str += "\n";

6953

else

6954

str += d->od->lines[LOGOFFSET(i)] + "\n";

6955

}

6956

str += d->od->lines[LOGOFFSET(d->od->selEnd.line)].left(d->od->selEnd.index);

6957

}

6958

return str;

6959

}

6960

6961

/*! \internal */

6962

bool Q3TextEdit::optimFind(const QString & expr, bool cs, bool /*wo*/,

6963

bool fw, int * para, int * index)

6964

{

6965

bool found = false;

6966

int parag = para ? *para : d->od->search.line,

6967

idx = index ? *index : d->od->search.index, i;

6968

6969

if (d->od->len == 0)

6970

return false;

6971

6972

for (i = parag; fw ? i < d->od->numLines : i >= 0; fw ? i++ : i--) {

6973

idx = fw

6974

? d->od->lines[LOGOFFSET(i)].indexOf(expr, idx,

6975

cs ? Qt::CaseSensitive : Qt::CaseInsensitive)

6976

: d->od->lines[LOGOFFSET(i)].lastIndexOf(expr, idx,

6977

cs ? Qt::CaseSensitive : Qt::CaseInsensitive);

6978

if (idx != -1) {

6979

found = true;

6980

break;

6981

} else if (fw)

6982

idx = 0;

6983

}

6984

6985

if (found) {

6986

if (index)

6987

*index = idx;

6988

if (para)

6989

*para = i;

6990

d->od->search.index = idx;

6991

d->od->search.line = i;

6992

optimSetSelection(i, idx, i, idx + expr.length());

6993

QFontMetrics fm(Q3ScrollView::font());

6994

int h = fm.lineSpacing();

6995

int x = fm.width(d->od->lines[LOGOFFSET(i)].left(idx + expr.length())) + 4;

6996

ensureVisible(x, i * h + h / 2, 1, h / 2 + 2);

6997

repaintContents(); // could possibly be optimized

6998

}

6999

return found;

7000

}

7001

7002

/*! \reimp */

7003

void Q3TextEdit::polishEvent(QEvent*)

7004

{

7005

// this will ensure that the last line is visible if text have

7006

// been added to the widget before it is shown

7007

if (d->optimMode)

7008

scrollToBottom();

7009

}

7010

7011

/*!

7012

Sets the maximum number of lines a Q3TextEdit can hold in \c

7013

Qt::LogText mode to \a limit. If \a limit is -1 (the default), this

7014

signifies an unlimited number of lines.

7015

7016

\warning Never use formatting tags that span more than one line

7017

when the maximum log lines is set. When lines are removed from the

7018

top of the buffer it could result in an unbalanced tag pair, i.e.

7019

the left formatting tag is removed before the right one.

7020

7021

void Q3TextEdit::setMaxLogLines(int limit)

7022

{

7023

d->maxLogLines = limit;

7024

if (d->maxLogLines < -1)

7025

d->maxLogLines = -1;

7026

if (d->maxLogLines == -1)

7027

d->logOffset = 0;

7028

}

7029

7030

/*!

7031

Returns the maximum number of lines Q3TextEdit can hold in \c

7032

Qt::LogText mode. By default the number of lines is unlimited, which

7033

is signified by a value of -1.

7034

7035

int Q3TextEdit::maxLogLines() const

7036

{

7037

return d->maxLogLines;

7038

}

7039

7040

/*!

7041

Check if the number of lines in the buffer is limited, and uphold

7042

that limit when appending new lines.

7043

7044

void Q3TextEdit::optimCheckLimit(const QString& str)

7045

{

7046

if (d->maxLogLines > -1 && d->maxLogLines == d->od->numLines) {

7047

// NB! Removing the top line in the buffer will potentially

7048

// destroy the structure holding the formatting tags - if line

7049

// spanning tags are used.

7050

Q3TextEditOptimPrivate::Tag *t = d->od->tags, *tmp, *itr;

7051

QList<Q3TextEditOptimPrivate::Tag *> lst;

7052

while (t) {

7053

t->line -= 1;

7054

// unhook the ptr from the tag structure

7055

if (((uint) LOGOFFSET(t->line) < (uint) d->logOffset &&

7056

(uint) LOGOFFSET(t->line) < (uint) LOGOFFSET(d->od->numLines) &&

7057

(uint) LOGOFFSET(d->od->numLines) > (uint) d->logOffset))

7058

{

7059

if (t->prev)

7060

t->prev->next = t->next;

7061

if (t->next)

7062

t->next->prev = t->prev;

7063

if (d->od->tags == t)

7064

d->od->tags = t->next;

7065

if (d->od->lastTag == t) {

7066

if (t->prev)

7067

d->od->lastTag = t->prev;

7068

else

7069

d->od->lastTag = d->od->tags;

7070

}

7071

tmp = t;

7072

t = t->next;

7073

lst.append(tmp);

7074

delete tmp;

7075

} else {

7076

t = t->next;

7077

}

7078

}

7079

// Remove all references to the ptrs we just deleted

7080

itr = d->od->tags;

7081

while (itr) {

7082

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

7083

tmp = lst.at(i);

7084

if (itr->parent == tmp)

7085

itr->parent = 0;

7086

if (itr->leftTag == tmp)

7087

itr->leftTag = 0;

7088

}

7089

itr = itr->next;

7090

}

7091

// ...in the tag index as well

7092

QMap<int, Q3TextEditOptimPrivate::Tag *>::Iterator idx;

7093

if ((idx = d->od->tagIndex.find(d->logOffset)) != d->od->tagIndex.end())

7094

d->od->tagIndex.erase(idx);

7095

7096

QMap<int,QString>::Iterator it;

7097

if ((it = d->od->lines.find(d->logOffset)) != d->od->lines.end()) {

7098

d->od->len -= (*it).length();

7099

d->od->lines.erase(it);

7100

d->od->numLines--;

7101

d->logOffset = LOGOFFSET(1);

7102

}

7103

}

7104

d->od->len += str.length();

7105

d->od->lines[LOGOFFSET(d->od->numLines++)] = str;

7106

}

7107

7108

#endif // QT_TEXTEDIT_OPTIMIZATION

7109

7110

/*!

7111

\property Q3TextEdit::autoFormatting

7112

\brief the enabled set of auto formatting features

7113

7114

The value can be any combination of the values in the \c

7115

AutoFormattingFlag enum. The default is \c AutoAll. Choose \c AutoNone

7116

to disable all automatic formatting.

7117

7118

Currently, the only automatic formatting feature provided is \c

7119

AutoBulletList; future versions of Qt may offer more.

7120

7121

7122

void Q3TextEdit::setAutoFormatting(AutoFormatting features)

7123

{

7124

d->autoFormatting = features;

7125

}

7126

7127

Q3TextEdit::AutoFormatting Q3TextEdit::autoFormatting() const

7128

{

7129

return d->autoFormatting;

7130

}

7131

7132

/*!

7133

Returns the QSyntaxHighlighter set on this Q3TextEdit. 0 is

7134

returned if no syntax highlighter is set.

7135

7136

Q3SyntaxHighlighter * Q3TextEdit::syntaxHighlighter() const

7137

{

7138

if (document()->preProcessor())

7139

return ((Q3SyntaxHighlighterInternal *) document()->preProcessor())->highlighter;

7140

else

7141

return 0;

7142

}

7143

7144

#endif //QT_NO_TEXTEDIT

Older »