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

void drawNativeImage(NativeImagePtr, const FloatSize& selfSize, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeSourceOver, ImageOrientation = DefaultImageOrientation);

275

276

// Allow font smoothing (LCD antialiasing). Not part of the graphics state.

277

void setAllowsFontSmoothing(bool);

278

279

void setIsCALayerContext(bool);

280

bool isCALayerContext() const;

281

282

void setIsAcceleratedContext(bool);

283

#endif

284

bool isAcceleratedContext() const;

285

286

void save();

287

void restore();

288

289

// These draw methods will do both stroking and filling.

290

// FIXME: ...except drawRect(), which fills properly but always strokes

291

// using a 1-pixel stroke inset from the rect borders (of the correct

292

// stroke color).

293

void drawRect(const IntRect&);

294

void drawLine(const IntPoint&, const IntPoint&);

295

void drawEllipse(const IntRect&);

296

void drawConvexPolygon(size_t numPoints, const FloatPoint*, bool shouldAntialias = false);

297

298

void fillPath(const Path&);

299

void strokePath(const Path&);

300

301

void fillEllipse(const FloatRect&);

302

void strokeEllipse(const FloatRect&);

303

304

// Arc drawing (used by border-radius in CSS) just supports stroking at the moment.

305

void strokeArc(const IntRect&, int startAngle, int angleSpan);

306

307

void fillRect(const FloatRect&);

308

void fillRect(const FloatRect&, const Color&, ColorSpace);

309

void fillRect(const FloatRect&, Generator&);

310

void fillRect(const FloatRect&, const Color&, ColorSpace, CompositeOperator);

311

void fillRoundedRect(const IntRect&, const IntSize& topLeft, const IntSize& topRight, const IntSize& bottomLeft, const IntSize& bottomRight, const Color&, ColorSpace);

312

void fillRoundedRect(const RoundedRect&, const Color&, ColorSpace);

313

void fillRectWithRoundedHole(const IntRect&, const RoundedRect& roundedHoleRect, const Color&, ColorSpace);

314

315

void clearRect(const FloatRect&);

316

317

void strokeRect(const FloatRect&, float lineWidth);

318

319

void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver, RespectImageOrientationEnum = DoNotRespectImageOrientation);

320

void drawImage(Image*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, RespectImageOrientationEnum = DoNotRespectImageOrientation, bool useLowQualityScale = false);

321

void drawImage(Image*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, RespectImageOrientationEnum = DoNotRespectImageOrientation);

322

void drawImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, RespectImageOrientationEnum = DoNotRespectImageOrientation, bool useLowQualityScale = false);

323

void drawImage(Image*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),

324

CompositeOperator = CompositeSourceOver, RespectImageOrientationEnum = DoNotRespectImageOrientation, bool useLowQualityScale = false);

325

void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize,

326

CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);

327

void drawTiledImage(Image*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect,

328

const FloatSize& tileScaleFactor, Image::TileRule hRule = Image::StretchTile, Image::TileRule vRule = Image::StretchTile,

329

CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);

330

331

void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint&, CompositeOperator = CompositeSourceOver);

332

void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect&, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);

333

void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntPoint& destPoint, const IntRect& srcRect, CompositeOperator = CompositeSourceOver);

334

void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);

335

void drawImageBuffer(ImageBuffer*, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),

336

CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);

337

338

void setImageInterpolationQuality(InterpolationQuality);

339

InterpolationQuality imageInterpolationQuality() const;

340

341

void clip(const IntRect&);

342

void clip(const FloatRect&);

343

void addRoundedRectClip(const RoundedRect&);

344

void addInnerRoundedRectClip(const IntRect&, int thickness);

345

void clipOut(const IntRect&);

346

void clipOutRoundedRect(const RoundedRect&);

347

void clipPath(const Path&, WindRule);

348

void clipConvexPolygon(size_t numPoints, const FloatPoint*, bool antialias = true);

