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

VisibleSelection selection = r ? VisibleSelection(r->startPosition(), r->endPosition(), affinity) : VisibleSelection(Position(), Position(), affinity);

setSelection(selection, true, true, userTriggered);

}

void SelectionController::moveTo(const Position &base, const Position &extent, EAffinity affinity, bool userTriggered)

{

setSelection(Selection(base, extent, affinity), true, true, userTriggered);

setSelection(VisibleSelection(base, extent, affinity), true, true, userTriggered);

100

}

100

101

void SelectionController::setSelection(const Selection& s, bool closeTyping, bool clearTypingStyle, bool userTriggered)

102

void SelectionController::setSelection(const VisibleSelection& s, bool closeTyping, bool clearTypingStyle, bool userTriggered)

102

103

{

104

m_lastChangeWasHorizontalExtension = false;

105

103

106

if (m_isDragCaretController) {

104

107

invalidateCaretRect();

105

108

m_sel = s;

111

114

m_sel = s;

112

115

return;

113

116

}

117

118

Node* baseNode = s.base().node();

119

Document* document = 0;

120

if (baseNode)

121

document = baseNode->document();

114

122

115

if (s.base().node() && s.base().node()->document() != m_frame->document()) {

116

s.base().node()->document()->frame()->selection()->setSelection(s, closeTyping, clearTypingStyle, userTriggered);

123

// <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at SelectionController::setSelection

124

// if document->frame() == m_frame we can get into an infinite loop

125

if (document && document->frame() != m_frame && document != m_frame->document()) {

126

document->frame()->selection()->setSelection(s, closeTyping, clearTypingStyle, userTriggered);

117

127

return;

118

128

}

119

129

126

136

if (m_sel == s)

127

137

return;

128

138

129

Selection oldSelection = m_sel;

139

VisibleSelection oldSelection = m_sel;

130

140

131

141

m_sel = s;

132

142

143

153

m_frame->notifyRendererOfSelectionChange(userTriggered);

144

154

m_frame->respondToChangedSelection(oldSelection, closeTyping);

145

155

if (userTriggered)

146

m_frame->revealCaret(RenderLayer::gAlignToEdgeIfNeeded);

156

m_frame->revealSelection(ScrollAlignment::alignToEdgeIfNeeded, true);

147

157

148

158

notifyAccessibilityForSelectionChange();

149

159

}

195

205

else

196

206

m_sel.setWithoutValidation(m_sel.end(), m_sel.start());

197

207

// FIXME: This could be more efficient if we had an isNodeInRange function on Ranges.

198

} else if (Range::compareBoundaryPoints(m_sel.start(), Position(node, 0)) == -1 &&

199

Range::compareBoundaryPoints(m_sel.end(), Position(node, 0)) == 1) {

208

} else if (comparePositions(m_sel.start(), Position(node, 0)) == -1 && comparePositions(m_sel.end(), Position(node, 0)) == 1) {

200

209

// If we did nothing here, when this node's renderer was destroyed, the rect that it

201

210

// occupied would be invalidated, but, selection gaps that change as a result of

202

211

// the removal wouldn't be invalidated.

206

215

207

216

if (clearRenderTreeSelection) {

208

217

RefPtr<Document> document = m_sel.start().node()->document();

209

document->updateRendering();

210

if (RenderView* view = static_cast<RenderView*>(document->renderer()))

218

document->updateStyleIfNeeded();

219

if (RenderView* view = toRenderView(document->renderer()))

211

220

view->clearSelection();

212

221

}

213

222

214

223

if (clearDOMTreeSelection)

215

setSelection(Selection(), false, false);

224

setSelection(VisibleSelection(), false, false);

216

225

}

217

226

218

227

void SelectionController::willBeModified(EAlteration alter, EDirection direction)

219

228

