~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

virtual void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect);

262

virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);

263

virtual void paintScrollbar(GraphicsContext*, Scrollbar*, const IntRect&) OVERRIDE;

264

265

Color documentBackgroundColor() const;

266

267

bool isInChildFrameWithFrameFlattening() const;

268

269

static double currentPaintTimeStamp() { return sCurrentPaintTimeStamp; } // returns 0 if not painting

270

271

void updateLayoutAndStyleIfNeededRecursive();

272

273

void incrementVisuallyNonEmptyCharacterCount(unsigned);

274

void incrementVisuallyNonEmptyPixelCount(const IntSize&);

275

void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; }

276

bool isVisuallyNonEmpty() const { return m_isVisuallyNonEmpty; }

277

void enableAutoSizeMode(bool enable, const IntSize& minSize, const IntSize& maxSize);

278

279

void forceLayout(bool allowSubtree = false);

280

void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor, AdjustViewSizeOrNot);

281

282

// FIXME: This method is retained because of embedded WebViews in AppKit. When a WebView is embedded inside

283

// some enclosing view with auto-pagination, no call happens to resize the view. The new pagination model

284

// needs the view to resize as a result of the breaks, but that means that the enclosing view has to potentially

285

// resize around that view. Auto-pagination uses the bounds of the actual view that's being printed to determine

286

// the edges of the print operation, so the resize is necessary if the enclosing view's bounds depend on the

287

// web document's bounds.

288

289

// This is already a problem if the view needs to be a different size because of printer fonts or because of print stylesheets.

290

// Mail/Dictionary work around this problem by using the _layoutForPrinting SPI

291

// to at least get print stylesheets and printer fonts into play, but since WebKit doesn't know about the page offset or

292

// page size, it can't actually paginate correctly during _layoutForPrinting.

293

294

// We can eventually move Mail to a newer SPI that would let them opt in to the layout-time pagination model,

295

// but that doesn't solve the general problem of how other AppKit views could opt in to the better model.

296

297

// NO OTHER PLATFORM BESIDES MAC SHOULD USE THIS METHOD.

298

void adjustPageHeightDeprecated(float* newBottom, float oldTop, float oldBottom, float bottomLimit);

299

300

bool scrollToFragment(const KURL&);

301

bool scrollToAnchor(const String&);

302

void maintainScrollPositionAtAnchor(Node*);

303

void scrollElementToRect(Element*, const IntRect&);

304

305

// Methods to convert points and rects between the coordinate space of the renderer, and this view.

306

virtual IntRect convertFromRenderer(const RenderObject*, const IntRect&) const;

307

virtual IntRect convertToRenderer(const RenderObject*, const IntRect&) const;

308

virtual IntPoint convertFromRenderer(const RenderObject*, const IntPoint&) const;

309

virtual IntPoint convertToRenderer(const RenderObject*, const IntPoint&) const;

310

311

bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; }

312

313

enum ScrollbarModesCalculationStrategy { RulesFromWebContentOnly, AnyRule };

314

void calculateScrollbarModesForLayout(ScrollbarMode& hMode, ScrollbarMode& vMode, ScrollbarModesCalculationStrategy = AnyRule);

315

316

// Normal delay

317

static void setRepaintThrottlingDeferredRepaintDelay(double p);

318

// Negative value would mean that first few repaints happen without a delay

319

static void setRepaintThrottlingnInitialDeferredRepaintDelayDuringLoading(double p);

320

// The delay grows on each repaint to this maximum value

321

static void setRepaintThrottlingMaxDeferredRepaintDelayDuringLoading(double p);

322

// On each repaint the delay increses by this amount

323

static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p);

324

325

virtual IntPoint currentMousePosition() const;

326

327

virtual bool scrollbarsCanBeActive() const OVERRIDE;

328

329

// FIXME: Remove this method once plugin loading is decoupled from layout.

330

void flushAnyPendingPostLayoutTasks();

331

332

virtual bool shouldSuspendScrollAnimations() const;

333

virtual void scrollbarStyleChanged(int newStyle, bool forceUpdate);

334

335

void setAnimatorsAreActive();

336

337

RenderBox* embeddedContentBox() const;

338

339

void setTracksRepaints(bool);

340

bool isTrackingRepaints() const { return m_isTrackingRepaints; }

341

void resetTrackedRepaints();

342

const Vector<IntRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }

343

String trackedRepaintRectsAsText() const;

344

345

typedef HashSet<ScrollableArea*> ScrollableAreaSet;

346

void addScrollableArea(ScrollableArea*);

347

void removeScrollableArea(ScrollableArea*);

348

bool containsScrollableArea(ScrollableArea*) const;

349

const ScrollableAreaSet* scrollableAreas() const { return m_scrollableAreas.get(); }

350

351

virtual void removeChild(Widget*) OVERRIDE;

352

353

// This function exists for ports that need to handle wheel events manually.

354

// On Mac WebKit1 the underlying NSScrollView just does the scrolling, but on most other platforms

355

// we need this function in order to do the scroll ourselves.

356

bool wheelEvent(const PlatformWheelEvent&);

357

358