349

void clipToImageBuffer(ImageBuffer*, const FloatRect&);

350

351

IntRect clipBounds() const;

352

353

TextDrawingModeFlags textDrawingMode() const;

354

void setTextDrawingMode(TextDrawingModeFlags);

355

356

void drawText(const Font&, const TextRun&, const FloatPoint&, int from = 0, int to = -1);

357

void drawEmphasisMarks(const Font&, const TextRun& , const AtomicString& mark, const FloatPoint&, int from = 0, int to = -1);

358

void drawBidiText(const Font&, const TextRun&, const FloatPoint&, Font::CustomFontNotReadyAction = Font::DoNotPaintIfFontNotReady);

359

void drawHighlightForText(const Font&, const TextRun&, const FloatPoint&, int h, const Color& backgroundColor, ColorSpace, int from = 0, int to = -1);

360

361

enum RoundingMode {

362

RoundAllSides,

363

RoundOriginAndDimensions

364

};

365

FloatRect roundToDevicePixels(const FloatRect&, RoundingMode = RoundAllSides);

366

367

void drawLineForText(const FloatPoint&, float width, bool printing);

368

enum DocumentMarkerLineStyle {

369

DocumentMarkerSpellingLineStyle,

370

DocumentMarkerGrammarLineStyle,

371

DocumentMarkerAutocorrectionReplacementLineStyle,

372

DocumentMarkerDictationAlternativesLineStyle

373

};

374

void drawLineForDocumentMarker(const FloatPoint&, float width, DocumentMarkerLineStyle);

375

376

bool paintingDisabled() const;

377

void setPaintingDisabled(bool);

378

379

bool updatingControlTints() const;

380

void setUpdatingControlTints(bool);

381

382

void beginTransparencyLayer(float opacity);

383

void endTransparencyLayer();

384

bool isInTransparencyLayer() const;

385

386

bool hasShadow() const;

387

void setShadow(const FloatSize&, float blur, const Color&, ColorSpace);

388

// Legacy shadow blur radius is used for canvas, and -webkit-box-shadow.

389

// It has different treatment of radii > 8px.

390

void setLegacyShadow(const FloatSize&, float blur, const Color&, ColorSpace);

391

392

bool getShadow(FloatSize&, float&, Color&, ColorSpace&) const;

393

void clearShadow();

394

395

void drawFocusRing(const Vector<IntRect>&, int width, int offset, const Color&);

396

void drawFocusRing(const Path&, int width, int offset, const Color&);

397

398

void setLineCap(LineCap);

399

void setLineDash(const DashArray&, float dashOffset);

400

void setLineJoin(LineJoin);

401

void setMiterLimit(float);

402

403

void setAlpha(float);

404

405

void setCompositeOperation(CompositeOperator);

406

CompositeOperator compositeOperation() const;

407

408

void clip(const Path&);

409

410

// This clip function is used only by <canvas> code. It allows

411

// implementations to handle clipping on the canvas differently since

412

// the discipline is different.

413

void canvasClip(const Path&);

414

void clipOut(const Path&);

415

416

void scale(const FloatSize&);

417

void rotate(float angleInRadians);

418

void translate(const FloatSize& size) { translate(size.width(), size.height()); }

419

void translate(float x, float y);

420

421

void setURLForRect(const KURL&, const IntRect&);

422

423

void concatCTM(const AffineTransform&);

424

void setCTM(const AffineTransform&);

425

426

enum IncludeDeviceScale { DefinitelyIncludeDeviceScale, PossiblyIncludeDeviceScale };

427

AffineTransform getCTM(IncludeDeviceScale includeScale = PossiblyIncludeDeviceScale) const;

428

429

#if ENABLE(3D_RENDERING) && USE(TEXTURE_MAPPER)

430

// This is needed when using accelerated-compositing in software mode, like in TextureMapper.

431

void concat3DTransform(const TransformationMatrix&);

432