{

220

switch (alter) {

221

case MOVE:

222

m_lastChangeWasHorizontalExtension = false;

223

break;

224

case EXTEND:

225

if (!m_lastChangeWasHorizontalExtension) {

226

m_lastChangeWasHorizontalExtension = true;

227

Position start = m_sel.start();

228

Position end = m_sel.end();

229

switch (direction) {

230

// FIXME: right for bidi?

231

case RIGHT:

232

case FORWARD:

233

m_sel.setBase(start);

234

m_sel.setExtent(end);

235

break;

236

case LEFT:

237

case BACKWARD:

238

m_sel.setBase(end);

239

m_sel.setExtent(start);

240

break;

241

}

242

}

243

break;

244

}

245

}

246

247

VisiblePosition SelectionController::modifyExtendingRightForward(TextGranularity granularity)

229

if (alter != EXTEND)

230

return;

231

if (m_lastChangeWasHorizontalExtension)

232

return;

233

234

Position start = m_sel.start();

235

Position end = m_sel.end();

236

// FIXME: This is probably not correct for right and left when the direction is RTL.

237

switch (direction) {

238

case RIGHT:

239

case FORWARD:

240

m_sel.setBase(start);

241

m_sel.setExtent(end);

242

break;

243

case LEFT:

244

case BACKWARD:

245

m_sel.setBase(end);

246

m_sel.setExtent(start);

247

break;

248

}

249

}

250

251

TextDirection SelectionController::directionOfEnclosingBlock()

252

{

253

Node* n = m_sel.extent().node();

254

Node* enclosingBlockNode = enclosingBlock(n);

255

if (!enclosingBlockNode)

256

return LTR;

257

RenderObject* renderer = enclosingBlockNode->renderer();

258

if (renderer)

259

return renderer->style()->direction();

260

return LTR;

261

}

262

263

VisiblePosition SelectionController::modifyExtendingRight(TextGranularity granularity)

264

{

265

VisiblePosition pos(m_sel.extent(), m_sel.affinity());

266

267

// The difference between modifyExtendingRight and modifyExtendingForward is:

268

// modifyExtendingForward always extends forward logically.

269

// modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,

270

// it extends forward logically if the enclosing block is LTR direction,

271

// but it extends backward logically if the enclosing block is RTL direction.

272

switch (granularity) {

273

case CharacterGranularity:

274

if (directionOfEnclosingBlock() == LTR)

275

pos = pos.next(true);

276

else

277

pos = pos.previous(true);

278

break;

279

case WordGranularity:

280

if (directionOfEnclosingBlock() == LTR)

281

pos = nextWordPosition(pos);

282

else

283

pos = previousWordPosition(pos);

284

break;

285

case SentenceGranularity:

286

case LineGranularity:

287

case ParagraphGranularity:

288

case SentenceBoundary:

289

case LineBoundary:

290

case ParagraphBoundary:

291

case DocumentBoundary:

292

// FIXME: implement all of the above?

293

pos = modifyExtendingForward(granularity);

294

}

295

return pos;

296

}

297

298

VisiblePosition SelectionController::modifyExtendingForward(TextGranularity granularity)

248

299