void setScrollingPerformanceLoggingEnabled(bool);

359

360

// Page and FrameView both store a Pagination value. Page::pagination() is set only by API,

361

// and FrameView::pagination() is set only by CSS. Page::pagination() will affect all

362

// FrameViews in the page cache, but FrameView::pagination() only affects the current

363

// FrameView. FrameView::pagination() will return m_pagination if it has been set. Otherwise,

364

// it will return Page::pagination() since currently there are no callers that need to

365

// distinguish between the two.

366

const Pagination& pagination() const;

367

void setPagination(const Pagination&);

368

369

bool inProgrammaticScroll() const { return m_inProgrammaticScroll; }

370

void setInProgrammaticScroll(bool programmaticScroll) { m_inProgrammaticScroll = programmaticScroll; }

371

372

#if ENABLE(CSS_FILTERS)

373

void setHasSoftwareFilters(bool hasSoftwareFilters) { m_hasSoftwareFilters = hasSoftwareFilters; }

374

bool hasSoftwareFilters() const { return m_hasSoftwareFilters; }

375

#endif

376

377

protected:

378

virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);

379

virtual void scrollContentsSlowPath(const IntRect& updateRect);

380

381

virtual bool isVerticalDocument() const;

382

virtual bool isFlippedDocument() const;

383

384

private:

385

explicit FrameView(Frame*);

386

387

void reset();

388

void init();

389

390

virtual bool isFrameView() const;

391

392

friend class RenderWidget;

393

bool useSlowRepaints(bool considerOverlap = true) const;

394

bool useSlowRepaintsIfNotOverlapped() const;

395

void updateCanBlitOnScrollRecursively();

396

bool contentsInCompositedLayer() const;

397

398

bool shouldUpdateFixedElementsAfterScrolling();

399

400

void applyOverflowToViewport(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);

401

void applyPaginationToViewport();

402

403

void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);

404

405

void paintControlTints();

406

407

void forceLayoutParentViewIfNeeded();

408

void performPostLayoutTasks();

409

void autoSizeIfEnabled();

410

411

virtual void repaintContentRectangle(const IntRect&, bool immediate);

412

virtual void contentsResized() OVERRIDE;

413

virtual void visibleContentsResized();

414

415

virtual void delegatesScrollingDidChange();

416

417

// Override ScrollView methods to do point conversion via renderers, in order to

418

// take transforms into account.

419

virtual IntRect convertToContainingView(const IntRect&) const OVERRIDE;

420

virtual IntRect convertFromContainingView(const IntRect&) const OVERRIDE;

421

virtual IntPoint convertToContainingView(const IntPoint&) const OVERRIDE;

422

virtual IntPoint convertFromContainingView(const IntPoint&) const OVERRIDE;

423

424

// ScrollableArea interface

425

virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) OVERRIDE;

426

virtual bool isActive() const OVERRIDE;

427

virtual void getTickmarks(Vector<IntRect>&) const OVERRIDE;

428

virtual void scrollTo(const IntSize&) OVERRIDE;

429

virtual void setVisibleScrollerThumbRect(const IntRect&) OVERRIDE;

430

virtual ScrollableArea* enclosingScrollableArea() const OVERRIDE;

431

virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;

432

virtual bool scrollAnimatorEnabled() const OVERRIDE;

433

#if USE(ACCELERATED_COMPOSITING)

434

virtual GraphicsLayer* layerForHorizontalScrollbar() const OVERRIDE;

435

virtual GraphicsLayer* layerForVerticalScrollbar() const OVERRIDE;

436

virtual GraphicsLayer* layerForScrollCorner() const OVERRIDE;

437

#if ENABLE(RUBBER_BANDING)

438

virtual GraphicsLayer* layerForOverhangAreas() const OVERRIDE;

439

#endif

440

#endif

441

442

void updateScrollableAreaSet();

443

444

virtual void notifyPageThatContentAreaWillPaint() const;

445

446

bool shouldUseLoadTimeDeferredRepaintDelay() const;

447

void deferredRepaintTimerFired(Timer<FrameView>*);

448

void doDeferredRepaints();

449

void updateDeferredRepaintDelayAfterRepaint();

450

double adjustedDeferredRepaintDelay() const;

451

452

bool updateWidgets();

453

void updateWidget(RenderEmbeddedObject*);

454

void scrollToAnchor();

455

void scrollPositionChanged();

456

457

bool hasCustomScrollbars() const;

458

459

virtual void updateScrollCorner();

460

461

FrameView* parentFrameView() const;

462

463

bool doLayoutWithFrameFlattening(bool allowSubtree);

464

465

void setViewportConstrainedObjectsNeedLayout();

466

467

virtual AXObjectCache* axObjectCache() const;

468

void notifyWidgetsInAllFrames(WidgetNotification);

469

470

static double sCurrentPaintTimeStamp; // used for detecting decoded resource thrash in the cache

471

472

LayoutSize m_size;

473

LayoutSize m_margins;

474

475

typedef HashSet<RenderEmbeddedObject*> RenderEmbeddedObjectSet;

476

OwnPtr<RenderEmbeddedObjectSet> m_widgetUpdateSet;