void set3DTransform(const TransformationMatrix&);

433

TransformationMatrix get3DTransform() const;

434

#endif

435

// Create an image buffer compatible with this context, with suitable resolution

436

// for drawing into the buffer and then into this context.

437

PassOwnPtr<ImageBuffer> createCompatibleBuffer(const IntSize&) const;

438

bool isCompatibleWithBuffer(ImageBuffer*) const;

439

440

// This function applies the device scale factor to the context, making the context capable of

441

// acting as a base-level context for a HiDPI environment.

442

void applyDeviceScaleFactor(float);

443

void platformApplyDeviceScaleFactor(float);

444

445

#if OS(WINDOWS)

446

HDC getWindowsContext(const IntRect&, bool supportAlphaBlend, bool mayCreateBitmap); // The passed in rect is used to create a bitmap for compositing inside transparency layers.

447

void releaseWindowsContext(HDC, const IntRect&, bool supportAlphaBlend, bool mayCreateBitmap); // The passed in HDC should be the one handed back by getWindowsContext.

448

#if PLATFORM(WIN)

449

#if OS(WINCE)

450

void setBitmap(PassRefPtr<SharedBitmap>);

451

const AffineTransform& affineTransform() const;

452

AffineTransform& affineTransform();

453

void resetAffineTransform();

454

void fillRect(const FloatRect&, const Gradient*);

455

void drawText(const SimpleFontData* fontData, const GlyphBuffer& glyphBuffer, int from, int numGlyphs, const FloatPoint& point);

456

void drawFrameControl(const IntRect& rect, unsigned type, unsigned state);

457

void drawFocusRect(const IntRect& rect);

458

void paintTextField(const IntRect& rect, unsigned state);

459

void drawBitmap(SharedBitmap*, const IntRect& dstRect, const IntRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp);

460

void drawBitmapPattern(SharedBitmap*, const FloatRect& tileRectIn, const AffineTransform& patternTransform, const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize);

461

void drawIcon(HICON icon, const IntRect& dstRect, UINT flags);

462

void drawRoundCorner(bool newClip, RECT clipRect, RECT rectWin, HDC dc, int width, int height);

463

#else

464

GraphicsContext(HDC, bool hasAlpha = false); // FIXME: To be removed.

465

466

// When set to true, child windows should be rendered into this context

467

// rather than allowing them just to render to the screen. Defaults to

468

// false.

469

// FIXME: This is a layering violation. GraphicsContext shouldn't know

470

// what a "window" is. It would be much more appropriate for this flag

471

// to be passed as a parameter alongside the GraphicsContext, but doing

472

// that would require lots of changes in cross-platform code that we

473

// aren't sure we want to make.

474

void setShouldIncludeChildWindows(bool);

475

bool shouldIncludeChildWindows() const;

476

477

class WindowsBitmap {

478

WTF_MAKE_NONCOPYABLE(WindowsBitmap);

479

public:

480

WindowsBitmap(HDC, const IntSize&);

481

~WindowsBitmap();

482

483

HDC hdc() const { return m_hdc; }

484

UInt8* buffer() const { return m_pixelData.buffer(); }

485

unsigned bufferLength() const { return m_pixelData.bufferLength(); }

486

const IntSize& size() const { return m_pixelData.size(); }

487

unsigned bytesPerRow() const { return m_pixelData.bytesPerRow(); }

488

unsigned short bitsPerPixel() const { return m_pixelData.bitsPerPixel(); }

489

const DIBPixelData& windowsDIB() const { return m_pixelData; }

490

491

private:

492

HDC m_hdc;

493

HBITMAP m_bitmap;

494

DIBPixelData m_pixelData;

495

};

496

497

PassOwnPtr<WindowsBitmap> createWindowsBitmap(const IntSize&);

498

// The bitmap should be non-premultiplied.

499

void drawWindowsBitmap(WindowsBitmap*, const IntPoint&);

500