{

249

300

VisiblePosition pos(m_sel.extent(), m_sel.affinity());

250

301

switch (granularity) {

267

318

pos = endOfSentence(VisiblePosition(m_sel.end(), m_sel.affinity()));

268

319

break;

269

320

case LineBoundary:

270

pos = endOfLine(VisiblePosition(m_sel.end(), m_sel.affinity()));

321

pos = logicalEndOfLine(VisiblePosition(m_sel.end(), m_sel.affinity()));

271

322

break;

272

323

case ParagraphBoundary:

273

324

pos = endOfParagraph(VisiblePosition(m_sel.end(), m_sel.affinity()));

341

392

pos = endOfSentence(VisiblePosition(m_sel.end(), m_sel.affinity()));

342

393

break;

343

394

case LineBoundary:

344

pos = endOfLine(VisiblePosition(m_sel.end(), m_sel.affinity()));

395

pos = logicalEndOfLine(VisiblePosition(m_sel.end(), m_sel.affinity()));

345

396

break;

346

397

case ParagraphBoundary:

347

398

pos = endOfParagraph(VisiblePosition(m_sel.end(), m_sel.affinity()));

358

409

return pos;

359

410

}

360

411

361

VisiblePosition SelectionController::modifyExtendingLeftBackward(TextGranularity granularity)

362

{

363

VisiblePosition pos(m_sel.extent(), m_sel.affinity());

364

412

VisiblePosition SelectionController::modifyExtendingLeft(TextGranularity granularity)

413

{

414

VisiblePosition pos(m_sel.extent(), m_sel.affinity());

415

416

// The difference between modifyExtendingLeft and modifyExtendingBackward is:

417

// modifyExtendingBackward always extends backward logically.

418

// modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,

419

// it extends backward logically if the enclosing block is LTR direction,

420

// but it extends forward logically if the enclosing block is RTL direction.

421

switch (granularity) {

422

case CharacterGranularity:

423

if (directionOfEnclosingBlock() == LTR)

424

pos = pos.previous(true);

425

else

426

pos = pos.next(true);

427

break;

428

case WordGranularity:

429

if (directionOfEnclosingBlock() == LTR)

430

pos = previousWordPosition(pos);

431

else

432

pos = nextWordPosition(pos);

433

break;

434

case SentenceGranularity:

435

case LineGranularity:

436

case ParagraphGranularity:

437

case SentenceBoundary:

438

case LineBoundary:

439

case ParagraphBoundary:

440

case DocumentBoundary:

441

pos = modifyExtendingBackward(granularity);

442

}

443

return pos;

444

}

445

446

VisiblePosition SelectionController::modifyExtendingBackward(TextGranularity granularity)

447

{

448

VisiblePosition pos(m_sel.extent(), m_sel.affinity());

449

365

450

// Extending a selection backward by word or character from just after a table selects

366

451

// the table. This "makes sense" from the user perspective, esp. when deleting.

367

452

// It was done here instead of in VisiblePosition because we want VPs to iterate

386

471

pos = startOfSentence(VisiblePosition(m_sel.start(), m_sel.affinity()));

387

472

break;

388

473

case LineBoundary:

389

pos = startOfLine(VisiblePosition(m_sel.start(), m_sel.affinity()));

474

pos = logicalStartOfLine(VisiblePosition(m_sel.start(), m_sel.affinity()));

390

475

break;

391

476

case ParagraphBoundary:

392

477

pos = startOfParagraph(VisiblePosition(m_sel.start(), m_sel.affinity()));

453

538

pos = startOfSentence(VisiblePosition(m_sel.start(), m_sel.affinity()));

454

539

break;

455

540

case LineBoundary:

456

pos = startOfLine(VisiblePosition(m_sel.start(), m_sel.affinity()));

541

pos = logicalStartOfLine(VisiblePosition(m_sel.start(), m_sel.affinity()));

457

542

break;

458

543

case ParagraphBoundary:

459

544

pos = startOfParagraph(VisiblePosition(m_sel.start(), m_sel.affinity()));

473

558

{

474

559

if (userTriggered) {

475

560

SelectionController trialSelectionController;

561

trialSelectionController.setSelection(m_sel);

476

562

trialSelectionController.setLastChangeWasHorizontalExtension(m_lastChangeWasHorizontalExtension);

477

trialSelectionController.setSelection(m_sel);

478

563

trialSelectionController.modify(alter, dir, granularity, false);

479

564

480

565

bool change = m_frame->shouldChangeSelection(trialSelectionController.selection());

493

578

if (alter == MOVE)

494

579

pos = modifyMovingRight(granularity);

495

580

else

496

pos = modifyExtendingRightForward(granularity);

581

pos = modifyExtendingRight(granularity);

497

582

break;

498

583

case FORWARD:

499

584

if (alter == EXTEND)

500

pos = modifyExtendingRightForward(granularity);

585

pos = modifyExtendingForward(granularity);

501

586

else

502

587

pos = modifyMovingForward(granularity);

503

588

break;

505

590

if (alter == MOVE)

506

591

pos = modifyMovingLeft(granularity);

507

592

else

508

pos = modifyExtendingLeftBackward(granularity);

593

pos = modifyExtendingLeft(granularity);

509

594

break;

510

595

case BACKWARD:

511

596

if (alter == EXTEND)

512

pos = modifyExtendingLeftBackward(granularity);

597

pos = modifyExtendingBackward(granularity);

513

598

else

514

599

pos = modifyMovingBackward(granularity);

515

600

break;

547

632

548

633

setNeedsLayout();

549

634

635

m_lastChangeWasHorizontalExtension = alter == EXTEND;

636

550

637

return true;

551

638

}

552

639

568

655

if (userTriggered) {

569

656

SelectionController trialSelectionController;

570

657

trialSelectionController.setSelection(m_sel);

658

trialSelectionController.setLastChangeWasHorizontalExtension(m_lastChangeWasHorizontalExtension);

571

659

trialSelectionController.modify(alter, verticalDistance, false);

572

660

573

661

bool change = m_frame->shouldChangeSelection(trialSelectionController.selection());

692

780

693

781

void SelectionController::clear()

694

782

{

695

setSelection(Selection());

783

setSelection(VisibleSelection());

696

784

}

697

785

698

786

void SelectionController::setBase(const VisiblePosition &pos, bool userTriggered)

699

787

{

700

setSelection(Selection(pos.deepEquivalent(), m_sel.extent(), pos.affinity()), true, true, userTriggered);

788

setSelection(VisibleSelection(pos.deepEquivalent(), m_sel.extent(), pos.affinity()), true, true, userTriggered);

701

789

}

702

790

703

791

void SelectionController::setExtent(const VisiblePosition &pos, bool userTriggered)

704

792

{

705

setSelection(Selection(m_sel.base(), pos.deepEquivalent(), pos.affinity()), true, true, userTriggered);

793

setSelection(VisibleSelection(m_sel.base(), pos.deepEquivalent(), pos.affinity()), true, true, userTriggered);

706

794

}

707

795

708

796

void SelectionController::setBase(const Position &pos, EAffinity affinity, bool userTriggered)

709

797

{

710

setSelection(Selection(pos, m_sel.extent(), affinity), true, true, userTriggered);

798

setSelection(VisibleSelection(pos, m_sel.extent(), affinity), true, true, userTriggered);

711

799

}

712

800

713

801

void SelectionController::setExtent(const Position &pos, EAffinity affinity, bool userTriggered)

714

802

{

715

setSelection(Selection(m_sel.base(), pos, affinity), true, true, userTriggered);

803

setSelection(VisibleSelection(m_sel.base(), pos, affinity), true, true, userTriggered);

716

804

}

717

805

718

806

void SelectionController::setNeedsLayout(bool flag)

727

815

return;

728

816

}

729

817

730

m_sel.start().node()->document()->updateRendering();

818

m_sel.start().node()->document()->updateStyleIfNeeded();

731

819

732

820

m_caretRect = IntRect();

733

821

788

876

IntRect SelectionController::localCaretRect() const

789

877

{

790

878

if (m_needsLayout)

791

const_cast<SelectionController *>(this)->layout();

879

const_cast<SelectionController*>(this)->layout();

792

880

793

881

return m_caretRect;

794

882

}

795

883

884

IntRect SelectionController::absoluteBoundsForLocalRect(const IntRect& rect) const

885

{

886

RenderObject* caretPainter = caretRenderer();

887

if (!caretPainter)

888

return IntRect();

889

890

return caretPainter->localToAbsoluteQuad(FloatRect(rect)).enclosingBoundingBox();

891

}

892

796

893

IntRect SelectionController::absoluteCaretBounds()

797

894

{

798

895

recomputeCaretRect();

811

908

812

909

IntRect SelectionController::caretRepaintRect() const

813

910

{

814

IntRect localRect = repaintRectForCaret(localCaretRect());

815

816

RenderObject* caretPainter = caretRenderer();

817

if (caretPainter)

818

return caretPainter->localToAbsoluteQuad(FloatRect(localRect)).enclosingBoundingBox();

819

820

return IntRect();

911

return absoluteBoundsForLocalRect(repaintRectForCaret(localCaretRect()));

821

912

}

822

913

823

914

bool SelectionController::recomputeCaretRect()

824

915

{

825

if (!m_frame || !m_frame->document())

916

if (!m_frame)

826

917

return false;

827

918

828

919

FrameView* v = m_frame->document()->view();

833

924

return false;

834

925

835

926

IntRect oldRect = m_caretRect;

836

m_needsLayout = true;

837

927

IntRect newRect = localCaretRect();

838

928

if (oldRect == newRect && !m_absCaretBoundsDirty)

839

929

return false;

840

930

841

IntRect oldAbsRepaintRect = m_absCaretBounds;

842

m_absCaretBounds = caretRepaintRect();

931

IntRect oldAbsCaretBounds = m_absCaretBounds;

932

// FIXME: Rename m_caretRect to m_localCaretRect.

933

m_absCaretBounds = absoluteBoundsForLocalRect(m_caretRect);

843

934

m_absCaretBoundsDirty = false;

844

935

845

if (oldAbsRepaintRect == m_absCaretBounds)

936

if (oldAbsCaretBounds == m_absCaretBounds)

846

937

return false;

938

939

IntRect oldAbsoluteCaretRepaintBounds = m_absoluteCaretRepaintBounds;

940

// We believe that we need to inflate the local rect before transforming it to obtain the repaint bounds.

941

m_absoluteCaretRepaintBounds = caretRepaintRect();

847

942

848

if (RenderView* view = static_cast<RenderView*>(m_frame->document()->renderer())) {

849

view->repaintViewRectangle(oldAbsRepaintRect, false);

850

view->repaintViewRectangle(m_absCaretBounds, false);

943

if (RenderView* view = toRenderView(m_frame->document()->renderer())) {

944

// FIXME: make caret repainting container-aware.

945

view->repaintRectangleInViewAndCompositedLayers(oldAbsoluteCaretRepaintBounds, false);

946

view->repaintRectangleInViewAndCompositedLayers(m_absoluteCaretRepaintBounds, false);

851

947

}

852

948

853

949

return true;

878

974

m_needsLayout = true;

879

975

880

976

if (!caretRectChanged) {

881

if (RenderView* view = static_cast<RenderView*>(d->renderer()))

882

view->repaintViewRectangle(caretRepaintRect(), false);

977

if (RenderView* view = toRenderView(d->renderer()))

978

view->repaintRectangleInViewAndCompositedLayers(caretRepaintRect(), false);

883

979

}

884

980

}

885

981

911

1007

fprintf(stderr, "%s%s\n", selected ? "==> " : " ", element->localName().string().utf8().data());

912

1008

}

913

1009

else if (r->isText()) {

914

RenderText* textRenderer = static_cast<RenderText*>(r);

1010

RenderText* textRenderer = toRenderText(r);

915

1011

if (textRenderer->textLength() == 0 || !textRenderer->firstTextBox()) {

916

1012

fprintf(stderr, "%s#text (empty)\n", selected ? "==> " : " ");

917

1013

return;

923

1019

if (selected) {

924

1020

int offset = 0;

925

1021

if (r->node() == m_sel.start().node())

926

offset = m_sel.start().offset();

1022

offset = m_sel.start().deprecatedEditingOffset();

927

1023

else if (r->node() == m_sel.end().node())

928

offset = m_sel.end().offset();

1024

offset = m_sel.end().deprecatedEditingOffset();

929

1025

930

1026

int pos;

931

1027

InlineTextBox *box = textRenderer->findNextInlineTextBox(offset, pos);

932

text = text.substring(box->m_start, box->m_len);

1028

text = text.substring(box->start(), box->len());

933

1029

934

1030

String show;

935

1031

int mid = max / 2;

987

1083

if (!document->renderer())

988

1084

return false;

989

1085

990

HitTestRequest request(true, true);

1086

HitTestRequest request(HitTestRequest::ReadOnly |

1087

HitTestRequest::Active);

991

1088

HitTestResult result(point);

992

document->renderer()->layer()->hitTest(request, result);

1089

document->renderView()->layer()->hitTest(request, result);

993

1090

Node* innerNode = result.innerNode();

994

1091

if (!innerNode || !innerNode->renderer())

995

1092

return false;

1033

1130

1034

1131

// Get to the <iframe> or <frame> (or even <object>) element in the parent frame.

1035

1132

Document* doc = m_frame->document();

1036

if (!doc)

1037

return;

1038

1133

Element* ownerElement = doc->ownerElement();

1039

1134

if (!ownerElement)

1040

1135

return;

1052

1147

VisiblePosition afterOwnerElement(VisiblePosition(ownerElementParent, ownerElementNodeIndex + 1, VP_UPSTREAM_IF_POSSIBLE));

1053

1148

1054

1149

// Focus on the parent frame, and then select from before this element to after.

1055

Selection newSelection(beforeOwnerElement, afterOwnerElement);

1150

VisibleSelection newSelection(beforeOwnerElement, afterOwnerElement);

1056

1151

if (parent->shouldChangeSelection(newSelection)) {

1057

1152

page->focusController()->setFocusedFrame(parent);

1058

1153

parent->selection()->setSelection(newSelection);

1062

1157

void SelectionController::selectAll()

1063

1158

{

1064

1159

Document* document = m_frame->document();

1065

if (!document)

1066

return;

1067

1160

1068

1161

if (document->focusedNode() && document->focusedNode()->canSelectAll()) {

1069

1162

document->focusedNode()->selectAll();

1080

1173

}

1081

1174

if (!root)

1082

1175

return;

1083

Selection newSelection(Selection::selectionFromContentsOfNode(root));

1176

VisibleSelection newSelection(VisibleSelection::selectionFromContentsOfNode(root));

1084

1177

if (m_frame->shouldChangeSelection(newSelection))

1085

1178

setSelection(newSelection);

1086

1179

selectFrameElementInParentIfFullySelected();

1124

1217

// FIXME: Can we provide extentAffinity?

1125

1218

VisiblePosition visibleStart(startContainer, startOffset, collapsed ? affinity : DOWNSTREAM);

1126

1219

VisiblePosition visibleEnd(endContainer, endOffset, SEL_DEFAULT_AFFINITY);

1127

setSelection(Selection(visibleStart, visibleEnd), closeTyping);

1220

setSelection(VisibleSelection(visibleStart, visibleEnd), closeTyping);

1128

1221

return true;

1129

1222

}

1130

1223

1158

1251

// Because RenderObject::selectionBackgroundColor() and

1159

1252

// RenderObject::selectionForegroundColor() check if the frame is active,

1160

1253

// we have to update places those colors were painted.

1161

if (RenderView* view = static_cast<RenderView*>(m_frame->document()->renderer()))

1162

view->repaintViewRectangle(enclosingIntRect(m_frame->selectionBounds()));

1254

if (RenderView* view = toRenderView(m_frame->document()->renderer()))

1255

view->repaintRectangleInViewAndCompositedLayers(enclosingIntRect(m_frame->selectionBounds()));

1163

1256

1164

1257

// Caret appears in the active frame.

1165

1258

if (activeAndFocused)

1173

1266

// RenderTheme::isFocused() check if the frame is active, we have to

1174

1267

// update style and theme state that depended on those.

1175

1268

if (Node* node = m_frame->document()->focusedNode()) {

1176

node->setChanged();

1269

node->setNeedsStyleRecalc();

1177

1270

if (RenderObject* renderer = node->renderer())

1178

1271

if (renderer && renderer->style()->hasAppearance())

1179

theme()->stateChanged(renderer, FocusState);

1272

renderer->theme()->stateChanged(renderer, FocusState);

1180

1273

}

1181

1274

1182

1275

// Secure keyboard entry is set by the active frame.

1196

1289

m_focused = flag;

1197

1290

1198

1291

focusedOrActiveStateChanged();

1199

1200

if (Document* doc = m_frame->document())

1201

doc->dispatchWindowEvent(flag ? eventNames().focusEvent : eventNames().blurEvent, false, false);

1202

1292

}

1203

1293

1204

1294

bool SelectionController::isFocusedAndActive() const

Older »