477

RefPtr<Frame> m_frame;

478

479

bool m_doFullRepaint;

480

481

bool m_canHaveScrollbars;

482

bool m_cannotBlitToWindow;

483

bool m_isOverlapped;

484

bool m_contentIsOpaque;

485

unsigned m_slowRepaintObjectCount;

486

int m_borderX;

487

int m_borderY;

488

489

Timer<FrameView> m_layoutTimer;

490

bool m_delayedLayout;

491

RenderObject* m_layoutRoot;

492

493

bool m_layoutSchedulingEnabled;

494

bool m_inLayout;

495

bool m_doingPreLayoutStyleUpdate;

496

bool m_inSynchronousPostLayout;

497

int m_layoutCount;

498

unsigned m_nestedLayoutCount;

499

Timer<FrameView> m_postLayoutTasksTimer;

500

bool m_firstLayoutCallbackPending;

501

502

bool m_firstLayout;

503

bool m_isTransparent;

504

Color m_baseBackgroundColor;

505

IntSize m_lastViewportSize;

506

float m_lastZoomFactor;

507

508

String m_mediaType;

509

String m_mediaTypeWhenNotPrinting;

510

511

OwnPtr<FrameActionScheduler> m_actionScheduler;

512

513

bool m_overflowStatusDirty;

514

bool m_horizontalOverflow;

515

bool m_verticalOverflow;

516

RenderObject* m_viewportRenderer;

517

518

Pagination m_pagination;

519

520

bool m_wasScrolledByUser;

521

bool m_inProgrammaticScroll;

522

bool m_safeToPropagateScrollToParent;

523

524

unsigned m_deferringRepaints;

525

unsigned m_repaintCount;

526

Vector<LayoutRect> m_repaintRects;

527

Timer<FrameView> m_deferredRepaintTimer;

528

double m_deferredRepaintDelay;

529

double m_lastPaintTime;

530

531

unsigned m_disableRepaints;

532

533

bool m_isTrackingRepaints; // Used for testing.

534

Vector<IntRect> m_trackedRepaintRects;

535

536

bool m_shouldUpdateWhileOffscreen;

537

538

unsigned m_deferSetNeedsLayouts;

539

bool m_setNeedsLayoutWasDeferred;

540

541

RefPtr<Node> m_nodeToDraw;

542

PaintBehavior m_paintBehavior;

543

bool m_isPainting;

544

545

unsigned m_visuallyNonEmptyCharacterCount;

546

unsigned m_visuallyNonEmptyPixelCount;

547

bool m_isVisuallyNonEmpty;

548

bool m_firstVisuallyNonEmptyLayoutCallbackPending;

549

550

RefPtr<Node> m_maintainScrollPositionAnchor;

551

552

// Renderer to hold our custom scroll corner.

553

RenderScrollbarPart* m_scrollCorner;

554

555

// If true, automatically resize the frame view around its content.

556

bool m_shouldAutoSize;

557

bool m_inAutoSize;

558

// True if autosize has been run since m_shouldAutoSize was set.

559

bool m_didRunAutosize;

560

// The lower bound on the size when autosizing.

561

IntSize m_minAutoSize;

562

// The upper bound on the size when autosizing.

563

IntSize m_maxAutoSize;

564

565

OwnPtr<ScrollableAreaSet> m_scrollableAreas;

566

OwnPtr<ViewportConstrainedObjectSet> m_viewportConstrainedObjects;

567

568

static double s_normalDeferredRepaintDelay;

569

static double s_initialDeferredRepaintDelayDuringLoading;

570

static double s_maxDeferredRepaintDelayDuringLoading;

571

static double s_deferredRepaintDelayIncrementDuringLoading;

572

573

#if ENABLE(CSS_FILTERS)

574

bool m_hasSoftwareFilters;

575

#endif

576

};

577

578

inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)

579

{

580

if (m_isVisuallyNonEmpty)

581

return;

582

m_visuallyNonEmptyCharacterCount += count;

583

// Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout.

584

// The first few hundred characters rarely contain the interesting content of the page.

585

static const unsigned visualCharacterThreshold = 200;

586

if (m_visuallyNonEmptyCharacterCount > visualCharacterThreshold)

587

setIsVisuallyNonEmpty();

588

}

589

590

inline void FrameView::incrementVisuallyNonEmptyPixelCount(const IntSize& size)

591

{

592

if (m_isVisuallyNonEmpty)

593

return;

594

m_visuallyNonEmptyPixelCount += size.width() * size.height();

595

// Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout

596

static const unsigned visualPixelThreshold = 32 * 32;

597

if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)

598

setIsVisuallyNonEmpty();

599

}

600

601

inline int FrameView::mapFromLayoutToCSSUnits(LayoutUnit value)

602

{

603

return value / (m_frame->pageZoomFactor() * m_frame->frameScaleFactor());

604

}

605

606

inline LayoutUnit FrameView::mapFromCSSToLayoutUnits(int value)

607

{

608

return value * m_frame->pageZoomFactor() * m_frame->frameScaleFactor();

609

}

610

611

} // namespace WebCore

612

613

#endif // FrameView_h

Older »