Home | History | Annotate | Download | only in utils 
      1 
      2 /*
      3  * Copyright 2011 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 #include "SkProxyCanvas.h"
      9 
     10 SkProxyCanvas::SkProxyCanvas(SkCanvas* proxy) : fProxy(proxy) {
     11     SkSafeRef(fProxy);
     12 }
     13 
     14 SkProxyCanvas::~SkProxyCanvas() {
     15     SkSafeUnref(fProxy);
     16 }
     17 
     18 void SkProxyCanvas::setProxy(SkCanvas* proxy) {
     19     SkRefCnt_SafeAssign(fProxy, proxy);
     20 }
     21 
     22 ///////////////////////////////// Overrides ///////////
     23 
     24 int SkProxyCanvas::save(SaveFlags flags) {
     25     return fProxy->save(flags);
     26 }
     27 
     28 int SkProxyCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
     29                              SaveFlags flags) {
     30     return fProxy->saveLayer(bounds, paint, flags);
     31 }
     32 
     33 void SkProxyCanvas::restore() {
     34     fProxy->restore();
     35 }
     36 
     37 bool SkProxyCanvas::translate(SkScalar dx, SkScalar dy) {
     38     return fProxy->translate(dx, dy);
     39 }
     40 
     41 bool SkProxyCanvas::scale(SkScalar sx, SkScalar sy) {
     42     return fProxy->scale(sx, sy);
     43 }
     44 
     45 bool SkProxyCanvas::rotate(SkScalar degrees) {
     46     return fProxy->rotate(degrees);
     47 }
     48 
     49 bool SkProxyCanvas::skew(SkScalar sx, SkScalar sy) {
     50     return fProxy->skew(sx, sy);
     51 }
     52 
     53 bool SkProxyCanvas::concat(const SkMatrix& matrix) {
     54     return fProxy->concat(matrix);
     55 }
     56 
     57 void SkProxyCanvas::setMatrix(const SkMatrix& matrix) {
     58     fProxy->setMatrix(matrix);
     59 }
     60 
     61 bool SkProxyCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
     62     return fProxy->clipRect(rect, op, doAA);
     63 }
     64 
     65 bool SkProxyCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
     66     return fProxy->clipPath(path, op, doAA);
     67 }
     68 
     69 bool SkProxyCanvas::clipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
     70     return fProxy->clipRegion(deviceRgn, op);
     71 }
     72 
     73 void SkProxyCanvas::drawPaint(const SkPaint& paint) {
     74     fProxy->drawPaint(paint);
     75 }
     76 
     77 void SkProxyCanvas::drawPoints(PointMode mode, size_t count,
     78                                const SkPoint pts[], const SkPaint& paint) {
     79     fProxy->drawPoints(mode, count, pts, paint);
     80 }
     81 
     82 void SkProxyCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
     83     fProxy->drawRect(rect, paint);
     84 }
     85 
     86 void SkProxyCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
     87     fProxy->drawPath(path, paint);
     88 }
     89 
     90 void SkProxyCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
     91                                const SkPaint* paint) {
     92     fProxy->drawBitmap(bitmap, x, y, paint);
     93 }
     94 
     95 void SkProxyCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src,
     96                                    const SkRect& dst, const SkPaint* paint) {
     97     fProxy->drawBitmapRect(bitmap, src, dst, paint);
     98 }
     99 
    100 void SkProxyCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
    101                                      const SkPaint* paint) {
    102     fProxy->drawBitmapMatrix(bitmap, m, paint);
    103 }
    104 
    105 void SkProxyCanvas::drawSprite(const SkBitmap& bitmap, int x, int y,
    106                                const SkPaint* paint) {
    107     fProxy->drawSprite(bitmap, x, y, paint);
    108 }
    109 
    110 void SkProxyCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
    111                              SkScalar y, const SkPaint& paint) {
    112     fProxy->drawText(text, byteLength, x, y, paint);
    113 }
    114 
    115 void SkProxyCanvas::drawPosText(const void* text, size_t byteLength,
    116                                 const SkPoint pos[], const SkPaint& paint) {
    117     fProxy->drawPosText(text, byteLength, pos, paint);
    118 }
    119 
    120 void SkProxyCanvas::drawPosTextH(const void* text, size_t byteLength,
    121                                  const SkScalar xpos[], SkScalar constY,
    122                                  const SkPaint& paint) {
    123     fProxy->drawPosTextH(text, byteLength, xpos, constY, paint);
    124 }
    125 
    126 void SkProxyCanvas::drawTextOnPath(const void* text, size_t byteLength,
    127                                    const SkPath& path, const SkMatrix* matrix,
    128                                    const SkPaint& paint) {
    129     fProxy->drawTextOnPath(text, byteLength, path, matrix, paint);
    130 }
    131 
    132 void SkProxyCanvas::drawPicture(SkPicture& picture) {
    133     fProxy->drawPicture(picture);
    134 }
    135 
    136 void SkProxyCanvas::drawVertices(VertexMode vmode, int vertexCount,
    137                                  const SkPoint vertices[], const SkPoint texs[],
    138                                  const SkColor colors[], SkXfermode* xmode,
    139                                  const uint16_t indices[], int indexCount,
    140                                  const SkPaint& paint) {
    141     fProxy->drawVertices(vmode, vertexCount, vertices, texs, colors,
    142                                      xmode, indices, indexCount, paint);
    143 }
    144 
    145 void SkProxyCanvas::drawData(const void* data, size_t length) {
    146     fProxy->drawData(data, length);
    147 }
    148 
    149 SkBounder* SkProxyCanvas::setBounder(SkBounder* bounder) {
    150     return fProxy->setBounder(bounder);
    151 }
    152 
    153 SkDrawFilter* SkProxyCanvas::setDrawFilter(SkDrawFilter* filter) {
    154     return fProxy->setDrawFilter(filter);
    155 }
    156 
    157