#endif

501

#else // PLATFORM(WIN)

502

bool shouldIncludeChildWindows() const { return false; }

503

#endif // PLATFORM(WIN)

504

#endif // OS(WINDOWS)

505

506

#if PLATFORM(WX)

507

// This is needed because of a bug whereby getting an HDC from a GDI+ context

508

// loses the scale operations applied to the context.

509

FloatSize currentScale();

510

#endif

511

512

#if PLATFORM(QT)

513

void pushTransparencyLayerInternal(const QRect&, qreal, QPixmap&);

514

void takeOwnershipOfPlatformContext();

515

#endif

516

517

#if PLATFORM(QT)

518

ShadowBlur* shadowBlur();

519

#endif

520

521

#if USE(CAIRO)

522

GraphicsContext(cairo_t*);

523

#endif

524

525

#if PLATFORM(GTK)

526

void setGdkExposeEvent(GdkEventExpose*);

527

GdkWindow* gdkWindow() const;

528

GdkEventExpose* gdkExposeEvent() const;

529

#endif

530

531

static void adjustLineToPixelBoundaries(FloatPoint& p1, FloatPoint& p2, float strokeWidth, StrokeStyle);

532

533

private:

534

void platformInit(PlatformGraphicsContext*);

535

void platformDestroy();

536

537

#if PLATFORM(WIN) && !OS(WINCE)

538

void platformInit(HDC, bool hasAlpha = false);

539

#endif

540

541

void savePlatformState();

542

void restorePlatformState();

543

544

void setPlatformTextDrawingMode(TextDrawingModeFlags);

545

void setPlatformFont(const Font& font);

546

547

void setPlatformStrokeColor(const Color&, ColorSpace);

548

void setPlatformStrokeStyle(StrokeStyle);

549

void setPlatformStrokeThickness(float);

550

551

void setPlatformFillColor(const Color&, ColorSpace);

552

553

void setPlatformShouldAntialias(bool);

554

void setPlatformShouldSmoothFonts(bool);

555

556

void setPlatformShadow(const FloatSize&, float blur, const Color&, ColorSpace);

557

void clearPlatformShadow();

558

559

void setPlatformCompositeOperation(CompositeOperator);

560

561

void beginPlatformTransparencyLayer(float opacity);

562

void endPlatformTransparencyLayer();

563

static bool supportsTransparencyLayers();

564

565

void fillEllipseAsPath(const FloatRect&);

566

void strokeEllipseAsPath(const FloatRect&);

567

568

void platformFillEllipse(const FloatRect&);

569

void platformStrokeEllipse(const FloatRect&);

570

571

GraphicsContextPlatformPrivate* m_data;

572

573

GraphicsContextState m_state;

574

Vector<GraphicsContextState> m_stack;

575

bool m_updatingControlTints;

576

unsigned m_transparencyCount;

577

};

578

579

class GraphicsContextStateSaver {

580

WTF_MAKE_FAST_ALLOCATED;

581

public:

582

GraphicsContextStateSaver(GraphicsContext& context, bool saveAndRestore = true)

583

: m_context(context)

584

, m_saveAndRestore(saveAndRestore)

585

{

586

if (m_saveAndRestore)

587

m_context.save();

588

}

589

590

~GraphicsContextStateSaver()

591

{

592

if (m_saveAndRestore)

593

m_context.restore();

594

}

595

596

void save()

597

{

598

ASSERT(!m_saveAndRestore);

599

m_context.save();

600

m_saveAndRestore = true;

601

}

602

603

void restore()

604

{

605

ASSERT(m_saveAndRestore);

606

m_context.restore();

607

m_saveAndRestore = false;

608

}

609

610

GraphicsContext* context() const { return &m_context; }

611

612

private:

613

GraphicsContext& m_context;

614

bool m_saveAndRestore;

615

};

616

617

} // namespace WebCore

618

619

#endif // GraphicsContext_h

620

Older »