diff options
Diffstat (limited to 'include/utils')
-rw-r--r-- | include/utils/SkCamera.h | 176 | ||||
-rw-r--r-- | include/utils/SkCullPoints.h | 75 | ||||
-rw-r--r-- | include/utils/SkDumpCanvas.h | 139 | ||||
-rw-r--r-- | include/utils/SkGLCanvas.h | 80 | ||||
-rw-r--r-- | include/utils/SkInterpolator.h | 139 | ||||
-rw-r--r-- | include/utils/SkNinePatch.h | 40 | ||||
-rw-r--r-- | include/utils/SkParse.h | 45 | ||||
-rw-r--r-- | include/utils/SkParsePaint.h | 34 | ||||
-rw-r--r-- | include/utils/SkProxyCanvas.h | 90 | ||||
-rw-r--r-- | include/utils/SkTextBox.h | 77 | ||||
-rw-r--r-- | include/utils/SkUnitMappers.h | 65 |
11 files changed, 960 insertions, 0 deletions
diff --git a/include/utils/SkCamera.h b/include/utils/SkCamera.h new file mode 100644 index 0000000000..8bbcabf478 --- /dev/null +++ b/include/utils/SkCamera.h @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +// Inspired by Rob Johnson's most excellent QuickDraw GX sample code + +#ifndef SkCamera_DEFINED +#define SkCamera_DEFINED + +#include "Sk64.h" +#include "SkMatrix.h" + +class SkCanvas; + +#ifdef SK_SCALAR_IS_FIXED + typedef SkFract SkUnitScalar; + #define SK_UnitScalar1 SK_Fract1 + #define SkUnitScalarMul(a, b) SkFractMul(a, b) + #define SkUnitScalarDiv(a, b) SkFractDiv(a, b) +#else + typedef float SkUnitScalar; + #define SK_UnitScalar1 SK_Scalar1 + #define SkUnitScalarMul(a, b) SkScalarMul(a, b) + #define SkUnitScalarDiv(a, b) SkScalarDiv(a, b) +#endif + +struct SkUnit3D { + SkUnitScalar fX, fY, fZ; + + void set(SkUnitScalar x, SkUnitScalar y, SkUnitScalar z) + { + fX = x; fY = y; fZ = z; + } + static SkUnitScalar Dot(const SkUnit3D&, const SkUnit3D&); + static void Cross(const SkUnit3D&, const SkUnit3D&, SkUnit3D* cross); +}; + +struct SkPoint3D { + SkScalar fX, fY, fZ; + + void set(SkScalar x, SkScalar y, SkScalar z) + { + fX = x; fY = y; fZ = z; + } + SkScalar normalize(SkUnit3D*) const; +}; +typedef SkPoint3D SkVector3D; + +struct SkMatrix3D { + SkScalar fMat[3][4]; + + void reset(); + + void setRow(int row, SkScalar a, SkScalar b, SkScalar c, SkScalar d = 0) + { + SkASSERT((unsigned)row < 3); + fMat[row][0] = a; + fMat[row][1] = b; + fMat[row][2] = c; + fMat[row][3] = d; + } + + void setRotateX(SkScalar deg); + void setRotateY(SkScalar deg); + void setRotateZ(SkScalar deg); + void setTranslate(SkScalar x, SkScalar y, SkScalar z); + + void preRotateX(SkScalar deg); + void preRotateY(SkScalar deg); + void preRotateZ(SkScalar deg); + void preTranslate(SkScalar x, SkScalar y, SkScalar z); + + void setConcat(const SkMatrix3D& a, const SkMatrix3D& b); + void mapPoint(const SkPoint3D& src, SkPoint3D* dst) const; + void mapVector(const SkVector3D& src, SkVector3D* dst) const; + + void mapPoint(SkPoint3D* v) const + { + this->mapPoint(*v, v); + } + void mapVector(SkVector3D* v) const + { + this->mapVector(*v, v); + } +}; + +class SkPatch3D { +public: + SkPatch3D(); + + void reset(); + void transform(const SkMatrix3D&, SkPatch3D* dst = NULL) const; + + // dot a unit vector with the patch's normal + SkScalar dotWith(SkScalar dx, SkScalar dy, SkScalar dz) const; + SkScalar dotWith(const SkVector3D& v) const + { + return this->dotWith(v.fX, v.fY, v.fZ); + } + + // depreicated, but still here for animator (for now) + void rotate(SkScalar x, SkScalar y, SkScalar z) {} + void rotateDegrees(SkScalar x, SkScalar y, SkScalar z) {} + +private: +public: // make public for SkDraw3D for now + SkVector3D fU, fV; + SkPoint3D fOrigin; + + friend class SkCamera3D; +}; + +class SkCamera3D { +public: + SkCamera3D(); + + void reset(); + void update(); + void patchToMatrix(const SkPatch3D&, SkMatrix* matrix) const; + + SkPoint3D fLocation; + SkPoint3D fAxis; + SkPoint3D fZenith; + SkPoint3D fObserver; + +private: + mutable SkMatrix fOrientation; + mutable bool fNeedToUpdate; + + void doUpdate() const; +}; + +class Sk3DView : SkNoncopyable { +public: + Sk3DView(); + ~Sk3DView(); + + void save(); + void restore(); + + void translate(SkScalar x, SkScalar y, SkScalar z); + void rotateX(SkScalar deg); + void rotateY(SkScalar deg); + void rotateZ(SkScalar deg); + + void getMatrix(SkMatrix*) const; + void applyToCanvas(SkCanvas*) const; + + SkScalar dotWithNormal(SkScalar dx, SkScalar dy, SkScalar dz) const; + +private: + struct Rec { + Rec* fNext; + SkMatrix3D fMatrix; + }; + Rec* fRec; + Rec fInitialRec; + SkCamera3D fCamera; +}; + +#endif + diff --git a/include/utils/SkCullPoints.h b/include/utils/SkCullPoints.h new file mode 100644 index 0000000000..cee64e2ac2 --- /dev/null +++ b/include/utils/SkCullPoints.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkCullPoints_DEFINED +#define SkCullPoints_DEFINED + +#include "SkRect.h" + +class SkCullPoints { +public: + SkCullPoints(); + SkCullPoints(const SkIRect& r); + + void reset(const SkIRect& r); + + /** Start a contour at (x,y). Follow this with call(s) to lineTo(...) + */ + void moveTo(int x, int y); + + enum LineToResult { + kNo_Result, //!< line segment was completely clipped out + kLineTo_Result, //!< path.lineTo(pts[1]); + kMoveToLineTo_Result //!< path.moveTo(pts[0]); path.lineTo(pts[1]); + }; + /** Connect a line to the previous call to lineTo (or moveTo). + */ + LineToResult lineTo(int x, int y, SkIPoint pts[2]); + +private: + SkIRect fR; // the caller's rectangle + SkIPoint fAsQuad[4]; // cache of fR as 4 points + SkIPoint fPrevPt; // private state + LineToResult fPrevResult; // private state + + bool sect_test(int x0, int y0, int x1, int y1) const; +}; + +///////////////////////////////////////////////////////////////////////////////// + +class SkPath; + +/** \class SkCullPointsPath + + Similar to SkCullPoints, but this class handles the return values + from lineTo, and automatically builds a SkPath with the result(s). +*/ +class SkCullPointsPath { +public: + SkCullPointsPath(); + SkCullPointsPath(const SkIRect& r, SkPath* dst); + + void reset(const SkIRect& r, SkPath* dst); + + void moveTo(int x, int y); + void lineTo(int x, int y); + +private: + SkCullPoints fCP; + SkPath* fPath; +}; + +#endif diff --git a/include/utils/SkDumpCanvas.h b/include/utils/SkDumpCanvas.h new file mode 100644 index 0000000000..b91962793b --- /dev/null +++ b/include/utils/SkDumpCanvas.h @@ -0,0 +1,139 @@ +#ifndef SkDumpCanvas_DEFINED +#define SkDumpCanvas_DEFINED + +#include "SkCanvas.h" + +/** This class overrides all the draw methods on SkCanvas, and formats them + as text, and then sends that to a Dumper helper object. + + Typical use might be to dump a display list to a log file to see what is + being drawn. + */ +class SkDumpCanvas : public SkCanvas { +public: + class Dumper; + + explicit SkDumpCanvas(Dumper* = 0); + virtual ~SkDumpCanvas(); + + enum Verb { + kNULL_Verb, + + kSave_Verb, + kRestore_Verb, + + kMatrix_Verb, + + kClip_Verb, + + kDrawPaint_Verb, + kDrawPoints_Verb, + kDrawRect_Verb, + kDrawPath_Verb, + kDrawBitmap_Verb, + kDrawText_Verb, + kDrawPicture_Verb, + kDrawVertices_Verb + }; + + /** Subclasses of this are installed on the DumpCanvas, and then called for + each drawing command. + */ + class Dumper : public SkRefCnt { + public: + virtual void dump(SkDumpCanvas*, SkDumpCanvas::Verb, const char str[], + const SkPaint*) = 0; + }; + + Dumper* getDumper() const { return fDumper; } + void setDumper(Dumper*); + + // overrides from SkCanvas + + virtual int save(SaveFlags flags = kMatrixClip_SaveFlag); + virtual int saveLayer(const SkRect* bounds, const SkPaint* paint, + SaveFlags flags = kARGB_ClipLayer_SaveFlag); + virtual void restore(); + + virtual bool translate(SkScalar dx, SkScalar dy); + virtual bool scale(SkScalar sx, SkScalar sy); + virtual bool rotate(SkScalar degrees); + virtual bool skew(SkScalar sx, SkScalar sy); + virtual bool concat(const SkMatrix& matrix); + virtual void setMatrix(const SkMatrix& matrix); + + virtual bool clipRect(const SkRect& rect, + SkRegion::Op op = SkRegion::kIntersect_Op); + virtual bool clipPath(const SkPath& path, + SkRegion::Op op = SkRegion::kIntersect_Op); + virtual bool clipRegion(const SkRegion& deviceRgn, + SkRegion::Op op = SkRegion::kIntersect_Op); + + virtual void drawPaint(const SkPaint& paint); + virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[], + const SkPaint& paint); + virtual void drawRect(const SkRect& rect, const SkPaint& paint); + virtual void drawPath(const SkPath& path, const SkPaint& paint); + virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, + const SkPaint* paint = NULL); + virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, + const SkRect& dst, const SkPaint* paint = NULL); + virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m, + const SkPaint* paint = NULL); + virtual void drawSprite(const SkBitmap& bitmap, int left, int top, + const SkPaint* paint = NULL); + virtual void drawText(const void* text, size_t byteLength, SkScalar x, + SkScalar y, const SkPaint& paint); + virtual void drawPosText(const void* text, size_t byteLength, + const SkPoint pos[], const SkPaint& paint); + virtual void drawPosTextH(const void* text, size_t byteLength, + const SkScalar xpos[], SkScalar constY, + const SkPaint& paint); + virtual void drawTextOnPath(const void* text, size_t byteLength, + const SkPath& path, const SkMatrix* matrix, + const SkPaint& paint); + virtual void drawPicture(SkPicture& picture); + virtual void drawVertices(VertexMode vmode, int vertexCount, + const SkPoint vertices[], const SkPoint texs[], + const SkColor colors[], SkXfermode* xmode, + const uint16_t indices[], int indexCount, + const SkPaint& paint); + +private: + Dumper* fDumper; + + void dump(Verb, const SkPaint*, const char format[], ...); + + typedef SkCanvas INHERITED; +}; + +/** Formats the draw commands, and send them to a function-pointer provided + by the caller. + */ +class SkFormatDumper : public SkDumpCanvas::Dumper { +public: + SkFormatDumper(void (*)(const char text[], void* refcon), void* refcon); + + // override from baseclass that does the formatting, and in turn calls + // the function pointer that was passed to the constructor + virtual void dump(SkDumpCanvas*, SkDumpCanvas::Verb, const char str[], + const SkPaint*); + +private: + void (*fProc)(const char*, void*); + void* fRefcon; + + typedef SkDumpCanvas::Dumper INHERITED; +}; + +/** Subclass of Dumper that dumps the drawing command to SkDebugf + */ +class SkDebugfDumper : public SkFormatDumper { +public: + SkDebugfDumper(); + +private: + typedef SkFormatDumper INHERITED; +}; + +#endif diff --git a/include/utils/SkGLCanvas.h b/include/utils/SkGLCanvas.h new file mode 100644 index 0000000000..40fc52d556 --- /dev/null +++ b/include/utils/SkGLCanvas.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkGLCanvas_DEFINED +#define SkGLCanvas_DEFINED + +#include "SkCanvas.h" + +#ifdef SK_BUILD_FOR_MAC + #include <OpenGL/gl.h> +#elif defined(ANDROID) + #include <GLES/gl.h> +#endif + +class SkGLDevice; +class SkGLClipIter; + +class SkGLCanvas : public SkCanvas { +public: + // notice, we do NOT allow the SkCanvas(bitmap) constructor, since that + // does not create a SkGLDevice, which we require + SkGLCanvas(); + virtual ~SkGLCanvas(); + + // overrides from SkCanvas + + virtual bool getViewport(SkIPoint*) const; + virtual bool setViewport(int width, int height); + + virtual SkDevice* createDevice(SkBitmap::Config, int width, int height, + bool isOpaque, bool isForLayer); + + // settings for the global texture cache + + static size_t GetTextureCacheMaxCount(); + static void SetTextureCacheMaxCount(size_t count); + + static size_t GetTextureCacheMaxSize(); + static void SetTextureCacheMaxSize(size_t size); + + /** Call glDeleteTextures for all textures (including those for text) + This should be called while the gl-context is still valid. Its purpose + is to free up gl resources. Note that if a bitmap or text is drawn after + this call, new caches will be created. + */ + static void DeleteAllTextures(); + + /** Forget all textures without calling delete (including those for text). + This should be called if the gl-context has changed, and the texture + IDs that have been cached are no longer valid. + */ + static void AbandonAllTextures(); + +private: + SkIPoint fViewportSize; + + // need to disallow this guy + virtual SkDevice* setBitmapDevice(const SkBitmap& bitmap) { + sk_throw(); + return NULL; + } + + typedef SkCanvas INHERITED; +}; + +#endif + diff --git a/include/utils/SkInterpolator.h b/include/utils/SkInterpolator.h new file mode 100644 index 0000000000..c03eb23090 --- /dev/null +++ b/include/utils/SkInterpolator.h @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkInterpolator_DEFINED +#define SkInterpolator_DEFINED + +#include "SkScalar.h" + +class SkInterpolatorBase : SkNoncopyable { +public: + enum Result { + kNormal_Result, + kFreezeStart_Result, + kFreezeEnd_Result + }; +protected: + SkInterpolatorBase(); + ~SkInterpolatorBase(); +public: + void reset(int elemCount, int frameCount); + + /** Return the start and end time for this interpolator. + If there are no key frames, return false. + @param startTime If not null, returns the time (in milliseconds) of the + first keyframe. If there are no keyframes, this param + is ignored (left unchanged). + @param endTime If not null, returns the time (in milliseconds) of the + last keyframe. If there are no keyframes, this parameter + is ignored (left unchanged). + @return True if there are key frames, or false if there are none. + */ + bool getDuration(SkMSec* startTime, SkMSec* endTime) const; + + + /** Set the whether the repeat is mirrored. + @param mirror If true, the odd repeats interpolate from the last key + frame and the first. + */ + void setMirror(bool mirror) { + fFlags = SkToU8((fFlags & ~kMirror) | (int)mirror); + } + + /** Set the repeat count. The repeat count may be fractional. + @param repeatCount Multiplies the total time by this scalar. + */ + void setRepeatCount(SkScalar repeatCount) { fRepeat = repeatCount; } + + /** Set the whether the repeat is mirrored. + @param reset If true, the odd repeats interpolate from the last key + frame and the first. + */ + void setReset(bool reset) { + fFlags = SkToU8((fFlags & ~kReset) | (int)reset); + } + + Result timeToT(SkMSec time, SkScalar* T, int* index, SkBool* exact) const; + +protected: + enum Flags { + kMirror = 1, + kReset = 2, + kHasBlend = 4 + }; + static SkScalar ComputeRelativeT(SkMSec time, SkMSec prevTime, + SkMSec nextTime, const SkScalar blend[4] = NULL); + int16_t fFrameCount; + uint8_t fElemCount; + uint8_t fFlags; + SkScalar fRepeat; + struct SkTimeCode { + SkMSec fTime; + SkScalar fBlend[4]; + }; + SkTimeCode* fTimes; // pointer into fStorage + void* fStorage; +#ifdef SK_DEBUG + SkTimeCode(* fTimesArray)[10]; +#endif +}; + +class SkInterpolator : public SkInterpolatorBase { +public: + SkInterpolator(); + SkInterpolator(int elemCount, int frameCount); + void reset(int elemCount, int frameCount); + + /** Add or replace a key frame, copying the values[] data into the + interpolator. + @param index The index of this frame (frames must be ordered by time) + @param time The millisecond time for this frame + @param values The array of values [elemCount] for this frame. The data + is copied into the interpolator. + @param blend A positive scalar specifying how to blend between this + and the next key frame. [0...1) is a cubic lag/log/lag + blend (slow to change at the beginning and end) + 1 is a linear blend (default) + */ + bool setKeyFrame(int index, SkMSec time, const SkScalar values[], + const SkScalar blend[4] = NULL); + + /** Return the computed values given the specified time. Return whether + those values are the result of pinning to either the first + (kFreezeStart) or last (kFreezeEnd), or from interpolated the two + nearest key values (kNormal). + @param time The time to sample (in milliseconds) + @param (may be null) where to write the computed values. + */ + Result timeToValues(SkMSec time, SkScalar values[] = NULL) const; + + SkDEBUGCODE(static void UnitTest();) +private: + SkScalar* fValues; // pointer into fStorage +#ifdef SK_DEBUG + SkScalar(* fScalarsArray)[10]; +#endif + typedef SkInterpolatorBase INHERITED; +}; + +/** Given all the parameters are [0...1], apply the cubic specified by (0,0) + (bx,by) (cx,cy) (1,1) to value, returning the answer, also [0...1]. +*/ +SkScalar SkUnitCubicInterp(SkScalar value, SkScalar bx, SkScalar by, + SkScalar cx, SkScalar cy); + +#endif + diff --git a/include/utils/SkNinePatch.h b/include/utils/SkNinePatch.h new file mode 100644 index 0000000000..a655621d49 --- /dev/null +++ b/include/utils/SkNinePatch.h @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkNinePatch_DEFINED +#define SkNinePatch_DEFINED + +#include "SkRect.h" +#include "SkRegion.h" + +class SkBitmap; +class SkCanvas; +class SkPaint; + +class SkNinePatch { +public: + static void DrawNine(SkCanvas* canvas, const SkRect& dst, + const SkBitmap& bitmap, const SkIRect& margins, + const SkPaint* paint = NULL); + + static void DrawMesh(SkCanvas* canvas, const SkRect& dst, + const SkBitmap& bitmap, + const int32_t xDivs[], int numXDivs, + const int32_t yDivs[], int numYDivs, + const SkPaint* paint = NULL); +}; + +#endif diff --git a/include/utils/SkParse.h b/include/utils/SkParse.h new file mode 100644 index 0000000000..57d040ce5a --- /dev/null +++ b/include/utils/SkParse.h @@ -0,0 +1,45 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkParse_DEFINED +#define SkParse_DEFINED + +#include "SkColor.h" +#include "SkMath.h" + +class SkParse { +public: + static int Count(const char str[]); // number of scalars or int values + static int Count(const char str[], char separator); + static const char* FindColor(const char str[], SkColor* value); + static const char* FindHex(const char str[], uint32_t* value); + static const char* FindMSec(const char str[], SkMSec* value); + static const char* FindNamedColor(const char str[], size_t len, SkColor* color); + static const char* FindS32(const char str[], int32_t* value); + static const char* FindScalar(const char str[], SkScalar* value); + static const char* FindScalars(const char str[], SkScalar value[], int count); + + static bool FindBool(const char str[], bool* value); + // return the index of str in list[], or -1 if not found + static int FindList(const char str[], const char list[]); +#ifdef SK_SUPPORT_UNITTEST + static void TestColor(); + static void UnitTest(); +#endif +}; + +#endif + diff --git a/include/utils/SkParsePaint.h b/include/utils/SkParsePaint.h new file mode 100644 index 0000000000..d23cd92040 --- /dev/null +++ b/include/utils/SkParsePaint.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkParsePaint_DEFINED +#define SkParsePaint_DEFINED + +#include "SkPaint.h" +#include "SkDOM.h" + +/** "color" color + "opacity" scalar [0..1] + "stroke-width" scalar (0...inf) + "text-size" scalar (0..inf) + "is-stroke" bool + "is-antialias" bool + "is-lineartext" bool +*/ +void SkPaint_Inflate(SkPaint*, const SkDOM&, const SkDOM::Node*); + +#endif + diff --git a/include/utils/SkProxyCanvas.h b/include/utils/SkProxyCanvas.h new file mode 100644 index 0000000000..1bc411a5d4 --- /dev/null +++ b/include/utils/SkProxyCanvas.h @@ -0,0 +1,90 @@ +#ifndef SkProxyCanvas_DEFINED +#define SkProxyCanvas_DEFINED + +#include "SkCanvas.h" + +/** This class overrides all virtual methods on SkCanvas, and redirects them + to a "proxy", another SkCanvas instance. It can be the basis for + intercepting (and possibly modifying) calls to a canvas. + + There must be a proxy installed before the proxycanvas can be used (i.e. + before its virtual methods can be called). + */ +class SkProxyCanvas : public SkCanvas { +public: + SkProxyCanvas() : fProxy(NULL) {} + SkProxyCanvas(SkCanvas* proxy); + virtual ~SkProxyCanvas(); + + SkCanvas* getProxy() const { return fProxy; } + void setProxy(SkCanvas* proxy); + + // overrides from SkCanvas + + virtual bool getViewport(SkIPoint* size) const; + virtual bool setViewport(int x, int y); + + virtual SkDevice* setBitmapDevice(const SkBitmap& bitmap); + + virtual int save(SaveFlags flags = kMatrixClip_SaveFlag); + virtual int saveLayer(const SkRect* bounds, const SkPaint* paint, + SaveFlags flags = kARGB_ClipLayer_SaveFlag); + virtual void restore(); + + virtual bool translate(SkScalar dx, SkScalar dy); + virtual bool scale(SkScalar sx, SkScalar sy); + virtual bool rotate(SkScalar degrees); + virtual bool skew(SkScalar sx, SkScalar sy); + virtual bool concat(const SkMatrix& matrix); + virtual void setMatrix(const SkMatrix& matrix); + + virtual bool clipRect(const SkRect& rect, + SkRegion::Op op = SkRegion::kIntersect_Op); + virtual bool clipPath(const SkPath& path, + SkRegion::Op op = SkRegion::kIntersect_Op); + virtual bool clipRegion(const SkRegion& deviceRgn, + SkRegion::Op op = SkRegion::kIntersect_Op); + + virtual void drawPaint(const SkPaint& paint); + virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[], + const SkPaint& paint); + virtual void drawRect(const SkRect& rect, const SkPaint& paint); + virtual void drawPath(const SkPath& path, const SkPaint& paint); + virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top, + const SkPaint* paint = NULL); + virtual void drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, + const SkRect& dst, const SkPaint* paint = NULL); + virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m, + const SkPaint* paint = NULL); + virtual void drawSprite(const SkBitmap& bitmap, int left, int top, + const SkPaint* paint = NULL); + virtual void drawText(const void* text, size_t byteLength, SkScalar x, + SkScalar y, const SkPaint& paint); + virtual void drawPosText(const void* text, size_t byteLength, + const SkPoint pos[], const SkPaint& paint); + virtual void drawPosTextH(const void* text, size_t byteLength, + const SkScalar xpos[], SkScalar constY, + const SkPaint& paint); + virtual void drawTextOnPath(const void* text, size_t byteLength, + const SkPath& path, const SkMatrix* matrix, + const SkPaint& paint); + virtual void drawPicture(SkPicture& picture); + virtual void drawVertices(VertexMode vmode, int vertexCount, + const SkPoint vertices[], const SkPoint texs[], + const SkColor colors[], SkXfermode* xmode, + const uint16_t indices[], int indexCount, + const SkPaint& paint); + + virtual SkBounder* setBounder(SkBounder* bounder); + virtual SkDrawFilter* setDrawFilter(SkDrawFilter* filter); + + virtual SkDevice* createDevice(SkBitmap::Config, int width, int height, + bool isOpaque, bool isForLayer); + +private: + SkCanvas* fProxy; + + typedef SkCanvas INHERITED; +}; + +#endif diff --git a/include/utils/SkTextBox.h b/include/utils/SkTextBox.h new file mode 100644 index 0000000000..2c34448977 --- /dev/null +++ b/include/utils/SkTextBox.h @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkTextBox_DEFINED +#define SkTextBox_DEFINED + +#include "SkCanvas.h" + +/** \class SkTextBox + + SkTextBox is a helper class for drawing 1 or more lines of text + within a rectangle. The textbox is positioned and clipped by its Frame. + The Margin rectangle controls where the text is drawn relative to + the Frame. Line-breaks occur inside the Margin rectangle. + + Spacing is a linear equation used to compute the distance between lines + of text. Spacing consists of two scalars: mul and add, and the spacing + between lines is computed as: spacing = paint.getTextSize() * mul + add +*/ +class SkTextBox { +public: + SkTextBox(); + + enum Mode { + kOneLine_Mode, + kLineBreak_Mode, + + kModeCount + }; + Mode getMode() const { return (Mode)fMode; } + void setMode(Mode); + + enum SpacingAlign { + kStart_SpacingAlign, + kCenter_SpacingAlign, + kEnd_SpacingAlign, + + kSpacingAlignCount + }; + SpacingAlign getSpacingAlign() const { return (SpacingAlign)fSpacingAlign; } + void setSpacingAlign(SpacingAlign); + + void getBox(SkRect*) const; + void setBox(const SkRect&); + void setBox(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom); + + void getSpacing(SkScalar* mul, SkScalar* add) const; + void setSpacing(SkScalar mul, SkScalar add); + + void draw(SkCanvas*, const char text[], size_t len, const SkPaint&); + +private: + SkRect fBox; + SkScalar fSpacingMul, fSpacingAdd; + uint8_t fMode, fSpacingAlign; +}; + +class SkTextLineBreaker { +public: + static int CountLines(const char text[], size_t len, const SkPaint&, SkScalar width); +}; + +#endif + diff --git a/include/utils/SkUnitMappers.h b/include/utils/SkUnitMappers.h new file mode 100644 index 0000000000..51708b63fc --- /dev/null +++ b/include/utils/SkUnitMappers.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SkUnitMappers_DEFINED +#define SkUnitMappers_DEFINED + +#include "SkUnitMapper.h" + +/** This discretizes the range [0...1) into N discret values. +*/ +class SkDiscreteMapper : public SkUnitMapper { +public: + SkDiscreteMapper(int segments); + // override from SkUnitMapper + virtual uint16_t mapUnit16(uint16_t x); + +protected: + SkDiscreteMapper(SkFlattenableReadBuffer& ); + // overrides from SkFlattenable + virtual void flatten(SkFlattenableWriteBuffer& ); + virtual Factory getFactory(); +private: + int fSegments; + SkFract fScale; // computed from fSegments + + static SkFlattenable* Create(SkFlattenableReadBuffer& buffer); + + typedef SkUnitMapper INHERITED; +}; + +/** This returns cos(x), to simulate lighting a sphere, where 0 maps to the + center of the sphere, and 1 maps to the edge. +*/ +class SkCosineMapper : public SkUnitMapper { +public: + SkCosineMapper() {} + // override from SkUnitMapper + virtual uint16_t mapUnit16(uint16_t x); + +protected: + SkCosineMapper(SkFlattenableReadBuffer&); + // overrides from SkFlattenable + virtual Factory getFactory(); + +private: + static SkFlattenable* Create(SkFlattenableReadBuffer&); + + typedef SkUnitMapper INHERITED; +}; + +#endif + |