diff options
426 files changed, 32658 insertions, 28750 deletions
diff --git a/Samples/SampleAll.cpp b/Samples/SampleAll.cpp new file mode 100644 index 0000000..968263b --- /dev/null +++ b/Samples/SampleAll.cpp @@ -0,0 +1,791 @@ +#include "SampleCode.h" +#include "SkCanvas.h" +#include "SkView.h" +#include "Sk1DPathEffect.h" +#include "Sk2DPathEffect.h" +#include "SkAvoidXfermode.h" +#include "SkBlurMaskFilter.h" +#include "SkColorFilter.h" +#include "SkColorPriv.h" +#include "SkCornerPathEffect.h" +#include "SkDashPathEffect.h" +#include "SkDiscretePathEffect.h" +#include "SkEmbossMaskFilter.h" +#include "SkGradientShader.h" +#include "SkImageDecoder.h" +#include "SkLayerRasterizer.h" +#include "SkMath.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkShaderExtras.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkPicture.h" +#include "SkRandom.h" +#include "SkTransparentShader.h" +#include "SkTypeface.h" +#include "SkUnitMappers.h" +#include "SkUtils.h" +#include "SkXfermode.h" + +#include <math.h> + +extern void Dump(); + +static inline SkPMColor rgb2gray(SkPMColor c) +{ + unsigned r = SkGetPackedR32(c); + unsigned g = SkGetPackedG32(c); + unsigned b = SkGetPackedB32(c); + + unsigned x = r * 5 + g * 7 + b * 4 >> 4; + + return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT)); +} + +class SkGrayScaleColorFilter : public SkColorFilter { +public: + virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) + { + for (int i = 0; i < count; i++) + result[i] = rgb2gray(src[i]); + } +}; + +class SkChannelMaskColorFilter : public SkColorFilter { +public: + SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask) + { + fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask); + } + + virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) + { + SkPMColor mask = fMask; + for (int i = 0; i < count; i++) + result[i] = src[i] & mask; + } + +private: + SkPMColor fMask; +}; + +/////////////////////////////////////////////////////////// + +static void r0(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3), + SkBlurMaskFilter::kNormal_BlurStyle))->unref(); + rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3)); + + p.setMaskFilter(NULL); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + rast->addLayer(p); + + p.setAlpha(0x11); + p.setStyle(SkPaint::kFill_Style); + p.setPorterDuffXfermode(SkPorterDuff::kSrc_Mode); + rast->addLayer(p); +} + +static void r1(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + p.setAlpha(0x40); + p.setPorterDuffXfermode(SkPorterDuff::kSrc_Mode); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*2); + rast->addLayer(p); +} + +static void r2(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setStyle(SkPaint::kStrokeAndFill_Style); + p.setStrokeWidth(SK_Scalar1*4); + rast->addLayer(p); + + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*3/2); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); +} + +static void r3(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*3); + rast->addLayer(p); + + p.setAlpha(0x20); + p.setStyle(SkPaint::kFill_Style); + p.setPorterDuffXfermode(SkPorterDuff::kSrc_Mode); + rast->addLayer(p); +} + +static void r4(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setAlpha(0x60); + rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3)); + + p.setAlpha(0xFF); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2); + + p.setXfermode(NULL); + rast->addLayer(p); +} + +static void r5(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kSrcOut_Mode); + rast->addLayer(p); +} + +static void r6(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + p.setAntiAlias(false); + SkLayerRasterizer* rast2 = new SkLayerRasterizer; + r5(rast2, p); + p.setRasterizer(rast2)->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); +} + +class Dot2DPathEffect : public Sk2DPathEffect { +public: + Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix) + : Sk2DPathEffect(matrix), fRadius(radius) {} + + virtual void flatten(SkFlattenableWriteBuffer& buffer) + { + this->INHERITED::flatten(buffer); + + buffer.writeScalar(fRadius); + } + virtual Factory getFactory() { return CreateProc; } + +protected: + virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) + { + dst->addCircle(loc.fX, loc.fY, fRadius); + } + + Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) + { + fRadius = buffer.readScalar(); + } +private: + SkScalar fRadius; + + static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) + { + return new Dot2DPathEffect(buffer); + } + + typedef Sk2DPathEffect INHERITED; +}; + +static void r7(SkLayerRasterizer* rast, SkPaint& p) +{ + SkMatrix lattice; + lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); + lattice.postSkew(SK_Scalar1/3, 0, 0, 0); + p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref(); + rast->addLayer(p); +} + +static void r8(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + SkMatrix lattice; + lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); + lattice.postSkew(SK_Scalar1/3, 0, 0, 0); + p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); + + p.setPathEffect(NULL); + p.setXfermode(NULL); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + rast->addLayer(p); +} + +class Line2DPathEffect : public Sk2DPathEffect { +public: + Line2DPathEffect(SkScalar width, const SkMatrix& matrix) + : Sk2DPathEffect(matrix), fWidth(width) {} + + virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width) + { + if (this->INHERITED::filterPath(dst, src, width)) + { + *width = fWidth; + return true; + } + return false; + } + + virtual Factory getFactory() { return CreateProc; } + virtual void flatten(SkFlattenableWriteBuffer& buffer) + { + this->INHERITED::flatten(buffer); + buffer.writeScalar(fWidth); + } +protected: + virtual void nextSpan(int u, int v, int ucount, SkPath* dst) + { + if (ucount > 1) + { + SkPoint src[2], dstP[2]; + + src[0].set(SkIntToScalar(u) + SK_ScalarHalf, + SkIntToScalar(v) + SK_ScalarHalf); + src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf, + SkIntToScalar(v) + SK_ScalarHalf); + this->getMatrix().mapPoints(dstP, src, 2); + + dst->moveTo(dstP[0]); + dst->lineTo(dstP[1]); + } + } + + Line2DPathEffect::Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) + { + fWidth = buffer.readScalar(); + } + +private: + SkScalar fWidth; + + static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { return new Line2DPathEffect(buffer); } + + typedef Sk2DPathEffect INHERITED; +}; + +static void r9(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + SkMatrix lattice; + lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0); + lattice.postRotate(SkIntToScalar(30), 0, 0); + p.setPathEffect(new Line2DPathEffect(SK_Scalar1*2, lattice))->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); + + p.setPathEffect(NULL); + p.setXfermode(NULL); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + rast->addLayer(p); +} + +typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&); + +static const raster_proc gRastProcs[] = { + r0, r1, r2, r3, r4, r5, r6, r7, r8, r9 +}; + +static const struct { + SkColor fMul, fAdd; +} gLightingColors[] = { + { 0x808080, 0x800000 }, // general case + { 0x707070, 0x707070 }, // no-pin case + { 0xFFFFFF, 0x800000 }, // just-add case + { 0x808080, 0x000000 }, // just-mul case + { 0xFFFFFF, 0x000000 } // identity case +}; + +static unsigned color_dist16(uint16_t a, uint16_t b) +{ + unsigned dr = SkAbs32(SkPacked16ToR32(a) - SkPacked16ToR32(b)); + unsigned dg = SkAbs32(SkPacked16ToG32(a) - SkPacked16ToG32(b)); + unsigned db = SkAbs32(SkPacked16ToB32(a) - SkPacked16ToB32(b)); + + return SkMax32(dr, SkMax32(dg, db)); +} + +static unsigned scale_dist(unsigned dist, unsigned scale) +{ + dist >>= 6; + dist = (dist << 2) | dist; + dist = (dist << 4) | dist; + return dist; + +// return SkAlphaMul(dist, scale); +} + +static void apply_shader(SkPaint* paint, int index) +{ + raster_proc proc = gRastProcs[index]; + if (proc) + { + SkPaint p; + SkLayerRasterizer* rast = new SkLayerRasterizer; + + p.setAntiAlias(true); + proc(rast, p); + paint->setRasterizer(rast)->unref(); + } + +#if 1 + SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 }; + paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref(); + paint->setColor(SK_ColorBLUE); +#endif +} + +static void test_math() +{ + float x; + const float PI = 3.141593; + + for (x = 0; x < 1; x += 0.05f) + printf("atan(%g) = %g\n", x, atanf(x) * 180/PI); + for (x = 1; x < 10000000; x *= 2) + printf("atan(%g) = %g\n", x, atanf(x) * 180/PI); +} + +class DemoView : public SkView { +public: + DemoView() + { + test_math(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Demo"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + + void makePath(SkPath& path) + { + path.addCircle(SkIntToScalar(20), SkIntToScalar(20), SkIntToScalar(20), + SkPath::kCCW_Direction); + for (int index = 0; index < 10; index++) { + SkScalar x = SkFloatToScalar(cos(index / 10.0f * 2 * 3.1415925358f)); + SkScalar y = SkFloatToScalar(sin(index / 10.0f * 2 * 3.1415925358f)); + x *= index & 1 ? 7 : 14; + y *= index & 1 ? 7 : 14; + x += SkIntToScalar(20); + y += SkIntToScalar(20); + if (index == 0) + path.moveTo(x, y); + else + path.lineTo(x, y); + } + path.close(); + } + + virtual void onDraw(SkCanvas* canvas) + { + canvas->drawColor(SK_ColorWHITE); + canvas->save(); + drawPicture(canvas, 0); + canvas->restore(); + + { + SkPicture picture; + SkCanvas* record = picture.beginRecording(320, 480); + drawPicture(record, 120); + canvas->translate(0, SkIntToScalar(120)); + + SkRect clip; + clip.set(0, 0, SkIntToScalar(160), SkIntToScalar(160)); + do { + canvas->save(); + canvas->clipRect(clip); + picture.draw(canvas); + canvas->restore(); + if (clip.fRight < SkIntToScalar(320)) + clip.offset(SkIntToScalar(160), 0); + else if (clip.fBottom < SkIntToScalar(480)) + clip.offset(-SkIntToScalar(320), SkIntToScalar(160)); + else + break; + } while (true); + } + Dump(); + } + + void drawPicture(SkCanvas* canvas, int spriteOffset) + { + SkMatrix matrix; matrix.reset(); + SkPaint paint; + SkPath path; + SkPoint start = {0, 0}; + SkPoint stop = { SkIntToScalar(40), SkIntToScalar(40) }; + SkRect rect = {0, 0, SkIntToScalar(40), SkIntToScalar(40) }; + SkRect rect2 = {0, 0, SkIntToScalar(65), SkIntToScalar(20) }; + SkScalar left = 0, top = 0, x = 0, y = 0; + int index; + + char ascii[] = "ascii..."; + size_t asciiLength = sizeof(ascii) - 1; + char utf8[] = "utf8" "\xe2\x80\xa6"; + short utf16[] = {'u', 't', 'f', '1', '6', 0x2026 }; + short utf16simple[] = {'u', 't', 'f', '1', '6', '!' }; + + makePath(path); + SkTDArray<SkPoint>(pos); + pos.setCount(asciiLength); + for (index = 0; index < asciiLength; index++) + pos[index].set(SkIntToScalar(index * 10), SkIntToScalar(index * 2)); + SkTDArray<SkPoint>(pos2); + pos2.setCount(asciiLength); + for (index = 0; index < asciiLength; index++) + pos2[index].set(SkIntToScalar(index * 10), SkIntToScalar(20)); + + // shaders + SkPoint linearPoints[] = { 0, 0, SkIntToScalar(40), SkIntToScalar(40) }; + SkColor linearColors[] = { SK_ColorRED, SK_ColorBLUE }; + SkScalar* linearPos = NULL; + int linearCount = 2; + SkShader::TileMode linearMode = SkShader::kMirror_TileMode; + SkUnitMapper* linearMapper = new SkDiscreteMapper(3); + SkAutoUnref unmapLinearMapper(linearMapper); + SkShader* linear = SkGradientShader::CreateLinear(linearPoints, + linearColors, linearPos, linearCount, linearMode, linearMapper); + + SkPoint radialCenter = { SkIntToScalar(25), SkIntToScalar(25) }; + SkScalar radialRadius = SkIntToScalar(25); + SkColor radialColors[] = { SK_ColorGREEN, SK_ColorGRAY, SK_ColorRED }; + SkScalar radialPos[] = { 0, SkIntToScalar(3) / 5, SkIntToScalar(1)}; + int radialCount = 3; + SkShader::TileMode radialMode = SkShader::kRepeat_TileMode; + SkUnitMapper* radialMapper = new SkCosineMapper(); + SkAutoUnref unmapRadialMapper(radialMapper); + SkShader* radial = SkGradientShader::CreateRadial(radialCenter, + radialRadius, radialColors, radialPos, radialCount, + radialMode, radialMapper); + + SkTransparentShader* transparentShader = new SkTransparentShader(); + SkEmbossMaskFilter::Light light; + light.fDirection[0] = SK_Scalar1/2; + light.fDirection[1] = SK_Scalar1/2; + light.fDirection[2] = SK_Scalar1/3; + light.fAmbient = 0x48; + light.fSpecular = 0x80; + SkScalar radius = SkIntToScalar(12)/5; + SkEmbossMaskFilter* embossFilter = new SkEmbossMaskFilter(light, + radius); + + SkXfermode* xfermode = SkPorterDuff::CreateXfermode(SkPorterDuff::kXor_Mode); + SkColorFilter* lightingFilter = SkColorFilter::CreateLightingFilter( + 0xff89bc45, 0xff112233); + + canvas->save(); + canvas->translate(SkIntToScalar(0), SkIntToScalar(5)); + paint.setFlags(SkPaint::kAntiAlias_Flag | SkPaint::kFilterBitmap_Flag); + // !!! draw through a clip + paint.setColor(SK_ColorLTGRAY); + paint.setStyle(SkPaint::kFill_Style); + SkRect clip = {0, 0, SkIntToScalar(320), SkIntToScalar(120)}; + canvas->clipRect(clip); + paint.setShader(SkShader::CreateBitmapShader(fTx, + SkShader::kMirror_TileMode, SkShader::kRepeat_TileMode))->unref(); + canvas->drawPaint(paint); + canvas->save(); + + // line (exercises xfermode, colorShader, colorFilter, filterShader) + paint.setColor(SK_ColorGREEN); + paint.setStrokeWidth(SkIntToScalar(10)); + paint.setStyle(SkPaint::kStroke_Style); + paint.setXfermode(xfermode)->unref(); + paint.setColorFilter(lightingFilter)->unref(); + canvas->drawLine(start.fX, start.fY, stop.fX, stop.fY, paint); // should not be green + paint.setXfermode(NULL); + paint.setColorFilter(NULL); + + // rectangle + paint.setStyle(SkPaint::kFill_Style); + canvas->translate(SkIntToScalar(50), 0); + paint.setColor(SK_ColorYELLOW); + paint.setShader(linear)->unref(); + paint.setPathEffect(pathEffectTest())->unref(); + canvas->drawRect(rect, paint); + paint.setPathEffect(NULL); + + // circle w/ emboss & transparent (exercises 3dshader) + canvas->translate(SkIntToScalar(50), 0); + paint.setMaskFilter(embossFilter)->unref(); + canvas->drawOval(rect, paint); + canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); + paint.setShader(transparentShader)->unref(); + canvas->drawOval(rect, paint); + canvas->translate(0, SkIntToScalar(-10)); + + // path + canvas->translate(SkIntToScalar(50), 0); + paint.setColor(SK_ColorRED); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(5)); + paint.setShader(radial)->unref(); + paint.setMaskFilter(NULL); + canvas->drawPath(path, paint); + + paint.setShader(NULL); + // bitmap, sprite + canvas->translate(SkIntToScalar(50), 0); + paint.setStyle(SkPaint::kFill_Style); + canvas->drawBitmap(fBug, left, top, &paint); + canvas->translate(SkIntToScalar(30), 0); + canvas->drawSprite(fTb, + SkScalarRound(canvas->getTotalMatrix().getTranslateX()), + spriteOffset + 10, &paint); + + canvas->translate(-SkIntToScalar(30), SkIntToScalar(30)); + paint.setShader(shaderTest())->unref(); // test compose shader + canvas->drawRect(rect2, paint); + paint.setShader(NULL); + + canvas->restore(); + // text + canvas->translate(0, SkIntToScalar(60)); + canvas->save(); + paint.setColor(SK_ColorGRAY); + canvas->drawPosText(ascii, asciiLength, pos.begin(), paint); + canvas->drawPosText(ascii, asciiLength, pos2.begin(), paint); + + canvas->translate(SkIntToScalar(50), 0); + paint.setColor(SK_ColorCYAN); + canvas->drawText(utf8, sizeof(utf8) - 1, x, y, paint); + + canvas->translate(SkIntToScalar(30), 0); + paint.setColor(SK_ColorMAGENTA); + paint.setTextEncoding(SkPaint::kUTF16_TextEncoding); + matrix.setTranslate(SkIntToScalar(10), SkIntToScalar(10)); + canvas->drawTextOnPath((void*) utf16, sizeof(utf16), path, &matrix, paint); + canvas->translate(0, SkIntToScalar(20)); + canvas->drawTextOnPath((void*) utf16simple, sizeof(utf16simple), path, &matrix, paint); + canvas->restore(); + + canvas->translate(0, SkIntToScalar(60)); + paint.setTextEncoding(SkPaint::kUTF8_TextEncoding); + canvas->restore(); + } + + /* +./SkColorFilter.h:25:class SkColorFilter : public SkFlattenable { -- abstract + static SkColorFilter* CreatXfermodeFilter() *** untested *** + static SkColorFilter* CreatePorterDuffFilter() *** untested *** + static SkColorFilter* CreateLightingFilter() -- tested +./SkDrawLooper.h:9:class SkDrawLooper : public SkFlattenable { -- virtually abstract + ./SkBlurDrawLooper.h:9:class SkBlurDrawLooper : public SkDrawLooper { *** untested *** +./SkMaskFilter.h:41:class SkMaskFilter : public SkFlattenable { -- abstract chmod +w .h + ./SkEmbossMaskFilter.h:27:class SkEmbossMaskFilter : public SkMaskFilter { -- tested +./SkPathEffect.h:33:class SkPathEffect : public SkFlattenable { -- abstract + ./Sk1DPathEffect.h:27:class Sk1DPathEffect : public SkPathEffect { -- abstract + ./Sk1DPathEffect.h:48:class SkPath1DPathEffect : public Sk1DPathEffect { -- tested + ./Sk2DPathEffect.h:25:class Sk2DPathEffect : public SkPathEffect { *** untested *** + ./SkCornerPathEffect.h:28:class SkCornerPathEffect : public SkPathEffect { *** untested *** + ./SkDashPathEffect.h:27:class SkDashPathEffect : public SkPathEffect { + ./SkDiscretePathEffect.h:27:class SkDiscretePathEffect : public SkPathEffect { + ./SkPaint.h:760:class SkStrokePathEffect : public SkPathEffect { + ./SkPathEffect.h:58:class SkPairPathEffect : public SkPathEffect { + ./SkPathEffect.h:78:class SkComposePathEffect : public SkPairPathEffect { + ./SkPathEffect.h:114:class SkSumPathEffect : public SkPairPathEffect { +./SkRasterizer.h:29:class SkRasterizer : public SkFlattenable { + ./SkLayerRasterizer.h:27:class SkLayerRasterizer : public SkRasterizer { +./SkShader.h:36:class SkShader : public SkFlattenable { + ./SkColorFilter.h:59:class SkFilterShader : public SkShader { + ./SkColorShader.h:26:class SkColorShader : public SkShader { + ./SkShaderExtras.h:31:class SkComposeShader : public SkShader { + ./SkTransparentShader.h:23:class SkTransparentShader : public SkShader { +./SkUnitMapper.h:24:class SkUnitMapper : public SkFlattenable { + ./SkUnitMapper.h:33:class SkDiscreteMapper : public SkUnitMapper { + ./SkUnitMapper.h:51:class SkFlipCosineMapper : public SkUnitMapper { +./SkXfermode.h:32:class SkXfermode : public SkFlattenable { + ./SkAvoidXfermode.h:28:class SkAvoidXfermode : public SkXfermode { *** not done *** chmod +w .h .cpp + ./SkXfermode.h:54:class SkProcXfermode : public SkXfermode { + */ + + /* +./SkBlurMaskFilter.h:25:class SkBlurMaskFilter { + chmod +w SkBlurMaskFilter.cpp +./SkGradientShader.h:30:class SkGradientShader { + */ + // save layer, bounder, looper + // matrix + // clip /path/region + // bitmap proc shader ? + +/* untested: +SkCornerPathEffect.h:28:class SkCornerPathEffect : public SkPathEffect { +*/ + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + fClickPt.set(x, y); + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + SkPathEffect* pathEffectTest() + { + static const int gXY[] = { 1, 0, 0, -1, 2, -1, 3, 0, 2, 1, 0, 1 }; + SkScalar gPhase = 0; + SkPath path; + path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1])); + for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2) + path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1])); + path.close(); + path.offset(SkIntToScalar(-6), 0); + SkPathEffect* outer = new SkPath1DPathEffect(path, SkIntToScalar(12), + gPhase, SkPath1DPathEffect::kRotate_Style); + SkPathEffect* inner = new SkDiscretePathEffect(SkIntToScalar(2), + SkIntToScalar(1)/10); // SkCornerPathEffect(SkIntToScalar(2)); + SkPathEffect* result = new SkComposePathEffect(outer, inner); + outer->unref(); + inner->unref(); + return result; + } + + SkPathEffect* pathEffectTest2() // unsure this works (has no visible effect) + { + SkPathEffect* outer = new SkStrokePathEffect(SkIntToScalar(4), + SkPaint::kStroke_Style, SkPaint::kMiter_Join, SkPaint::kButt_Cap); + static const SkScalar intervals[] = {SkIntToScalar(1), SkIntToScalar(2), + SkIntToScalar(2), SkIntToScalar(1)}; + SkPathEffect* inner = new SkDashPathEffect(intervals, + sizeof(intervals) / sizeof(intervals[0]), 0); + SkPathEffect* result = new SkSumPathEffect(outer, inner); + outer->unref(); + inner->unref(); + return result; + } + + SkShader* shaderTest() + { + SkPoint pts[] = {0, 0, SkIntToScalar(100), 0 }; + SkColor colors[] = { SK_ColorRED, SK_ColorBLUE }; + SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, + 2, SkShader::kClamp_TileMode); + pts[1].set(0, SkIntToScalar(100)); + SkColor colors2[] = {SK_ColorBLACK, SkColorSetARGB(0x80, 0, 0, 0)}; + SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors2, NULL, + 2, SkShader::kClamp_TileMode); + SkXfermode* mode = SkPorterDuff::CreateXfermode(SkPorterDuff::kDstIn_Mode); + SkShader* result = new SkComposeShader(shaderA, shaderB, mode); + shaderA->unref(); + shaderB->unref(); + mode->unref(); + return result; + } + + virtual void startTest() { + SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/bugcirc.gif", &fBug); + SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/tbcirc.gif", &fTb); + SkImageDecoder::DecodeFile("/Users/caryclark/Desktop/05psp04.gif", &fTx); + } + + void drawRaster(SkCanvas* canvas) + { + for (int index = 0; index < SK_ARRAY_COUNT(gRastProcs); index++) + drawOneRaster(canvas); + } + + void drawOneRaster(SkCanvas* canvas) + { + canvas->save(); +// canvas->scale(SK_Scalar1*2, SK_Scalar1*2, 0, 0); + + SkScalar x = SkIntToScalar(20); + SkScalar y = SkIntToScalar(40); + SkPaint paint; + + paint.setAntiAlias(true); + paint.setTextSize(SkIntToScalar(48)); + paint.setTypeface(SkTypeface::Create("sans-serif", SkTypeface::kBold)); + + SkString str("GOOGLE"); + + for (int i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) + { + apply_shader(&paint, i); + + // paint.setMaskFilter(NULL); + // paint.setColor(SK_ColorBLACK); + +#if 01 + int index = i % SK_ARRAY_COUNT(gLightingColors); + paint.setColorFilter(SkColorFilter::CreateLightingFilter( + gLightingColors[index].fMul, + gLightingColors[index].fAdd))->unref(); +#endif + + canvas->drawText(str.c_str(), str.size(), x, y, paint); + SkRect oval = { x, y - SkIntToScalar(40), x + SkIntToScalar(40), y }; + paint.setStyle(SkPaint::kStroke_Style); + canvas->drawOval(oval, paint); + paint.setStyle(SkPaint::kFill_Style); + if (0) + { + SkPath path; + paint.getTextPath(str.c_str(), str.size(), x + SkIntToScalar(260), y, &path); + canvas->drawPath(path, paint); + } + + y += paint.getFontSpacing(); + } + + canvas->restore(); + + if (0) + { + SkPoint pts[] = { 0, 0, 0, SkIntToScalar(150) }; + SkColor colors[] = { 0xFFE6E6E6, 0xFFFFFFFF }; + SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + + paint.reset(); + paint.setShader(s)->unref(); + canvas->drawRectCoords(0, 0, SkIntToScalar(120), SkIntToScalar(150), paint); + } + + if (1) + { + SkAvoidXfermode mode(SK_ColorWHITE, 0xFF, + SkAvoidXfermode::kTargetColor_Mode); + SkPaint paint; + x += SkIntToScalar(20); + SkRect r = { x, 0, x + SkIntToScalar(360), SkIntToScalar(700) }; + paint.setXfermode(&mode); + paint.setColor(SK_ColorGREEN); + paint.setAntiAlias(true); + canvas->drawOval(r, paint); + } + } + +private: + SkPoint fClickPt; + SkBitmap fBug, fTb, fTx; + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new DemoView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleApp.cpp b/Samples/SampleApp.cpp new file mode 100644 index 0000000..5ff8362 --- /dev/null +++ b/Samples/SampleApp.cpp @@ -0,0 +1,563 @@ +#include "SkCanvas.h" +#include "SkDevice.h" +#include "SkGLCanvas.h" +#include "SkGraphics.h" +#include "SkPaint.h" +#include "SkPicture.h" +#include "SkStream.h" +#include "SkWindow.h" + +#include "SampleCode.h" + +#include <AGL/agl.h> +#include <OpenGL/gl.h> + +#define ANIMATING_EVENTTYPE "nextSample" +#define ANIMATING_DELAY 750 + +#define USE_OFFSCREEN + +SkViewRegister* SkViewRegister::gHead; +SkViewRegister::SkViewRegister(SkViewFactory fact) : fFact(fact) { + static bool gOnce; + if (!gOnce) { + gHead = NULL; + gOnce = true; + } + + fChain = gHead; + gHead = this; +} + +static AGLContext gAGLContext; + +static void init_gl(WindowRef wref) { + GLint major, minor; + + aglGetVersion(&major, &minor); + SkDebugf("---- agl version %d %d\n", major, minor); + + const GLint pixelAttrs[] = { + AGL_RGBA, + AGL_DEPTH_SIZE, 32, + AGL_OFFSCREEN, + AGL_NONE + }; + + AGLPixelFormat format = aglCreatePixelFormat(pixelAttrs); + SkDebugf("----- agl format %p\n", format); + gAGLContext = aglCreateContext(format, NULL); + SkDebugf("----- agl context %p\n", gAGLContext); + aglDestroyPixelFormat(format); + + aglEnable(gAGLContext, GL_BLEND); + aglEnable(gAGLContext, GL_LINE_SMOOTH); + aglEnable(gAGLContext, GL_POINT_SMOOTH); + aglEnable(gAGLContext, GL_POLYGON_SMOOTH); + + aglSetCurrentContext(gAGLContext); +} + +static void setup_offscreen_gl(const SkBitmap& offscreen, WindowRef wref) { + GLboolean success = true; + +#ifdef USE_OFFSCREEN + success = aglSetOffScreen(gAGLContext, + offscreen.width(), + offscreen.height(), + offscreen.rowBytes(), + offscreen.getPixels()); +#else + success = aglSetWindowRef(gAGLContext, wref); +#endif + + GLenum err = aglGetError(); + if (err) { + SkDebugf("---- setoffscreen %d %d %s [%d %d]\n", success, err, + aglErrorString(err), offscreen.width(), offscreen.height()); + } + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE); + glEnable(GL_TEXTURE_2D); + + glClearColor(0, 0, 0, 0); + glClear(GL_COLOR_BUFFER_BIT); +} + +////////////////////////////////////////////////////////////////////////////// + +static const char gTitleEvtName[] = "SampleCode_Title_Event"; +static const char gPrefSizeEvtName[] = "SampleCode_PrefSize_Event"; + +bool SampleCode::TitleQ(const SkEvent& evt) { + return evt.isType(gTitleEvtName, sizeof(gTitleEvtName) - 1); +} + +void SampleCode::TitleR(SkEvent* evt, const char title[]) { + SkASSERT(evt && TitleQ(*evt)); + evt->setString(gTitleEvtName, title); +} + +bool SampleCode::PrefSizeQ(const SkEvent& evt) { + return evt.isType(gPrefSizeEvtName, sizeof(gPrefSizeEvtName) - 1); +} + +void SampleCode::PrefSizeR(SkEvent* evt, SkScalar width, SkScalar height) { + SkASSERT(evt && PrefSizeQ(*evt)); + SkScalar size[2]; + size[0] = width; + size[1] = height; + evt->setScalars(gPrefSizeEvtName, 2, size); +} + +////////////////////////////////////////////////////////////////////////////// + +class SampleWindow : public SkOSWindow { +public: + SampleWindow(void* hwnd); + virtual ~SampleWindow(); + +protected: + virtual void onDraw(SkCanvas* canvas); + virtual bool onHandleKey(SkKey key); + virtual bool onHandleChar(SkUnichar); + virtual void onSizeChange(); + + virtual SkCanvas* beforeChildren(SkCanvas*); + virtual void afterChildren(SkCanvas*); + + virtual bool onEvent(const SkEvent& evt); + +#if 0 + virtual bool handleChar(SkUnichar uni); + virtual bool handleEvent(const SkEvent& evt); + virtual bool handleKey(SkKey key); + virtual bool handleKeyUp(SkKey key); + + virtual bool onClick(Click* click); + virtual Click* onFindClickHandler(SkScalar x, SkScalar y); + virtual bool onHandleKeyUp(SkKey key); +#endif +private: + const SkViewRegister* fCurr; + + SkPicture* fPicture; + SkGLCanvas* fGLCanvas; + SkPath fClipPath; + + enum CanvasType { + kRaster_CanvasType, + kPicture_CanvasType, + kOpenGL_CanvasType + }; + CanvasType fCanvasType; + + bool fUseClip; + bool fRepeatDrawing; + bool fAnimating; + + int fScrollTestX, fScrollTestY; + + void loadView(SkView*); + void updateTitle(); + bool nextSample(); + + void postAnimatingEvent() { + if (fAnimating) { + SkEvent* evt = new SkEvent(ANIMATING_EVENTTYPE); + evt->post(this->getSinkID(), ANIMATING_DELAY); + } + } + + + static CanvasType cycle_canvastype(CanvasType); + + typedef SkOSWindow INHERITED; +}; + +SampleWindow::CanvasType SampleWindow::cycle_canvastype(CanvasType ct) { + static const CanvasType gCT[] = { + kPicture_CanvasType, + kOpenGL_CanvasType, + kRaster_CanvasType + }; + return gCT[ct]; +} + +SampleWindow::SampleWindow(void* hwnd) : INHERITED(hwnd) { + init_gl((WindowRef)hwnd); + + fPicture = NULL; + fGLCanvas = NULL; + + fCanvasType = kRaster_CanvasType; + fUseClip = false; + fRepeatDrawing = false; + fAnimating = false; + + fScrollTestX = fScrollTestY = 0; + +// this->setConfig(SkBitmap::kRGB_565_Config); + this->setConfig(SkBitmap::kARGB_8888_Config); + this->setVisibleP(true); + + fCurr = SkViewRegister::Head(); + this->loadView(fCurr->factory()()); +} + +SampleWindow::~SampleWindow() { + delete fPicture; + delete fGLCanvas; +} + +void SampleWindow::onDraw(SkCanvas* canvas) { + if (fRepeatDrawing) { + this->inval(NULL); + } +} + +#include "SkColorPriv.h" + +static void reverseRedAndBlue(const SkBitmap& bm) { + SkASSERT(bm.config() == SkBitmap::kARGB_8888_Config); + uint8_t* p = (uint8_t*)bm.getPixels(); + uint8_t* stop = p + bm.getSize(); + while (p < stop) { + // swap red/blue (to go from ARGB(int) to RGBA(memory) and premultiply + unsigned scale = SkAlpha255To256(p[3]); + unsigned r = p[2]; + unsigned b = p[0]; + p[0] = SkAlphaMul(r, scale); + p[1] = SkAlphaMul(p[1], scale); + p[2] = SkAlphaMul(b, scale); + p += 4; + } +} + +SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) { +#ifndef USE_OFFSCREEN + aglSetWindowRef(gAGLContext, NULL); +#endif + switch (fCanvasType) { + case kRaster_CanvasType: + canvas = this->INHERITED::beforeChildren(canvas); + break; + case kPicture_CanvasType: + fPicture = new SkPicture; + canvas = fPicture->beginRecording(9999, 9999); + break; + case kOpenGL_CanvasType: { + //SkGLCanvas::DeleteAllTextures(); // just for testing + SkDevice* device = canvas->getDevice(); + const SkBitmap& bitmap = device->accessBitmap(true); + // first clear the raster bitmap, so we don't see any leftover bits + bitmap.eraseColor(0); + // now setup our glcanvas + setup_offscreen_gl(bitmap, (WindowRef)this->getHWND()); + fGLCanvas = new SkGLCanvas; + fGLCanvas->setViewport(bitmap.width(), bitmap.height()); + canvas = fGLCanvas; + break; + } + } + + if (fUseClip) { + canvas->drawColor(0xFFFF88FF); + canvas->clipPath(fClipPath); + } + + return canvas; +} + +static void paint_rgn(const SkBitmap& bm, const SkIRect& r, + const SkRegion& rgn) { + SkCanvas canvas(bm); + SkRegion inval(rgn); + + inval.translate(r.fLeft, r.fTop); + canvas.clipRegion(inval); + canvas.drawColor(0xFFFF8080); +} + +void SampleWindow::afterChildren(SkCanvas* orig) { + switch (fCanvasType) { + case kRaster_CanvasType: + break; + case kPicture_CanvasType: + if (false) { + SkPicture* pict = new SkPicture(*fPicture); + fPicture->unref(); + orig->drawPicture(*pict); + pict->unref(); + } if (true) { + SkDynamicMemoryWStream ostream; + fPicture->serialize(&ostream); + fPicture->unref(); + + SkMemoryStream istream(ostream.getStream(), ostream.getOffset()); + SkPicture pict(&istream); + orig->drawPicture(pict); + } else { + fPicture->draw(orig); + fPicture->unref(); + } + fPicture = NULL; + break; + case kOpenGL_CanvasType: + glFlush(); + delete fGLCanvas; + fGLCanvas = NULL; +#ifdef USE_OFFSCREEN + reverseRedAndBlue(orig->getDevice()->accessBitmap(true)); +#endif + break; + } + +// if ((fScrollTestX | fScrollTestY) != 0) + { + const SkBitmap& bm = orig->getDevice()->accessBitmap(true); + int dx = fScrollTestX * 7; + int dy = fScrollTestY * 7; + SkIRect r; + SkRegion inval; + + r.set(50, 50, 50+100, 50+100); + bm.scrollRect(&r, dx, dy, &inval); + paint_rgn(bm, r, inval); + } +} + +static SkBitmap::Config gConfigCycle[] = { + SkBitmap::kNo_Config, // none -> none + SkBitmap::kNo_Config, // a1 -> none + SkBitmap::kNo_Config, // a8 -> none + SkBitmap::kNo_Config, // index8 -> none + SkBitmap::kARGB_4444_Config, // 565 -> 4444 + SkBitmap::kARGB_8888_Config, // 4444 -> 8888 + SkBitmap::kRGB_565_Config // 8888 -> 565 +}; + +static SkBitmap::Config cycle_configs(SkBitmap::Config c) { + return gConfigCycle[c]; +} + +bool SampleWindow::nextSample() { + if (fCurr) { + fCurr = fCurr->next(); + if (NULL == fCurr) { + fCurr = SkViewRegister::Head(); + } + this->loadView(fCurr->factory()()); + return true; + } + return false; +} + +bool SampleWindow::onEvent(const SkEvent& evt) { + if (evt.isType(ANIMATING_EVENTTYPE)) { + if (fAnimating) { + this->nextSample(); + this->postAnimatingEvent(); + } + return true; + } + return this->INHERITED::onEvent(evt); +} + + +bool SampleWindow::onHandleChar(SkUnichar uni) { + int dx = 0xFF; + int dy = 0xFF; + + switch (uni) { + case '5': dx = 0; dy = 0; break; + case '8': dx = 0; dy = -1; break; + case '6': dx = 1; dy = 0; break; + case '2': dx = 0; dy = 1; break; + case '4': dx = -1; dy = 0; break; + case '7': dx = -1; dy = -1; break; + case '9': dx = 1; dy = -1; break; + case '3': dx = 1; dy = 1; break; + case '1': dx = -1; dy = 1; break; + + default: + break; + } + + if (0xFF != dx && 0xFF != dy) { + if ((dx | dy) == 0) { + fScrollTestX = fScrollTestY = 0; + } else { + fScrollTestX += dx; + fScrollTestY += dy; + } + this->inval(NULL); + return true; + } + + if ('a' == uni) { + fAnimating = !fAnimating; + this->postAnimatingEvent(); + this->updateTitle(); + } + + return this->INHERITED::onHandleChar(uni); +} + +#include "SkDumpCanvas.h" + +bool SampleWindow::onHandleKey(SkKey key) { + switch (key) { + case kRight_SkKey: + if (this->nextSample()) { + return true; + } + break; + case kLeft_SkKey: + fCanvasType = cycle_canvastype(fCanvasType); + this->updateTitle(); + this->inval(NULL); + return true; + case kUp_SkKey: + fUseClip = !fUseClip; + this->updateTitle(); + this->inval(NULL); + return true; + case kDown_SkKey: + this->setConfig(cycle_configs(this->getBitmap().config())); + this->updateTitle(); + return true; + case kOK_SkKey: + if (true) { + SkDebugfDumper dumper; + SkDumpCanvas dc(&dumper); + this->draw(&dc); + } else { + fRepeatDrawing = !fRepeatDrawing; + if (fRepeatDrawing) { + this->inval(NULL); + } + } + return true; + default: + break; + } + return this->INHERITED::onHandleKey(key); +} + +void SampleWindow::loadView(SkView* view) { + SkView::F2BIter iter(this); + SkView* prev = iter.next(); + if (prev) { + prev->detachFromParent(); + } + view->setVisibleP(true); + this->attachChildToFront(view)->unref(); + view->setSize(this->width(), this->height()); + + this->updateTitle(); +} + +static const char* gConfigNames[] = { + "unknown config", + "A1", + "A8", + "Index8", + "565", + "4444", + "8888" +}; + +static const char* configToString(SkBitmap::Config c) { + return gConfigNames[c]; +} + +static const char* gCanvasTypePrefix[] = { + "raster: ", + "picture: ", + "opengl: " +}; + +void SampleWindow::updateTitle() { + SkString title; + + SkView::F2BIter iter(this); + SkView* view = iter.next(); + SkEvent evt(gTitleEvtName); + if (view->doQuery(&evt)) { + title.set(evt.findString(gTitleEvtName)); + } + if (title.size() == 0) { + title.set("<unknown>"); + } + + title.prepend(gCanvasTypePrefix[fCanvasType]); + + title.prepend(" "); + title.prepend(configToString(this->getBitmap().config())); + + if (fAnimating) { + title.prepend("<A> "); + } + + this->setTitle(title.c_str()); +} + +void SampleWindow::onSizeChange() { + this->INHERITED::onSizeChange(); + + SkView::F2BIter iter(this); + SkView* view = iter.next(); + view->setSize(this->width(), this->height()); + + // rebuild our clippath + { + const SkScalar W = this->width(); + const SkScalar H = this->height(); + + fClipPath.reset(); +#if 0 + for (SkScalar y = SK_Scalar1; y < H; y += SkIntToScalar(32)) { + SkRect r; + r.set(SK_Scalar1, y, SkIntToScalar(30), y + SkIntToScalar(30)); + for (; r.fLeft < W; r.offset(SkIntToScalar(32), 0)) + fClipPath.addRect(r); + } +#else + SkRect r; + r.set(0, 0, W, H); + fClipPath.addRect(r, SkPath::kCCW_Direction); + r.set(W/4, H/4, W*3/4, H*3/4); + fClipPath.addRect(r, SkPath::kCW_Direction); +#endif + } + + this->updateTitle(); // to refresh our config +} + +/////////////////////////////////////////////////////////////////////////////// + +SkOSWindow* create_sk_window(void* hwnd) { + return new SampleWindow(hwnd); +} + +void get_preferred_size(int* x, int* y, int* width, int* height) { + *x = 10; + *y = 50; + *width = 640; + *height = 480; +} + +void application_init() { +// setenv("ANDROID_ROOT", "../../../data", 0); + setenv("ANDROID_ROOT", "/android/device/data", 0); + SkGraphics::Init(true); + SkEvent::Init(); +} + +void application_term() { + SkEvent::Term(); + SkGraphics::Term(); +} diff --git a/Samples/SampleArc.cpp b/Samples/SampleArc.cpp new file mode 100644 index 0000000..7bc862b --- /dev/null +++ b/Samples/SampleArc.cpp @@ -0,0 +1,187 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "Sk1DPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkPorterDuff.h" +#include "SkLayerRasterizer.h" + +class ArcsView : public SkView { +public: + ArcsView() + { + fSweep = SkIntToScalar(100); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Arcs"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); + } + + static void drawRectWithLines(SkCanvas* canvas, const SkRect& r, const SkPaint& p) + { + canvas->drawRect(r, p); + canvas->drawLine(r.fLeft, r.fTop, r.fRight, r.fBottom, p); + canvas->drawLine(r.fLeft, r.fBottom, r.fRight, r.fTop, p); + canvas->drawLine(r.fLeft, r.centerY(), r.fRight, r.centerY(), p); + canvas->drawLine(r.centerX(), r.fTop, r.centerX(), r.fBottom, p); + } + + static void draw_label(SkCanvas* canvas, const SkRect& rect, + int start, int sweep) + { + SkPaint paint; + + paint.setAntiAlias(true); + paint.setTextAlign(SkPaint::kCenter_Align); + + SkString str; + + str.appendS32(start); + str.append(", "); + str.appendS32(sweep); + canvas->drawText(str.c_str(), str.size(), rect.centerX(), + rect.fBottom + paint.getTextSize() * 5/4, paint); + } + + static void drawArcs(SkCanvas* canvas) + { + SkPaint paint; + SkRect r; + SkScalar w = SkIntToScalar(75); + SkScalar h = SkIntToScalar(50); + + r.set(0, 0, w, h); + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + + canvas->save(); + canvas->translate(SkIntToScalar(10), SkIntToScalar(300)); + + paint.setStrokeWidth(SkIntToScalar(1)); + + static const int gAngles[] = { + 0, 360, + 0, 45, + 0, -45, + 720, 135, + -90, 269, + -90, 270, + -90, 271, + -180, -270, + 225, 90 + }; + + for (int i = 0; i < SK_ARRAY_COUNT(gAngles); i += 2) + { + paint.setColor(SK_ColorBLACK); + drawRectWithLines(canvas, r, paint); + + paint.setColor(SK_ColorRED); + canvas->drawArc(r, SkIntToScalar(gAngles[i]), + SkIntToScalar(gAngles[i+1]), false, paint); + + draw_label(canvas, r, gAngles[i], gAngles[i+1]); + + canvas->translate(w * 8 / 7, 0); + } + + canvas->restore(); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + SkRect r; + SkPaint paint; + + paint.setAntiAlias(true); + paint.setStrokeWidth(SkIntToScalar(2)); + paint.setStyle(SkPaint::kStroke_Style); + + r.set(0, 0, SkIntToScalar(200), SkIntToScalar(200)); + r.offset(SkIntToScalar(20), SkIntToScalar(20)); + + if (false) { + const SkScalar d = SkIntToScalar(3); + const SkScalar rad[] = { d, d, d, d, d, d, d, d }; + SkPath path; + path.addRoundRect(r, rad); + canvas->drawPath(path, paint); + return; + } + + drawRectWithLines(canvas, r, paint); + + // printf("----- sweep %g %X\n", SkScalarToFloat(fSweep), SkDegreesToRadians(fSweep)); + + + paint.setStyle(SkPaint::kFill_Style); + paint.setColor(0x800000FF); + canvas->drawArc(r, 0, fSweep, true, paint); + + paint.setColor(0x800FF000); + canvas->drawArc(r, 0, fSweep, false, paint); + + paint.setStyle(SkPaint::kStroke_Style); + paint.setColor(SK_ColorRED); + canvas->drawArc(r, 0, fSweep, true, paint); + + paint.setStrokeWidth(0); + paint.setColor(SK_ColorBLUE); + canvas->drawArc(r, 0, fSweep, false, paint); + + fSweep += SK_Scalar1/4; + if (fSweep > SkIntToScalar(360)) + fSweep = 0; + + drawArcs(canvas); + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + // fSweep += SK_Scalar1; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + SkScalar fSweep; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new ArcsView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleBitmapRect.cpp b/Samples/SampleBitmapRect.cpp new file mode 100644 index 0000000..5919084 --- /dev/null +++ b/Samples/SampleBitmapRect.cpp @@ -0,0 +1,111 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef.h" +#include "SkOSFile.h" +#include "SkStream.h" + +#define SPECIFIC_IMAGE "/skimages/main.gif" + +class BitmapRectView : public SkView { +public: + SkBitmap fBitmap; + int fCurrX, fCurrY; + + BitmapRectView() { + SkImageDecoder::DecodeFile(SPECIFIC_IMAGE, &fBitmap); + fCurrX = fCurrY = 0; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SkString str("BitmapRect: "); + str.append(SPECIFIC_IMAGE); + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(SK_ColorGRAY); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->drawBitmap(fBitmap, 0, 0, NULL); + + SkIRect subset; + const int SRC_WIDTH = 16; + const int SRC_HEIGHT = 16; + + subset.set(0, 0, SRC_WIDTH, SRC_HEIGHT); + subset.offset(fCurrX, fCurrY); + + SkDebugf("---- src x=%d y=%d\n", subset.fLeft, subset.fTop); + + SkRect dst0, dst1; + SkScalar y = SkIntToScalar(fBitmap.height() + 16); + + dst0.set(SkIntToScalar(50), y, + SkIntToScalar(50+SRC_WIDTH), + y + SkIntToScalar(SRC_HEIGHT)); + dst1 = dst0; + dst1.offset(SkIntToScalar(200), 0); + dst1.fRight = dst1.fLeft + 8 * dst0.width(); + dst1.fBottom = dst1.fTop + 8 * dst0.height(); + + canvas->drawBitmapRect(fBitmap, &subset, dst0, NULL); + canvas->drawBitmapRect(fBitmap, &subset, dst1, NULL); + + SkPaint paint; + paint.setColor(0x88FF0000); + canvas->drawRect(dst0, paint); + paint.setColor(0x880000FF); + canvas->drawRect(dst1, paint); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + return new Click(this); + } + + virtual bool onClick(Click* click) + { + fCurrX = click->fICurr.fX; + fCurrY = click->fICurr.fY; + this->inval(NULL); + return true; + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new BitmapRectView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleCamera.cpp b/Samples/SampleCamera.cpp new file mode 100644 index 0000000..9a8d1ef --- /dev/null +++ b/Samples/SampleCamera.cpp @@ -0,0 +1,106 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkCamera.h" +#include "SkEmbossMaskFilter.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkRandom.h" + +class CameraView : public SkView { +public: + CameraView() + { + fRX = fRY = fRZ = 0; + } + + virtual ~CameraView() + { + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Camera"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(0, SkPorterDuff::kClear_Mode); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->translate(this->width()/2, this->height()/2); + + Sk3DView view; + view.rotateX(SkIntToScalar(fRX)); + view.rotateY(SkIntToScalar(fRY)); + view.applyToCanvas(canvas); + + SkPaint paint; + SkScalar rad = SkIntToScalar(50); + SkScalar dim = rad*2; + + if (view.dotWithNormal(0, 0, SK_Scalar1) < 0) { + paint.setColor(SK_ColorRED); + } + + paint.setAntiAlias(true); + +#if 0 + SkEmbossMaskFilter::Light light; + light.fDirection[0] = SK_Scalar1; + light.fDirection[1] = SK_Scalar1; + light.fDirection[2] = SK_Scalar1; + light.fAmbient = 180; + light.fSpecular = 16 * 2; + paint.setMaskFilter(new SkEmbossMaskFilter(light, SkIntToScalar(4))); +#endif + + canvas->drawCircle(0, 0, rad, paint); + canvas->drawCircle(-dim, -dim, rad, paint); + canvas->drawCircle(-dim, dim, rad, paint); + canvas->drawCircle( dim, -dim, rad, paint); + canvas->drawCircle( dim, dim, rad, paint); + + fRY += 1; + if (fRY >= 360) + fRY = 0; + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + SkScalar angle = SkScalarDiv(this->height()/2 - y, this->height()); + fRX = SkScalarRound(angle * 180); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + int fRX, fRY, fRZ; + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new CameraView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleCircle.cpp b/Samples/SampleCircle.cpp new file mode 100644 index 0000000..bfb92d4 --- /dev/null +++ b/Samples/SampleCircle.cpp @@ -0,0 +1,137 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkDevice.h" +#include "SkPaint.h" + +// ensure that we don't accidentally screw up the bounds when the oval is +// fractional, and the impl computes the center and radii, and uses them to +// reconstruct the edges of the circle. +// see bug# 1504910 +static void test_circlebounds(SkCanvas* canvas) { +#ifdef SK_SCALAR_IS_FLOAT + SkRect r = { 1.39999998, 1, 21.3999996, 21 }; + SkPath p; + p.addOval(r); + SkRect r2; + p.computeBounds(&r2, SkPath::kFast_BoundsType); + SkASSERT(r == r2); +#endif +} + +class CircleView : public SkView { +public: + static const SkScalar ANIM_DX = SK_Scalar1 / 67; + static const SkScalar ANIM_DY = SK_Scalar1 / 29; + static const SkScalar ANIM_RAD = SK_Scalar1 / 19; + SkScalar fDX, fDY, fRAD; + + CircleView() { + fDX = fDY = fRAD = 0; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Circles"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + void circle(SkCanvas* canvas, int width, bool aa) { + SkPaint paint; + + paint.setAntiAlias(aa); + if (width < 0) { + paint.setStyle(SkPaint::kFill_Style); + } else { + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(width)); + } + canvas->drawCircle(0, 0, SkIntToScalar(9) + fRAD, paint); + } + + void drawSix(SkCanvas* canvas, SkScalar dx, SkScalar dy) { + for (int width = -1; width <= 1; width++) { + canvas->save(); + circle(canvas, width, false); + canvas->translate(0, dy); + circle(canvas, width, true); + canvas->restore(); + canvas->translate(dx, 0); + } + } + + static void blowup(SkCanvas* canvas, const SkIRect& src, const SkRect& dst) { + SkDevice* device = canvas->getDevice(); + const SkBitmap& bm = device->accessBitmap(false); + canvas->drawBitmapRect(bm, &src, dst, NULL); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + test_circlebounds(canvas); + + if (false) { + // canvas->translate(SK_ScalarHalf, SK_ScalarHalf); + + SkPaint paint; + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + canvas->drawCircle(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(2), paint); + + SkIRect r; + r.set(7, 7, 13, 13); + SkRect dst; + dst.set(SkIntToScalar(100), SkIntToScalar(10), SkIntToScalar(200), SkIntToScalar(110)); + blowup(canvas, r, dst); + return; + } + + // test that degenerate rects do nothing + if (true) { + SkScalar x = SkIntToScalar(30); + SkRect r; + r.set(x, x, x, x); + SkPaint p; + canvas->drawRect(r, p); + p.setAntiAlias(true); + canvas->drawRect(r, p); + } + + SkScalar dx = SkIntToScalar(32); + SkScalar dy = SkIntToScalar(32); + + canvas->translate(dx + fDX, dy + fDY); + drawSix(canvas, dx, dy); + + canvas->translate(dx, 0); + canvas->translate(SK_ScalarHalf, SK_ScalarHalf); + drawSix(canvas, dx, dy); + + fDX += ANIM_DX; + fDY += ANIM_DY; + fRAD += ANIM_RAD; + this->inval(NULL); + } + +private: + typedef SkView INHERITED; +}; + +const SkScalar CircleView::ANIM_DX; +const SkScalar CircleView::ANIM_DY; +const SkScalar CircleView::ANIM_RAD; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new CircleView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleCode.h b/Samples/SampleCode.h new file mode 100644 index 0000000..ff660f2 --- /dev/null +++ b/Samples/SampleCode.h @@ -0,0 +1,38 @@ +#ifndef SampleCode_DEFINED +#define SampleCode_DEFINED + +#include "SkEvent.h" + +class SampleCode { +public: + static bool TitleQ(const SkEvent&); + static void TitleR(SkEvent*, const char title[]); + + static bool PrefSizeQ(const SkEvent&); + static void PrefSizeR(SkEvent*, SkScalar width, SkScalar height); +}; + +////////////////////////////////////////////////////////////////////////////// + +class SkView; + +typedef SkView* (*SkViewFactory)(); + +class SkViewRegister : SkNoncopyable { +public: + SkViewRegister(SkViewFactory); + + static const SkViewRegister* Head() { return gHead; } + + SkViewRegister* next() const { return fChain; } + SkViewFactory factory() const { return fFact; } + +private: + SkViewFactory fFact; + SkViewRegister* fChain; + + static SkViewRegister* gHead; +}; + +#endif + diff --git a/Samples/SampleCull.cpp b/Samples/SampleCull.cpp new file mode 100644 index 0000000..ea1bb77 --- /dev/null +++ b/Samples/SampleCull.cpp @@ -0,0 +1,230 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkCornerPathEffect.h" +#include "SkCullPoints.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkRandom.h" + +static void addbump(SkPath* path, const SkPoint pts[2], SkScalar bump) +{ + SkVector tang; + + tang.setLength(pts[1].fX - pts[0].fX, pts[1].fY - pts[0].fY, bump); + + path->lineTo(SkScalarHalf(pts[0].fX + pts[1].fX) - tang.fY, + SkScalarHalf(pts[0].fY + pts[1].fY) + tang.fX); + path->lineTo(pts[1]); +} + +static void subdivide(SkPath* path, SkScalar bump) +{ + SkPath::Iter iter(*path, false); + SkPoint pts[4]; + SkPath tmp; + + for (;;) + switch (iter.next(pts)) { + case SkPath::kMove_Verb: + tmp.moveTo(pts[0]); + break; + case SkPath::kLine_Verb: + addbump(&tmp, pts, bump); + bump = -bump; + break; + case SkPath::kDone_Verb: + goto FINISH; + default: + break; + } + +FINISH: + path->swap(tmp); +} + +static SkIPoint* getpts(const SkPath& path, int* count) +{ + SkPoint pts[4]; + int n = 1; + SkIPoint* array; + + { + SkPath::Iter iter(path, false); + for (;;) + switch (iter.next(pts)) { + case SkPath::kLine_Verb: + n += 1; + break; + case SkPath::kDone_Verb: + goto FINISHED; + default: + break; + } + } + +FINISHED: + array = new SkIPoint[n]; + n = 0; + + { + SkPath::Iter iter(path, false); + for (;;) + switch (iter.next(pts)) { + case SkPath::kMove_Verb: + array[n++].set(SkScalarRound(pts[0].fX), SkScalarRound(pts[0].fY)); + break; + case SkPath::kLine_Verb: + array[n++].set(SkScalarRound(pts[1].fX), SkScalarRound(pts[1].fY)); + break; + case SkPath::kDone_Verb: + goto FINISHED2; + default: + break; + } + } + +FINISHED2: + *count = n; + return array; +} + +static SkScalar nextScalarRange(SkRandom& rand, SkScalar min, SkScalar max) +{ + return min + SkScalarMul(rand.nextUScalar1(), max - min); +} + +class CullView : public SkView { +public: + CullView() + { + fClip.set(0, 0, SkIntToScalar(160), SkIntToScalar(160)); + + SkRandom rand; + + for (int i = 0; i < 50; i++) { + int x = nextScalarRange(rand, -fClip.width()*1, fClip.width()*2); + int y = nextScalarRange(rand, -fClip.height()*1, fClip.height()*2); + if (i == 0) + fPath.moveTo(x, y); + else + fPath.lineTo(x, y); + } + + SkScalar bump = fClip.width()/8; + subdivide(&fPath, bump); + subdivide(&fPath, bump); + subdivide(&fPath, bump); + fPoints = getpts(fPath, &fPtCount); + } + + virtual ~CullView() + { + delete[] fPoints; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Culling"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); + + #if 0 + SkPaint paint; + + paint.setAntiAliasOn(true); + paint.setTextSize(SkIntToScalar(20)); + paint.setTypeface(SkTypeface::Create("serif", SkTypeface::kBoldItalic))->unref(); + + uint16_t text[20]; + + text[0] = 'H'; + text[1] = 'i'; + text[2] = ' '; + for (int i = 3; i < 20; i++) + text[i] = 0x3040 + i; + canvas->drawText16(text, 20, SkIntToScalar(20), SkIntToScalar(20), paint); + #endif + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + SkAutoCanvasRestore ar(canvas, true); + + canvas->translate( SkScalarHalf(this->width() - fClip.width()), + SkScalarHalf(this->height() - fClip.height())); + + // canvas->scale(SK_Scalar1*3, SK_Scalar1*3, 0, 0); + + SkPaint paint; + + // paint.setAntiAliasOn(true); + paint.setStyle(SkPaint::kStroke_Style); + + canvas->drawRect(fClip, paint); + +#if 1 + paint.setColor(0xFF555555); + paint.setStrokeWidth(SkIntToScalar(2)); +// paint.setPathEffect(new SkCornerPathEffect(SkIntToScalar(30)))->unref(); + canvas->drawPath(fPath, paint); +// paint.setPathEffect(NULL); +#endif + + SkPath tmp; + SkIRect iclip; + fClip.round(&iclip); + + SkCullPointsPath cpp(iclip, &tmp); + + cpp.moveTo(fPoints[0].fX, fPoints[0].fY); + for (int i = 0; i < fPtCount; i++) + cpp.lineTo(fPoints[i].fX, fPoints[i].fY); + + paint.setColor(SK_ColorRED); + paint.setStrokeWidth(SkIntToScalar(3)); + paint.setStrokeJoin(SkPaint::kRound_Join); + canvas->drawPath(tmp, paint); + + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + SkRect fClip; + SkIPoint* fPoints; + SkPath fPath; + int fPtCount; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new CullView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleDither.cpp b/Samples/SampleDither.cpp new file mode 100644 index 0000000..7f7877a --- /dev/null +++ b/Samples/SampleDither.cpp @@ -0,0 +1,198 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "Sk1DPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkDither.h" + +static void draw_sweep(SkCanvas* c, int width, int height, SkScalar angle) { + SkRect r; + SkPaint p; + + p.setAntiAlias(true); +// p.setDither(true); + p.setStrokeWidth(SkIntToScalar(width/10)); + p.setStyle(SkPaint::kStroke_Style); + + r.set(0, 0, SkIntToScalar(width), SkIntToScalar(height)); + + // SkColor colors[] = { SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN, SK_ColorCYAN }; + SkColor colors[] = { 0x4c737373, 0x4c737373, 0xffffd300 }; + SkShader* s = SkGradientShader::CreateSweep(r.centerX(), r.centerY(), + colors, NULL, SK_ARRAY_COUNT(colors)); + p.setShader(s)->unref(); + + SkAutoCanvasRestore acr(c, true); + + c->translate(r.centerX(), r.centerY()); + c->rotate(angle); + c->translate(-r.centerX(), -r.centerY()); + + SkRect bounds = r; + r.inset(p.getStrokeWidth(), p.getStrokeWidth()); + SkRect innerBounds = r; + + if (true) { + c->drawOval(r, p); + } else { + SkScalar x = r.centerX(); + SkScalar y = r.centerY(); + SkScalar radius = r.width() / 2; + SkScalar thickness = p.getStrokeWidth(); + SkScalar sweep = SkFloatToScalar(360.0f); + SkPath path; + + path.moveTo(x + radius, y); + // outer top + path.lineTo(x + radius + thickness, y); + // outer arc + path.arcTo(bounds, 0, sweep, false); + // inner arc + path.arcTo(innerBounds, sweep, -sweep, false); + path.close(); + } +} + +static void make_bm(SkBitmap* bm) +{ + bm->setConfig(SkBitmap::kARGB_8888_Config, 100, 100); + bm->allocPixels(); +#if 0 + bm->eraseColor(SK_ColorBLUE); + return; +#else + bm->eraseColor(0); +#endif + + SkCanvas c(*bm); + draw_sweep(&c, bm->width(), bm->height(), 0); +} + +static void pre_dither(const SkBitmap& bm) +{ + SkAutoLockPixels alp(bm); + + for (unsigned y = 0; y < bm.height(); y++) { + DITHER_4444_SCAN(y); + + SkPMColor* p = bm.getAddr32(0, y); + for (unsigned x = 0; x < bm.width(); x++) { + SkPMColor c = *p; + + unsigned a = SkGetPackedA32(c); + unsigned r = SkGetPackedR32(c); + unsigned g = SkGetPackedG32(c); + unsigned b = SkGetPackedB32(c); + + unsigned d = DITHER_VALUE(x); + + a = SkDITHER_A32To4444(a, d); + r = SkDITHER_R32To4444(r, d); + g = SkDITHER_G32To4444(g, d); + b = SkDITHER_B32To4444(b, d); + + a = SkA4444ToA32(a); + r = SkR4444ToR32(r); + g = SkG4444ToG32(g); + b = SkB4444ToB32(b); + + *p++ = SkPackARGB32(a, r, g, b); + } + } +} + +class DitherView : public SkView { +public: + SkBitmap fBM, fBMPreDither, fBM16; + SkScalar fAngle; + + DitherView() { + make_bm(&fBM); + make_bm(&fBMPreDither); + pre_dither(fBMPreDither); + fBM.copyTo(&fBM16, SkBitmap::kARGB_4444_Config); + + fAngle = 0; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Dither"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(0xFF181818); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkPaint paint; + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(10); + const SkScalar DX = SkIntToScalar(fBM.width() + 10); + + paint.setAntiAlias(true); + + if (true) { + canvas->drawBitmap(fBM, x, y, &paint); + x += DX; + paint.setDither(true); + canvas->drawBitmap(fBM, x, y, &paint); + + x += DX; + paint.setDither(false); + canvas->drawBitmap(fBMPreDither, x, y, &paint); + + x += DX; + canvas->drawBitmap(fBM16, x, y, &paint); + } + + canvas->translate(DX, DX*2); + draw_sweep(canvas, fBM.width(), fBM.height(), fAngle); + canvas->translate(DX, 0); + draw_sweep(canvas, fBM.width()>>1, fBM.height()>>1, fAngle); + canvas->translate(DX, 0); + draw_sweep(canvas, fBM.width()>>2, fBM.height()>>2, fAngle); + + fAngle += SK_Scalar1/2; + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + // fSweep += SK_Scalar1; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new DitherView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleDrawLooper.cpp b/Samples/SampleDrawLooper.cpp new file mode 100644 index 0000000..1a7a870 --- /dev/null +++ b/Samples/SampleDrawLooper.cpp @@ -0,0 +1,103 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGraphics.h" +#include "SkRandom.h" +#include "SkLayerDrawLooper.h" +#include "SkBlurMaskFilter.h" + +#include <pthread.h> + +#define WIDTH 200 +#define HEIGHT 200 + +class LooperView : public SkView { +public: + + SkLayerDrawLooper* fLooper; + + LooperView() { + static const struct { + SkColor fColor; + SkPaint::Style fStyle; + SkScalar fWidth; + SkScalar fOffset; + int fBlur; + } gParams[] = { + { SK_ColorWHITE, SkPaint::kStroke_Style, SkIntToScalar(1)*3/4, 0, 0 }, + { SK_ColorRED, SkPaint::kStroke_Style, SkIntToScalar(4), 0, 0 }, + { SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0 }, + { 0x88000000, SkPaint::kFill_Style, 0, SkIntToScalar(10), 3 } + }; + + fLooper = new SkLayerDrawLooper; + + for (int i = 0; i < SK_ARRAY_COUNT(gParams); i++) { + SkPaint* paint = fLooper->addLayer(gParams[i].fOffset, + gParams[i].fOffset); + paint->setAntiAlias(true); + paint->setColor(gParams[i].fColor); + paint->setStyle(gParams[i].fStyle); + paint->setStrokeWidth(gParams[i].fWidth); + paint->setTextSize(SkIntToScalar(72)); + if (gParams[i].fBlur > 0) { + SkMaskFilter* mf = SkBlurMaskFilter::Create(SkIntToScalar(gParams[i].fBlur), + SkBlurMaskFilter::kNormal_BlurStyle); + paint->setMaskFilter(mf)->unref(); + } + } + } + + virtual ~LooperView() { + fLooper->safeUnref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "DrawLooper"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkPaint paint; + paint.setLooper(fLooper); + + canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50), + SkIntToScalar(30), paint); + + canvas->drawRectCoords(SkIntToScalar(150), SkIntToScalar(50), + SkIntToScalar(200), SkIntToScalar(100), paint); + + canvas->drawText("Looper", 6, SkIntToScalar(230), SkIntToScalar(100), + paint); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new LooperView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleEmboss.cpp b/Samples/SampleEmboss.cpp new file mode 100644 index 0000000..cdc8b47 --- /dev/null +++ b/Samples/SampleEmboss.cpp @@ -0,0 +1,78 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkColorShader.h" +#include "SkEmbossMaskFilter.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +class EmbossView : public SkView { + SkEmbossMaskFilter::Light fLight; +public: + EmbossView() + { + fLight.fDirection[0] = SK_Scalar1; + fLight.fDirection[1] = SK_Scalar1; + fLight.fDirection[2] = SK_Scalar1; + fLight.fAmbient = 128; + fLight.fSpecular = 16*2; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Emboss"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + SkPaint paint; + + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(10)); + paint.setMaskFilter(new SkEmbossMaskFilter(fLight, SkIntToScalar(4)))->unref(); + paint.setShader(new SkColorShader(SK_ColorBLUE))->unref(); + paint.setDither(true); + + canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50), + SkIntToScalar(30), paint); + } + +private: + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new EmbossView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleEncode.cpp b/Samples/SampleEncode.cpp new file mode 100644 index 0000000..221b6f8 --- /dev/null +++ b/Samples/SampleEncode.cpp @@ -0,0 +1,254 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef.h" +#include "SkStream.h" + +static void make_image(SkBitmap* bm, SkBitmap::Config config, int configIndex) { + const int width = 98; + const int height = 100; + SkBitmap device; + + device.setConfig(SkBitmap::kARGB_8888_Config, width, height); + device.allocPixels(); + + SkCanvas canvas(device); + SkPaint paint; + + paint.setAntiAlias(true); + canvas.drawColor(SK_ColorRED); + paint.setColor(SK_ColorBLUE); + canvas.drawCircle(SkIntToScalar(width)/2, SkIntToScalar(height)/2, + SkIntToScalar(width)/2, paint); + + bm->setConfig(config, width, height); + switch (config) { + case SkBitmap::kARGB_8888_Config: + bm->swap(device); + break; + case SkBitmap::kRGB_565_Config: { + bm->allocPixels(); + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + *bm->getAddr16(x, y) = SkPixel32ToPixel16(*device.getAddr32(x, y)); + } + } + break; + } + case SkBitmap::kIndex8_Config: { + SkPMColor colors[256]; + for (int i = 0; i < 256; i++) { + if (configIndex & 1) { + colors[i] = SkPackARGB32(255-i, 0, 0, 255-i); + } else { + colors[i] = SkPackARGB32(0xFF, i, 0, 255-i); + } + } + SkColorTable* ctable = new SkColorTable(colors, 256); + bm->allocPixels(ctable); + ctable->unref(); + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + *bm->getAddr8(x, y) = SkGetPackedR32(*device.getAddr32(x, y)); + } + } + break; + } + default: + break; + } +} + +// configs to build the original bitmap in. Can be at most these 3 +static const SkBitmap::Config gConfigs[] = { + SkBitmap::kARGB_8888_Config, + SkBitmap::kRGB_565_Config, + SkBitmap::kIndex8_Config, // opaque + SkBitmap::kIndex8_Config // alpha +}; + +static const char* const gConfigLabels[] = { + "8888", "565", "Index8", "Index8 alpha" +}; + +// types to encode into. Can be at most these 3. Must match up with gExt[] +static const SkImageEncoder::Type gTypes[] = { + SkImageEncoder::kJPEG_Type, + SkImageEncoder::kPNG_Type +}; + +// must match up with gTypes[] +static const char* const gExt[] = { + ".jpg", ".png" +}; + +static const char* gPath = "/encoded/"; + +static void make_name(SkString* name, int config, int ext) { + name->set(gPath); + name->append(gConfigLabels[config]); + name->append(gExt[ext]); +} + +#include <sys/stat.h> + +class EncodeView : public SkView { +public: + SkBitmap* fBitmaps; + size_t fBitmapCount; + + EncodeView() { + #if 1 + (void)mkdir(gPath, S_IRWXU | S_IRWXG | S_IRWXO); + + fBitmapCount = SK_ARRAY_COUNT(gConfigs); + fBitmaps = new SkBitmap[fBitmapCount]; + for (size_t i = 0; i < fBitmapCount; i++) { + make_image(&fBitmaps[i], gConfigs[i], i); + + for (size_t j = 0; j < SK_ARRAY_COUNT(gExt); j++) { + SkString path; + make_name(&path, i, j); + + // remove any previous run of this file + remove(path.c_str()); + + SkImageEncoder* codec = SkImageEncoder::Create(gTypes[j]); + if (!codec->encodeFile(path.c_str(), fBitmaps[i])) { + SkDebugf("------ failed to encode %s\n", path.c_str()); + remove(path.c_str()); // remove any partial file + } + delete codec; + } + } + #else + fBitmaps = NULL; + fBitmapCount = 0; + #endif + } + + virtual ~EncodeView() { + delete[] fBitmaps; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "ImageEncoder"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + if (fBitmapCount == 0) { + return; + } + + SkPaint paint; + if (false) { +// SkColor colors[] = { 0xFE000000, SK_ColorWHITE }; + SkColor colors[] = { SK_ColorRED, SK_ColorBLUE }; + SkShader* shader = SkGradientShader::CreateSweep(SkIntToScalar(50), SkIntToScalar(50), + colors, NULL, 2); + paint.setShader(shader)->unref(); + + SkRect r; + r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100)); + canvas->drawRect(r, paint); + + canvas->translate(SkIntToScalar(200), SkIntToScalar(200)); + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(10)); + canvas->drawOval(r, paint); + return; + } + + paint.setAntiAlias(true); + paint.setTextAlign(SkPaint::kCenter_Align); + + canvas->translate(SkIntToScalar(10), SkIntToScalar(20)); + + SkScalar x = 0, y = 0, maxX = 0; + const int SPACER = 10; + + for (size_t i = 0; i < fBitmapCount; i++) { + canvas->drawText(gConfigLabels[i], strlen(gConfigLabels[i]), + x + SkIntToScalar(fBitmaps[i].width()) / 2, 0, + paint); + y = paint.getTextSize(); + + canvas->drawBitmap(fBitmaps[i], x, y); + + SkScalar yy = y; + for (size_t j = 0; j < SK_ARRAY_COUNT(gExt); j++) { + yy += SkIntToScalar(fBitmaps[i].height() + 10); + + SkBitmap bm; + SkString name; + + make_name(&name, i, j); + + SkImageDecoder::DecodeFile(name.c_str(), &bm); + canvas->drawBitmap(bm, x, yy); + } + + x += SkIntToScalar(fBitmaps[i].width() + SPACER); + if (x > maxX) { + maxX = x; + } + } + + y = (paint.getTextSize() + SkIntToScalar(fBitmaps[0].height())) * 3 / 2; + x = maxX + SkIntToScalar(10); + paint.setTextAlign(SkPaint::kLeft_Align); + + for (size_t j = 0; j < SK_ARRAY_COUNT(gExt); j++) { + canvas->drawText(gExt[j], strlen(gExt[j]), x, y, paint); + y += SkIntToScalar(fBitmaps[0].height() + SPACER); + } + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new EncodeView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleFillType.cpp b/Samples/SampleFillType.cpp new file mode 100644 index 0000000..bb268cd --- /dev/null +++ b/Samples/SampleFillType.cpp @@ -0,0 +1,101 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkCornerPathEffect.h" +#include "SkCullPoints.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" + +class FillTypeView : public SkView { + SkPath fPath; +public: + FillTypeView() { + const SkScalar radius = SkIntToScalar(45); + fPath.addCircle(SkIntToScalar(50), SkIntToScalar(50), radius); + fPath.addCircle(SkIntToScalar(100), SkIntToScalar(100), radius); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "FillType"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); + } + + void showPath(SkCanvas* canvas, int x, int y, SkPath::FillType ft, + SkScalar scale, const SkPaint& paint) { + + const SkRect r = { 0, 0, SkIntToScalar(150), SkIntToScalar(150) }; + + canvas->save(); + canvas->translate(SkIntToScalar(x), SkIntToScalar(y)); + canvas->clipRect(r); + canvas->drawColor(SK_ColorWHITE); + fPath.setFillType(ft); + canvas->translate(r.centerX(), r.centerY()); + canvas->scale(scale, scale); + canvas->translate(-r.centerX(), -r.centerY()); + canvas->drawPath(fPath, paint); + canvas->restore(); + } + + void showFour(SkCanvas* canvas, SkScalar scale, const SkPaint& paint) { + showPath(canvas, 0, 0, SkPath::kWinding_FillType, + scale, paint); + showPath(canvas, 200, 0, SkPath::kEvenOdd_FillType, + scale, paint); + showPath(canvas, 00, 200, SkPath::kInverseWinding_FillType, + scale, paint); + showPath(canvas, 200, 200, SkPath::kInverseEvenOdd_FillType, + scale, paint); + } + + virtual void onDraw(SkCanvas* canvas) { + drawBG(canvas); + + canvas->translate(SkIntToScalar(20), SkIntToScalar(20)); + + SkPaint paint; + const SkScalar scale = SkIntToScalar(5)/4; + + paint.setAntiAlias(false); + + showFour(canvas, SK_Scalar1, paint); + canvas->translate(SkIntToScalar(450), 0); + showFour(canvas, scale, paint); + + paint.setAntiAlias(true); + + canvas->translate(SkIntToScalar(-450), SkIntToScalar(450)); + showFour(canvas, SK_Scalar1, paint); + canvas->translate(SkIntToScalar(450), 0); + showFour(canvas, scale, paint); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new FillTypeView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleFilter.cpp b/Samples/SampleFilter.cpp new file mode 100644 index 0000000..8d26470 --- /dev/null +++ b/Samples/SampleFilter.cpp @@ -0,0 +1,164 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "Sk1DPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkDither.h" + +static void make_bm(SkBitmap* bm) +{ + const SkColor colors[] = { + SK_ColorRED, SK_ColorGREEN, + SK_ColorBLUE, SK_ColorWHITE + }; + SkColorTable* ctable = new SkColorTable(colors, 4); + bm->setConfig(SkBitmap::kIndex8_Config, 2, 2); + bm->allocPixels(ctable); + ctable->unref(); + + *bm->getAddr8(0, 0) = 0; + *bm->getAddr8(1, 0) = 1; + *bm->getAddr8(0, 1) = 2; + *bm->getAddr8(1, 1) = 3; +} + +static SkScalar draw_bm(SkCanvas* canvas, const SkBitmap& bm, + SkScalar x, SkScalar y, SkPaint* paint) +{ +#if 1 + canvas->drawBitmap(bm, x, y, paint); + return SkIntToScalar(bm.width()) * 5/4; +#else + SkRect r; + + r.set(x, y, + x + SkIntToScalar(bm.width() * 2), + y + SkIntToScalar(bm.height() * 2)); + SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode); + paint->setShader(s)->unref(); + canvas->drawRect(r, *paint); + paint->setShader(NULL); + return r.width() * 5/4; +#endif +} + +static SkScalar draw_set(SkCanvas* c, const SkBitmap& bm, SkScalar x, SkPaint* p) +{ + x += draw_bm(c, bm, x, 0, p); + p->setFilterBitmap(true); + x += draw_bm(c, bm, x, 0, p); + p->setDither(true); + return x + draw_bm(c, bm, x, 0, p); +} + +static const char* gConfigNames[] = { + "unknown config", + "A1", + "A8", + "Index8", + "565", + "4444", + "8888" +}; + +static SkScalar draw_row(SkCanvas* canvas, const SkBitmap& bm) +{ + SkAutoCanvasRestore acr(canvas, true); + + SkPaint paint; + SkScalar x = 0; + const int scale = 32; + + paint.setAntiAlias(true); + const char* name = gConfigNames[bm.config()]; + canvas->drawText(name, strlen(name), x, SkIntToScalar(bm.height())*scale*5/8, + paint); + canvas->translate(SkIntToScalar(48), 0); + + canvas->scale(SkIntToScalar(scale), SkIntToScalar(scale)); + + x += draw_set(canvas, bm, 0, &paint); + paint.reset(); + paint.setAlpha(0x80); + draw_set(canvas, bm, x, &paint); + return x * scale / 3; +} + +class FilterView : public SkView { +public: + SkBitmap fBM8, fBM4444, fBM16, fBM32; + + FilterView() + { + make_bm(&fBM8); + fBM8.copyTo(&fBM4444, SkBitmap::kARGB_4444_Config); + fBM8.copyTo(&fBM16, SkBitmap::kRGB_565_Config); + fBM8.copyTo(&fBM32, SkBitmap::kARGB_8888_Config); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Filter"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(10); + + canvas->translate(x, y); + y = draw_row(canvas, fBM8); + canvas->translate(0, y); + y = draw_row(canvas, fBM4444); + canvas->translate(0, y); + y = draw_row(canvas, fBM16); + canvas->translate(0, y); + draw_row(canvas, fBM32); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + // fSweep += SK_Scalar1; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new FilterView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleFilter2.cpp b/Samples/SampleFilter2.cpp new file mode 100644 index 0000000..30ac2bd --- /dev/null +++ b/Samples/SampleFilter2.cpp @@ -0,0 +1,124 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" + +static const char* gNames[] = { + "/skimages/background_01.png" +}; + +class Filter2View : public SkView { +public: + SkBitmap* fBitmaps; + int fBitmapCount; + int fCurrIndex; + + Filter2View() { + fBitmapCount = SK_ARRAY_COUNT(gNames)*2; + fBitmaps = new SkBitmap[fBitmapCount]; + + for (int i = 0; i < fBitmapCount/2; i++) { + SkImageDecoder::DecodeFile(gNames[i], &fBitmaps[i], + SkBitmap::kARGB_8888_Config, + SkImageDecoder::kDecodePixels_Mode); + } + for (int i = fBitmapCount/2; i < fBitmapCount; i++) { + SkImageDecoder::DecodeFile(gNames[i-fBitmapCount/2], &fBitmaps[i], + SkBitmap::kRGB_565_Config, + SkImageDecoder::kDecodePixels_Mode); + } + fCurrIndex = 0; + } + + virtual ~Filter2View() { + delete[] fBitmaps; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SkString str("Filter/Dither "); + str.append(gNames[fCurrIndex]); + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorGRAY); +// canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + canvas->translate(SkIntToScalar(10), SkIntToScalar(50)); + + const SkScalar W = SkIntToScalar(fBitmaps[0].width() + 1); + const SkScalar H = SkIntToScalar(fBitmaps[0].height() + 1); + SkPaint paint; + + const SkScalar scale = SkFloatToScalar(0.897917f); + canvas->scale(SK_Scalar1, scale); + + for (int k = 0; k < 2; k++) { + paint.setFilterBitmap(k == 1); + for (int j = 0; j < 2; j++) { + paint.setDither(j == 1); + for (int i = 0; i < fBitmapCount; i++) { + SkScalar x = (k * fBitmapCount + j) * W; + SkScalar y = i * H; + x = SkIntToScalar(SkScalarRound(x)); + y = SkIntToScalar(SkScalarRound(y)); + canvas->drawBitmap(fBitmaps[i], x, y, &paint); + if (i == 0) { + SkPaint p; + p.setAntiAlias(true); + p.setTextAlign(SkPaint::kCenter_Align); + p.setTextSize(SkIntToScalar(18)); + SkString s("dither="); + s.appendS32(paint.isDither()); + s.append(" filter="); + s.appendS32(paint.isFilterBitmap()); + canvas->drawText(s.c_str(), s.size(), x + W/2, + y - p.getTextSize(), p); + } + if (k+j == 2) { + SkPaint p; + p.setAntiAlias(true); + p.setTextSize(SkIntToScalar(18)); + SkString s; + s.append(" depth="); + s.appendS32(fBitmaps[i].config() == SkBitmap::kRGB_565_Config ? 16 : 32); + canvas->drawText(s.c_str(), s.size(), x + W + SkIntToScalar(4), + y + H/2, p); + } + } + } + } + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new Filter2View; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleFontCache.cpp b/Samples/SampleFontCache.cpp new file mode 100644 index 0000000..fb63f71 --- /dev/null +++ b/Samples/SampleFontCache.cpp @@ -0,0 +1,171 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGraphics.h" +#include "SkRandom.h" + +#include <pthread.h> + +static void call_measure() +{ + SkPaint paint; + uint16_t text[32]; + SkRandom rand; + + paint.setAntiAlias(true); + paint.setTextEncoding(SkPaint::kUTF16_TextEncoding); + for (int j = 0; j < SK_ARRAY_COUNT(text); j++) + text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32); + + for (int i = 9; i < 36; i++) + { + SkPaint::FontMetrics m; + + paint.setTextSize(SkIntToScalar(i)); + paint.getFontMetrics(&m); + paint.measureText(text, sizeof(text)); + } +} + +static void call_draw(SkCanvas* canvas) +{ + SkPaint paint; + uint16_t text[32]; + SkRandom rand; + + paint.setAntiAlias(true); + paint.setTextEncoding(SkPaint::kUTF16_TextEncoding); + for (int j = 0; j < SK_ARRAY_COUNT(text); j++) + text[j] = (uint16_t)((rand.nextU() & 0xFF) + 32); + + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(20); + + canvas->drawColor(SK_ColorWHITE); + for (int i = 9; i < 36; i++) + { + SkPaint::FontMetrics m; + + paint.setTextSize(SkIntToScalar(i)); + paint.getFontMetrics(&m); + canvas->drawText(text, sizeof(text), x, y, paint); + y += m.fDescent - m.fAscent; + } +} + +static bool gDone; + +static void* measure_proc(void* context) +{ + while (!gDone) + { + call_measure(); + } + return NULL; +} + +static void* draw_proc(void* context) +{ + SkBitmap* bm = (SkBitmap*)context; + SkCanvas canvas(*bm); + + while (!gDone) + { + call_draw(&canvas); + } + return NULL; +} + +class FontCacheView : public SkView { +public: + enum { N = 4 }; + + pthread_t fMThreads[N]; + pthread_t fDThreads[N]; + SkBitmap fBitmaps[N]; + + FontCacheView() + { + gDone = false; + for (int i = 0; i < N; i++) + { + int status; + pthread_attr_t attr; + + status = pthread_attr_init(&attr); + SkASSERT(0 == status); + status = pthread_create(&fMThreads[i], &attr, measure_proc, NULL); + SkASSERT(0 == status); + + fBitmaps[i].setConfig(SkBitmap::kRGB_565_Config, 320, 240); + fBitmaps[i].allocPixels(); + status = pthread_create(&fDThreads[i], &attr, draw_proc, &fBitmaps[i]); + SkASSERT(0 == status); + } + } + + virtual ~FontCacheView() + { + gDone = true; + for (int i = 0; i < N; i++) + { + void* ret; + int status = pthread_join(fMThreads[i], &ret); + SkASSERT(0 == status); + status = pthread_join(fDThreads[i], &ret); + SkASSERT(0 == status); + } + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "FontCache"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + SkScalar x = 0; + SkScalar y = 0; + for (int i = 0; i < N; i++) + { + canvas->drawBitmap(fBitmaps[i], x, y); + x += SkIntToScalar(fBitmaps[i].width()); + } + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new FontCacheView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleGL.cpp b/Samples/SampleGL.cpp new file mode 100644 index 0000000..7180e3e --- /dev/null +++ b/Samples/SampleGL.cpp @@ -0,0 +1,207 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +// effects +#include "SkGradientShader.h" +#include "SkShaderExtras.h" +#include "SkUnitMappers.h" + +#include "SkStream.h" +#include "SkXMLParser.h" + +#include "SkGLCanvas.h" + +#include <AGL/agl.h> +#include <OpenGL/gl.h> + +extern void* gSampleWind; + +static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) +{ + bm->setConfig(config, w, h); + bm->allocPixels(); + bm->eraseColor(0); + + SkCanvas canvas(*bm); + SkPoint pts[] = { 0, 0, SkIntToScalar(w), SkIntToScalar(h) }; + SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE }; + SkScalar pos[] = { 0, SK_Scalar1/2, SK_Scalar1 }; + SkPaint paint; + + SkUnitMapper* um = NULL; + +// um = new SkCosineMapper; + // um = new SkDiscreteMapper(12); + + SkAutoUnref au(um); + + paint.setAntiAlias(true); + paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos, + SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode, um))->unref(); + + SkRect r; + r.set(0, 0, SkIntToScalar(w), SkIntToScalar(h)); + canvas.drawOval(r, paint); +} + +static void premulBitmap(const SkBitmap& bm) { + for (int y = 0; y < bm.height(); y++) { + SkPMColor* p = bm.getAddr32(0, y); + for (int x = 0; x < bm.width(); x++) { + SkPMColor c = *p; + unsigned a = SkGetPackedA32(c); + unsigned r = SkGetPackedR32(c); + unsigned g = SkGetPackedG32(c); + unsigned b = SkGetPackedB32(c); + + unsigned scale = SkAlpha255To256(a); + r = SkAlphaMul(r, scale); + g = SkAlphaMul(g, scale); + b = SkAlphaMul(b, scale); + *p++ = SkPackARGB32(a, r, g, b); + } + } +} + +class GLView : public SkView { +public: + AGLContext fCtx; + SkBitmap fOffscreen; + SkBitmap fTexture[3]; + + GLView() { + makebm(&fTexture[0], SkBitmap::kARGB_8888_Config, 64, 100); + makebm(&fTexture[1], SkBitmap::kRGB_565_Config, 64, 100); + makebm(&fTexture[2], SkBitmap::kARGB_4444_Config, 64, 100); + + GLint major, minor; + + aglGetVersion(&major, &minor); + SkDebugf("---- version %d %d\n", major, minor); + + GLint attr[] = { + AGL_RGBA, + AGL_DEPTH_SIZE, 32, + AGL_OFFSCREEN, + AGL_NONE + }; + + SkDebugf("------ attr %p %d\n", attr, sizeof(attr)); + AGLPixelFormat format = aglCreatePixelFormat(attr); + SkDebugf("----- format %p\n", format); + fCtx = aglCreateContext(format, 0); + SkDebugf("----- context %p\n", fCtx); + GLboolean success; //= aglSetWindowRef(fCtx, (WindowRef)gSampleWind); +// SkDebugf("----- aglSetWindowRef %d\n", success); + + aglEnable(fCtx, GL_BLEND); + aglEnable(fCtx, GL_LINE_SMOOTH); + aglEnable(fCtx, GL_POINT_SMOOTH); + aglEnable(fCtx, GL_POLYGON_SMOOTH); + + fOffscreen.setConfig(SkBitmap::kARGB_8888_Config, 300, 300); + fOffscreen.allocPixels(); + + success = aglSetOffScreen(fCtx, + fOffscreen.width(), + fOffscreen.height(), + fOffscreen.rowBytes(), + fOffscreen.getPixels()); + GLenum err = aglGetError(); + SkDebugf("---- setoffscreen %d %d %s\n", success, err, aglErrorString(err)); + + aglSetCurrentContext(fCtx); + glOrtho(0, fOffscreen.width(), + fOffscreen.height(), 0, + -1, 1); + + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE); + + glEnable(GL_TEXTURE_2D); +} + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "GL"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkGLCanvas c(fOffscreen.width(), fOffscreen.height()); + + glClearColor(0, 0, 0, 0); + glClear(GL_COLOR_BUFFER_BIT); + + SkPaint p; + + p.setAntiAlias(true); + + c.drawColor(SK_ColorWHITE); + + p.setColor(SK_ColorRED); + c.drawCircle(SkIntToScalar(40), SkIntToScalar(40), SkIntToScalar(20), p); + + p.setColor(SK_ColorGREEN); + p.setStrokeWidth(SkIntToScalar(6)); + p.setStrokeCap(SkPaint::kRound_Cap); + c.drawLine(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(40), SkIntToScalar(50), p); + + // c.scale(SkIntToScalar(3)/2, SkIntToScalar(3)/2); + p.setColor(0x880000FF); + c.drawCircle(SkIntToScalar(40), SkIntToScalar(40), SkIntToScalar(20), p); + + for (int i = 0; i < SK_ARRAY_COUNT(fTexture); i++) { + c.drawBitmap(fTexture[i], SkIntToScalar(10), SkIntToScalar(100), NULL); + c.translate(SkIntToScalar(fTexture[i].width()), 0); + } + p.setColor(SK_ColorBLUE); + c.drawRectCoords(SkIntToScalar(10), SkIntToScalar(100), + SkIntToScalar(10+fTexture[0].width()), + SkIntToScalar(100+fTexture[0].height()), + p); + + //////// + glFlush(); + premulBitmap(fOffscreen); + canvas->drawBitmap(fOffscreen, SkIntToScalar(10), SkIntToScalar(10), NULL); + } + +private: + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new GLView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleImage.cpp b/Samples/SampleImage.cpp new file mode 100644 index 0000000..b0f8656 --- /dev/null +++ b/Samples/SampleImage.cpp @@ -0,0 +1,159 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef_GlobalPool.h" +#include "SkStream.h" + +static const char* gNames[] = { + "1.bmp", "1.gif", "1.jpg", "1.png", + "2.bmp", "2.gif", "2.jpg", "2.png" +}; + +// ownership of the stream is transferred +static bool SetImageRef(SkBitmap* bitmap, SkStream* stream, + SkBitmap::Config pref, const char name[] = NULL) +{ + if (SkImageDecoder::DecodeStream(stream, bitmap, pref, + SkImageDecoder::kDecodeBounds_Mode)) { + SkASSERT(bitmap->config() != SkBitmap::kNo_Config); + + SkImageRef* ref = new SkImageRef_GlobalPool(stream, bitmap->config()); + ref->setURI(name); + bitmap->setPixelRef(ref)->unref(); + return true; + } else { + delete stream; + return false; + } +} + +class ImageView : public SkView { +public: + SkBitmap* fBitmaps; + SkShader* fShader; + + ImageView() { + SkImageRef_GlobalPool::SetRAMBudget(32 * 1024); + + int i, N = SK_ARRAY_COUNT(gNames); + fBitmaps = new SkBitmap[N]; + + for (i = 0; i < N; i++) { + SkString str("/skimages/"); + str.append(gNames[i]); + SkFILEStream* stream = new SkFILEStream(str.c_str()); + + SetImageRef(&fBitmaps[i], stream, SkBitmap::kNo_Config, gNames[i]); + if (i & 1) + fBitmaps[i].buildMipMap(); + } + + fShader = SkShader::CreateBitmapShader(fBitmaps[5], + SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode); + + if (true) { + SkMatrix m; + + m.setRotate(SkIntToScalar(30)); + fShader->setLocalMatrix(m); + } + +#if 0 + SkImageRef::DumpPool(); + for (i = 0; i < N; i++) { + SkBitmap& bm = fBitmaps[i]; + + SkDebugf("<%s> addr=%p", gNames[i], bm.getPixels()); + bool success = bm.lockPixels(); + SkDebugf(" addr=%d", bm.getPixels()); + if (success) + bm.unlockPixels(); + SkDebugf(" addr=%p", bm.getPixels()); + success = bm.lockPixels(); + SkDebugf(" addr=%d", bm.getPixels()); + if (success) + bm.unlockPixels(); + SkDebugf("\n"); + } + SkImageRef::DumpPool(); +#endif + } + + virtual ~ImageView() { + delete[] fBitmaps; + delete fShader; + + SkImageRef_GlobalPool::DumpPool(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Image"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); + + SkScalar x = 0, y = 0; + + for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); i++) { + canvas->drawBitmap(fBitmaps[i], x, y); + x += SkIntToScalar(fBitmaps[i].width() + 10); + } + + canvas->translate(0, SkIntToScalar(120)); + + SkPaint paint; + paint.setShader(fShader); + paint.setFilterBitmap(true); + SkRect r = { 0, 0, SkIntToScalar(300), SkIntToScalar(100) }; + + canvas->drawRect(r, paint); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new ImageView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleImageDir.cpp b/Samples/SampleImageDir.cpp new file mode 100644 index 0000000..50cf89a --- /dev/null +++ b/Samples/SampleImageDir.cpp @@ -0,0 +1,290 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef_GlobalPool.h" +#include "SkOSFile.h" +#include "SkStream.h" + +#include "SkBlurDrawLooper.h" +#include "SkColorMatrixFilter.h" + +static void DrawRoundRect(SkCanvas& canvas) { + bool ret = false; + SkPaint paint; + SkBitmap bitmap; + SkMatrix matrix; + matrix.reset(); + + bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812); + bitmap.allocPixels(); +#if 0 + SkCanvas canvas; + canvas.setBitmapDevice(bitmap); +#endif + + // set up clipper + SkRect skclip; + skclip.set(SkIntToFixed(284), SkIntToFixed(40), SkIntToFixed(1370), SkIntToFixed(708)); + +// ret = canvas.clipRect(skclip); +// SkASSERT(ret); + + matrix.set(SkMatrix::kMTransX, SkFloatToFixed(-1153.28)); + matrix.set(SkMatrix::kMTransY, SkFloatToFixed(1180.50)); + + matrix.set(SkMatrix::kMScaleX, SkFloatToFixed(0.177171)); + matrix.set(SkMatrix::kMScaleY, SkFloatToFixed(0.177043)); + + matrix.set(SkMatrix::kMSkewX, SkFloatToFixed(0.126968)); + matrix.set(SkMatrix::kMSkewY, SkFloatToFixed(-0.126876)); + + matrix.set(SkMatrix::kMPersp0, SkFloatToFixed(0.0)); + matrix.set(SkMatrix::kMPersp1, SkFloatToFixed(0.0)); + + ret = canvas.concat(matrix); + + paint.setAntiAlias(true); + paint.setColor(0xb2202020); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkFloatToFixed(68.13)); + + SkRect r; + r.set(SkFloatToFixed(-313.714417), SkFloatToFixed(-4.826389), SkFloatToFixed(18014.447266), SkFloatToFixed(1858.154541)); + canvas.drawRoundRect(r, SkFloatToFixed(91.756363), SkFloatToFixed(91.756363), paint); +} + +// ownership of the stream is transferred +static bool SetImageRef(SkBitmap* bitmap, SkStream* stream, + SkBitmap::Config pref, const char name[] = NULL) { +#if 0 + // test buffer streams + SkStream* str = new SkBufferStream(stream, 717); + stream->unref(); + stream = str; +#endif + + SkImageRef* ref = new SkImageRef_GlobalPool(stream, pref, 1); + ref->setURI(name); + if (!ref->getInfo(bitmap)) { + delete ref; + return false; + } + bitmap->setPixelRef(ref)->unref(); + return true; +} + +//#define SPECIFIC_IMAGE "/skimages/72.jpg" +#define SPECIFIC_IMAGE "/Users/reed/Downloads/3elfs.jpg" + +#define IMAGE_DIR "/skimages/" +#define IMAGE_SUFFIX ".gif" + +class ImageDirView : public SkView { +public: + SkBitmap* fBitmaps; + SkString* fStrings; + int fBitmapCount; + int fCurrIndex; + SkScalar fSaturation; + SkScalar fAngle; + + ImageDirView() { + SkImageRef_GlobalPool::SetRAMBudget(320 * 1024); + +#ifdef SPECIFIC_IMAGE + fBitmaps = new SkBitmap[3]; + fStrings = new SkString[3]; + fBitmapCount = 3; + const SkBitmap::Config configs[] = { + SkBitmap::kARGB_8888_Config, + SkBitmap::kRGB_565_Config, + SkBitmap::kARGB_4444_Config + }; + for (int i = 0; i < fBitmapCount; i++) { +#if 1 + SkStream* stream = new SkFILEStream(SPECIFIC_IMAGE); + SetImageRef(&fBitmaps[i], stream, configs[i], SPECIFIC_IMAGE); +#else + SkImageDecoder::DecodeFile(SPECIFIC_IMAGE, &fBitmaps[i]); +#endif + } +#else + int i, N = 0; + SkOSFile::Iter iter(IMAGE_DIR, IMAGE_SUFFIX); + SkString name; + while (iter.next(&name)) { + N += 1; + } + fBitmaps = new SkBitmap[N]; + fStrings = new SkString[N]; + iter.reset(IMAGE_DIR, IMAGE_SUFFIX); + for (i = 0; i < N; i++) { + iter.next(&name); + SkString path(IMAGE_DIR); + path.append(name); + SkStream* stream = new SkFILEStream(path.c_str()); + + SetImageRef(&fBitmaps[i], stream, SkBitmap::kNo_Config, + name.c_str()); + fStrings[i] = name; + } + fBitmapCount = N; +#endif + fCurrIndex = 0; + fDX = fDY = 0; + + fSaturation = SK_Scalar1; + fAngle = 0; + + fScale = SK_Scalar1; + } + + virtual ~ImageDirView() { + delete[] fBitmaps; + delete[] fStrings; + + SkImageRef_GlobalPool::DumpPool(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SkString str("ImageDir: "); +#ifdef SPECIFIC_IMAGE + str.append(SPECIFIC_IMAGE); +#else + str.append(IMAGE_DIR); +#endif + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorGRAY); + canvas->drawColor(SK_ColorWHITE); + } + + SkScalar fScale; + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + if (false) { + SkPaint p; + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SkIntToScalar(4)); + canvas->drawCircle(SkIntToScalar(100), SkIntToScalar(100), SkIntToScalar(50), p); + p.setAntiAlias(true); + canvas->drawCircle(SkIntToScalar(300), SkIntToScalar(100), SkIntToScalar(50), p); + } + if (false) { + SkScalar cx = this->width()/2; + SkScalar cy = this->height()/2; + canvas->translate(cx, cy); + canvas->scale(fScale, fScale); + canvas->translate(-cx, -cy); + DrawRoundRect(*canvas); + return; + } + + SkScalar scale = SK_Scalar1 * 999/1000; +// scale = SK_Scalar1/2; + + canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); + // canvas->scale(scale, scale); + + SkScalar x = SkIntToScalar(32), y = SkIntToScalar(32); + SkPaint paint; + + // x += fDX; + // y += fDY; + +// paint.setLooper(new SkBlurDrawLooper(SkIntToScalar(12), 0, 0, 0xDD000000))->unref(); + +#if 0 + for (int i = 0; i < fBitmapCount; i++) { + SkPaint p; + +#if 1 + const SkScalar cm[] = { + SkIntToScalar(2), 0, 0, 0, SkIntToScalar(-255), + 0, SkIntToScalar(2), 0, 0, SkIntToScalar(-255), + 0, 0, SkIntToScalar(2), 0, SkIntToScalar(-255), + 0, 0, 0, SkIntToScalar(1), 0 + }; + SkColorFilter* cf = new SkColorMatrixFilter(cm); + p.setColorFilter(cf)->unref(); +#endif + + canvas->drawBitmap(fBitmaps[i], x, y, &p); + x += SkIntToScalar(fBitmaps[i].width() + 10); + } + return; +#endif + + canvas->drawBitmap(fBitmaps[fCurrIndex], x, y, &paint); +#ifndef SPECIFIC_IMAGE + if (true) { + fCurrIndex += 1; + if (fCurrIndex >= fBitmapCount) { + fCurrIndex = 0; + } + this->inval(NULL); + } +#endif + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + if (true) { + fCurrIndex += 1; + if (fCurrIndex >= fBitmapCount) + fCurrIndex = 0; + this->inval(NULL); + } + return new Click(this); + } + + virtual bool onClick(Click* click) { + SkScalar center = this->width()/2; + fSaturation = SkScalarDiv(click->fCurr.fX - center, center/2); + center = this->height()/2; + fAngle = SkScalarDiv(click->fCurr.fY - center, center) * 180; + + fDX += click->fCurr.fX - click->fPrev.fX; + fDY += click->fCurr.fY - click->fPrev.fY; + + fScale = SkScalarDiv(click->fCurr.fX, this->width()); + + this->inval(NULL); + return true; + return this->INHERITED::onClick(click); + } + +private: + SkScalar fDX, fDY; + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new ImageDirView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleLayers.cpp b/Samples/SampleLayers.cpp new file mode 100644 index 0000000..fcf7107 --- /dev/null +++ b/Samples/SampleLayers.cpp @@ -0,0 +1,259 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkBlurMaskFilter.h" +#include "SkCamera.h" +#include "SkColorFilter.h" +#include "SkColorPriv.h" +#include "SkDevice.h" +#include "SkGradientShader.h" +#include "SkImageDecoder.h" +#include "SkInterpolator.h" +#include "SkMaskFilter.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkShaderExtras.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkUtils.h" +#include "SkKey.h" +#include "SkPorterDuff.h" +#include "SkXfermode.h" +#include "SkDrawFilter.h" + +static void make_paint(SkPaint* paint) { + SkColor colors[] = { 0, SK_ColorWHITE }; + SkPoint pts[] = { 0, 0, 0, SK_Scalar1*20 }; + SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + + paint->setShader(s)->unref(); + paint->setXfermode(SkPorterDuff::CreateXfermode(SkPorterDuff::kDstIn_Mode))->unref(); +} + +static void dump_layers(const char label[], SkCanvas* canvas) { + SkDebugf("Dump Layers(%s)\n", label); + + SkCanvas::LayerIter iter(canvas, true); + int index = 0; + while (!iter.done()) { + const SkBitmap& bm = iter.device()->accessBitmap(false); + const SkIRect& clip = iter.clip().getBounds(); + SkDebugf("Layer[%d] bitmap [%d %d] X=%d Y=%d clip=[%d %d %d %d] alpha=%d\n", index++, + bm.width(), bm.height(), iter.x(), iter.y(), + clip.fLeft, clip.fTop, clip.fRight, clip.fBottom, + iter.paint().getAlpha()); + iter.next(); + } +} + +// test drawing with strips of fading gradient above and below +static void test_fade(SkCanvas* canvas) { + SkAutoCanvasRestore ar(canvas, true); + + SkRect r; + + SkPaint p; + p.setAlpha(0x88); + + SkAutoCanvasRestore(canvas, false); + + // create the layers + + r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100)); + canvas->clipRect(r); + + r.fBottom = SkIntToScalar(20); + canvas->saveLayer(&r, NULL, (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag)); + + r.fTop = SkIntToScalar(80); + r.fBottom = SkIntToScalar(100); + canvas->saveLayer(&r, NULL, (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag)); + + // now draw the "content" + + if (true) { + r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100)); + + canvas->saveLayerAlpha(&r, 0x80); + + SkPaint p; + p.setColor(SK_ColorRED); + p.setAntiAlias(true); + canvas->drawOval(r, p); + + dump_layers("inside layer alpha", canvas); + + canvas->restore(); + } else { + r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100)); + + SkPaint p; + p.setColor(SK_ColorRED); + p.setAntiAlias(true); + canvas->drawOval(r, p); + } + +// return; + + dump_layers("outside layer alpha", canvas); + + // now apply an effect + + SkPaint paint; + make_paint(&paint); + r.set(0, 0, SkIntToScalar(100), SkIntToScalar(20)); +// SkDebugf("--------- draw top grad\n"); + canvas->drawRect(r, paint); + + SkMatrix m; + SkShader* s = paint.getShader(); + m.setScale(SK_Scalar1, -SK_Scalar1); + m.postTranslate(0, SkIntToScalar(100)); + s->setLocalMatrix(m); + + r.fTop = SkIntToScalar(80); + r.fBottom = SkIntToScalar(100); +// SkDebugf("--------- draw bot grad\n"); + canvas->drawRect(r, paint); +} + +class RedFilter : public SkDrawFilter { +public: + virtual bool filter(SkCanvas*, SkPaint* p, SkDrawFilter::Type) { + fColor = p->getColor(); + if (fColor == SK_ColorRED) { + p->setColor(SK_ColorGREEN); + } + return true; + } + virtual void restore(SkCanvas*, SkPaint* p, SkDrawFilter::Type) { + p->setColor(fColor); + } + +private: + SkColor fColor; +}; + +class LayersView : public SkView { +public: + LayersView() {} + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Layers"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + if (false) { + SkRect r; + r.set(SkIntToScalar(0), SkIntToScalar(0), + SkIntToScalar(220), SkIntToScalar(120)); + SkPaint p; + p.setAlpha(0x88); + p.setAntiAlias(true); + + if (true) { + canvas->saveLayer(&r, &p); + p.setColor(0xFFFF0000); + canvas->drawOval(r, p); + canvas->restore(); + } + + p.setColor(0xFF0000FF); + r.offset(SkIntToScalar(20), SkIntToScalar(50)); + canvas->drawOval(r, p); + } + + if (false) { + SkPaint p; + p.setAlpha(0x88); + p.setAntiAlias(true); + + canvas->translate(SkIntToScalar(300), 0); + + SkRect r; + r.set(SkIntToScalar(0), SkIntToScalar(0), + SkIntToScalar(220), SkIntToScalar(60)); + + canvas->saveLayer(&r, &p, (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag)); +// canvas->clipRect(r, SkRegion::kDifference_Op); +// canvas->clipRect(r, SkRegion::kIntersect_Op); + + r.set(SkIntToScalar(0), SkIntToScalar(0), + SkIntToScalar(220), SkIntToScalar(120)); + p.setColor(SK_ColorBLUE); + canvas->drawOval(r, p); + canvas->restore(); + return; + } + + //canvas->translate(SkIntToScalar(20), SkIntToScalar(20)); + test_fade(canvas); + return; + + // canvas->setDrawFilter(new RedFilter)->unref(); + + SkRect r; + SkPaint p; + + canvas->translate(SkIntToScalar(220), SkIntToScalar(20)); + + p.setAntiAlias(true); + r.set(SkIntToScalar(20), SkIntToScalar(20), + SkIntToScalar(220), SkIntToScalar(120)); + + p.setColor(SK_ColorBLUE); + // p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(8), SkBlurMaskFilter::kNormal_BlurStyle))->unref(); + canvas->drawRect(r, p); + p.setMaskFilter(NULL); + + SkRect bounds = r; + bounds.fBottom = bounds.centerY(); + canvas->saveLayer(&bounds, NULL, SkCanvas::kARGB_NoClipLayer_SaveFlag); + + p.setColor(SK_ColorRED); + canvas->drawOval(r, p); + + p.setAlpha(0x80); + p.setPorterDuffXfermode(SkPorterDuff::kDstIn_Mode); + canvas->drawRect(bounds, p); + + canvas->restore(); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + + virtual bool handleKey(SkKey key) { + this->inval(NULL); + return true; + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new LayersView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleLines.cpp b/Samples/SampleLines.cpp new file mode 100644 index 0000000..eed0e5a --- /dev/null +++ b/Samples/SampleLines.cpp @@ -0,0 +1,147 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkCornerPathEffect.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +#include "SkStream.h" +#include "SkXMLParser.h" +#include "SkColorPriv.h" +#include "SkImageDecoder.h" + +class LinesView : public SkView { +public: + LinesView() + { + unsigned r = 0x1F; + unsigned g = 0x3F; + for (unsigned a = 0; a <= 0xF; a++) { + unsigned scale = 16 - SkAlpha15To16(a); + unsigned sr = (a << 1) | (a >> 3); + unsigned dr = r * scale >> 4; + unsigned sg = (a << 2) | (a >> 2); + unsigned dg = g * scale >> 4; + + unsigned ssg = sg & ~(~(a >> 3) & 1); + + printf("4444 sa=%d sr=%d sg=%d da=%d dr=%d dg=%d total-r=%d total-g=%d %d\n", + a, sr, sg, scale, dr, dg, sr+dr, sg+dg, ssg+dg); + } + + for (unsigned aa = 0; aa <= 0xFF; aa++) { + unsigned invScale = SkAlpha255To256(255 - aa); + unsigned dst = SkAlphaMul(0xFF, invScale); + printf("8888 sa=%02x dst=%02x sum=%d %s\n", aa, dst, aa+dst, + (aa+dst) > 0xFF ? "OVERFLOW" : ""); + } + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Lines"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorWHITE); + // canvas->drawColor(SK_ColorBLACK); + } + + /* + 0x1F * x + 0x1F * (32 - x) + */ + void drawRings(SkCanvas* canvas) + { + canvas->scale(SkIntToScalar(1)/2, SkIntToScalar(1)/2); + + SkRect r; + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(10); + r.set(x, y, x + SkIntToScalar(100), y + SkIntToScalar(100)); + + SkPaint paint; + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkScalarHalf(SkIntToScalar(3))); + paint.setColor(0xFFFF8800); + paint.setColor(0xFFFFFFFF); + canvas->drawRect(r, paint); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + SkBitmap bm; + SkImageDecoder::DecodeFile("/kill.gif", &bm); + canvas->drawBitmap(bm, 0, 0, NULL); + + this->drawRings(canvas); + return; + + SkPaint paint; + + // fAlpha = 0x80; + paint.setColor(SK_ColorWHITE); + paint.setAlpha(fAlpha & 0xFF); + SkRect r; + + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(10); + r.set(x, y, x + SkIntToScalar(100), y + SkIntToScalar(100)); + canvas->drawRect(r, paint); + return; + + paint.setColor(0xffffff00); // yellow + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(2)); + +// y += SK_Scalar1/2; + + canvas->drawLine(x, y, x + SkIntToScalar(90), y + SkIntToScalar(90), paint); + + paint.setAntiAlias(true); // with anti-aliasing + y += SkIntToScalar(10); + canvas->drawLine(x, y, x + SkIntToScalar(90), y + SkIntToScalar(90), paint); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + fAlpha = SkScalarRound(y); + this->inval(NULL); + return NULL; + } +private: + + int fAlpha; + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new LinesView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleMeasure.cpp b/Samples/SampleMeasure.cpp new file mode 100644 index 0000000..3cc0c81 --- /dev/null +++ b/Samples/SampleMeasure.cpp @@ -0,0 +1,139 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "Sk1DPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkDither.h" + +// exercise scale/linear/devkern +struct Setting { + SkScalar fScale; + bool fLinearText; + bool fDevKernText; +}; + +static const SkScalar ONE = SkIntToScalar(9999)/10000; + +static const Setting gSettings[] = { + { 0, false, false }, + { 0, false, true }, + { 0, true, false }, + { 0, true, true }, + { ONE, false, false }, + { ONE, false, true }, + { ONE, true, false }, + { ONE, true, true } +}; + +static void doMeasure(SkCanvas* canvas, const SkPaint& paint, const char text[]) +{ + SkScalar dy = paint.getFontMetrics(NULL); + + size_t len = strlen(text); + SkAutoTMalloc<SkScalar> autoWidths(len); + SkScalar* widths = autoWidths.get(); + SkAutoTMalloc<SkRect> autoRects(len); + SkRect* rects = autoRects.get(); + SkRect bounds; + + SkPaint p(paint); + for (int i = 0; i < SK_ARRAY_COUNT(gSettings); i++) { + p.setLinearText(gSettings[i].fLinearText); + p.setDevKernText(gSettings[i].fDevKernText); + SkScalar scale = gSettings[i].fScale; + + int n = p.getTextWidths(text, len, widths, rects); + SkScalar w = p.measureText(text, len, &bounds, scale); + + p.setStyle(SkPaint::kFill_Style); + p.setColor(0x8888FF88); + canvas->drawRect(bounds, p); + p.setColor(0xFF000000); + canvas->drawText(text, len, 0, 0, p); + + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(0); + p.setColor(0xFFFF0000); + SkScalar x = 0; + for (int j = 0; j < n; j++) { + SkRect r = rects[j]; + r.offset(x, 0); + canvas->drawRect(r, p); + x += widths[j]; + } + + p.setColor(0xFF0000FF); + canvas->drawLine(0, 0, w, 0, p); + p.setStrokeWidth(SkIntToScalar(4)); + canvas->drawPoint(x, 0, p); + + canvas->translate(0, dy); + } +} + +class MeasureView : public SkView { +public: + SkPaint fPaint; + + MeasureView() + { + fPaint.setAntiAlias(true); + fPaint.setTextSize(SkIntToScalar(64)); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Measure"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->translate(fPaint.getTextSize(), fPaint.getTextSize()); + doMeasure(canvas, fPaint, "Hamburgefons"); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + // fSweep += SK_Scalar1; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new MeasureView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleNinePatch.cpp b/Samples/SampleNinePatch.cpp new file mode 100644 index 0000000..5c075b5 --- /dev/null +++ b/Samples/SampleNinePatch.cpp @@ -0,0 +1,63 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkImageDecoder.h" +#include "SkNinePatch.h" +#include "SkPaint.h" +#include "SkUnPreMultiply.h" + +class NinePatchView : public SkView { +public: + SkBitmap fBM; + + NinePatchView() { + SkImageDecoder::DecodeFile("/skimages/folder_background.9.png", &fBM); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "NinePatch"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + + canvas->drawBitmap(fBM, 0, 0); + + SkIRect margins; + SkRect dst; + int d = 25; + + margins.set(d, d, d, d); + dst.set(0, 0, SkIntToScalar(200), SkIntToScalar(200)); + dst.offset(SkIntToScalar(fBM.width()), 0); + dst.offset(SkIntToScalar(2), SkIntToScalar(2)); + + SkNinePatch::DrawNine(canvas, dst, fBM, margins); + + int cx = fBM.width()/2; + int cy = fBM.height()/2; + SkPMColor pm = *fBM.getAddr32(cx, cy); + SkColor c = SkUnPreMultiply::PMColorToColor(pm); + SkColor pm2 = SkPreMultiplyColor(c); + //SkDebugf("--- pm %x c %x pm2 %x\n", pm, c, pm2); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new NinePatchView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleOverflow.cpp b/Samples/SampleOverflow.cpp new file mode 100644 index 0000000..229683f --- /dev/null +++ b/Samples/SampleOverflow.cpp @@ -0,0 +1,106 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkDevice.h" +#include "SkPaint.h" + +static void DrawRoundRect() { +#ifdef SK_SCALAR_IS_FIXED + bool ret = false; + SkPaint paint; + SkBitmap bitmap; + SkCanvas canvas; + SkMatrix matrix; + matrix.reset(); + + bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812); + bitmap.allocPixels(); + canvas.setBitmapDevice(bitmap); + + // set up clipper + SkRect skclip; + skclip.set(SkIntToFixed(284), SkIntToFixed(40), SkIntToFixed(1370), SkIntToFixed(708)); + + ret = canvas.clipRect(skclip); + SkASSERT(ret); + + matrix.set(SkMatrix::kMTransX, SkFloatToFixed(-1153.28)); + matrix.set(SkMatrix::kMTransY, SkFloatToFixed(1180.50)); + + matrix.set(SkMatrix::kMScaleX, SkFloatToFixed(0.177171)); + matrix.set(SkMatrix::kMScaleY, SkFloatToFixed(0.177043)); + + matrix.set(SkMatrix::kMSkewX, SkFloatToFixed(0.126968)); + matrix.set(SkMatrix::kMSkewY, SkFloatToFixed(-0.126876)); + + matrix.set(SkMatrix::kMPersp0, SkFloatToFixed(0.0)); + matrix.set(SkMatrix::kMPersp1, SkFloatToFixed(0.0)); + + ret = canvas.concat(matrix); + + paint.setAntiAlias(true); + paint.setColor(0xb2202020); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkFloatToFixed(68.13)); + + SkRect r; + r.set(SkFloatToFixed(-313.714417), SkFloatToFixed(-4.826389), SkFloatToFixed(18014.447266), SkFloatToFixed(1858.154541)); + canvas.drawRoundRect(r, SkFloatToFixed(91.756363), SkFloatToFixed(91.756363), paint); +#endif +} + +static bool HitTestPath(const SkPath& path, SkScalar x, SkScalar y) { + SkRegion rgn, clip; + + int ix = SkScalarFloor(x); + int iy = SkScalarFloor(y); + + clip.setRect(ix, iy, ix + 1, iy + 1); + + bool contains = rgn.setPath(path, clip); + return contains; +} + +static void TestOverflowHitTest() { + SkPath path; + +#ifdef SK_SCALAR_IS_FLOATx + path.addCircle(0, 0, 70000, SkPath::kCCW_Direction); + SkASSERT(HitTestPath(path, 40000, 40000)); +#endif +} + +class OverflowView : public SkView { +public: + OverflowView() {} + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Circles"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + DrawRoundRect(); + TestOverflowHitTest(); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new OverflowView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePageFlip.cpp b/Samples/SamplePageFlip.cpp new file mode 100644 index 0000000..6b1adfd --- /dev/null +++ b/Samples/SamplePageFlip.cpp @@ -0,0 +1,173 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGraphics.h" +#include "SkRandom.h" +#include "SkFlipPixelRef.h" +#include "SkPageFlipper.h" + +#include <pthread.h> + +#define WIDTH 200 +#define HEIGHT 200 + +static bool gDone; + +static void bounce(SkScalar* x, SkScalar* dx, const int max) { + *x += *dx; + if (*x < 0) { + *x = 0; + if (*dx < 0) { + *dx = -*dx; + } + } else if (*x > SkIntToScalar(max)) { + *x = SkIntToScalar(max); + if (*dx > 0) { + *dx = -*dx; + } + } +} + +static void* draw_proc(void* context) { + const int OVALW = 32; + const int OVALH = 32; + + const SkBitmap* bm = static_cast<const SkBitmap*>(context); + SkFlipPixelRef* ref = static_cast<SkFlipPixelRef*>(bm->pixelRef()); + + const int DSCALE = 1; + SkScalar dx = SkIntToScalar(7) / DSCALE; + SkScalar dy = SkIntToScalar(5) / DSCALE; + SkScalar x = 0; + SkScalar y = 0; + + SkPaint paint; + + paint.setAntiAlias(true); + paint.setColor(reinterpret_cast<SkColor>(ref) | (0xFF << 24)); + + SkRect oval; + oval.setEmpty(); + + while (!gDone) { + ref->inval(oval, true); + oval.set(x, y, x + SkIntToScalar(OVALW), y + SkIntToScalar(OVALH)); + ref->inval(oval, true); + + SkAutoFlipUpdate update(ref); + + if (!update.dirty().isEmpty()) { + // this must be local to the loop, since it needs to forget the pixels + // its writing to after each iteration, since we do the swap + SkCanvas canvas(update.bitmap()); + +// SkDebugf("----- dirty [%d %d %d %d]\n", dirty.getBounds().fLeft, dirty.getBounds().fTop, dirty.getBounds().width(), dirty.getBounds().height()); + canvas.clipRegion(update.dirty()); + + canvas.drawColor(0, SkPorterDuff::kClear_Mode); + canvas.drawOval(oval, paint); + } + bounce(&x, &dx, WIDTH-OVALW); + bounce(&y, &dy, HEIGHT-OVALH); + +#if 1 + for (int i = 0; i < 1000; i++) { + for (int j = 0; j < 10000; j++) { + SkFixedMul(j, 10); + } + } +#endif + } + return NULL; +} + +static const SkBitmap::Config gConfigs[] = { + SkBitmap::kARGB_8888_Config, +#if 1 + SkBitmap::kRGB_565_Config, + SkBitmap::kARGB_4444_Config, + SkBitmap::kA8_Config +#endif +}; + +class PageFlipView : public SkView { +public: + + enum { N = SK_ARRAY_COUNT(gConfigs) }; + + pthread_t fThreads[N]; + SkBitmap fBitmaps[N]; + + PageFlipView() { + gDone = false; + for (int i = 0; i < N; i++) { + int status; + pthread_attr_t attr; + + status = pthread_attr_init(&attr); + SkASSERT(0 == status); + + fBitmaps[i].setConfig(gConfigs[i], WIDTH, HEIGHT); + SkFlipPixelRef* pr = new SkFlipPixelRef(gConfigs[i], WIDTH, HEIGHT); + fBitmaps[i].setPixelRef(pr)->unref(); + fBitmaps[i].eraseColor(0); + + status = pthread_create(&fThreads[i], &attr, draw_proc, &fBitmaps[i]); + SkASSERT(0 == status); + } + } + + virtual ~PageFlipView() { + gDone = true; + for (int i = 0; i < N; i++) { + void* ret; + int status = pthread_join(fThreads[i], &ret); + SkASSERT(0 == status); + } + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "PageFlip"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(10); + for (int i = 0; i < N; i++) { + canvas->drawBitmap(fBitmaps[i], x, y); + x += SkIntToScalar(fBitmaps[i].width() + 20); + } + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PageFlipView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePatch.cpp b/Samples/SamplePatch.cpp new file mode 100644 index 0000000..2e55db2 --- /dev/null +++ b/Samples/SamplePatch.cpp @@ -0,0 +1,418 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef.h" +#include "SkOSFile.h" +#include "SkStream.h" + +#include "SkGeometry.h" // private include :( + +static void drawtriangle(SkCanvas* canvas, const SkPaint& paint, + const SkPoint pts[3]) { + SkPath path; + + path.moveTo(pts[0]); + path.lineTo(pts[1]); + path.lineTo(pts[2]); + + canvas->drawPath(path, paint); +} + +static SkShader* make_shader0(SkIPoint* size) { + SkBitmap bm; + +// SkImageDecoder::DecodeFile("/skimages/progressivejpg.jpg", &bm); + SkImageDecoder::DecodeFile("/skimages/beach.jpg", &bm); + size->set(bm.width(), bm.height()); + return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode); +} + +static SkShader* make_shader1(const SkIPoint& size) { + SkPoint pts[] = { 0, 0, SkIntToScalar(size.fX), SkIntToScalar(size.fY) }; + SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED }; + return SkGradientShader::CreateLinear(pts, colors, NULL, + SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode, NULL); +} + +/////////////////////////////////////////////////////////////////////////////// + +class Patch { +public: + Patch() { bzero(fPts, sizeof(fPts)); } + ~Patch() {} + + void setPatch(const SkPoint pts[12]) { + memcpy(fPts, pts, 12 * sizeof(SkPoint)); + fPts[12] = pts[0]; // the last shall be first + } + void setBounds(int w, int h) { fW = w; fH = h; } + + void draw(SkCanvas*, const SkPaint&, int segsU, int segsV, + bool doTextures, bool doColors); + +private: + SkPoint fPts[13]; + int fW, fH; +}; + +static void eval_patch_edge(const SkPoint cubic[], SkPoint samples[], int segs) { + SkScalar t = 0; + SkScalar dt = SK_Scalar1 / segs; + + samples[0] = cubic[0]; + for (int i = 1; i < segs; i++) { + t += dt; + SkEvalCubicAt(cubic, t, &samples[i], NULL, NULL); + } +} + +static void eval_sheet(const SkPoint edge[], int nu, int nv, int iu, int iv, + SkPoint* pt) { + const int TL = 0; + const int TR = nu; + const int BR = TR + nv; + const int BL = BR + nu; + + SkScalar u = SkIntToScalar(iu) / nu; + SkScalar v = SkIntToScalar(iv) / nv; + + SkScalar uv = SkScalarMul(u, v); + SkScalar Uv = SkScalarMul(SK_Scalar1 - u, v); + SkScalar uV = SkScalarMul(u, SK_Scalar1 - v); + SkScalar UV = SkScalarMul(SK_Scalar1 - u, SK_Scalar1 - v); + + SkScalar x0 = SkScalarMul(UV, edge[TL].fX) + SkScalarMul(uV, edge[TR].fX) + + SkScalarMul(Uv, edge[BL].fX) + SkScalarMul(uv, edge[BR].fX); + SkScalar y0 = SkScalarMul(UV, edge[TL].fY) + SkScalarMul(uV, edge[TR].fY) + + SkScalarMul(Uv, edge[BL].fY) + SkScalarMul(uv, edge[BR].fY); + + SkScalar x = SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fX) + + SkScalarMul(u, edge[TR+iv].fX) + + SkScalarMul(v, edge[BR+nu-iu].fX) + + SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fX) - x0; + SkScalar y = SkScalarMul(SK_Scalar1 - v, edge[TL+iu].fY) + + SkScalarMul(u, edge[TR+iv].fY) + + SkScalarMul(v, edge[BR+nu-iu].fY) + + SkScalarMul(SK_Scalar1 - u, edge[BL+nv-iv].fY) - y0; + pt->set(x, y); +} + +static int ScalarTo255(SkScalar v) { + int scale = SkScalarToFixed(v) >> 8; + if (scale < 0) { + scale = 0; + } else if (scale > 255) { + scale = 255; + } + return scale; +} + +static SkColor make_color(SkScalar s, SkScalar t) { + int cs = ScalarTo255(s); + int ct = ScalarTo255(t); + return SkColorSetARGB(0xFF, cs, 0, 0) + SkColorSetARGB(0, 0, ct, 0); +} + +void Patch::draw(SkCanvas* canvas, const SkPaint& paint, int nu, int nv, + bool doTextures, bool doColors) { + if (nu < 1 || nv < 1) { + return; + } + + int i, npts = (nu + nv) * 2; + SkAutoSTMalloc<16, SkPoint> storage(npts + 1); + SkPoint* edge0 = storage.get(); + SkPoint* edge1 = edge0 + nu; + SkPoint* edge2 = edge1 + nv; + SkPoint* edge3 = edge2 + nu; + + // evaluate the edge points + eval_patch_edge(fPts + 0, edge0, nu); + eval_patch_edge(fPts + 3, edge1, nv); + eval_patch_edge(fPts + 6, edge2, nu); + eval_patch_edge(fPts + 9, edge3, nv); + edge3[nv] = edge0[0]; // the last shall be first + + for (i = 0; i < npts; i++) { +// canvas->drawLine(edge0[i].fX, edge0[i].fY, edge0[i+1].fX, edge0[i+1].fY, paint); + } + + int row, vertCount = (nu + 1) * (nv + 1); + SkAutoTMalloc<SkPoint> vertStorage(vertCount); + SkPoint* verts = vertStorage.get(); + + // first row + memcpy(verts, edge0, (nu + 1) * sizeof(SkPoint)); + // rows + SkPoint* r = verts; + for (row = 1; row < nv; row++) { + r += nu + 1; + r[0] = edge3[nv - row]; + for (int col = 1; col < nu; col++) { + eval_sheet(edge0, nu, nv, col, row, &r[col]); + } + r[nu] = edge1[row]; + } + // last row + SkPoint* last = verts + nv * (nu + 1); + for (i = 0; i <= nu; i++) { + last[i] = edge2[nu - i]; + } + +// canvas->drawPoints(verts, vertCount, paint); + + int stripCount = (nu + 1) * 2; + SkAutoTMalloc<SkPoint> stripStorage(stripCount * 2); + SkAutoTMalloc<SkColor> colorStorage(stripCount); + SkPoint* strip = stripStorage.get(); + SkPoint* tex = strip + stripCount; + SkColor* colors = colorStorage.get(); + SkScalar t = 0; + const SkScalar ds = SK_Scalar1 * fW / nu; + const SkScalar dt = SK_Scalar1 * fH / nv; + r = verts; + for (row = 0; row < nv; row++) { + SkPoint* upper = r; + SkPoint* lower = r + nu + 1; + r = lower; + SkScalar s = 0; + for (i = 0; i <= nu; i++) { + strip[i*2 + 0] = *upper++; + strip[i*2 + 1] = *lower++; + tex[i*2 + 0].set(s, t); + tex[i*2 + 1].set(s, t + dt); + colors[i*2 + 0] = make_color(s/fW, t/fH); + colors[i*2 + 1] = make_color(s/fW, (t + dt)/fH); + s += ds; + } + t += dt; + canvas->drawVertices(SkCanvas::kTriangleStrip_VertexMode, stripCount, + strip, doTextures ? tex : NULL, + doColors ? colors : NULL, NULL, + NULL, 0, paint); + } +} + +static void drawpatches(SkCanvas* canvas, const SkPaint& paint, int nu, int nv, + Patch* patch) { + + SkAutoCanvasRestore ar(canvas, true); + + patch->draw(canvas, paint, 10, 10, false, false); + canvas->translate(SkIntToScalar(300), 0); + patch->draw(canvas, paint, 10, 10, true, false); + canvas->translate(SkIntToScalar(300), 0); + patch->draw(canvas, paint, 10, 10, false, true); + canvas->translate(SkIntToScalar(300), 0); + patch->draw(canvas, paint, 10, 10, true, true); +} + +class PatchView : public SkView { + SkShader* fShader0; + SkShader* fShader1; + SkIPoint fSize0, fSize1; + SkPoint fPts[12]; + +public: + PatchView() { + fShader0 = make_shader0(&fSize0); + fSize1 = fSize0; + if (fSize0.fX == 0 || fSize0.fY == 0) { + fSize1.set(2, 2); + } + fShader1 = make_shader1(fSize1); + + const SkScalar S = SkIntToScalar(90); + const SkScalar T = SkIntToScalar(64); + fPts[0].set(S*1, T); + fPts[1].set(S*2, T); + fPts[2].set(S*3, T); + fPts[3].set(S*4, T); + fPts[4].set(S*4, T*2); + fPts[5].set(S*4, T*3); + fPts[6].set(S*4, T*4); + fPts[7].set(S*3, T*4); + fPts[8].set(S*2, T*4); + fPts[9].set(S*1, T*4); + fPts[10].set(S*1, T*3); + fPts[11].set(S*1, T*2); + } + + virtual ~PatchView() { + fShader0->safeUnref(); + fShader1->safeUnref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) + { + SkString str("Patch"); + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorGRAY); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkPaint paint; + paint.setDither(true); + paint.setFilterBitmap(true); + + if (false) { + SkPath p; + p.moveTo(0, 0); + p.lineTo(SkIntToScalar(30000), SkIntToScalar(30000)); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(4)); + paint.setAntiAlias(true); + canvas->scale(SkIntToScalar(3), SkIntToScalar(3)); + canvas->drawPath(p, paint); + return; + } + + if (false) { + for (int dy = -1; dy <= 2; dy++) { + canvas->save(); + if (dy == 2) { + canvas->translate(0, SK_Scalar1/2); + } else { + canvas->translate(0, SkIntToScalar(dy)/100); + } + + SkBitmap bm; + bm.setConfig(SkBitmap::kARGB_8888_Config, 20, 20); + bm.allocPixels(); + SkCanvas c(bm); + SkRect r = { 0, 0, 20*SK_Scalar1, SK_Scalar1 }; + for (int y = 0; y < 20; y++) { + SkPaint p; + p.setARGB(0xFF, y*5&0xFF, y*13&0xFF, y*29&0xFF); + c.drawRect(r, p); + r.offset(0, SK_Scalar1); + } + SkIRect src; + SkRect dst; + + static const int srcPts[] = { + // 2, 0, 15, 2, + 2, 2, 15, 16, + 17, 2, 2, 16, + 19, 2, 1, 16, + // 2, 18, 15, 2 + }; + static const double dstPts[] = { + // 7, 262 15, 24.5, + 7, 286.5, 15, 16, + 22, 286.5, 5, 16, + 27, 286.5, 1, 16, + // 7, 302.5, 15, 24.5 + }; + + SkPaint p; +// p.setFilterBitmap(true); + const int* s = srcPts; + const double* d = dstPts; + for (int i = 0; i < 3; i++) { + src.set(s[0], s[1], s[0]+s[2], s[1]+s[3]); + dst.set(SkDoubleToScalar(d[0]), + SkDoubleToScalar(d[1]), + SkDoubleToScalar(d[0]+d[2]), + SkDoubleToScalar(d[1]+d[3])); + canvas->drawBitmapRect(bm, &src, dst, &p); + canvas->translate(SkDoubleToScalar(1), 0); + s += 4; + d += 4; + } + canvas->restore(); + canvas->translate(SkIntToScalar(32), 0); + } + return; + } + + Patch patch; + + paint.setShader(fShader0); + if (fSize0.fX == 0) { + fSize0.fX = 1; + } + if (fSize0.fY == 0) { + fSize0.fY = 1; + } + patch.setBounds(fSize0.fX, fSize0.fY); + + patch.setPatch(fPts); + drawpatches(canvas, paint, 10, 10, &patch); + + paint.setShader(NULL); + paint.setAntiAlias(true); + paint.setStrokeWidth(SkIntToScalar(5)); + canvas->drawPoints(SkCanvas::kPoints_PointMode, SK_ARRAY_COUNT(fPts), + fPts, paint); + + canvas->translate(0, SkIntToScalar(300)); + + paint.setAntiAlias(false); + paint.setShader(fShader1); + patch.setBounds(fSize1.fX, fSize1.fY); + drawpatches(canvas, paint, 10, 10, &patch); + } + + class PtClick : public Click { + public: + int fIndex; + PtClick(SkView* view, int index) : Click(view), fIndex(index) {} + }; + + static bool hittest(const SkPoint& pt, SkScalar x, SkScalar y) { + return SkPoint::Length(pt.fX - x, pt.fY - y) < SkIntToScalar(5); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + for (int i = 0; i < SK_ARRAY_COUNT(fPts); i++) { + if (hittest(fPts[i], x, y)) { + return new PtClick(this, i); + } + } + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + fPts[((PtClick*)click)->fIndex].set(click->fCurr.fX, click->fCurr.fY); + this->inval(NULL); + return true; + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PatchView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePath.cpp b/Samples/SamplePath.cpp new file mode 100644 index 0000000..04d006a --- /dev/null +++ b/Samples/SamplePath.cpp @@ -0,0 +1,164 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +class PathView : public SkView { +public: + int fDStroke, fStroke, fMinStroke, fMaxStroke; + SkPath fPath[6]; + bool fShowHairline; + + PathView() + { + fShowHairline = false; + + fDStroke = 1; + fStroke = 10; + fMinStroke = 10; + fMaxStroke = 180; + + const int V = 85; + + fPath[0].moveTo(SkIntToScalar(40), SkIntToScalar(70)); + fPath[0].lineTo(SkIntToScalar(70), SkIntToScalar(70) + SK_Scalar1/1); + fPath[0].lineTo(SkIntToScalar(110), SkIntToScalar(70)); + + fPath[1].moveTo(SkIntToScalar(40), SkIntToScalar(70)); + fPath[1].lineTo(SkIntToScalar(70), SkIntToScalar(70) - SK_Scalar1/1); + fPath[1].lineTo(SkIntToScalar(110), SkIntToScalar(70)); + + fPath[2].moveTo(SkIntToScalar(V), SkIntToScalar(V)); + fPath[2].lineTo(SkIntToScalar(50), SkIntToScalar(V)); + fPath[2].lineTo(SkIntToScalar(50), SkIntToScalar(50)); + + fPath[3].moveTo(SkIntToScalar(50), SkIntToScalar(50)); + fPath[3].lineTo(SkIntToScalar(50), SkIntToScalar(V)); + fPath[3].lineTo(SkIntToScalar(V), SkIntToScalar(V)); + + fPath[4].moveTo(SkIntToScalar(50), SkIntToScalar(50)); + fPath[4].lineTo(SkIntToScalar(50), SkIntToScalar(V)); + fPath[4].lineTo(SkIntToScalar(52), SkIntToScalar(50)); + + fPath[5].moveTo(SkIntToScalar(52), SkIntToScalar(50)); + fPath[5].lineTo(SkIntToScalar(50), SkIntToScalar(V)); + fPath[5].lineTo(SkIntToScalar(50), SkIntToScalar(50)); + } + + virtual ~PathView() + { + } + + void nextStroke() + { + fStroke += fDStroke; + if (fStroke > fMaxStroke || fStroke < fMinStroke) + fDStroke = -fDStroke; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Paths"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); +// canvas->drawColor(SK_ColorWHITE); + } + + void drawPath(SkCanvas* canvas, const SkPath& path, SkPaint::Join j) + { + SkPaint paint; + + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeJoin(j); + paint.setStrokeWidth(SkIntToScalar(fStroke)); + + if (fShowHairline) + { + SkPath fill; + + paint.getFillPath(path, &fill); + paint.setStrokeWidth(0); + canvas->drawPath(fill, paint); + } + else + canvas->drawPath(path, paint); + + paint.setColor(SK_ColorRED); + paint.setStrokeWidth(0); + canvas->drawPath(path, paint); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->translate(SkIntToScalar(50), SkIntToScalar(50)); + + static const SkPaint::Join gJoins[] = { + SkPaint::kBevel_Join, + SkPaint::kMiter_Join, + SkPaint::kRound_Join + }; + + for (int i = 0; i < SK_ARRAY_COUNT(gJoins); i++) + { + canvas->save(); + for (int j = 0; j < SK_ARRAY_COUNT(fPath); j++) + { + this->drawPath(canvas, fPath[j], gJoins[i]); + canvas->translate(SkIntToScalar(200), 0); + } + canvas->restore(); + + canvas->translate(0, SkIntToScalar(200)); + } + + this->nextStroke(); + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + fShowHairline = !fShowHairline; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PathView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePathEffects.cpp b/Samples/SamplePathEffects.cpp new file mode 100644 index 0000000..4082288 --- /dev/null +++ b/Samples/SamplePathEffects.cpp @@ -0,0 +1,283 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "Sk1DPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkColorPriv.h" +#include "SkPixelXorXfermode.h" + +static void test_grow(SkPath* path) +{ + for (int i = 0; i < 100000; i++) + { + path->lineTo(i, i); + path->lineTo(i, i*2); + } +} + +#define CORNER_RADIUS 12 +static SkScalar gPhase; + +static const int gXY[] = { + 4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4 +}; + +static SkPathEffect* make_pe(int flags) +{ + if (flags == 1) + return new SkCornerPathEffect(SkIntToScalar(CORNER_RADIUS)); + + SkPath path; + path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1])); + for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2) + path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1])); + path.close(); + path.offset(SkIntToScalar(-6), 0); + + SkPathEffect* outer = new SkPath1DPathEffect(path, SkIntToScalar(12), gPhase, SkPath1DPathEffect::kRotate_Style); + + if (flags == 2) + return outer; + + SkPathEffect* inner = new SkCornerPathEffect(SkIntToScalar(CORNER_RADIUS)); + + SkPathEffect* pe = new SkComposePathEffect(outer, inner); + outer->unref(); + inner->unref(); + return pe; +} + +static SkPathEffect* make_warp_pe() +{ + SkPath path; + path.moveTo(SkIntToScalar(gXY[0]), SkIntToScalar(gXY[1])); + for (unsigned i = 2; i < SK_ARRAY_COUNT(gXY); i += 2) + path.lineTo(SkIntToScalar(gXY[i]), SkIntToScalar(gXY[i+1])); + path.close(); + path.offset(SkIntToScalar(-6), 0); + + SkPathEffect* outer = new SkPath1DPathEffect(path, SkIntToScalar(12), gPhase, SkPath1DPathEffect::kMorph_Style); + SkPathEffect* inner = new SkCornerPathEffect(SkIntToScalar(CORNER_RADIUS)); + + SkPathEffect* pe = new SkComposePathEffect(outer, inner); + outer->unref(); + inner->unref(); + return pe; +} + +/////////////////////////////////////////////////////////// + +#include "SkColorFilter.h" +#include "SkPorterDuff.h" +#include "SkLayerRasterizer.h" + +class testrast : public SkLayerRasterizer { +public: + testrast() + { + SkPaint paint; + paint.setAntiAlias(true); + +#if 0 + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SK_Scalar1*4); + this->addLayer(paint); + + paint.setStrokeWidth(SK_Scalar1*1); + paint.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + this->addLayer(paint); +#else + paint.setAlpha(0x66); + this->addLayer(paint, SkIntToScalar(4), SkIntToScalar(4)); + + paint.setAlpha(0xFF); + this->addLayer(paint); +#endif + } +}; + +class PathEffectView : public SkView { + SkPath fPath; + SkPoint fClickPt; +public: + PathEffectView() + { + SkRandom rand; + int steps = 20; + SkScalar dist = SkIntToScalar(500); + SkScalar x = SkIntToScalar(20); + SkScalar y = SkIntToScalar(50); + + fPath.moveTo(x, y); + for (int i = 0; i < steps; i++) + { + x += dist/steps; + fPath.lineTo(x, y + SkIntToScalar(rand.nextS() % 25)); + } + + fClickPt.set(SkIntToScalar(200), SkIntToScalar(200)); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "PathEffects"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); + +#if 0 + SkPath path; + test_grow(&path); + SkPaint p; + + p.setAntiAlias(true); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + canvas->drawPath(path, p); + path.close(); +#endif + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + if (true) + { + canvas->drawColor(SK_ColorWHITE); + + SkPixelXorXfermode mode(SK_ColorWHITE); + SkPaint paint; + + paint.setColor(SK_ColorRED); + paint.setXfermode(&mode); + paint.setStrokeWidth(SkIntToScalar(8)); + + canvas->drawLine(SkIntToScalar(100), SkIntToScalar(100), + SkIntToScalar(200), SkIntToScalar(200), paint); + canvas->drawLine(SkIntToScalar(100), SkIntToScalar(200), + SkIntToScalar(200), SkIntToScalar(100), paint); + // return; + } + + if (false) + { + SkPath path; + SkPoint pts[] = { SkIntToScalar(100), SkIntToScalar(100), + SkIntToScalar(200), SkIntToScalar(100), + SkIntToScalar(100), SkIntToScalar(200) + }; + SkPaint paint; + + pts[2] = fClickPt; + + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(5)); + + path.moveTo(pts[0]); + path.arcTo(pts[1], pts[2], SkIntToScalar(50)); + canvas->drawPath(path, paint); + + paint.setStrokeWidth(0); + paint.setColor(SK_ColorRED); + canvas->drawLine(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, paint); + canvas->drawLine(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, paint); + return; + } + + gPhase -= SK_Scalar1; + this->inval(nil); + + SkPaint paint; + + paint.setAntiAlias(true); + paint.setStyle(SkPaint::kStroke_Style); + paint.setStrokeWidth(SkIntToScalar(5)); + canvas->drawPath(fPath, paint); + paint.setStrokeWidth(0); + + paint.setColor(SK_ColorRED); + paint.setPathEffect(make_pe(1))->unref(); + canvas->drawPath(fPath, paint); + + canvas->translate(0, SkIntToScalar(50)); + + paint.setColor(SK_ColorBLUE); + paint.setPathEffect(make_pe(2))->unref(); + canvas->drawPath(fPath, paint); + + canvas->translate(0, SkIntToScalar(50)); + + paint.setARGB(0xFF, 0, 0xBB, 0); + paint.setPathEffect(make_pe(3))->unref(); + canvas->drawPath(fPath, paint); + + canvas->translate(0, SkIntToScalar(50)); + + paint.setARGB(0xFF, 0, 0, 0); + paint.setPathEffect(make_warp_pe())->unref(); + paint.setRasterizer(new testrast)->unref(); + canvas->drawPath(fPath, paint); + + { + SkRect oval; + + oval.set(SkIntToScalar(50), SkIntToScalar(100), + SkIntToScalar(150), SkIntToScalar(150)); + canvas->drawRoundRect(oval, SkIntToScalar(8), SkIntToScalar(8), paint); + } + + { + SkRect bounds; + SkPaint paint; + + paint.setAntiAlias(true); + paint.setAlpha(0x80); + paint.setColorFilter( + SkColorFilter::CreatePorterDuffFilter( + SkColorSetARGB(0x44, 0, 0xFF, 0), SkPorterDuff::kSrcATop_Mode))->unref(); + + bounds.set(SkIntToScalar(10), SkIntToScalar(10), SkIntToScalar(150), SkIntToScalar(70)); + canvas->saveLayer(&bounds, &paint, + (SkCanvas::SaveFlags)(SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag)); + + paint.setColorFilter(NULL); + paint.setColor(SK_ColorRED); + canvas->drawOval(bounds, paint); + + paint.setColor(SK_ColorBLUE); + paint.setAlpha(0x80); + bounds.inset(SkIntToScalar(10), SkIntToScalar(10)); + canvas->drawOval(bounds, paint); + + canvas->restore(); + } + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PathEffectView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePicture.cpp b/Samples/SamplePicture.cpp new file mode 100644 index 0000000..48de7df --- /dev/null +++ b/Samples/SamplePicture.cpp @@ -0,0 +1,158 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkPicture.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +#include "SkStream.h" +#include "SkXMLParser.h" + +static void drawCircle(SkCanvas* canvas, int r, SkColor color) { + SkPaint paint; + paint.setAntiAlias(true); + paint.setColor(color); + + canvas->drawCircle(SkIntToScalar(r), SkIntToScalar(r), SkIntToScalar(r), + paint); +} + +class PictureView : public SkView { +public: + PictureView() { + fPicture = new SkPicture; + SkCanvas* canvas = fPicture->beginRecording(100, 100); + SkPaint paint; + paint.setAntiAlias(true); + + drawCircle(canvas, 50, SK_ColorBLACK); + fSubPicture = new SkPicture; + canvas->drawPicture(*fSubPicture); + canvas->translate(SkIntToScalar(50), 0); + canvas->drawPicture(*fSubPicture); + canvas->translate(0, SkIntToScalar(50)); + canvas->drawPicture(*fSubPicture); + canvas->translate(SkIntToScalar(-50), 0); + canvas->drawPicture(*fSubPicture); + // fPicture now has (4) references to us. We can release ours, and just + // unref fPicture in our destructor, and it will in turn take care of + // the other references to fSubPicture + fSubPicture->unref(); + } + + virtual ~PictureView() { + fPicture->unref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Picture"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorWHITE); + // canvas->drawColor(SK_ColorBLACK); + } + + void drawSomething(SkCanvas* canvas) { + SkPaint paint; + + paint.setAntiAlias(true); + + paint.setColor(SK_ColorRED); + canvas->drawCircle(SkIntToScalar(50), SkIntToScalar(50), + SkIntToScalar(40), paint); + paint.setColor(SK_ColorBLACK); + paint.setTextSize(SkIntToScalar(40)); + canvas->drawText("Picture", 7, SkIntToScalar(50), SkIntToScalar(62), + paint); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + drawSomething(canvas); + + SkPicture* pict = new SkPicture; + SkAutoUnref aur(pict); + + drawSomething(pict->beginRecording(100, 100)); + pict->endRecording(); + + canvas->save(); + canvas->translate(SkIntToScalar(300), SkIntToScalar(50)); + canvas->scale(-SK_Scalar1, -SK_Scalar1); + canvas->translate(-SkIntToScalar(100), -SkIntToScalar(50)); + canvas->drawPicture(*pict); + canvas->restore(); + + canvas->save(); + canvas->translate(SkIntToScalar(200), SkIntToScalar(150)); + canvas->scale(SK_Scalar1, -SK_Scalar1); + canvas->translate(0, -SkIntToScalar(50)); + canvas->drawPicture(*pict); + canvas->restore(); + + canvas->save(); + canvas->translate(SkIntToScalar(100), SkIntToScalar(100)); + canvas->scale(-SK_Scalar1, SK_Scalar1); + canvas->translate(-SkIntToScalar(100), 0); + canvas->drawPicture(*pict); + canvas->restore(); + + // test that we can re-record a subpicture, and see the results + + canvas->translate(SkIntToScalar(10), SkIntToScalar(250)); + drawCircle(fSubPicture->beginRecording(50, 50), 25, + fRand.nextU() | 0xFF000000); + canvas->drawPicture(*fPicture); + delayInval(500); + } + +private: + #define INVAL_ALL_TYPE "inval-all" + + void delayInval(SkMSec delay) { + (new SkEvent(INVAL_ALL_TYPE))->post(this->getSinkID(), delay); + } + + virtual bool onEvent(const SkEvent& evt) { + if (evt.isType(INVAL_ALL_TYPE)) { + this->inval(NULL); + return true; + } + return this->INHERITED::onEvent(evt); + } + + SkPicture* fPicture; + SkPicture* fSubPicture; + SkRandom fRand; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PictureView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePoints.cpp b/Samples/SamplePoints.cpp new file mode 100644 index 0000000..2c19658 --- /dev/null +++ b/Samples/SamplePoints.cpp @@ -0,0 +1,122 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +#include "SkStream.h" +#include "SkXMLParser.h" + +static SkRandom gRand; + +static const struct { + const char* fName; + uint32_t fFlags; + bool fFlushCache; +} gHints[] = { + { "Linear", SkPaint::kLinearText_Flag, false }, + { "Normal", 0, true }, + { "Subpixel", SkPaint::kSubpixelText_Flag, true } +}; + +#ifdef SK_DEBUG + #define REPEAT_COUNT 1 +#else + #define REPEAT_COUNT 5000 +#endif + +class PointsView : public SkView { + bool fAA; +public: + PointsView() : fAA(false) {} + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Points"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorWHITE); + // canvas->drawColor(SK_ColorBLACK); + } + + static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand) + { + for (size_t i = 0; i < n; i++) + pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->translate(SK_Scalar1, SK_Scalar1); + + SkRandom rand; + SkPaint p0, p1, p2, p3; + const size_t n = 99; + const int TIMES = 1; + + p0.setColor(SK_ColorRED); + p1.setColor(SK_ColorGREEN); + p2.setColor(SK_ColorBLUE); + p3.setColor(SK_ColorWHITE); + + // fAA = !fAA; + + p0.setAntiAlias(fAA); + p1.setAntiAlias(fAA); + p2.setAntiAlias(fAA); + p3.setAntiAlias(fAA); + + p0.setStrokeWidth(SkIntToScalar(4)); + p2.setStrokeWidth(SkIntToScalar(6)); + + SkPoint* pts = new SkPoint[n]; + fill_pts(pts, n, &rand); + +// SkMSec now = SkTime::GetMSecs(); + for (int times = 0; times < TIMES; times++) + { + canvas->drawPoints(SkCanvas::kPolygon_PointMode, n, pts, p0); + canvas->drawPoints(SkCanvas::kLines_PointMode, n, pts, p1); + canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts, p2); + canvas->drawPoints(SkCanvas::kPoints_PointMode, n, pts, p3); + } + // printf("----- msecs %d\n", SkTime::GetMSecs() - now); + delete[] pts; + } + +private: + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PointsView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SamplePolyToPoly.cpp b/Samples/SamplePolyToPoly.cpp new file mode 100644 index 0000000..98e4484 --- /dev/null +++ b/Samples/SamplePolyToPoly.cpp @@ -0,0 +1,165 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGraphics.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkTime.h" + +extern bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]); + +class PolyToPolyView : public SkView { +public: + PolyToPolyView() { + // tests + { + SkPoint src[] = { 0, 0, SK_Scalar1, 0, 0, SK_Scalar1 }; + SkPoint dst[] = { 0, 0, 2*SK_Scalar1, 0, 0, 2*SK_Scalar1 }; + SkMatrix m1, m2; + bool success; + + success = m1.setPolyToPoly(src, dst, 3); + SkDebugf("--- setPolyToPoly1 %d\n", success); + + m2.reset(); + m2.set(SkMatrix::kMScaleX, dst[1].fX - dst[0].fX); + m2.set(SkMatrix::kMSkewX, dst[2].fX - dst[0].fX); + m2.set(SkMatrix::kMTransX, dst[0].fX); + m2.set(SkMatrix::kMSkewY, dst[1].fY - dst[0].fY); + m2.set(SkMatrix::kMScaleY, dst[2].fY - dst[0].fY); + m2.set(SkMatrix::kMTransY, dst[0].fY); + + m1.reset(); + + const SkScalar src1[] = { + 0, 0, 0, SkFloatToScalar(427), SkFloatToScalar(316), SkFloatToScalar(427), SkFloatToScalar(316), 0 + }; + const SkScalar dst1[] = { + SkFloatToScalar(158), SkFloatToScalar(177.5f), SkFloatToScalar(158), SkFloatToScalar(249.5f), + SkFloatToScalar(158), SkFloatToScalar(604.5f), SkFloatToScalar(158), SkFloatToScalar(-177.5f) + }; + + success = m2.setPolyToPoly((const SkPoint*)src1, (SkPoint*)dst1, 4); + SkDebugf("--- setPolyToPoly2 %d\n", success); + + { + const SkPoint src[] = { + SkIntToScalar(1), SkIntToScalar(0), + SkIntToScalar(4), SkIntToScalar(7), + SkIntToScalar(10), SkIntToScalar(2) + }; + const SkPoint dst[] = { + SkIntToScalar(4), SkIntToScalar(2), + SkIntToScalar(45), SkIntToScalar(26), + SkIntToScalar(32), SkIntToScalar(17) + }; + + SkMatrix m0, m1; + m0.setPolyToPoly(src, dst, 3); + SkSetPoly3To3(&m1, src, dst); + m0.dump(); + m1.dump(); + } + } + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SkString str("PolyToPolyView"); + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + static void doDraw(SkCanvas* canvas, SkPaint* paint, const int isrc[], + const int idst[], int count) { + SkMatrix matrix; + SkPoint src[4], dst[4]; + + for (int i = 0; i < count; i++) { + src[i].set(SkIntToScalar(isrc[2*i+0]), SkIntToScalar(isrc[2*i+1])); + dst[i].set(SkIntToScalar(idst[2*i+0]), SkIntToScalar(idst[2*i+1])); + } + + canvas->save(); + matrix.setPolyToPoly(src, dst, count); + canvas->concat(matrix); + + paint->setColor(SK_ColorGRAY); + paint->setStyle(SkPaint::kStroke_Style); + const SkScalar D = SkIntToScalar(64); + canvas->drawRectCoords(0, 0, D, D, *paint); + canvas->drawLine(0, 0, D, D, *paint); + canvas->drawLine(0, D, D, 0, *paint); + + SkPaint::FontMetrics fm; + paint->getFontMetrics(&fm); + paint->setColor(SK_ColorRED); + paint->setStyle(SkPaint::kFill_Style); + SkScalar x = D/2; + float y = D/2 - (fm.fAscent + fm.fDescent)/2; + SkString str; + str.appendS32(count); + canvas->drawText(str.c_str(), str.size(), x, y, *paint); + + canvas->restore(); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkPaint paint; + paint.setAntiAlias(true); + paint.setStrokeWidth(SkIntToScalar(4)); + paint.setTextSize(SkIntToScalar(40)); + paint.setTextAlign(SkPaint::kCenter_Align); + + canvas->save(); + canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); + // translate (1 point) + const int src1[] = { 0, 0 }; + const int dst1[] = { 5, 5 }; + doDraw(canvas, &paint, src1, dst1, 1); + canvas->restore(); + + canvas->save(); + canvas->translate(SkIntToScalar(160), SkIntToScalar(10)); + // rotate/uniform-scale (2 points) + const int src2[] = { 32, 32, 64, 32 }; + const int dst2[] = { 32, 32, 64, 48 }; + doDraw(canvas, &paint, src2, dst2, 2); + canvas->restore(); + + canvas->save(); + canvas->translate(SkIntToScalar(10), SkIntToScalar(110)); + // rotate/skew (3 points) + const int src3[] = { 0, 0, 64, 0, 0, 64 }; + const int dst3[] = { 0, 0, 96, 0, 24, 64 }; + doDraw(canvas, &paint, src3, dst3, 3); + canvas->restore(); + + canvas->save(); + canvas->translate(SkIntToScalar(160), SkIntToScalar(110)); + // perspective (4 points) + const int src4[] = { 0, 0, 64, 0, 64, 64, 0, 64 }; + const int dst4[] = { 0, 0, 96, 0, 64, 96, 0, 64 }; + doDraw(canvas, &paint, src4, dst4, 4); + canvas->restore(); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new PolyToPolyView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleRegion.cpp b/Samples/SampleRegion.cpp new file mode 100644 index 0000000..8958c82 --- /dev/null +++ b/Samples/SampleRegion.cpp @@ -0,0 +1,329 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkImageDecoder.h" + +#ifdef SK_DEBUG +static void make_rgn(SkRegion* rgn, int left, int top, int right, int bottom, + size_t count, int32_t runs[]) { + SkIRect r; + r.set(left, top, right, bottom); + + rgn->debugSetRuns(runs, count); + SkASSERT(rgn->getBounds() == r); +} + +static void test_union_bug_1505668(SkRegion* ra, SkRegion* rb, SkRegion* rc) { + static int32_t dataA[] = { + 0x00000001, 0x000001dd, + 0x00000001, 0x0000000c, 0x0000000d, 0x00000025, + 0x7fffffff, 0x000001de, 0x00000001, 0x00000025, + 0x7fffffff, 0x000004b3, 0x00000001, 0x00000026, + 0x7fffffff, 0x000004b4, 0x0000000c, 0x00000026, + 0x7fffffff, 0x00000579, 0x00000000, 0x0000013a, + 0x7fffffff, 0x000005d8, 0x00000000, 0x0000013b, + 0x7fffffff, 0x7fffffff + }; + make_rgn(ra, 0, 1, 315, 1496, SK_ARRAY_COUNT(dataA), dataA); + + static int32_t dataB[] = { + 0x000000b6, 0x000000c4, + 0x000000a1, 0x000000f0, 0x7fffffff, 0x000000d6, + 0x7fffffff, 0x000000e4, 0x00000070, 0x00000079, + 0x000000a1, 0x000000b0, 0x7fffffff, 0x000000e6, + 0x7fffffff, 0x000000f4, 0x00000070, 0x00000079, + 0x000000a1, 0x000000b0, 0x7fffffff, 0x000000f6, + 0x7fffffff, 0x00000104, 0x000000a1, 0x000000b0, + 0x7fffffff, 0x7fffffff + }; + make_rgn(rb, 112, 182, 240, 260, SK_ARRAY_COUNT(dataB), dataB); + + rc->op(*ra, *rb, SkRegion::kUnion_Op); +} +#endif + +static void paint_rgn(SkCanvas* canvas, const SkRegion& rgn, const SkPaint& paint) +{ + SkRegion::Iterator iter(rgn); + + for (; !iter.done(); iter.next()) + { + SkRect r; + r.set(iter.rect()); + canvas->drawRect(r, paint); + } +} + +class RegionView : public SkView { +public: + RegionView() + { + fBase.set(100, 100, 150, 150); + fRect = fBase; + fRect.inset(5, 5); + fRect.offset(25, 25); + } + + void build_rgn(SkRegion* rgn, SkRegion::Op op) + { + rgn->setRect(fBase); + SkIRect r = fBase; + r.offset(75, 20); + rgn->op(r, SkRegion::kUnion_Op); + rgn->op(fRect, op); + } + + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Regions"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawOrig(SkCanvas* canvas, bool bg) + { + SkRect r; + SkPaint paint; + + paint.setStyle(SkPaint::kStroke_Style); + if (bg) + paint.setColor(0xFFBBBBBB); + + r.set(fBase); + canvas->drawRect(r, paint); + r.set(fRect); + canvas->drawRect(r, paint); + } + + void drawRgnOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) + { + SkRegion rgn; + + this->build_rgn(&rgn, op); + + { + SkRegion tmp, tmp2(rgn); + + tmp = tmp2; + tmp.translate(5, -3); + + { + char buffer[1000]; + size_t size = tmp.flatten(NULL); + SkASSERT(size <= sizeof(buffer)); + size_t size2 = tmp.flatten(buffer); + SkASSERT(size == size2); + + SkRegion tmp3; + size2 = tmp3.unflatten(buffer); + SkASSERT(size == size2); + + SkASSERT(tmp3 == tmp); + } + + rgn.translate(20, 30, &tmp); + SkASSERT(rgn.isEmpty() || tmp != rgn); + tmp.translate(-20, -30); + SkASSERT(tmp == rgn); + } + + this->drawOrig(canvas, true); + + SkPaint paint; + paint.setColor((color & ~(0xFF << 24)) | (0x44 << 24)); + paint_rgn(canvas, rgn, paint); + + paint.setStyle(SkPaint::kStroke_Style); + paint.setColor(color); + paint_rgn(canvas, rgn, paint); + } + + void drawPathOped(SkCanvas* canvas, SkRegion::Op op, SkColor color) + { + SkRegion rgn; + SkPath path; + + this->build_rgn(&rgn, op); + rgn.getBoundaryPath(&path); + + this->drawOrig(canvas, true); + + SkPaint paint; + + paint.setStyle(SkPaint::kFill_Style); + paint.setColor((color & ~(0xFF << 24)) | (0x44 << 24)); + canvas->drawPath(path, paint); + paint.setColor(color); + paint.setStyle(SkPaint::kStroke_Style); + canvas->drawPath(path, paint); + } + + void drawBG(SkCanvas* canvas) + { + canvas->drawColor(0xFFDDDDDD); + return; + +#if 0 + SkColorTable ct; + SkPMColor colors[] = { SK_ColorRED, SK_ColorBLUE }; + ct.setColors(colors, 2); + ct.setFlags(ct.getFlags() | SkColorTable::kColorsAreOpaque_Flag); + + SkBitmap bm; + bm.setConfig(SkBitmap::kIndex8_Config, 20, 20, 21); + bm.setColorTable(&ct); + bm.allocPixels(); + sk_memset16((uint16_t*)bm.getAddr8(0, 0), 0x0001, bm.rowBytes() * bm.height() / 2); +#endif +#if 0 + SkBitmap bm; + bm.setConfig(SkBitmap::kRGB_565_Config, 20, 20, 42); + bm.allocPixels(); + sk_memset32((uint32_t*)bm.getAddr16(0, 0), 0x0000FFFF, bm.rowBytes() * bm.height() / 4); +#endif +#if 1 + SkBitmap bm; + bm.setConfig(SkBitmap::kARGB_8888_Config, 20, 20); + bm.allocPixels(); + sk_memset32((uint32_t*)bm.getAddr32(0, 0), 0xFFDDDDDD, bm.rowBytes() * bm.height() / 4); +#endif + + SkPaint paint; + +// SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kBilinear_FilterType, SkShader::kRepeat_TileMode); + SkPoint pts[] = { 0, 0, SkIntToScalar(100), SkIntToScalar(0) }; + SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE }; + SkShader* shader = SkGradientShader::CreateLinear(pts, colors, nil, 2, SkShader::kMirror_TileMode); + paint.setShader(shader)->unref(); + + canvas->drawPaint(paint); + } + + virtual void onDraw(SkCanvas* canvas) + { + if (true) { + SkRect r = { 0, 0, 1 << 30, 1 << 30 }; + bool open = canvas->clipRect(r); + SkDebugf("---- giant clip is %d\n", open); + } + this->drawBG(canvas); + +#ifdef SK_DEBUG + if (true) { + SkRegion a, b, c; + test_union_bug_1505668(&a, &b, &c); + + if (false) { // draw the result of the test + SkPaint paint; + + canvas->translate(SkIntToScalar(10), SkIntToScalar(10)); + paint.setColor(SK_ColorRED); + paint_rgn(canvas, a, paint); + paint.setColor(0x800000FF); + paint_rgn(canvas, b, paint); + paint.setColor(SK_ColorBLACK); + paint.setStyle(SkPaint::kStroke_Style); + // paint_rgn(canvas, c, paint); + return; + } + } +#endif + + static const struct { + SkColor fColor; + const char* fName; + SkRegion::Op fOp; + } gOps[] = { + { SK_ColorBLACK, "Difference", SkRegion::kDifference_Op }, + { SK_ColorRED, "Intersect", SkRegion::kIntersect_Op }, + { 0xFF008800, "Union", SkRegion::kUnion_Op }, + { SK_ColorBLUE, "XOR", SkRegion::kXOR_Op } + }; + + SkPaint textPaint; + textPaint.setAntiAlias(true); + textPaint.setTextSize(SK_Scalar1*24); + + this->drawOrig(canvas, false); + canvas->save(); + canvas->translate(SkIntToScalar(200), 0); + this->drawRgnOped(canvas, SkRegion::kUnion_Op, SK_ColorBLACK); + canvas->restore(); + + canvas->translate(0, SkIntToScalar(200)); + + for (int op = 0; op < SK_ARRAY_COUNT(gOps); op++) + { + canvas->drawText(gOps[op].fName, strlen(gOps[op].fName), SkIntToScalar(75), SkIntToScalar(50), textPaint); + + this->drawRgnOped(canvas, gOps[op].fOp, gOps[op].fColor); + + if (true) + { + canvas->save(); + canvas->translate(0, SkIntToScalar(200)); + this->drawPathOped(canvas, gOps[op].fOp, gOps[op].fColor); + canvas->restore(); + } + + canvas->translate(SkIntToScalar(200), 0); + } + + if (false) + { + SkBitmap bitmap; + + bitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100); + bitmap.allocPixels(); + bitmap.eraseColor(0); + + SkCanvas canvas(bitmap); + SkPaint paint; + SkRect r; + + paint.setAntiAlias(true); + paint.setARGB(0xFF, 0xFF, 0, 0xFF); + r.set(0, 0, SkIntToScalar(100), SkIntToScalar(100)); + canvas.drawOval(r, paint); + + SkImageEncoder* en = SkImageEncoder::Create(SkImageEncoder::kPNG_Type); + en->encodeFile("testfile.png", bitmap); + delete en; + } + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + return fRect.contains(SkScalarRound(x), SkScalarRound(y)) ? new Click(this) : nil; + } + + virtual bool onClick(Click* click) + { + fRect.offset(click->fICurr.fX - click->fIPrev.fX, + click->fICurr.fY - click->fIPrev.fY); + this->inval(nil); + return true; + } + +private: + SkIRect fBase, fRect; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new RegionView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleShaders.cpp b/Samples/SampleShaders.cpp new file mode 100644 index 0000000..4d82182 --- /dev/null +++ b/Samples/SampleShaders.cpp @@ -0,0 +1,157 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTransparentShader.h" +#include "SkTypeface.h" + +static SkShader* make_bitmapfade(const SkBitmap& bm) +{ + SkPoint pts[2]; + SkColor colors[2]; + + pts[0].set(0, 0); + pts[1].set(0, SkIntToScalar(bm.height())); + colors[0] = SK_ColorBLACK; + colors[1] = SkColorSetARGB(0, 0, 0, 0); + SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + + SkShader* shaderB = SkShader::CreateBitmapShader(bm, + SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); + + SkXfermode* mode = SkPorterDuff::CreateXfermode(SkPorterDuff::kDstIn_Mode); + + SkShader* shader = new SkComposeShader(shaderB, shaderA, mode); + shaderA->unref(); + shaderB->unref(); + mode->unref(); + + return shader; +} + +class ShaderView : public SkView { +public: + SkShader* fShader; + SkBitmap fBitmap; + + ShaderView() + { + SkImageDecoder::DecodeFile("/cover.png", &fBitmap); + + SkPoint pts[2]; + SkColor colors[2]; + + pts[0].set(0, 0); + pts[1].set(SkIntToScalar(100), 0); + colors[0] = SK_ColorRED; + colors[1] = SK_ColorBLUE; + SkShader* shaderA = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + + pts[0].set(0, 0); + pts[1].set(0, SkIntToScalar(100)); + colors[0] = SK_ColorBLACK; + colors[1] = SkColorSetARGB(0x80, 0, 0, 0); + SkShader* shaderB = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + + SkXfermode* mode = SkPorterDuff::CreateXfermode(SkPorterDuff::kDstIn_Mode); + + fShader = new SkComposeShader(shaderA, shaderB, mode); + shaderA->unref(); + shaderB->unref(); + mode->unref(); + } + virtual ~ShaderView() + { + fShader->safeUnref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Shaders"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->drawBitmap(fBitmap, 0, 0); + + { + SkIRect src; + SkRect dst; + + src.set(20, 50, 120, 70); + dst.set(src); + dst.offset(SkIntToScalar(300), 0); + + canvas->drawBitmapRect(fBitmap, &src, dst); + } + + canvas->translate(SkIntToScalar(80), SkIntToScalar(80)); + + SkPaint paint; + SkRect r; + + paint.setColor(SK_ColorGREEN); + canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint); + paint.setShader(fShader); + canvas->drawRectCoords(0, 0, SkIntToScalar(100), SkIntToScalar(100), paint); + + canvas->translate(SkIntToScalar(110), 0); + + r.set(0, 0, SkIntToScalar(fBitmap.width()), SkIntToScalar(fBitmap.height())); + + paint.setShader(NULL); + canvas->drawRect(r, paint); + paint.setShader(make_bitmapfade(fBitmap))->unref(); + canvas->drawRect(r, paint); + + paint.setShader(new SkTransparentShader)->unref(); + canvas->drawRect(r, paint); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new ShaderView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleStrokeText.cpp b/Samples/SampleStrokeText.cpp new file mode 100644 index 0000000..8b78585 --- /dev/null +++ b/Samples/SampleStrokeText.cpp @@ -0,0 +1,148 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +static void lettersToBitmap(SkBitmap* dst, const char chars[], + const SkPaint& original, SkBitmap::Config config) { + SkPath path; + SkScalar x = 0; + SkScalar width; + SkPath p; + for (int i = 0; i < strlen(chars); i++) { + original.getTextPath(&chars[i], 1, x, 0, &p); + path.addPath(p); + original.getTextWidths(&chars[i], 1, &width); + x += width; + } + SkRect bounds; + path.computeBounds(&bounds, SkPath::kExact_BoundsType); + SkScalar sw = -original.getStrokeWidth(); + bounds.inset(sw, sw); + path.offset(-bounds.fLeft, -bounds.fTop); + bounds.offset(-bounds.fLeft, -bounds.fTop); + + int w = SkScalarRound(bounds.width()); + int h = SkScalarRound(bounds.height()); + SkPaint paint(original); + SkBitmap src; + src.setConfig(config, w, h); + src.allocPixels(); + src.eraseColor(0); + { + SkCanvas canvas(src); + paint.setAntiAlias(true); + paint.setColor(SK_ColorBLACK); + paint.setStyle(SkPaint::kFill_Style); + canvas.drawPath(path, paint); + } + + dst->setConfig(config, w, h); + dst->allocPixels(); + dst->eraseColor(SK_ColorWHITE); + { + SkCanvas canvas(*dst); + paint.setPorterDuffXfermode(SkPorterDuff::kDstATop_Mode); + canvas.drawBitmap(src, 0, 0, &paint); + paint.setColor(original.getColor()); + paint.setStyle(SkPaint::kStroke_Style); + canvas.drawPath(path, paint); + } +} + +static void lettersToBitmap2(SkBitmap* dst, const char chars[], + const SkPaint& original, SkBitmap::Config config) { + SkPath path; + SkScalar x = 0; + SkScalar width; + SkPath p; + for (int i = 0; i < strlen(chars); i++) { + original.getTextPath(&chars[i], 1, x, 0, &p); + path.addPath(p); + original.getTextWidths(&chars[i], 1, &width); + x += width; + } + SkRect bounds; + path.computeBounds(&bounds, SkPath::kExact_BoundsType); + SkScalar sw = -original.getStrokeWidth(); + bounds.inset(sw, sw); + path.offset(-bounds.fLeft, -bounds.fTop); + bounds.offset(-bounds.fLeft, -bounds.fTop); + + int w = SkScalarRound(bounds.width()); + int h = SkScalarRound(bounds.height()); + SkPaint paint(original); + + paint.setAntiAlias(true); + paint.setPorterDuffXfermode(SkPorterDuff::kDstATop_Mode); + paint.setColor(original.getColor()); + paint.setStyle(SkPaint::kStroke_Style); + + dst->setConfig(config, w, h); + dst->allocPixels(); + dst->eraseColor(SK_ColorWHITE); + + SkCanvas canvas(*dst); + canvas.drawPath(path, paint); +} + +class StrokeTextView : public SkView { + bool fAA; +public: + StrokeTextView() : fAA(false) {} + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "StrokeText"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFF333333); + canvas->drawColor(0xFFCC8844); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkBitmap bm; + SkPaint paint; + + paint.setStrokeWidth(SkIntToScalar(6)); + paint.setTextSize(SkIntToScalar(80)); +// paint.setTypeface(Typeface.DEFAULT_BOLD); + + lettersToBitmap(&bm, "Test Case", paint, SkBitmap::kARGB_4444_Config); + + canvas->drawBitmap(bm, 0, 0); + } + +private: + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new StrokeTextView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleTests.cpp b/Samples/SampleTests.cpp new file mode 100644 index 0000000..d021672 --- /dev/null +++ b/Samples/SampleTests.cpp @@ -0,0 +1,99 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkBlurMaskFilter.h" +#include "SkCamera.h" +#include "SkColorFilter.h" +#include "SkColorPriv.h" +#include "SkDevice.h" +#include "SkGradientShader.h" +#include "SkImageDecoder.h" +#include "SkInterpolator.h" +#include "SkMaskFilter.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkShaderExtras.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkUtils.h" +#include "SkKey.h" +#include "SkPorterDuff.h" +#include "SkXfermode.h" +#include "SkDrawFilter.h" + +#include "test.h" + +class TestsView : public SkView { +public: + skia::Test::Iter fIter; + + TestsView() {} + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Tests"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + skia::Test* test = fIter.next(); + if (NULL == test) { + fIter.reset(); + test = fIter.next(); + } + + SkIPoint size; + test->getSize(&size); + + SkBitmap bitmap; + bitmap.setConfig(SkBitmap::kARGB_8888_Config, size.fX, size.fY); + bitmap.allocPixels(); + bitmap.eraseColor(0); + + SkCanvas c(bitmap); + test->draw(&c); + + canvas->drawBitmap(bitmap, SkIntToScalar(10), SkIntToScalar(10), NULL); + + SkString str; + test->getString(skia::Test::kTitle, &str); + SkDebugf("--- %s\n", str.c_str()); + delete test; + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + this->inval(NULL); + return this->INHERITED::onClick(click); + } + + virtual bool handleKey(SkKey key) { + this->inval(NULL); + return true; + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new TestsView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleText.cpp b/Samples/SampleText.cpp new file mode 100644 index 0000000..9fc3708 --- /dev/null +++ b/Samples/SampleText.cpp @@ -0,0 +1,790 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +#include "SkStream.h" +#include "SkXMLParser.h" + +static const int gKernel[3][3] = { +// { -1, -2, -1 }, { -2, 12, -2 }, { -1, -2, -1 } + { 1, 2, 1 }, { 2, 64-12, 2 }, { 1, 2, 1 } +}; +static const int gShift = 6; + +class ReduceNoise : public SkKernel33ProcMaskFilter { +public: + ReduceNoise(int percent256) : SkKernel33ProcMaskFilter(percent256) {} + virtual uint8_t computeValue(uint8_t* const* srcRows) + { + int c = srcRows[1][1]; + int min = 255, max = 0; + for (int i = 0; i < 3; i++) + for (int j = 0; j < 3; j++) + if (i != 1 || j != 1) + { + int v = srcRows[i][j]; + if (max < v) + max = v; + if (min > v) + min = v; + } + if (c > max) c = max; + // if (c < min) c = min; + return c; + } + virtual Factory getFactory() { return Create; } +private: + ReduceNoise(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {} + static SkFlattenable* Create(SkFlattenableReadBuffer& rb) + { + return new ReduceNoise(rb); + } +}; + +class Darken : public SkKernel33ProcMaskFilter { +public: + Darken(int percent256) : SkKernel33ProcMaskFilter(percent256) {} + virtual uint8_t computeValue(uint8_t* const* srcRows) + { + int c = srcRows[1][1]; + float f = c / 255.f; + + if (c >= 0) + { + f = sqrtf(f); + } + else + { + f *= f; + } + SkASSERT(f >= 0 && f <= 1); + return (int)(f * 255); + } + virtual Factory getFactory() { return Create; } +private: + Darken(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {} + static SkFlattenable* Create(SkFlattenableReadBuffer& rb) + { + return new Darken(rb); + } +}; + +static SkMaskFilter* makemf() { return new Darken(0x30); } + +//#ifdef TEST_CLICKX + +static void test_typefaceCache() +{ + SkTypeface* t0 = SkTypeface::Create("sans-serif", SkTypeface::kNormal); + SkTypeface* t1 = SkTypeface::Create(NULL, SkTypeface::kNormal); + SkTypeface* t2 = SkTypeface::Create("arial", SkTypeface::kNormal); + SkTypeface* t3 = SkTypeface::Create("helvetica", SkTypeface::kItalic); + + SkASSERT(t0 == t1); + SkASSERT(t0 == t2); + SkASSERT(t0 == t3); +} + +static void test_breakText() +{ + SkPaint paint; + const char* text = "sdfkljAKLDFJKEWkldfjlk#$%&sdfs.dsj"; + size_t length = strlen(text); + SkScalar width = paint.measureText(text, length); + + SkScalar mm = 0; + SkScalar nn = 0; + for (SkScalar w = 0; w <= width; w += SK_Scalar1) + { + SkScalar m; + size_t n = paint.breakText(text, length, w, &m, + SkPaint::kBackward_TextBufferDirection); + + SkASSERT(n <= length); + SkASSERT(m <= width); + + if (n == 0) + SkASSERT(m == 0); + else + { + // now assert that we're monotonic + if (n == nn) + SkASSERT(m == mm); + else + { + SkASSERT(n > nn); + SkASSERT(m > mm); + } + } + nn = n; + mm = m; + } + + nn = paint.breakText(text, length, width, &mm); + SkASSERT(nn == length); + SkASSERT(mm == width); +} + +static SkRandom gRand; + +class SkPowerMode : public SkXfermode { +public: + SkPowerMode(SkScalar exponent) { this->init(exponent); } + + virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count, const SkAlpha aa[]); + + typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&); + + // overrides for SkFlattenable + virtual Factory getFactory() { return Create; } + virtual void flatten(SkFlattenableWriteBuffer& b) + { + // this->INHERITED::flatten(b); How can we know if this is legal???? + b.write32(SkScalarToFixed(fExp)); + } + +private: + SkScalar fExp; // user's value + uint8_t fTable[256]; // cache + + void init(SkScalar exponent); + SkPowerMode(SkFlattenableReadBuffer& b) : SkXfermode(b) + { + // read the exponent + this->init(SkFixedToScalar(b.readS32())); + } + static SkFlattenable* Create(SkFlattenableReadBuffer& b) + { + return SkNEW_ARGS(SkPowerMode, (b)); + } + + typedef SkXfermode INHERITED; +}; + +void SkPowerMode::init(SkScalar e) +{ + fExp = e; + float ee = SkScalarToFloat(e); + + printf("------ %g\n", ee); + for (int i = 0; i < 256; i++) + { + float x = i / 255.f; + // printf(" %d %g", i, x); + x = powf(x, ee); + // printf(" %g", x); + int xx = SkScalarRound(SkFloatToScalar(x * 255)); + // printf(" %d\n", xx); + fTable[i] = SkToU8(xx); + } +} + +void SkPowerMode::xfer16(uint16_t dst[], const SkPMColor src[], int count, const SkAlpha aa[]) +{ + for (int i = 0; i < count; i++) + { + SkPMColor c = src[i]; + int r = SkGetPackedR32(c); + int g = SkGetPackedG32(c); + int b = SkGetPackedB32(c); + r = fTable[r]; + g = fTable[g]; + b = fTable[b]; + dst[i] = SkPack888ToRGB16(r, g, b); + } +} + +static const struct { + const char* fName; + uint32_t fFlags; + bool fFlushCache; +} gHints[] = { + { "Linear", SkPaint::kLinearText_Flag, false }, + { "Normal", 0, true }, + { "Subpixel", SkPaint::kSubpixelText_Flag, true } +}; + +#ifdef SK_DEBUG + #define REPEAT_COUNT 1 +#else + #define REPEAT_COUNT 5000 +#endif + +static int count_char_points(const SkPaint& paint, char c) +{ + SkPath path; + + paint.getTextPath(&c, 1, 0, 0, &path); + return path.getPoints(NULL, 0); +} + +static int gOld, gNew, gCount; + +static void dump(int c, int oldc, int newc) +{ + if (oldc != newc) + { + gOld += oldc; + gNew += newc; + gCount += 1; + printf("char %c: old = %3d, new = %3d, reduction %g%%\n", c, oldc, newc, 100. * (oldc - newc) / oldc); + } +} + +static void tab(int n) +{ +// printf("[%d] ", n); return; + SkASSERT(n >= 0); + for (int i = 0; i < n; i++) + printf(" "); +} + +#if 0 +#include "badrects.cpp" + +static void make_badrgn(SkRegion* rgn, int insetAmount) +{ + SkRect16 r, bounds; + int i; + + rgn->setEmpty(); + bounds.setEmpty(); + + for (i = 0; i < SK_ARRAY_COUNT(badrects); i++) + { + SkASSERT(badrects[i].width > 0 && badrects[i].height > 0); + + r.set(badrects[i].x, badrects[i].y, badrects[i].x + badrects[i].width, badrects[i].y + badrects[i].height); + r.inset(insetAmount, insetAmount); + rgn->op(r, SkRegion::kUnion_Op); + bounds.join(r); + } + SkASSERT(bounds == rgn->getBounds()); + + for (i = 0; i < SK_ARRAY_COUNT(badrects); i++) + { + r.set(badrects[i].x, badrects[i].y, badrects[i].x + badrects[i].width, badrects[i].y + badrects[i].height); + SkASSERT(rgn->contains(r)); + } +} +#endif + +static void draw_rgn(const SkRegion& rgn, SkCanvas* canvas, const SkPaint& paint) +{ + SkRect r; + SkRegion::Iterator iter(rgn); + + for (; !iter.done(); iter.next()) + { + r.set(iter.rect()); + canvas->drawRect(r, paint); + } +} + +static void test_break(SkCanvas* canvas, const char text[], size_t length, + SkScalar x, SkScalar y, const SkPaint& paint, + SkScalar clickX) +{ + SkPaint linePaint; + + linePaint.setAntiAlias(true); + + SkScalar measured; + + if (paint.breakText(text, length, clickX - x, &measured, SkPaint::kForward_TextBufferDirection)) + { + linePaint.setColor(SK_ColorRED); + canvas->drawLine(x, y, x + measured, y, linePaint); + } + + x += paint.measureText(text, length); + if (paint.breakText(text, length, x - clickX, &measured, SkPaint::kBackward_TextBufferDirection)) + { + linePaint.setColor(SK_ColorBLUE); + canvas->drawLine(x - measured, y, x, y, linePaint); + } +} + +static void test_poly() +{ + static const SkPoint dst[] = { + SkIntToScalar(2), SkIntToScalar(1), + SkIntToScalar(5), SkIntToScalar(1), + SkIntToScalar(5), SkIntToScalar(3), + SkIntToScalar(2), SkIntToScalar(3) + }; + + static const SkPoint src[] = { + SkIntToScalar(0), SkIntToScalar(0), + SkIntToScalar(1), SkIntToScalar(0), + SkIntToScalar(1), SkIntToScalar(1), + SkIntToScalar(0), SkIntToScalar(1) + }; + + SkMatrix matrix; + + if (matrix.setPolyToPoly(src, dst, 4)) + { + SkPoint pt = { SK_Scalar1/2, SK_Scalar1/2 }; + matrix.mapPoints(&pt, 1); + printf("---- x = %g y = %g\n", SkScalarToFloat(pt.fX), SkScalarToFloat(pt.fY)); + } + else + printf("---- setPolyToPoly failed\n"); +} + +#include "SkColorShader.h" + +static void DrawTheText(SkCanvas* canvas, const char text[], size_t length, + SkScalar x, SkScalar y, const SkPaint& paint, + SkScalar clickX, SkMaskFilter* mf) +{ + SkPaint p(paint); + +#if 0 + canvas->drawText(text, length, x, y, paint); +#else + { + SkPoint pts[1000]; + SkScalar xpos = x; + SkASSERT(length <= SK_ARRAY_COUNT(pts)); + for (size_t i = 0; i < length; i++) + pts[i].set(xpos, y), xpos += paint.getTextSize(); + canvas->drawPosText(text, length, pts, paint); + } +#endif + + p.setSubpixelText(true); + x += SkIntToScalar(180); + canvas->drawText(text, length, x, y, p); + +#ifdef TEST_CLICKX + test_break(canvas, text, length, x, y, p, clickX); +#endif + +#ifdef SK_DEBUG + if (false) + { + SkColorShader shader; + p.setShader(&shader); + x += SkIntToScalar(180); + canvas->drawText(text, length, x, y, p); + p.setShader(NULL); + } + + if (true) + { + // p.setMaskFilter(mf); + p.setSubpixelText(false); + p.setLinearText(true); + x += SkIntToScalar(180); + canvas->drawText(text, length, x, y, p); + } +#endif +} + +class TextSpeedView : public SkView { +public: + TextSpeedView() + { + fMF = makemf(); + + fHints = 0; + + if (false) + { + static const char extra[] = { '.', ',', ':', ';', '!' }; + SkPaint paint, paint2; + + paint2.setTypeface(SkTypeface::Create(NULL, SkTypeface::kItalic))->unref(); + + for (int i = 0; i < 26; i++) + ::dump('a' + i, count_char_points(paint, 'a' + i), count_char_points(paint2, 'a' + i)); + for (int j = 0; j < SK_ARRAY_COUNT(extra); j++) + ::dump(extra[j], count_char_points(paint, extra[j]), count_char_points(paint2, extra[j])); + + printf("--- ave reduction = %g%%\n", 100. * (gOld - gNew) / gOld); + } + + if (true) + { + SkPoint pts[] = { SkIntToScalar(20), 0, SkIntToScalar(256+20), 0 }; + SkColor colors[] = { SkColorSetARGB(0, 255, 255, 255), SkColorSetARGB(255, 255, 255, 255) }; + fGradient = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + } + + fClickX = 0; + + test_breakText(); + test_typefaceCache(); + test_poly(); + } + + virtual ~TextSpeedView() + { + fGradient->unref(); + fMF->safeUnref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Text"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorWHITE); + // canvas->drawColor(SK_ColorBLACK); + } + + static void make_textstrip(SkBitmap* bm) + { + bm->setConfig(SkBitmap::kRGB_565_Config, 200, 18); + bm->allocPixels(); + bm->eraseColor(SK_ColorWHITE); + + SkCanvas canvas(*bm); + SkPaint paint; + const char* s = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit"; + + paint.setFlags(paint.getFlags() | SkPaint::kAntiAlias_Flag + | SkPaint::kDevKernText_Flag); + paint.setTextSize(SkIntToScalar(14)); + canvas.drawText(s, strlen(s), SkIntToScalar(8), SkIntToScalar(14), paint); + } + + static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand) + { + for (size_t i = 0; i < n; i++) + pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480); + } + + virtual void onDraw(SkCanvas* canvas) + { + if (false) + { + canvas->translate(SkIntToScalar(480), 0); + canvas->rotate(SkIntToScalar(90)); + } + + this->drawBG(canvas); + + if (false) + { + SkPaint p; + + p.setAntiAlias(true); + p.setSubpixelText(true); + // p.setLinearText(true); + + SkScalar size = SkIntToScalar(6); + SkMSec dur = 0; + const int LOOP = 16; + const int TIMES = 10; + + for (int times = 0; times < TIMES; times++) + { + SkMSec now = SkTime::GetMSecs(); + for (int loop = 0; loop < LOOP; loop++) + { + p.setTextSize(size); + size += SK_Scalar1/5; + canvas->drawText("Hamburgefons", 12, SkIntToScalar(10), SkIntToScalar(50), p); + } + dur += SkTime::GetMSecs() - now; + SkGraphics::SetFontCacheUsed(0); + } + + printf("----- duration = %g\n", dur * 1.0 / TIMES); + this->inval(NULL); + return; + } + + if (false) + { + SkPaint p; + p.setAntiAlias(true); + for (int i = 6; i <= 36; i++) + { + SkRect r; + SkPaint::FontMetrics m; + p.setTextSize(SkIntToScalar(i)); + p.getFontMetrics(&m); + int ascent = SkScalarRound(m.fAscent); + int descent = SkScalarRound(m.fDescent); + for (uint8_t c = ' '; c <= 127; c++) + { + p.getTextWidths(&c, 1, NULL, &r); + if (SkScalarRound(r.fTop) < ascent) + printf("PS %d --- %c [%d] top=%g, ascent=%g ymax=%g\n", i, c, c, + SkScalarToFloat(r.fTop), SkScalarToFloat(m.fAscent), SkScalarToFloat(m.fTop)); + if (SkScalarRound(r.fBottom) > descent) + printf("PS %d --- %c [%d] bottom=%g, descent=%g ymin=%g\n", i, c, c, + SkScalarToFloat(r.fBottom), SkScalarToFloat(m.fDescent), SkScalarToFloat(m.fBottom)); + } + } + } + + if (false) + { + SkPaint p; + p.setShader(fGradient); + +#ifdef SK_RELEASE + SkMSec now = SkTime::GetMSecs(); + for (int i = 0; i < 100; i++) +#endif + canvas->drawPaint(p); +#ifdef SK_RELEASE + printf("----- %d ms\n", SkTime::GetMSecs() - now); + this->inval(NULL); +#endif + return; + } + + if (false) + { + SkBitmap bm; + + make_textstrip(&bm); + canvas->translate(0, SkIntToScalar(50)); + for (int i = 0; i < 10; i++) + { + float gamma = 1 + i * 0.2f; + SkPowerMode mode(SkFloatToScalar(1 / gamma)); + SkPaint p; + p.setXfermode(&mode); + + canvas->drawBitmap(bm, 0, SkIntToScalar(i) * bm.height(), &p); + } + return; + } + + if (false) + { + SkPaint paint; + + paint.setAntiAlias(true); + paint.setDevKernText(true); + SkMSec now = SkTime::GetMSecs(); + for (int i = 0; i < 1000000; i++) + { + paint.measureText("Hamburgefons", 15, NULL, NULL); + } + printf("--------- measure %d\n", SkTime::GetMSecs() - now); + this->inval(NULL); + return; + } + + if (false) + { + SkRegion rgn; + SkPath path; + SkPaint paint; + + // make_badrgn(&rgn, -2); + + if (false) + { + paint.setColor(SK_ColorBLUE); + canvas->drawIRect(rgn.getBounds(), paint); + } + paint.setColor(SK_ColorRED); + draw_rgn(rgn, canvas, paint); + + rgn.getBoundaryPath(&path); + paint.setARGB(0x80, 0, 0, 0xFF); + canvas->drawPath(path, paint); + return; + } + + if (false) + { + SkRect r = { SkIntToScalar(50), SkIntToScalar(50), SkIntToScalar(300), SkIntToScalar(300) }; + SkPaint p; + + p.setStyle(SkPaint::kStroke_Style); + p.setAlpha(0x80); + p.setStrokeWidth(SkIntToScalar(20)); + canvas->drawRect(r, p); + } + + if (false) + { + SkPaint p; + SkRect r = { SkIntToScalar(100), SkIntToScalar(100), SkIntToScalar(104), SkIntToScalar(104) }; + // r.offset(SK_ScalarHalf, SK_ScalarHalf); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*2); + // p.setAntiAliasOn(true); + canvas->drawRect(r, p); + return; + } + + if (false) + { + Sk64 aa, bb; + int64_t a = (int64_t)6062080 * -30596; + int64_t b = (int64_t)4816896 * 57957; + aa.setMul(6062080, -30596); + bb.setMul(4816896, 57957); + + a += b; + b = a >> 16; + +// SkFixed c = aa.addGetFixed(bb); + + printf("%d %d\n", (int)a, a >> 32); + + SkBitmap bm; + SkPaint paint; + SkScalar scale = SkFloatToScalar(0.5625f); + SkScalar x = SkIntToScalar(100); + SkScalar y = SkIntToScalar(100); + + //paint.setFilterType(SkPaint::kBilinear_FilterType); + + SkImageDecoder::DecodeFile("/app_web_browser.png", &bm); + + // canvas->drawBitmap(bm, x, y, paint); + x += SkIntToScalar(100); + canvas->save(); + canvas->translate(x, y); + canvas->scale(SkIntToScalar(2)/1, SkIntToScalar(2)/1); + canvas->translate(-x, -y); + canvas->drawBitmap(bm, x, y, &paint); + canvas->restore(); + x += SkIntToScalar(100); + canvas->save(); + canvas->translate(x, y); + canvas->scale(scale, scale); + canvas->translate(-x, -y); + // canvas->drawBitmap(bm, x, y, paint); + canvas->restore(); + return; + } + + SkAutoCanvasRestore restore(canvas, false); + { + SkRect r; + r.set(0, 0, SkIntToScalar(1000), SkIntToScalar(20)); + // canvas->saveLayer(&r, NULL, SkCanvas::kHasAlphaLayer_SaveFlag); + } + + SkPaint paint; +// const uint16_t glyphs[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 }; + int index = fHints % SK_ARRAY_COUNT(gHints); + index = 1; +// const char* style = gHints[index].fName; + +// canvas->translate(0, SkIntToScalar(50)); + + // canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint); + +// paint.setTypeface(SkTypeface::Create(NULL, SkTypeface::kItalic))->unref(); + paint.setAntiAlias(true); + paint.setFlags(paint.getFlags() | gHints[index].fFlags); + + SkMSec now = 0; + if (REPEAT_COUNT > 1) + now = SkTime::GetMSecs(); + + SkRect clip; + clip.set(SkIntToScalar(25), SkIntToScalar(34), SkIntToScalar(88), SkIntToScalar(155)); + + if (0) { + canvas->clipRect(clip); + } + + if (0) { + SkPath clipPath; + clipPath.addOval(clip); + canvas->clipPath(clipPath); + } + + const char* text = "Hamburgefons"; + size_t length = strlen(text); + +#ifdef TEST_CLICKX + { + SkPaint p; + + p.setColor(SK_ColorGREEN); + p.setAntiAlias(true); + canvas->drawLine(fClickX, 0, fClickX, SkIntToScalar(1000), p); + } +#endif + + for (int j = 0; j < REPEAT_COUNT; j++) + { + SkScalar y = SkIntToScalar(0); + for (int i = 9; i <= 24; i++) { + paint.setTextSize(SkIntToScalar(i) /*+ (gRand.nextU() & 0xFFFF)*/); + for (SkScalar dx = 0; dx <= SkIntToScalar(3)/4; dx += SkIntToScalar(1) /* /4 */) + { + y += paint.getFontSpacing(); + DrawTheText(canvas, text, length, SkIntToScalar(20) + dx, y, paint, fClickX, fMF); + } + } + if (gHints[index].fFlushCache) { + SkGraphics::SetFontCacheUsed(0); + } + } + + if (REPEAT_COUNT > 1) + { + printf("--------- FPS = %g\n", REPEAT_COUNT * 1000. / (SkTime::GetMSecs() - now)); + this->inval(NULL); + } + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + fClickX = x; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + int fHints; + SkScalar fClickX; + SkMaskFilter* fMF; + SkShader* fGradient; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new TextSpeedView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleTextAlpha.cpp b/Samples/SampleTextAlpha.cpp new file mode 100644 index 0000000..f2a6530 --- /dev/null +++ b/Samples/SampleTextAlpha.cpp @@ -0,0 +1,123 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkBlurMaskFilter.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef.h" +#include "SkOSFile.h" +#include "SkStream.h" + +static void check_for_nonwhite(const SkBitmap& bm, int alpha) { + if (bm.config() != SkBitmap::kRGB_565_Config) { + return; + } + + for (int y = 0; y < bm.height(); y++) { + for (int x = 0; x < bm.width(); x++) { + uint16_t c = *bm.getAddr16(x, y); + if (c != 0xFFFF) { + SkDebugf("------ nonwhite alpha=%x [%d %d] %x\n", alpha, x, y, c); + return; + } + } + } +} + +class TextAlphaView : public SkView { +public: + TextAlphaView() { + fByte = 0xFF; + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SkString str("TextAlpha"); + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + const char* str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + SkPaint paint; + SkScalar x = SkIntToScalar(10); + SkScalar y = SkIntToScalar(20); + + paint.setFlags(0x105); + + paint.setARGB(fByte, 0xFF, 0xFF, 0xFF); + + paint.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3), + SkBlurMaskFilter::kNormal_BlurStyle)); + paint.getMaskFilter()->unref(); + + SkRandom rand; + + for (int ps = 6; ps <= 35; ps++) { + paint.setColor(rand.nextU() | (0xFF << 24)); + paint.setTextSize(SkIntToScalar(ps)); + paint.setTextSize(SkIntToScalar(24)); + canvas->drawText(str, strlen(str), x, y, paint); + y += paint.getFontMetrics(NULL); + } + //check_for_nonwhite(canvas->getDevice()->accessBitmap(), fByte); + //SkDebugf("------ byte %x\n", fByte); + + if (false) { + fByte += 1; + fByte &= 0xFF; + this->inval(NULL); + } + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + return new Click(this); + } + + virtual bool onClick(Click* click) { + int y = click->fICurr.fY; + if (y < 0) { + y = 0; + } else if (y > 255) { + y = 255; + } + fByte = y; + this->inval(NULL); + return true; + } + +private: + int fByte; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new TextAlphaView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleTextEffects.cpp b/Samples/SampleTextEffects.cpp new file mode 100644 index 0000000..b7a986f --- /dev/null +++ b/Samples/SampleTextEffects.cpp @@ -0,0 +1,467 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTypeface.h" +#include "SkAvoidXfermode.h" + +static inline SkPMColor rgb2gray(SkPMColor c) +{ + unsigned r = SkGetPackedR32(c); + unsigned g = SkGetPackedG32(c); + unsigned b = SkGetPackedB32(c); + + unsigned x = r * 5 + g * 7 + b * 4 >> 4; + + return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT)); +} + +class SkGrayScaleColorFilter : public SkColorFilter { +public: + virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) + { + for (int i = 0; i < count; i++) + result[i] = rgb2gray(src[i]); + } +}; + +class SkChannelMaskColorFilter : public SkColorFilter { +public: + SkChannelMaskColorFilter(U8CPU redMask, U8CPU greenMask, U8CPU blueMask) + { + fMask = SkPackARGB32(0xFF, redMask, greenMask, blueMask); + } + + virtual void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) + { + SkPMColor mask = fMask; + for (int i = 0; i < count; i++) + result[i] = src[i] & mask; + } + +private: + SkPMColor fMask; +}; + +/////////////////////////////////////////////////////////// + +#include "SkGradientShader.h" +#include "SkLayerRasterizer.h" +#include "SkBlurMaskFilter.h" + +static void r0(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setMaskFilter(SkBlurMaskFilter::Create(SkIntToScalar(3), + SkBlurMaskFilter::kNormal_BlurStyle))->unref(); + rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3)); + + p.setMaskFilter(NULL); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + rast->addLayer(p); + + p.setAlpha(0x11); + p.setStyle(SkPaint::kFill_Style); + p.setPorterDuffXfermode(SkPorterDuff::kSrc_Mode); + rast->addLayer(p); +} + +static void r1(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + p.setAlpha(0x40); + p.setPorterDuffXfermode(SkPorterDuff::kSrc_Mode); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*2); + rast->addLayer(p); +} + +static void r2(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setStyle(SkPaint::kStrokeAndFill_Style); + p.setStrokeWidth(SK_Scalar1*4); + rast->addLayer(p); + + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*3/2); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); +} + +static void r3(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1*3); + rast->addLayer(p); + + p.setAlpha(0x20); + p.setStyle(SkPaint::kFill_Style); + p.setPorterDuffXfermode(SkPorterDuff::kSrc_Mode); + rast->addLayer(p); +} + +static void r4(SkLayerRasterizer* rast, SkPaint& p) +{ + p.setAlpha(0x60); + rast->addLayer(p, SkIntToScalar(3), SkIntToScalar(3)); + + p.setAlpha(0xFF); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2); + + p.setXfermode(NULL); + rast->addLayer(p); +} + +#include "SkDiscretePathEffect.h" + +static void r5(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + p.setPathEffect(new SkDiscretePathEffect(SK_Scalar1*4, SK_Scalar1*3))->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kSrcOut_Mode); + rast->addLayer(p); +} + +static void r6(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + p.setAntiAlias(false); + SkLayerRasterizer* rast2 = new SkLayerRasterizer; + r5(rast2, p); + p.setRasterizer(rast2)->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); +} + +#include "Sk2DPathEffect.h" + +class Dot2DPathEffect : public Sk2DPathEffect { +public: + Dot2DPathEffect(SkScalar radius, const SkMatrix& matrix) + : Sk2DPathEffect(matrix), fRadius(radius) {} + + virtual void flatten(SkFlattenableWriteBuffer& buffer) + { + this->INHERITED::flatten(buffer); + + buffer.writeScalar(fRadius); + } + virtual Factory getFactory() { return CreateProc; } + +protected: + virtual void next(const SkPoint& loc, int u, int v, SkPath* dst) + { + dst->addCircle(loc.fX, loc.fY, fRadius); + } + + Dot2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) + { + fRadius = buffer.readScalar(); + } +private: + SkScalar fRadius; + + static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) + { + return new Dot2DPathEffect(buffer); + } + + typedef Sk2DPathEffect INHERITED; +}; + +static void r7(SkLayerRasterizer* rast, SkPaint& p) +{ + SkMatrix lattice; + lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); + lattice.postSkew(SK_Scalar1/3, 0, 0, 0); + p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*4, lattice))->unref(); + rast->addLayer(p); +} + +static void r8(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + SkMatrix lattice; + lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0); + lattice.postSkew(SK_Scalar1/3, 0, 0, 0); + p.setPathEffect(new Dot2DPathEffect(SK_Scalar1*2, lattice))->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); + + p.setPathEffect(NULL); + p.setXfermode(NULL); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + rast->addLayer(p); +} + +class Line2DPathEffect : public Sk2DPathEffect { +public: + Line2DPathEffect(SkScalar width, const SkMatrix& matrix) + : Sk2DPathEffect(matrix), fWidth(width) {} + + virtual bool filterPath(SkPath* dst, const SkPath& src, SkScalar* width) + { + if (this->INHERITED::filterPath(dst, src, width)) + { + *width = fWidth; + return true; + } + return false; + } + + virtual Factory getFactory() { return CreateProc; } + virtual void flatten(SkFlattenableWriteBuffer& buffer) + { + this->INHERITED::flatten(buffer); + buffer.writeScalar(fWidth); + } +protected: + virtual void nextSpan(int u, int v, int ucount, SkPath* dst) + { + if (ucount > 1) + { + SkPoint src[2], dstP[2]; + + src[0].set(SkIntToScalar(u) + SK_ScalarHalf, + SkIntToScalar(v) + SK_ScalarHalf); + src[1].set(SkIntToScalar(u+ucount) + SK_ScalarHalf, + SkIntToScalar(v) + SK_ScalarHalf); + this->getMatrix().mapPoints(dstP, src, 2); + + dst->moveTo(dstP[0]); + dst->lineTo(dstP[1]); + } + } + + Line2DPathEffect::Line2DPathEffect(SkFlattenableReadBuffer& buffer) : Sk2DPathEffect(buffer) + { + fWidth = buffer.readScalar(); + } + +private: + SkScalar fWidth; + + static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) + { + return new Line2DPathEffect(buffer); + } + + typedef Sk2DPathEffect INHERITED; +}; + +static void r9(SkLayerRasterizer* rast, SkPaint& p) +{ + rast->addLayer(p); + + SkMatrix lattice; + lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0); + lattice.postRotate(SkIntToScalar(30), 0, 0); + p.setPathEffect(new Line2DPathEffect(SK_Scalar1*2, lattice))->unref(); + p.setPorterDuffXfermode(SkPorterDuff::kClear_Mode); + rast->addLayer(p); + + p.setPathEffect(NULL); + p.setXfermode(NULL); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + rast->addLayer(p); +} + +typedef void (*raster_proc)(SkLayerRasterizer*, SkPaint&); + +static const raster_proc gRastProcs[] = { + r0, r1, r2, r3, r4, r5, r6, r7, r8, r9 +}; + +static const struct { + SkColor fMul, fAdd; +} gLightingColors[] = { + { 0x808080, 0x800000 }, // general case + { 0x707070, 0x707070 }, // no-pin case + { 0xFFFFFF, 0x800000 }, // just-add case + { 0x808080, 0x000000 }, // just-mul case + { 0xFFFFFF, 0x000000 } // identity case +}; + +#include "SkXfermode.h" + +static unsigned color_dist16(uint16_t a, uint16_t b) +{ + unsigned dr = SkAbs32(SkPacked16ToR32(a) - SkPacked16ToR32(b)); + unsigned dg = SkAbs32(SkPacked16ToG32(a) - SkPacked16ToG32(b)); + unsigned db = SkAbs32(SkPacked16ToB32(a) - SkPacked16ToB32(b)); + + return SkMax32(dr, SkMax32(dg, db)); +} + +static unsigned scale_dist(unsigned dist, unsigned scale) +{ + dist >>= 6; + dist = (dist << 2) | dist; + dist = (dist << 4) | dist; + return dist; + +// return SkAlphaMul(dist, scale); +} + +static void apply_shader(SkPaint* paint, int index) +{ + raster_proc proc = gRastProcs[index]; + if (proc) + { + SkPaint p; + SkLayerRasterizer* rast = new SkLayerRasterizer; + + p.setAntiAlias(true); + proc(rast, p); + paint->setRasterizer(rast)->unref(); + } + +#if 0 + SkScalar dir[] = { SK_Scalar1, SK_Scalar1, SK_Scalar1 }; + paint->setMaskFilter(SkBlurMaskFilter::CreateEmboss(dir, SK_Scalar1/4, SkIntToScalar(4), SkIntToScalar(3)))->unref(); +#endif + paint->setColor(SK_ColorBLUE); +} + +static int gRastIndex; + +class TextEffectView : public SkView { + SkTypeface* fFace; +public: + TextEffectView() + { + fFace = SkTypeface::CreateFromFile("/Computerfont.ttf"); + } + + virtual ~TextEffectView() + { + fFace->safeUnref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) + { + if (SampleCode::TitleQ(*evt)) + { + SampleCode::TitleR(evt, "Text Effects"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) + { +// canvas->drawColor(0xFFDDDDDD); + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) + { + this->drawBG(canvas); + + canvas->save(); +// canvas->scale(SK_Scalar1*2, SK_Scalar1*2, 0, 0); + + SkScalar x = SkIntToScalar(20); + SkScalar y = SkIntToScalar(40); + SkPaint paint; + + paint.setAntiAlias(true); + paint.setTextSize(SkIntToScalar(48)); + paint.setTypeface(SkTypeface::Create("sans-serif", SkTypeface::kBold)); + + SkString str("GOOGLE "); + str.appendUnichar(0x5700); + + paint.setTypeface(fFace); + + for (int i = 0; i < SK_ARRAY_COUNT(gRastProcs); i++) + { + apply_shader(&paint, i); + + // paint.setMaskFilter(NULL); + // paint.setColor(SK_ColorBLACK); + +#if 0 + int index = i % SK_ARRAY_COUNT(gLightingColors); + paint.setColorFilter(SkColorFilter::CreateLightingFilter( + gLightingColors[index].fMul, + gLightingColors[index].fAdd))->unref(); +#endif + + canvas->drawText(str.c_str(), str.size(), x, y, paint); + + if (0) + { + SkPath path; + paint.getTextPath(str.c_str(), str.size(), x + SkIntToScalar(260), y, &path); + canvas->drawPath(path, paint); + } + + y += paint.getFontSpacing(); + } + + canvas->restore(); + + if (0) + { + SkPoint pts[] = { 0, 0, 0, SkIntToScalar(150) }; + SkColor colors[] = { 0xFFE6E6E6, 0xFFFFFFFF }; + SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, SkShader::kClamp_TileMode); + + paint.reset(); + paint.setShader(s); + canvas->drawRectCoords(0, 0, SkIntToScalar(120), SkIntToScalar(150), paint); + } + + if (1) + { + SkAvoidXfermode mode(SK_ColorWHITE, 0xFF, + SkAvoidXfermode::kTargetColor_Mode); + SkPaint paint; + x += SkIntToScalar(20); + SkRect r = { x, 0, x + SkIntToScalar(360), SkIntToScalar(700) }; + paint.setXfermode(&mode); + paint.setColor(SK_ColorGREEN); + paint.setAntiAlias(true); + canvas->drawOval(r, paint); + } + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) + { + gRastIndex = (gRastIndex + 1) % SK_ARRAY_COUNT(gRastProcs); + this->inval(NULL); + + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) + { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new TextEffectView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleTextOnPath.cpp b/Samples/SampleTextOnPath.cpp new file mode 100644 index 0000000..382b4d9 --- /dev/null +++ b/Samples/SampleTextOnPath.cpp @@ -0,0 +1,443 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPackBits.h" +#include "SkPath.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTypeface.h" +#include "SkAvoidXfermode.h" + +#define REPEAT_COUNT 1 + +static const char gText[] = "Hamburgefons"; + +static bool gDevKern; + +static void rand_text(char text[], SkRandom& rand, size_t count) { + for (size_t i = 0; i < count; i++) { + text[i] = rand.nextU() & 0x7F; + } +} + +static SkScalar sum_widths(const SkScalar widths[], int count) { + SkScalar w = 0; + for (int i = 0; i < count; i++) { + w += widths[i]; + } + return w; +} + +static void test_measure(const SkPaint& paint) { + char text[256]; + SkScalar widths[256]; + SkRect rects[256]; + SkRect bounds; + int count = 256; + + SkRandom rand; + + for (int i = 0; i < 100; i++) { + rand_text(text, rand, 256); + paint.getTextWidths(text, count, widths, NULL); + SkScalar tw0 = sum_widths(widths, count); + paint.getTextWidths(text, count, widths, rects); + SkScalar tw1 = sum_widths(widths, count); + SkASSERT(tw0 == tw1); + + SkScalar w0 = paint.measureText(text, count, NULL); + SkScalar w1 = paint.measureText(text, count, &bounds); + SkASSERT(w0 == w1); + SkASSERT(w0 == tw0); + + SkRect r = rects[0]; + SkScalar x = 0; + for (int j = 1; j < count; j++) { + x += widths[j-1]; + rects[j].offset(x, 0); + r.join(rects[j]); + } + SkASSERT(r == bounds); + + if (r != bounds) { + printf("flags=%x i=%d [%g %g %g %g] [%g %g %g %g]\n", + paint.getFlags(), i, + SkScalarToFloat(r.fLeft), + SkScalarToFloat(r.fTop), + SkScalarToFloat(r.fRight), + SkScalarToFloat(r.fBottom), + SkScalarToFloat(bounds.fLeft), + SkScalarToFloat(bounds.fTop), + SkScalarToFloat(bounds.fRight), + SkScalarToFloat(bounds.fBottom)); + } + } +} + +static void test_measure() { + SkPaint paint; + + for (int i = 0; i <= SkPaint::kAllFlags; i++) { + paint.setFlags(i); + test_measure(paint); + } +} + +////////////////////////////////////////////////////////////////////////////// + +static void test_textBounds(SkCanvas* canvas) { +// canvas->scale(SK_Scalar1/2, SK_Scalar1/2); + +// canvas->rotate(SkIntToScalar(30)); + + gDevKern = !gDevKern; + + SkScalar x = SkIntToScalar(50); + SkScalar y = SkIntToScalar(150); + SkScalar w[100]; + SkRect r[100], bounds; + + SkPaint paint; + paint.setTextSize(SkIntToScalar(64)); + paint.setAntiAlias(true); + paint.setDevKernText(gDevKern); + + (void)paint.measureText(gText, strlen(gText), &bounds, NULL); + paint.setColor(SK_ColorGREEN); + bounds.offset(x, y); + canvas->drawRect(bounds, paint); + + int count = paint.getTextWidths(gText, strlen(gText), w, r); + + paint.setColor(SK_ColorRED); + for (int i = 0; i < count; i++) { + r[i].offset(x, y); + canvas->drawRect(r[i], paint); + x += w[i]; + } + x = SkIntToScalar(50); + paint.setColor(gDevKern ? SK_ColorDKGRAY : SK_ColorBLACK); + canvas->drawText(gText, strlen(gText), x, y, paint); +} + +static void create_src(SkBitmap* bitmap, SkBitmap::Config config) { + bitmap->setConfig(config, 100, 100); + bitmap->allocPixels(); + bitmap->eraseColor(0); + + SkCanvas canvas(*bitmap); + SkPaint paint; + + paint.setAntiAlias(true); + canvas.drawCircle(SkIntToScalar(50), SkIntToScalar(50), + SkIntToScalar(50), paint); +} + +static void blur(SkBitmap* dst, const SkBitmap& src, SkScalar radius) { + *dst = src; +} + +static void test_bitmap_blur(SkCanvas* canvas) { + SkBitmap src, dst; + + create_src(&src, SkBitmap::kARGB_8888_Config); + blur(&dst, src, SkIntToScalar(4)); + + SkPaint paint; + + paint.setColor(SK_ColorRED); + + canvas->drawBitmap(dst, SkIntToScalar(30), SkIntToScalar(60), &paint); +} + +static SkScalar getpathlen(const SkPath& path) { + SkPathMeasure meas(path, false); + return meas.getLength(); +} + +static void test_textpathmatrix(SkCanvas* canvas) { + SkPaint paint; + SkPath path; + SkMatrix matrix; + + path.moveTo(SkIntToScalar(200), SkIntToScalar(300)); + path.quadTo(SkIntToScalar(400), SkIntToScalar(100), + SkIntToScalar(600), SkIntToScalar(300)); + + paint.setAntiAlias(true); + + paint.setStyle(SkPaint::kStroke_Style); + canvas->drawPath(path, paint); + paint.setStyle(SkPaint::kFill_Style); + paint.setTextSize(SkIntToScalar(48)); + paint.setTextAlign(SkPaint::kRight_Align); + + const char* text = "Android"; + size_t len = strlen(text); + SkScalar pathLen = getpathlen(path); + + canvas->drawTextOnPath(text, len, path, NULL, paint); + + paint.setColor(SK_ColorRED); + matrix.setScale(-SK_Scalar1, SK_Scalar1); + matrix.postTranslate(pathLen, 0); + canvas->drawTextOnPath(text, len, path, &matrix, paint); + + paint.setColor(SK_ColorBLUE); + matrix.setScale(SK_Scalar1, -SK_Scalar1); + canvas->drawTextOnPath(text, len, path, &matrix, paint); + + paint.setColor(SK_ColorGREEN); + matrix.setScale(-SK_Scalar1, -SK_Scalar1); + matrix.postTranslate(pathLen, 0); + canvas->drawTextOnPath(text, len, path, &matrix, paint); +} + +class TextOnPathView : public SkView { +public: + SkPath fPath; + SkScalar fHOffset; + + TextOnPathView() { + SkRect r; + r.set(SkIntToScalar(100), SkIntToScalar(100), + SkIntToScalar(300), SkIntToScalar(300)); + fPath.addOval(r); + + fHOffset = SkIntToScalar(50); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Text On Path"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); +#if 0 + SkRect r; + SkPaint p; + SkRandom rand; + p.setAntiAlias(true); + + for (int i = 0; i < 100; i++) { + SkScalar x = rand.nextUScalar1() * 300 + SkIntToScalar(50); + SkScalar y = rand.nextUScalar1() * 200 + SkIntToScalar(50); + SkScalar w = rand.nextUScalar1() * 10; + SkScalar h = rand.nextUScalar1() * 10; + r.set(x, y, x + w, y + h); + canvas->drawRect(r, p); + } + + test_textBounds(canvas); +// return; + + SkBitmap bm; + if (SkImageDecoder::DecodeFile("/loading_tile.png", + &bm, SkBitmap::kRGB_565_Config, true)) + canvas->drawBitmap(bm, 0, 0); +#endif + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkPaint paint; + + paint.setAntiAlias(true); + paint.setTextSize(SkIntToScalar(50)); + + for (int j = 0; j < REPEAT_COUNT; j++) { + SkScalar x = fHOffset; + + paint.setColor(SK_ColorBLACK); + canvas->drawTextOnPathHV(gText, sizeof(gText)-1, fPath, + x, paint.getTextSize()/2, paint); + + paint.setColor(SK_ColorRED); + canvas->drawTextOnPathHV(gText, sizeof(gText)-1, fPath, + x + SkIntToScalar(50), 0, paint); + + paint.setColor(SK_ColorBLUE); + canvas->drawTextOnPathHV(gText, sizeof(gText)-1, fPath, + x + SkIntToScalar(100), -paint.getTextSize()/2, paint); + } + + paint.setColor(SK_ColorGREEN); + paint.setStyle(SkPaint::kStroke_Style); + canvas->drawPath(fPath, paint); + + canvas->translate(SkIntToScalar(200), 0); + test_textpathmatrix(canvas); + + test_bitmap_blur(canvas); + + if (REPEAT_COUNT > 1) + this->inval(NULL); + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + fHints += 1; + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + int fHints; + typedef SkView INHERITED; +}; + +static const uint16_t gTest0[] = { 0, 0, 1, 1 }; +static const uint16_t gTest1[] = { 1, 2, 3, 4, 5, 6 }; +static const uint16_t gTest2[] = { 0, 0, 0, 1, 2, 3, 3, 3 }; +static const uint16_t gTest3[] = { 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 0, 0, 1 }; + +#include "SkRandom.h" +static SkRandom gRand; +static void rand_fill(uint16_t buffer[], int count) { + for (int i = 0; i < count; i++) + buffer[i] = (uint16_t)gRand.nextU(); +} + +static void test_pack16() { + static const struct { + const uint16_t* fSrc; + int fCount; + } gTests[] = { + { gTest0, SK_ARRAY_COUNT(gTest0) }, + { gTest1, SK_ARRAY_COUNT(gTest1) }, + { gTest2, SK_ARRAY_COUNT(gTest2) }, + { gTest3, SK_ARRAY_COUNT(gTest3) } + }; + + for (size_t i = 0; i < SK_ARRAY_COUNT(gTests); i++) { + uint8_t dst[100]; + size_t dstSize = SkPackBits::Pack16(gTests[i].fSrc, + gTests[i].fCount, dst); + printf("Test[%d] orig size = %d, dst size = %d", + i, gTests[i].fCount, (int)dstSize); + uint16_t src[100]; + int srcCount = SkPackBits::Unpack16(dst, dstSize, src); + printf(", src size = %d", srcCount); + bool match = gTests[i].fCount == srcCount && memcmp(gTests[i].fSrc, src, + gTests[i].fCount * sizeof(uint16_t)) == 0; + printf(", match = %d\n", match); + } + + for (int n = 1000; n; n--) { + size_t size = 50; + uint16_t src[100], src2[100]; + uint8_t dst[200]; + rand_fill(src, size); + + size_t dstSize = SkPackBits::Pack16(src, size, dst); + size_t maxSize = SkPackBits::ComputeMaxSize16(size); + SkASSERT(maxSize >= dstSize); + + int srcCount = SkPackBits::Unpack16(dst, dstSize, src2); + SkASSERT(size == srcCount); + bool match = memcmp(src, src2, size * sizeof(uint16_t)) == 0; + SkASSERT(match); + } +} + +static const uint8_t gTest80[] = { 0, 0, 1, 1 }; +static const uint8_t gTest81[] = { 1, 2, 3, 4, 5, 6 }; +static const uint8_t gTest82[] = { 0, 0, 0, 1, 2, 3, 3, 3 }; +static const uint8_t gTest83[] = { 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 0, 0, 1 }; +static const uint8_t gTest84[] = { 1, 0, 3, 0, 0, 0, 2, 1, 1, 2 }; + +static void rand_fill(uint8_t buffer[], int count) { + for (int i = 0; i < count; i++) + buffer[i] = (uint8_t)((gRand.nextU() >> 8) & 0x3); +} + +static void test_pack8() { + static const struct { + const uint8_t* fSrc; + int fCount; + } gTests[] = { + { gTest80, SK_ARRAY_COUNT(gTest80) }, + { gTest81, SK_ARRAY_COUNT(gTest81) }, + { gTest82, SK_ARRAY_COUNT(gTest82) }, + { gTest83, SK_ARRAY_COUNT(gTest83) }, + { gTest84, SK_ARRAY_COUNT(gTest84) } + }; + + for (size_t i = 4; i < SK_ARRAY_COUNT(gTests); i++) { + uint8_t dst[100]; + size_t maxSize = SkPackBits::ComputeMaxSize8(gTests[i].fCount); + size_t dstSize = SkPackBits::Pack8(gTests[i].fSrc, + gTests[i].fCount, dst); + SkASSERT(dstSize <= maxSize); + printf("Test[%d] orig size = %d, dst size = %d", i, + gTests[i].fCount, (int)dstSize); + uint8_t src[100]; + int srcCount = SkPackBits::Unpack8(dst, dstSize, src); + printf(", src size = %d", srcCount); + bool match = gTests[i].fCount == srcCount && + memcmp(gTests[i].fSrc, src, + gTests[i].fCount * sizeof(uint8_t)) == 0; + printf(", match = %d\n", match); + } + + for (size_t size = 1; size <= 512; size += 1) { + for (int n = 200; n; n--) { + uint8_t src[600], src2[600]; + uint8_t dst[600]; + rand_fill(src, size); + + size_t dstSize = SkPackBits::Pack8(src, size, dst); + size_t maxSize = SkPackBits::ComputeMaxSize8(size); + SkASSERT(maxSize >= dstSize); + + int srcCount = SkPackBits::Unpack8(dst, dstSize, src2); + SkASSERT(size == srcCount); + bool match = memcmp(src, src2, size * sizeof(uint8_t)) == 0; + SkASSERT(match); + + for (int j = 0; j < 200; j++) { + size_t skip = gRand.nextU() % size; + size_t write = gRand.nextU() % size; + if (skip + write > size) { + write = size - skip; + } + SkPackBits::Unpack8(src, skip, write, dst); + bool match = memcmp(src, src2 + skip, write) == 0; + SkASSERT(match); + } + } + } +} + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { + static bool gOnce; + if (!gOnce) { +// test_pack8(); + gOnce = true; + } + return new TextOnPathView; +} + +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleTiling.cpp b/Samples/SampleTiling.cpp new file mode 100644 index 0000000..559d9d4 --- /dev/null +++ b/Samples/SampleTiling.cpp @@ -0,0 +1,171 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkPaint.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTypeface.h" + +// effects +#include "SkGradientShader.h" +#include "SkShaderExtras.h" +#include "SkUnitMappers.h" +#include "SkBlurDrawLooper.h" + +static void makebm(SkBitmap* bm, SkBitmap::Config config, int w, int h) { + bm->setConfig(config, w, h); + bm->allocPixels(); + bm->eraseColor(0); + + SkCanvas canvas(*bm); + SkPoint pts[] = { 0, 0, SkIntToScalar(w), SkIntToScalar(h) }; + SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE }; + SkScalar pos[] = { 0, SK_Scalar1/2, SK_Scalar1 }; + SkPaint paint; + + SkUnitMapper* um = NULL; + + um = new SkCosineMapper; +// um = new SkDiscreteMapper(12); + + SkAutoUnref au(um); + + paint.setDither(true); + paint.setShader(SkGradientShader::CreateLinear(pts, colors, pos, + SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode, um))->unref(); + canvas.drawPaint(paint); +} + +static void setup(SkPaint* paint, const SkBitmap& bm, bool filter, + SkShader::TileMode tmx, SkShader::TileMode tmy) { + SkShader* shader = SkShader::CreateBitmapShader(bm, tmx, tmy); + paint->setShader(shader)->unref(); + paint->setFilterBitmap(filter); +} + +static const SkBitmap::Config gConfigs[] = { + SkBitmap::kARGB_8888_Config, + SkBitmap::kRGB_565_Config, + SkBitmap::kARGB_4444_Config +}; +static const int gWidth = 32; +static const int gHeight = 32; + +class TilingView : public SkView { + SkBlurDrawLooper fLooper; +public: + TilingView() + : fLooper(SkIntToScalar(1), SkIntToScalar(2), SkIntToScalar(2), + 0x88000000) { + for (int i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) { + makebm(&fTexture[i], gConfigs[i], gWidth, gHeight); + } + } + + SkBitmap fTexture[SK_ARRAY_COUNT(gConfigs)]; + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Tiling"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkRect r = { 0, 0, SkIntToScalar(gWidth*2), SkIntToScalar(gHeight*2) }; + + static const char* gConfigNames[] = { "8888", "565", "4444" }; + + static const bool gFilters[] = { false, true }; + static const char* gFilterNames[] = { "point", "bilinear" }; + + static const SkShader::TileMode gModes[] = { SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode }; + static const char* gModeNames[] = { "C", "R", "M" }; + + SkScalar y = SkIntToScalar(24); + SkScalar x = SkIntToScalar(10); + + for (int kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) { + for (int ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) { + SkPaint p; + SkString str; + p.setAntiAlias(true); + p.setDither(true); + p.setLooper(&fLooper); + str.printf("[%s,%s]", gModeNames[kx], gModeNames[ky]); + + p.setTextAlign(SkPaint::kCenter_Align); + canvas->drawText(str.c_str(), str.size(), x + r.width()/2, y, p); + + x += r.width() * 4 / 3; + } + } + + y += SkIntToScalar(16); + + for (int i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) { + for (int j = 0; j < SK_ARRAY_COUNT(gFilters); j++) { + x = SkIntToScalar(10); + for (int kx = 0; kx < SK_ARRAY_COUNT(gModes); kx++) { + for (int ky = 0; ky < SK_ARRAY_COUNT(gModes); ky++) { + SkPaint paint; + setup(&paint, fTexture[i], gFilters[j], gModes[kx], gModes[ky]); + paint.setDither(true); + + canvas->save(); + canvas->translate(x, y); + canvas->drawRect(r, paint); + canvas->restore(); + + x += r.width() * 4 / 3; + } + } + { + SkPaint p; + SkString str; + p.setAntiAlias(true); + p.setLooper(&fLooper); + str.printf("%s, %s", gConfigNames[i], gFilterNames[j]); + canvas->drawText(str.c_str(), str.size(), x, y + r.height() * 2 / 3, p); + } + + y += r.height() * 4 / 3; + } + } + + #ifdef SK_RELEASE + this->inval(NULL); + #endif + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + this->inval(NULL); + return this->INHERITED::onFindClickHandler(x, y); + } + + virtual bool onClick(Click* click) { + return this->INHERITED::onClick(click); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new TilingView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleTypeface.cpp b/Samples/SampleTypeface.cpp new file mode 100644 index 0000000..e78c525 --- /dev/null +++ b/Samples/SampleTypeface.cpp @@ -0,0 +1,92 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkTypeface.h" +#include "SkPath.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "Sk1DPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkPathMeasure.h" +#include "SkRandom.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkDither.h" + +static const struct { + const char* fName; + SkTypeface::Style fStyle; +} gFaces[] = { + { NULL, SkTypeface::kNormal }, + { NULL, SkTypeface::kBold }, + { "serif", SkTypeface::kNormal }, + { "serif", SkTypeface::kBold }, + { "serif", SkTypeface::kItalic }, + { "serif", SkTypeface::kBoldItalic }, + { "monospace", SkTypeface::kNormal } +}; + +static const int gFaceCount = SK_ARRAY_COUNT(gFaces); + +class TypefaceView : public SkView { + SkTypeface* fFaces[gFaceCount]; + +public: + TypefaceView() { + for (int i = 0; i < gFaceCount; i++) { + fFaces[i] = SkTypeface::Create(gFaces[i].fName, gFaces[i].fStyle); + } + } + + virtual ~TypefaceView() { + for (int i = 0; i < gFaceCount; i++) { + fFaces[i]->safeUnref(); + } + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Typefaces"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(0xFFDDDDDD); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + SkPaint paint; + paint.setAntiAlias(true); + paint.setTextSize(SkIntToScalar(30)); + + const char* text = "Hamburgefons"; + const size_t textLen = strlen(text); + + SkScalar x = SkIntToScalar(10); + SkScalar dy = paint.getFontMetrics(NULL); + SkScalar y = dy; + + for (int i = 0; i < gFaceCount; i++) { + paint.setTypeface(fFaces[i]); + canvas->drawText(text, textLen, x, y, paint); + y += dy; + } + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new TypefaceView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleVertices.cpp b/Samples/SampleVertices.cpp new file mode 100644 index 0000000..54dada2 --- /dev/null +++ b/Samples/SampleVertices.cpp @@ -0,0 +1,279 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkPath.h" +#include "SkPorterDuff.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkXfermode.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" + +#include "SkImageRef.h" +#include "SkOSFile.h" +#include "SkStream.h" +#include "SkNinePatch.h" + +void setup_vertexbug(SkPoint verts[], SkPoint texs[], uint16_t index[]); + +static void drawbug(SkCanvas* canvas, SkScalar scale) { + SkBitmap bm, bm2; + + SkImageDecoder::DecodeFile("/skimages/btn_default_normal.9.png", &bm); + SkPaint paint; + + SkIRect subset; + subset.set(1, 1, bm.width() - 1, bm.height() - 1); + bm.extractSubset(&bm2, subset); + +#if 0 + SkPoint verts[16], texs[16]; + uint16_t index[54]; + + SkShader* s = SkShader::CreateBitmapShader(bm2, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode); + paint.setShader(s)->unref(); + + setup_vertexbug(verts, texs, index); + int indexCount = 6; // 54 + canvas->drawVertices(SkCanvas::kTriangles_VertexMode, 16, verts, texs, + NULL, NULL, &index[6], indexCount, paint); + +#if 0 + paint.setShader(NULL); + canvas->drawVertices(SkCanvas::kTriangles_VertexMode, 16, verts, NULL, + NULL, NULL, index, indexCount, paint); +#endif +#else + SkRect dst; + SkIRect margin; + + dst.set(SkIntToScalar(10), SkIntToScalar(10), + SkIntToScalar(100) + scale, + SkIntToScalar(40) + scale); + margin.set(9, 9, 9, 9); + SkNinePatch::DrawNine(canvas, dst, bm2, margin, NULL); +#endif +} + +static SkShader* make_shader0(SkIPoint* size) { + SkBitmap bm; + + SkImageDecoder::DecodeFile("/skimages/logo.gif", &bm); + size->set(bm.width(), bm.height()); + return SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode, + SkShader::kClamp_TileMode); +} + +static SkShader* make_shader1(const SkIPoint& size) { + SkPoint pts[] = { 0, 0, SkIntToScalar(size.fX), SkIntToScalar(size.fY) }; + SkColor colors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorRED }; + return SkGradientShader::CreateLinear(pts, colors, NULL, + SK_ARRAY_COUNT(colors), SkShader::kMirror_TileMode, NULL); +} + +class VerticesView : public SkView { + SkShader* fShader0; + SkShader* fShader1; + +public: + VerticesView() { + SkIPoint size; + + fShader0 = make_shader0(&size); + fShader1 = make_shader1(size); + + make_strip(&fRecs[0], size.fX, size.fY); + make_fan(&fRecs[1], size.fX, size.fY); + make_tris(&fRecs[2]); + + fScale = SK_Scalar1; + } + + virtual ~VerticesView() { + fShader0->safeUnref(); + fShader1->safeUnref(); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) + { + SkString str("Vertices"); + SampleCode::TitleR(evt, str.c_str()); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorGRAY); + } + + SkScalar fScale; + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + +#if 1 + canvas->drawColor(SK_ColorWHITE); + canvas->translate(SK_Scalar1/2, SkIntToScalar(15) + SK_Scalar1/2); + canvas->scale(SkIntToScalar(3)/2, SkIntToScalar(3)/2); + drawbug(canvas, fScale); + fScale += SK_Scalar1/93; + this->inval(NULL); + return; +#endif + + SkPaint paint; + paint.setDither(true); + paint.setFilterBitmap(true); + + for (int i = 0; i < SK_ARRAY_COUNT(fRecs); i++) { + canvas->save(); + + paint.setShader(NULL); + canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount, + fRecs[i].fVerts, fRecs[i].fTexs, + NULL, NULL, NULL, 0, paint); + + canvas->translate(SkIntToScalar(250), 0); + + paint.setShader(fShader0); + canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount, + fRecs[i].fVerts, fRecs[i].fTexs, + NULL, NULL, NULL, 0, paint); + + canvas->translate(SkIntToScalar(250), 0); + + paint.setShader(fShader1); + canvas->drawVertices(fRecs[i].fMode, fRecs[i].fCount, + fRecs[i].fVerts, fRecs[i].fTexs, + NULL, NULL, NULL, 0, paint); + canvas->restore(); + + canvas->translate(0, SkIntToScalar(250)); + } + } + + virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) { + return new Click(this); + } + + virtual bool onClick(Click* click) { + // fCurrX = click->fICurr.fX; + // fCurrY = click->fICurr.fY; + this->inval(NULL); + return true; + } + +private: + struct Rec { + SkCanvas::VertexMode fMode; + int fCount; + SkPoint* fVerts; + SkPoint* fTexs; + + Rec() : fCount(0), fVerts(NULL), fTexs(NULL) {} + ~Rec() { delete[] fVerts; delete[] fTexs; } + }; + + void make_tris(Rec* rec) { + int n = 10; + SkRandom rand; + + rec->fMode = SkCanvas::kTriangles_VertexMode; + rec->fCount = n * 3; + rec->fVerts = new SkPoint[rec->fCount]; + + for (int i = 0; i < n; i++) { + SkPoint* v = &rec->fVerts[i*3]; + for (int j = 0; j < 3; j++) { + v[j].set(rand.nextUScalar1() * 250, rand.nextUScalar1() * 250); + } + } + } + + void make_fan(Rec* rec, int texWidth, int texHeight) { + const SkScalar tx = SkIntToScalar(texWidth); + const SkScalar ty = SkIntToScalar(texHeight); + const int n = 24; + + rec->fMode = SkCanvas::kTriangleFan_VertexMode; + rec->fCount = n + 2; + rec->fVerts = new SkPoint[rec->fCount]; + rec->fTexs = new SkPoint[rec->fCount]; + + SkPoint* v = rec->fVerts; + SkPoint* t = rec->fTexs; + + v[0].set(0, 0); + t[0].set(0, 0); + for (int i = 0; i < n; i++) { + SkScalar cos; + SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos); + v[i+1].set(cos, sin); + t[i+1].set(i*tx/n, ty); + } + v[n+1] = v[1]; + t[n+1].set(tx, ty); + + SkMatrix m; + m.setScale(SkIntToScalar(100), SkIntToScalar(100)); + m.postTranslate(SkIntToScalar(110), SkIntToScalar(110)); + m.mapPoints(v, rec->fCount); + } + + void make_strip(Rec* rec, int texWidth, int texHeight) { + const SkScalar tx = SkIntToScalar(texWidth); + const SkScalar ty = SkIntToScalar(texHeight); + const int n = 24; + + rec->fMode = SkCanvas::kTriangleStrip_VertexMode; + rec->fCount = 2 * (n + 1); + rec->fVerts = new SkPoint[rec->fCount]; + rec->fTexs = new SkPoint[rec->fCount]; + + SkPoint* v = rec->fVerts; + SkPoint* t = rec->fTexs; + + for (int i = 0; i < n; i++) { + SkScalar cos; + SkScalar sin = SkScalarSinCos(SK_ScalarPI * 2 * i / n, &cos); + v[i*2 + 0].set(cos/2, sin/2); + v[i*2 + 1].set(cos, sin); + + t[i*2 + 0].set(tx * i / n, ty); + t[i*2 + 1].set(tx * i / n, 0); + } + v[2*n + 0] = v[0]; + v[2*n + 1] = v[1]; + + t[2*n + 0].set(tx, ty); + t[2*n + 1].set(tx, 0); + + SkMatrix m; + m.setScale(SkIntToScalar(100), SkIntToScalar(100)); + m.postTranslate(SkIntToScalar(110), SkIntToScalar(110)); + m.mapPoints(v, rec->fCount); + } + + Rec fRecs[3]; + + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new VerticesView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/SampleXfermodes.cpp b/Samples/SampleXfermodes.cpp new file mode 100644 index 0000000..5a05fc8 --- /dev/null +++ b/Samples/SampleXfermodes.cpp @@ -0,0 +1,266 @@ +#include "SampleCode.h" +#include "SkView.h" +#include "SkCanvas.h" +#include "Sk64.h" +#include "SkCornerPathEffect.h" +#include "SkGradientShader.h" +#include "SkGraphics.h" +#include "SkImageDecoder.h" +#include "SkKernel33MaskFilter.h" +#include "SkPath.h" +#include "SkRandom.h" +#include "SkRegion.h" +#include "SkShader.h" +#include "SkUtils.h" +#include "SkShaderExtras.h" +#include "SkColorPriv.h" +#include "SkColorFilter.h" +#include "SkTime.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +#include "SkStream.h" +#include "SkXMLParser.h" +#include "SkColorPriv.h" +#include "SkImageDecoder.h" + +static int newscale(U8CPU a, U8CPU b, int shift) { + unsigned prod = a * b + (1 << (shift - 1)); + return (prod + (prod >> shift)) >> shift; +} + +static void test_srcover565(SkCanvas* canvas) { + const int width = 32; + SkBitmap bm1, bm2, bm3; + bm1.setConfig(SkBitmap::kRGB_565_Config, width, 256); bm1.allocPixels(NULL); + bm2.setConfig(SkBitmap::kRGB_565_Config, width, 256); bm2.allocPixels(NULL); + bm3.setConfig(SkBitmap::kRGB_565_Config, width, 256); bm3.allocPixels(NULL); + + int rgb = 0x18; + int r = rgb >> 3; + int g = rgb >> 2; + uint16_t dst = SkPackRGB16(r, g, r); + for (int alpha = 0; alpha <= 255; alpha++) { + SkPMColor pm = SkPreMultiplyARGB(alpha, rgb, rgb, rgb); + uint16_t newdst = SkSrcOver32To16(pm, dst); + sk_memset16(bm1.getAddr16(0, alpha), newdst, bm1.width()); + + int ia = 255 - alpha; + int iscale = SkAlpha255To256(ia); + int dr = (SkGetPackedR32(pm) + (r * iscale >> 5)) >> 3; + int dg = (SkGetPackedG32(pm) + (g * iscale >> 6)) >> 2; + + sk_memset16(bm2.getAddr16(0, alpha), SkPackRGB16(dr, dg, dr), bm2.width()); + + int dr2 = (SkMulDiv255Round(alpha, rgb) + newscale(r, ia, 5)) >> 3; + int dg2 = (SkMulDiv255Round(alpha, rgb) + newscale(g, ia, 6)) >> 2; + + sk_memset16(bm3.getAddr16(0, alpha), SkPackRGB16(dr2, dg2, dr2), bm3.width()); + +// if (mr != dr || mg != dg) + { +// SkDebugf("[%d] macro [%d %d] inline [%d %d] new [%d %d]\n", alpha, mr, mg, dr, dg, dr2, dg2); + } + } + + SkScalar dx = SkIntToScalar(width+4); + + canvas->drawBitmap(bm1, 0, 0, NULL); canvas->translate(dx, 0); + canvas->drawBitmap(bm2, 0, 0, NULL); canvas->translate(dx, 0); + canvas->drawBitmap(bm3, 0, 0, NULL); canvas->translate(dx, 0); + + SkRect rect = { 0, 0, SkIntToScalar(bm1.width()), SkIntToScalar(bm1.height()) }; + SkPaint p; + p.setARGB(0xFF, rgb, rgb, rgb); + canvas->drawRect(rect, p); +} + +static void make_bitmaps(int w, int h, SkBitmap* src, SkBitmap* dst) { + src->setConfig(SkBitmap::kARGB_8888_Config, w, h); + src->allocPixels(); + src->eraseColor(0); + + SkCanvas c(*src); + SkPaint p; + SkRect r; + SkScalar ww = SkIntToScalar(w); + SkScalar hh = SkIntToScalar(h); + + p.setAntiAlias(true); + p.setColor(0xFFFFCC44); + r.set(0, 0, ww*3/4, hh*3/4); + c.drawOval(r, p); + + dst->setConfig(SkBitmap::kARGB_8888_Config, w, h); + dst->allocPixels(); + dst->eraseColor(0); + c.setBitmapDevice(*dst); + + p.setColor(0xFF66AAFF); + r.set(ww/3, hh/3, ww*19/20, hh*19/20); + c.drawRect(r, p); +} + +static uint16_t gBG[] = { 0xFFFF, 0xCCCF, 0xCCCF, 0xFFFF }; + +class XfermodesView : public SkView { + SkBitmap fBitmap; + SkBitmap fBG; + SkBitmap fSrcB, fDstB; + + void draw_mode(SkCanvas* canvas, SkXfermode* mode, int alpha) { + SkPaint p; + + canvas->drawBitmap(fSrcB, 0, 0, &p); + p.setAlpha(alpha); + p.setXfermode(mode); + canvas->drawBitmap(fDstB, 0, 0, &p); + } + +public: + XfermodesView() { + const int W = 64; + const int H = 64; + + fBitmap.setConfig(SkBitmap::kARGB_8888_Config, W, H); + fBitmap.allocPixels(); + + fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4); + fBG.setPixels(gBG); + fBG.setIsOpaque(true); + + make_bitmaps(W, H, &fSrcB, &fDstB); + } + +protected: + // overrides from SkEventSink + virtual bool onQuery(SkEvent* evt) { + if (SampleCode::TitleQ(*evt)) { + SampleCode::TitleR(evt, "Xfermodes"); + return true; + } + return this->INHERITED::onQuery(evt); + } + + void drawBG(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + return; + SkShader* s = SkShader::CreateBitmapShader(fBG, + SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode); + SkPaint p; + SkMatrix m; + + p.setShader(s)->unref(); + m.setScale(SkIntToScalar(8), SkIntToScalar(8)); + s->setLocalMatrix(m); + canvas->drawPaint(p); + } + + virtual void onDraw(SkCanvas* canvas) { + this->drawBG(canvas); + + if (false) { + test_srcover565(canvas); + } + + if (false) { + SkPaint paint; + paint.setFlags(0x43); + paint.setTextSize(SkIntToScalar(128)); + SkMatrix matrix; + matrix.reset(); + matrix.set(0, 0x0019d049); + matrix.set(2, 0x712cf400); + matrix.set(4, 0x0019c96f); + matrix.set(5, 0xF8d76598); + canvas->concat(matrix); + canvas->drawText("HamburgefonsHamburgefonsHamburgefonsHamburgefons", + 48, 0, 0, paint); + return; + } + + const struct { + SkPorterDuff::Mode fMode; + const char* fLabel; + } gModes[] = { + { SkPorterDuff::kClear_Mode, "Clear" }, + { SkPorterDuff::kSrc_Mode, "Src" }, + { SkPorterDuff::kDst_Mode, "Dst" }, + { SkPorterDuff::kSrcOver_Mode, "SrcOver" }, + { SkPorterDuff::kDstOver_Mode, "DstOver" }, + { SkPorterDuff::kSrcIn_Mode, "SrcIn" }, + { SkPorterDuff::kDstIn_Mode, "DstIn" }, + { SkPorterDuff::kSrcOut_Mode, "SrcOut" }, + { SkPorterDuff::kDstOut_Mode, "DstOut" }, + { SkPorterDuff::kSrcATop_Mode, "SrcATop" }, + { SkPorterDuff::kDstATop_Mode, "DstATop" }, + { SkPorterDuff::kXor_Mode, "Xor" }, + { SkPorterDuff::kDarken_Mode, "Darken" }, + { SkPorterDuff::kLighten_Mode, "Lighten" }, + { SkPorterDuff::kMultiply_Mode, "Multiply" }, + { SkPorterDuff::kScreen_Mode, "Screen" } + }; + + canvas->translate(SkIntToScalar(10), SkIntToScalar(20)); + + SkCanvas c(fBitmap); + const SkScalar w = SkIntToScalar(fBitmap.width()); + const SkScalar h = SkIntToScalar(fBitmap.height()); + SkShader* s = SkShader::CreateBitmapShader(fBG, + SkShader::kRepeat_TileMode, + SkShader::kRepeat_TileMode); + SkMatrix m; + m.setScale(SkIntToScalar(6), SkIntToScalar(6)); + s->setLocalMatrix(m); + + SkPaint labelP; + labelP.setAntiAlias(true); + labelP.setTextAlign(SkPaint::kCenter_Align); + + SkScalar x0 = 0; + for (int twice = 0; twice < 2; twice++) { + SkScalar x = x0, y = 0; + for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) { + SkXfermode* mode = SkPorterDuff::CreateXfermode(gModes[i].fMode); + + fBitmap.eraseColor(0); + draw_mode(&c, mode, twice ? 0x88 : 0xFF); + mode->safeUnref(); + + SkPaint p; + SkRect r; + r.set(x, y, x+w, y+h); + r.inset(-SK_ScalarHalf, -SK_ScalarHalf); + p.setStyle(SkPaint::kStroke_Style); + canvas->drawRect(r, p); + p.setStyle(SkPaint::kFill_Style); + p.setShader(s); + r.inset(SK_ScalarHalf, SK_ScalarHalf); + canvas->drawRect(r, p); + + canvas->drawBitmap(fBitmap, x, y, NULL); + + canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel), + x + w/2, y - labelP.getTextSize()/2, labelP); + + x += w + SkIntToScalar(10); + if ((i & 3) == 3) { + x = x0; + y += h + SkIntToScalar(30); + } + } + x0 += SkIntToScalar(330); + } + s->unref(); + } + +private: + typedef SkView INHERITED; +}; + +////////////////////////////////////////////////////////////////////////////// + +static SkView* MyFactory() { return new XfermodesView; } +static SkViewRegister reg(MyFactory); + diff --git a/Samples/vertexdump.cpp b/Samples/vertexdump.cpp new file mode 100644 index 0000000..c124ad8 --- /dev/null +++ b/Samples/vertexdump.cpp @@ -0,0 +1,88 @@ +#include "SkPoint.h" + +void setup_vertexbug(SkPoint verts[], SkPoint texs[], uint16_t index[]); + +void setup_vertexbug(SkPoint verts[], SkPoint texs[], uint16_t index[]) { + verts[0].set(SkFloatToScalar(107), SkFloatToScalar(189)); + texs[0].set(SkFloatToScalar(0), SkFloatToScalar(0)); + verts[1].set(SkFloatToScalar(116), SkFloatToScalar(189)); + texs[1].set(SkFloatToScalar(9), SkFloatToScalar(0)); + verts[2].set(SkFloatToScalar(203), SkFloatToScalar(189)); + texs[2].set(SkFloatToScalar(35), SkFloatToScalar(0)); + verts[3].set(SkFloatToScalar(212), SkFloatToScalar(189)); + texs[3].set(SkFloatToScalar(44), SkFloatToScalar(0)); + verts[4].set(SkFloatToScalar(107), SkFloatToScalar(198)); + texs[4].set(SkFloatToScalar(0), SkFloatToScalar(9)); + verts[5].set(SkFloatToScalar(116), SkFloatToScalar(198)); + texs[5].set(SkFloatToScalar(9), SkFloatToScalar(9)); + verts[6].set(SkFloatToScalar(203), SkFloatToScalar(198)); + texs[6].set(SkFloatToScalar(35), SkFloatToScalar(9)); + verts[7].set(SkFloatToScalar(212), SkFloatToScalar(198)); + texs[7].set(SkFloatToScalar(44), SkFloatToScalar(9)); + verts[8].set(SkFloatToScalar(107), SkFloatToScalar(224)); + texs[8].set(SkFloatToScalar(0), SkFloatToScalar(39)); + verts[9].set(SkFloatToScalar(116), SkFloatToScalar(224)); + texs[9].set(SkFloatToScalar(9), SkFloatToScalar(39)); + verts[10].set(SkFloatToScalar(203), SkFloatToScalar(224)); + texs[10].set(SkFloatToScalar(35), SkFloatToScalar(39)); + verts[11].set(SkFloatToScalar(212), SkFloatToScalar(224)); + texs[11].set(SkFloatToScalar(44), SkFloatToScalar(39)); + verts[12].set(SkFloatToScalar(107), SkFloatToScalar(233)); + texs[12].set(SkFloatToScalar(0), SkFloatToScalar(48)); + verts[13].set(SkFloatToScalar(116), SkFloatToScalar(233)); + texs[13].set(SkFloatToScalar(9), SkFloatToScalar(48)); + verts[14].set(SkFloatToScalar(203), SkFloatToScalar(233)); + texs[14].set(SkFloatToScalar(35), SkFloatToScalar(48)); + verts[15].set(SkFloatToScalar(212), SkFloatToScalar(233)); + texs[15].set(SkFloatToScalar(44), SkFloatToScalar(48)); + index[0] = 0; index[1] = 5; index[2] = 1; + index[3] = 0; index[4] = 4; index[5] = 5; +#if 0 + index[6] = 1; index[7] = 6; index[8] = 2; +#else + index[6] = 6; index[7] = 2; index[8] = 1; +#endif + index[9] = 1; index[10] = 5; index[11] = 6; + index[12] = 2; + index[13] = 7; + index[14] = 3; + index[15] = 2; + index[16] = 6; + index[17] = 7; + index[18] = 4; + index[19] = 9; + index[20] = 5; + index[21] = 4; + index[22] = 8; + index[23] = 9; + index[24] = 5; + index[25] = 10; + index[26] = 6; + index[27] = 5; + index[28] = 9; + index[29] = 10; + index[30] = 6; + index[31] = 11; + index[32] = 7; + index[33] = 6; + index[34] = 10; + index[35] = 11; + index[36] = 8; + index[37] = 13; + index[38] = 9; + index[39] = 8; + index[40] = 12; + index[41] = 13; + index[42] = 9; + index[43] = 14; + index[44] = 10; + index[45] = 9; + index[46] = 13; + index[47] = 14; + index[48] = 10; + index[49] = 15; + index[50] = 11; + index[51] = 10; + index[52] = 14; + index[53] = 15; +} diff --git a/include/corecg/SkFloatBits.h b/include/corecg/SkFloatBits.h index caf8e75..1628f6e 100644 --- a/include/corecg/SkFloatBits.h +++ b/include/corecg/SkFloatBits.h @@ -31,6 +31,18 @@ static inline int32_t SkSignBitTo2sCompliment(int32_t x) { return x; } +/** Convert a 2s compliment int to a sign-bit (i.e. int interpreted as float). + This undoes the result of SkSignBitTo2sCompliment(). + */ +static inline int32_t Sk2sComplimentToSignBit(int32_t x) { + int sign = x >> 31; + // make x positive + x = (x ^ sign) - sign; + // set the sign bit as needed + x |= sign << 31; + return x; +} + /** Given the bit representation of a float, return its value cast to an int. If the value is out of range, or NaN, return return +/- SK_MaxS32 */ @@ -77,11 +89,18 @@ static inline float SkBits2Float(int32_t floatAsBits) { to each other or against positive float-bit-constants (like 0). This does not return the int equivalent of the float, just something cheaper for compares-only. -*/ + */ static inline int32_t SkFloatAs2sCompliment(float x) { return SkSignBitTo2sCompliment(SkFloat2Bits(x)); } +/** Return the 2s compliment int as a float. This undos the result of + SkFloatAs2sCompliment + */ +static inline float Sk2sComplimentAsFloat(int32_t x) { + return SkBits2Float(Sk2sComplimentToSignBit(x)); +} + /** Return x cast to a float (i.e. (float)x) */ float SkIntToFloatCast(int x); @@ -121,8 +140,10 @@ static inline int32_t SkFloatToIntCeil(float x) { #ifdef SK_SCALAR_IS_FLOAT #define SkScalarAs2sCompliment(x) SkFloatAs2sCompliment(x) + #define Sk2sComplimentAsScalar(x) Sk2sComplimentAsFloat(x) #else #define SkScalarAs2sCompliment(x) (x) + #define Sk2sComplimentAsScalar(x) (x) #endif #endif diff --git a/include/corecg/SkMath.h b/include/corecg/SkMath.h index 76cf279..5c2b475 100644 --- a/include/corecg/SkMath.h +++ b/include/corecg/SkMath.h @@ -209,7 +209,7 @@ static inline U8CPU SkMulDiv255Round(U8CPU a, U8CPU b) { /** Return a*b/((1 << shift) - 1), rounding any fractional bits. Only valid if a and b are unsigned and <= 32767 and shift is > 0 and <= 8 */ -static unsigned SkMul16ShiftRound(unsigned a, unsigned b, int shift) { +static inline unsigned SkMul16ShiftRound(unsigned a, unsigned b, int shift) { SkASSERT(a <= 32767); SkASSERT(b <= 32767); SkASSERT(shift > 0 && shift <= 8); diff --git a/include/corecg/SkMatrix.h b/include/corecg/SkMatrix.h index 04751f2..2b25dca 100644 --- a/include/corecg/SkMatrix.h +++ b/include/corecg/SkMatrix.h @@ -19,6 +19,8 @@ #include "SkRect.h" +class SkString; + /** \class SkMatrix The SkMatrix class holds a 3x3 matrix for transforming coordinates. @@ -399,6 +401,7 @@ public: } void dump() const; + void toDumpString(SkString*) const; #ifdef SK_DEBUG /** @cond UNIT_TEST */ diff --git a/include/corecg/SkPageFlipper.h b/include/corecg/SkPageFlipper.h new file mode 100644 index 0000000..0d791ee --- /dev/null +++ b/include/corecg/SkPageFlipper.h @@ -0,0 +1,70 @@ +/* + * 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 SkPageFlipper_DEFINED +#define SkPageFlipper_DEFINED + +#include "SkRegion.h" + +/** SkPageFlipper manages alternating inval/dirty regions for a rectangular area + (like a bitmap). You call inval() to accumulate inval areas, and then when + you're ready to "flip" pages (i.e. draw into the one you've been + invalidating) you call update, which swaps the inval regions, and returns + two things to you: 1) the final inval region to be drawn into, and 2) the + region of pixels that should be copied from the "front" page onto the one + you're about to draw into. This copyBits region will be disjoint from the + inval region, so both need to be handled. + */ +class SkPageFlipper { +public: + SkPageFlipper(); + SkPageFlipper(int width, int height); + + int width() const { return fWidth; } + int height() const { return fHeight; } + + void resize(int width, int height); + + bool isDirty() const { return !fDirty1->isEmpty(); } + const SkRegion& dirtyRgn() const { return *fDirty1; } + + void inval(); + void inval(const SkIRect&); + void inval(const SkRegion&); + void inval(const SkRect&, bool antialias); + + /** When you're ready to write to the back page, call update. The returned + region is the invalidate are that needs to be drawn to. The copyBits + region (provided by the caller) is the area that should be copied from + the front page to the back page (will not intersect with the returned + inval region. + + Once this is called, the two internal regions are swapped, so the *new* + back inval region is ready to receive new inval calls. + */ + const SkRegion& update(SkRegion* copyBits); + +private: + SkRegion* fDirty0; + SkRegion* fDirty1; + SkRegion fDirty0Storage; + SkRegion fDirty1Storage; + int fWidth; + int fHeight; +}; + +#endif + diff --git a/include/corecg/SkPostConfig.h b/include/corecg/SkPostConfig.h index c008d71..e32d6a1 100644 --- a/include/corecg/SkPostConfig.h +++ b/include/corecg/SkPostConfig.h @@ -63,6 +63,8 @@ #endif #endif +/////////////////////////////////////////////////////////////////////////////// + #ifndef SkNEW #define SkNEW(type_name) new type_name #define SkNEW_ARGS(type_name, args) new type_name args @@ -81,6 +83,13 @@ /////////////////////////////////////////////////////////////////////////////// +#if defined(SK_SOFTWARE_FLOAT) && defined(SK_SCALAR_IS_FLOAT) + // if this is defined, we convert floats to 2scompliment ints for compares + #ifndef SK_SCALAR_SLOW_COMPARES + #define SK_SCALAR_SLOW_COMPARES + #endif +#endif + #ifdef SK_BUILD_FOR_WIN #define WIN32_LEAN_AND_MEAN #include <windows.h> diff --git a/include/corecg/SkRect.h b/include/corecg/SkRect.h index 2b05fb5..a9f25aa 100644 --- a/include/corecg/SkRect.h +++ b/include/corecg/SkRect.h @@ -279,6 +279,16 @@ struct SkRect { fRight = right; fBottom = bottom; } + + /** Initialize the rect with the 4 specified integers. The routine handles + converting them to scalars (by calling SkIntToScalar) + */ + void iset(int left, int top, int right, int bottom) { + fLeft = SkIntToScalar(left); + fTop = SkIntToScalar(top); + fRight = SkIntToScalar(right); + fBottom = SkIntToScalar(bottom); + } /** Set this rectangle to be the bounds of the array of points. If the array is empty (count == 0), then set this rectangle diff --git a/include/corecg/SkRegion.h b/include/corecg/SkRegion.h index 673da23..8b15a89 100644 --- a/include/corecg/SkRegion.h +++ b/include/corecg/SkRegion.h @@ -108,6 +108,16 @@ public: drawn by the path (with no antialiasing) with the specified clip. */ bool setPath(const SkPath&, const SkRegion& clip); + + /** Returns true if the specified rectangle has a non-empty intersection + with this region. + */ + bool intersects(const SkIRect&) const; + + /** Returns true if the specified region has a non-empty intersection + with this region. + */ + bool intersects(const SkRegion&) const; /** Return true if the specified x,y coordinate is inside the region. */ @@ -298,6 +308,9 @@ public: SkDEBUGCODE(void validate() const;) SkDEBUGCODE(static void UnitTest();) + // expose this to allow for regression test on complex regions + SkDEBUGCODE(bool debugSetRuns(const RunType runs[], int count);) + private: enum { kOpCount = kReplace_Op + 1 diff --git a/include/corecg/SkScalarCompare.h b/include/corecg/SkScalarCompare.h new file mode 100644 index 0000000..fee554c --- /dev/null +++ b/include/corecg/SkScalarCompare.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 SkScalarCompare_DEFINED +#define SkScalarCompare_DEFINED + +#include "SkFloatBits.h" +#include "SkRect.h" + +#ifdef SK_SCALAR_SLOW_COMPARES + typedef int32_t SkScalarCompareType; + typedef SkIRect SkRectCompareType; + #define SkScalarToCompareType(x) SkScalarAs2sCompliment(x) +#else + typedef SkScalar SkScalarCompareType; + typedef SkRect SkRectCompareType; + #define SkScalarToCompareType(x) (x) +#endif + +#endif + diff --git a/include/graphics/SkString.h b/include/corecg/SkString.h index 46b1d9e..743b093 100644 --- a/include/graphics/SkString.h +++ b/include/corecg/SkString.h @@ -111,6 +111,8 @@ public: void prependScalar(SkScalar value) { this->insertScalar((size_t)-1, value); } void printf(const char format[], ...); + void appendf(const char format[], ...); + void prependf(const char format[], ...); void remove(size_t offset, size_t length); diff --git a/include/corecg/SkTemplates.h b/include/corecg/SkTemplates.h index c81be2a..27ebd41 100644 --- a/include/corecg/SkTemplates.h +++ b/include/corecg/SkTemplates.h @@ -85,59 +85,89 @@ private: T* fArray; }; +/** Allocate an array of T elements, and free the array in the destructor + */ template <typename T> class SkAutoTArray : SkNoncopyable { public: - SkAutoTArray(size_t count) - { - fArray = NULL; // init first in case we throw - if (count) + /** Allocate count number of T elements + */ + SkAutoTArray(size_t count) { + fArray = NULL; + if (count) { fArray = new T[count]; -#ifdef SK_DEBUG - fCount = count; -#endif + } + SkDEBUGCODE(fCount = count;) } - ~SkAutoTArray() - { + + ~SkAutoTArray() { delete[] fArray; } + /** Return the array of T elements. Will be NULL if count == 0 + */ T* get() const { return fArray; } - T& operator[](int index) const { SkASSERT((unsigned)index < fCount); return fArray[index]; } + + /** Return the nth element in the array + */ + T& operator[](int index) const { + SkASSERT((unsigned)index < fCount); + return fArray[index]; + } - void reset() - { - if (fArray) - { - delete[] fArray; +private: + T* fArray; + SkDEBUGCODE(size_t fCount;) +}; + +/** Wraps SkAutoTArray, with room for up to N elements preallocated + */ +template <size_t N, typename T> class SkAutoSTArray : SkNoncopyable { +public: + /** Allocate count number of T elements + */ + SkAutoSTArray(size_t count) { + if (count > N) { + fArray = new T[count]; + } else if (count) { + fArray = new (fStorage) T[count]; + } else { fArray = NULL; } + fCount = count; } - - void replace(T* array) - { - if (fArray != array) - { + + ~SkAutoSTArray() { + if (fCount > N) { delete[] fArray; - fArray = array; + } else { + T* start = fArray; + T* iter = start + fCount; + while (iter > start) { + (--iter)->~T(); + } } } - - /** Call swap to exchange your pointer to an array of T with the SkAutoTArray object. - After this call, the SkAutoTArray object will be responsible for deleting your - array, and you will be responsible for deleting its. - */ - void swap(T*& other) - { - T* tmp = fArray; - fArray = other; - other = tmp; + + /** Return the number of T elements in the array + */ + size_t count() const { return fCount; } + + /** Return the array of T elements. Will be NULL if count == 0 + */ + T* get() const { return fArray; } + + /** Return the nth element in the array + */ + T& operator[](int index) const { + SkASSERT((unsigned)index < fCount); + return fArray[index]; } - + private: -#ifdef SK_DEBUG - size_t fCount; -#endif - T* fArray; + size_t fCount; + T* fArray; + // since we come right after fArray, fStorage should be properly aligned + char fStorage[N * sizeof(T)]; }; /** Allocate a temp array on the stack/heap. diff --git a/include/corecg/SkUserConfig.h b/include/corecg/SkUserConfig.h index 4afd646..cc69cd7 100644 --- a/include/corecg/SkUserConfig.h +++ b/include/corecg/SkUserConfig.h @@ -23,6 +23,12 @@ #define SK_DEBUG #endif +// remove the x if you want to force us into SK_RELEASE mode +#ifdef SK_DEBUGx + #undef SK_DEBUG + #define SK_RELEASE +#endif + #ifdef ANDROID #include <utils/misc.h> @@ -39,6 +45,7 @@ #endif #define SK_CAN_USE_FLOAT + #define SK_SOFTWARE_FLOAT #define SkLONGLONG int64_t // replace some sw float routines (floor, ceil, etc.) diff --git a/include/graphics/SkUtils.h b/include/corecg/SkUtils.h index f3e3341..f3e3341 100644 --- a/include/graphics/SkUtils.h +++ b/include/corecg/SkUtils.h diff --git a/include/graphics/SkBitmap.h b/include/graphics/SkBitmap.h index e446a01..02c8cd9 100644 --- a/include/graphics/SkBitmap.h +++ b/include/graphics/SkBitmap.h @@ -172,6 +172,9 @@ public: static int ComputeShiftPerPixel(Config c) { return ComputeBytesPerPixel(c) >> 1; } + + static Sk64 ComputeSize64(Config, int width, int height); + static size_t ComputeSize(Config, int width, int height); /** Set the bitmap's config and dimensions. If rowBytes is 0, then ComputeRowBytes() is called to compute the optimal value. This resets @@ -603,6 +606,12 @@ public: fCTable = bm.getColorTable(); fColors = fCTable ? fCTable->lockColors() : NULL; } + /** Initialize with a colortable (may be null) + */ + explicit SkAutoLockColors(SkColorTable* ctable) { + fCTable = ctable; + fColors = ctable ? ctable->lockColors() : NULL; + } ~SkAutoLockColors() { if (fCTable) { fCTable->unlockColors(false); diff --git a/include/graphics/SkBlurDrawLooper.h b/include/graphics/SkBlurDrawLooper.h index ae42393..028b2eb 100644 --- a/include/graphics/SkBlurDrawLooper.h +++ b/include/graphics/SkBlurDrawLooper.h @@ -37,6 +37,10 @@ public: virtual bool next(); virtual void restore(); + static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { + return SkNEW_ARGS(SkBlurDrawLooper, (buffer)); + } + protected: SkBlurDrawLooper(SkFlattenableReadBuffer&); // overrides from SkFlattenable @@ -44,9 +48,6 @@ protected: virtual Factory getFactory() { return CreateProc; } private: - static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { - return SkNEW_ARGS(SkBlurDrawLooper, (buffer)); } - SkCanvas* fCanvas; SkPaint* fPaint; SkMaskFilter* fBlur; diff --git a/include/graphics/SkCanvas.h b/include/graphics/SkCanvas.h index 12fd9c3..a19a5ae 100644 --- a/include/graphics/SkCanvas.h +++ b/include/graphics/SkCanvas.h @@ -25,6 +25,7 @@ #include "SkPorterDuff.h" #include "SkPath.h" #include "SkRegion.h" +#include "SkScalarCompare.h" class SkBounder; class SkDevice; @@ -310,7 +311,7 @@ public: in a way similar to quickReject, in that it tells you that drawing outside of these bounds will be clipped out. */ - bool getClipBounds(SkRect* bounds) const; + bool getClipBounds(SkRect* bounds, EdgeType et = kAA_EdgeType) const; /** Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB color, using the specified PorterDuff mode. @@ -704,6 +705,7 @@ public: SkDevice* device() const; const SkMatrix& matrix() const; const SkRegion& clip() const; + const SkPaint& paint() const; int x() const; int y() const; @@ -711,9 +713,11 @@ public: // used to embed the SkDrawIter object directly in our instance, w/o // having to expose that class def to the public. There is an assert // in our constructor to ensure that fStorage is large enough - // (though needs to be a compile-time-assert!) - uint32_t fStorage[11]; + // (though needs to be a compile-time-assert!). We use intptr_t to work + // safely with 32 and 64 bit machines (to ensure the storage is enough) + intptr_t fStorage[12]; class SkDrawIter* fImpl; // this points at fStorage + SkPaint fDefaultPaint; bool fDone; }; @@ -747,6 +751,21 @@ private: // shared by save() and saveLayer() int internalSave(SaveFlags flags); void internalRestore(); + + /* These maintain a cache of the clip bounds in local coordinates, + (converted to 2s-compliment if floats are slow). + */ + mutable SkRectCompareType fLocalBoundsCompareType; + mutable bool fLocalBoundsCompareTypeDirty; + + const SkRectCompareType& getLocalClipBoundsCompareType() const { + if (fLocalBoundsCompareTypeDirty) { + this->computeLocalClipBoundsCompareType(); + fLocalBoundsCompareTypeDirty = false; + } + return fLocalBoundsCompareType; + } + void computeLocalClipBoundsCompareType() const; }; /** Stack helper class to automatically call restoreToCount() on the canvas diff --git a/include/graphics/SkDrawLooper.h b/include/graphics/SkDrawLooper.h index e46576c..333fb41 100644 --- a/include/graphics/SkDrawLooper.h +++ b/include/graphics/SkDrawLooper.h @@ -52,6 +52,13 @@ public: loop? */ virtual void restore() {} + +protected: + SkDrawLooper() {} + SkDrawLooper(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {} + +private: + typedef SkFlattenable INHERITED; }; #endif diff --git a/include/graphics/SkDumpCanvas.h b/include/graphics/SkDumpCanvas.h new file mode 100644 index 0000000..b919627 --- /dev/null +++ b/include/graphics/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/graphics/SkFlattenable.h b/include/graphics/SkFlattenable.h index d23e20f..6958462 100644 --- a/include/graphics/SkFlattenable.h +++ b/include/graphics/SkFlattenable.h @@ -25,6 +25,7 @@ class SkFlattenableReadBuffer; class SkFlattenableWriteBuffer; +class SkString; /** \class SkFlattenable @@ -49,6 +50,11 @@ public: */ virtual void flatten(SkFlattenableWriteBuffer&); + /** Set the string to describe the sublass and return true. If this is not + overridden, ignore the string param and return false. + */ + virtual bool toDumpString(SkString*) const; + static Factory NameToFactory(const char name[]); static const char* FactoryToName(Factory); static void Register(const char name[], Factory); diff --git a/include/graphics/SkFlipPixelRef.h b/include/graphics/SkFlipPixelRef.h new file mode 100644 index 0000000..3b4e97a --- /dev/null +++ b/include/graphics/SkFlipPixelRef.h @@ -0,0 +1,114 @@ +/* + * 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 SkFlipPixelRef_DEFINED +#define SkFlipPixelRef_DEFINED + +#include "SkBitmap.h" +#include "SkPageFlipper.h" +#include "SkPixelRef.h" +#include "SkThread.h" + +class SkRegion; + +class SkFlipPixelRef : public SkPixelRef { +public: + SkFlipPixelRef(SkBitmap::Config, int width, int height); + virtual ~SkFlipPixelRef(); + + bool isDirty() const { return fFlipper.isDirty(); } + const SkRegion& dirtyRgn() const { return fFlipper.dirtyRgn(); } + + void inval() { fFlipper.inval(); } + void inval(const SkIRect& rect) { fFlipper.inval(rect); } + void inval(const SkRegion& rgn) { fFlipper.inval(rgn); } + void inval(const SkRect& r, bool doAA) { fFlipper.inval(r, doAA); } + + const SkRegion& beginUpdate(SkBitmap* device); + void endUpdate(); + +private: + void getFrontBack(const void** front, void** back) const { + if (front) { + *front = fPage0; + } + if (back) { + *back = fPage1; + } + } + + void swapPages(); + + // Helper to copy pixels from srcAddr to the dst bitmap, clipped to clip. + // srcAddr points to memory with the same config as dst. + static void CopyBitsFromAddr(const SkBitmap& dst, const SkRegion& clip, + const void* srcAddr); + + // serialization + +public: + virtual Factory getFactory() const { return Create; } + virtual void flatten(SkFlattenableWriteBuffer&) const; + static SkPixelRef* Create(SkFlattenableReadBuffer& buffer); + +protected: + virtual void* onLockPixels(SkColorTable**); + virtual void onUnlockPixels(); + + SkFlipPixelRef(SkFlattenableReadBuffer&); + +private: + SkMutex fMutex; + SkPageFlipper fFlipper; + + void* fStorage; + void* fPage0; // points into fStorage; + void* fPage1; // points into fStorage; + size_t fSize; // size of 1 page. fStorage holds 2 pages + SkBitmap::Config fConfig; + + typedef SkPixelRef INHERITED; +}; + +class SkAutoFlipUpdate : SkNoncopyable { +public: + SkAutoFlipUpdate(SkFlipPixelRef* ref) : fRef(ref) { + fDirty = &ref->beginUpdate(&fBitmap); + } + ~SkAutoFlipUpdate() { + if (fRef) { + fRef->endUpdate(); + } + } + + const SkBitmap& bitmap() const { return fBitmap; } + const SkRegion& dirty() const { return *fDirty; } + + // optional. This gets automatically called in the destructor (only once) + void endUpdate() { + if (fRef) { + fRef->endUpdate(); + fRef = NULL; + } + } + +private: + SkFlipPixelRef* fRef; + SkBitmap fBitmap; + const SkRegion* fDirty; +}; + +#endif diff --git a/include/graphics/SkFontHost.h b/include/graphics/SkFontHost.h index 73010e7..ede40b7 100644 --- a/include/graphics/SkFontHost.h +++ b/include/graphics/SkFontHost.h @@ -37,24 +37,38 @@ public: 1) If familyFace is null, use famillyName. 2) If famillyName is null, use familyFace. 3) If both are null, return the default font that best matches style - */ + + NOTE: this does not return a new typeface, nor does it affect the + owner count of an existing one, so the caller is free to ignore the + return result, or just compare it against null. + */ static SkTypeface* FindTypeface(const SkTypeface* familyFace, const char famillyName[], SkTypeface::Style style); /** Return the typeface associated with the uniqueID, or null if that ID does not match any faces. + + NOTE: this does not return a new typeface, nor does it affect the + owner count of an existing one, so the caller is free to ignore the + return result, or just compare it against null. */ static SkTypeface* ResolveTypeface(uint32_t uniqueID); /** Return a new stream to read the font data, or null if the uniqueID does - not match an existing typeface + not match an existing typeface. The caller must call CloseStream() when + it is finished reading the stream. */ static SkStream* OpenStream(uint32_t uniqueID); + + /** Call this when finished reading from the stream returned by OpenStream. + The caller should NOT try to delete the stream. + */ static void CloseStream(uint32_t uniqueID, SkStream*); /** Return a new typeface given the data buffer (owned by the caller). - If the data does not represent a valid font, return null. + If the data does not represent a valid font, return null. The caller is + responsible for unref-ing the returned typeface (if it is not null). */ static SkTypeface* CreateTypeface(SkStream*); @@ -64,6 +78,14 @@ public: be retrieved with Deserialize(). */ static void Serialize(const SkTypeface*, SkWStream*); + + /** Given a stream created by Serialize(), return the corresponding typeface + or null if no match is found. + + NOTE: this does not return a new typeface, nor does it affect the + owner count of an existing one, so the caller is free to ignore the + return result, or just compare it against null. + */ static SkTypeface* Deserialize(SkStream*); /////////////////////////////////////////////////////////////////////////// @@ -71,6 +93,7 @@ public: /** Return a subclass of SkScalarContext */ static SkScalerContext* CreateScalerContext(const SkDescriptor* desc); + /** Return a scalercontext using the "fallback" font. If there is no designated fallback, return null. */ diff --git a/include/graphics/SkImageDecoder.h b/include/graphics/SkImageDecoder.h index e6389e4..4a18cab 100644 --- a/include/graphics/SkImageDecoder.h +++ b/include/graphics/SkImageDecoder.h @@ -279,12 +279,17 @@ public: static SkImageEncoder* Create(Type); virtual ~SkImageEncoder(); - + /* Quality ranges from 0..100 */ bool encodeFile(const char file[], const SkBitmap&, int quality = 80); bool encodeStream(SkWStream*, const SkBitmap&, int quality = 80); + static bool EncodeFile(const char file[], const SkBitmap&, Type, + int quality = 80); + static bool EncodeStream(SkWStream*, const SkBitmap&, Type, + int quality = 80); + protected: virtual bool onEncode(SkWStream*, const SkBitmap&, int quality) = 0; }; diff --git a/include/graphics/SkImageRef.h b/include/graphics/SkImageRef.h index 7462d4e..e94b7d4 100644 --- a/include/graphics/SkImageRef.h +++ b/include/graphics/SkImageRef.h @@ -44,12 +44,12 @@ public: SkImageRef(SkStream*, SkBitmap::Config config, int sampleSize = 1); virtual ~SkImageRef(); - const char* getName() const { return fName.c_str(); } - void setName(const char name[]) { fName.set(name); } - /** Return true if the image can be decoded. If so, and bitmap is non-null, call its setConfig() with the corresponding values, but explicitly will not set its pixels or colortable. Use SkPixelRef::lockPixels() for that. + + If there has been an error decoding the bitmap, this will return false + and ignore the bitmap parameter. */ bool getInfo(SkBitmap* bm); @@ -85,8 +85,6 @@ private: SkBitmap::Config fConfig; int fSampleSize; bool fErrorInDecoding; - - SkString fName; // for debugging friend class SkImageRefPool; diff --git a/include/graphics/SkLayerDrawLooper.h b/include/graphics/SkLayerDrawLooper.h new file mode 100644 index 0000000..670ac23 --- /dev/null +++ b/include/graphics/SkLayerDrawLooper.h @@ -0,0 +1,70 @@ +#ifndef SkLayerDrawLooper_DEFINED +#define SkLayerDrawLooper_DEFINED + +#include "SkDrawLooper.h" + +struct SkPoint; + +class SkLayerDrawLooper : public SkDrawLooper { +public: + SkLayerDrawLooper(); + virtual ~SkLayerDrawLooper(); + + /** Call for each layer you want to add (from top to bottom). + This returns a paint you can modify, but that ptr is only valid until + the next call made to this object. + */ + SkPaint* addLayer(SkScalar dx, SkScalar dy); + + /** Helper for addLayer() which passes (0, 0) for the offset parameters + */ + SkPaint* addLayer() { + return this->addLayer(0, 0); + } + + // overrides from SkDrawLooper + virtual void init(SkCanvas*, SkPaint*); + virtual bool next(); + virtual void restore(); + + // must be public for Registrar :( + static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { + return SkNEW_ARGS(SkLayerDrawLooper, (buffer)); + } + +protected: + SkLayerDrawLooper(SkFlattenableReadBuffer&); + + // overrides from SkFlattenable + virtual void flatten(SkFlattenableWriteBuffer& ); + virtual Factory getFactory() { return CreateProc; } + +private: + struct Rec { + Rec* fNext; + SkPaint fPaint; + SkPoint fOffset; + + static Rec* Reverse(Rec*); + }; + Rec* fRecs; + int fCount; + + struct Iter { + SkPaint fSavedPaint; + SkPaint* fPaint; + SkCanvas* fCanvas; + Rec* fRec; + }; + Iter fIter; + + class MyRegistrar : public SkFlattenable::Registrar { + public: + MyRegistrar(); + }; + + typedef SkDrawLooper INHERITED; +}; + + +#endif diff --git a/include/graphics/SkPaint.h b/include/graphics/SkPaint.h index 6906b96..fc390ab 100644 --- a/include/graphics/SkPaint.h +++ b/include/graphics/SkPaint.h @@ -367,6 +367,35 @@ public: */ bool getFillPath(const SkPath& src, SkPath* dst) const; + /** Returns true if the current paint settings allow for fast computation of + bounds (i.e. there is nothing complex like a patheffect that would make + the bounds computation expensive. + */ + bool canComputeFastBounds() const; + + /** Only call this if canComputeFastBounds() returned true. This takes a + raw rectangle (the raw bounds of a shape), and adjusts it for stylistic + effects in the paint (e.g. stroking). If needed, it uses the storage + rect parameter. It returns the adjusted bounds that can then be used + for quickReject tests. + + The returned rect will either be orig or storage, thus the caller + should not rely on storage being set to the result, but should always + use the retured value. It is legal for orig and storage to be the same + rect. + + e.g. + if (paint.canComputeFastBounds()) { + SkRect r, storage; + path.computeBounds(&r, SkPath::kFast_BoundsType); + const SkRect& fastR = paint.computeFastBounds(r, &storage); + if (canvas->quickReject(fastR, ...)) { + // don't draw the path + } + } + */ + const SkRect& computeFastBounds(const SkRect& orig, SkRect* storage) const; + /** Get the paint's shader object. <p /> The shader's reference count is not affected. diff --git a/include/graphics/SkPath.h b/include/graphics/SkPath.h index 821c549..e2409ad 100644 --- a/include/graphics/SkPath.h +++ b/include/graphics/SkPath.h @@ -22,6 +22,7 @@ class SkFlattenableReadBuffer; class SkFlattenableWriteBuffer; +class SkAutoPathBoundsUpdate; class SkString; /** \class SkPath @@ -580,6 +581,7 @@ private: void reversePathTo(const SkPath&); friend const SkPoint* sk_get_path_points(const SkPath&, int index); + friend class SkAutoPathBoundsUpdate; }; #endif diff --git a/include/graphics/SkPicture.h b/include/graphics/SkPicture.h index 46d189c..fa614c9 100644 --- a/include/graphics/SkPicture.h +++ b/include/graphics/SkPicture.h @@ -86,6 +86,12 @@ public: void serialize(SkWStream*) const; + /** Signals that the caller is prematurely done replaying the drawing + commands. This can be called from a canvas virtual while the picture + is drawing. Has no effect if the picture is not drawing. + */ + void abortPlayback(); + private: int fWidth, fHeight; SkPictureRecord* fRecord; diff --git a/include/graphics/SkPixelRef.h b/include/graphics/SkPixelRef.h index 0ddfedc..82e5ca7 100644 --- a/include/graphics/SkPixelRef.h +++ b/include/graphics/SkPixelRef.h @@ -89,9 +89,15 @@ public: */ const char* getURI() const { return fURI.size() ? fURI.c_str() : NULL; } - /** Assign a URI string to this pixelref. If not null, the string is copied. - */ - void setURI(const char uri[], size_t len = (size_t)-1) { + /** Copy a URI string to this pixelref, or clear the URI if the uri is null + */ + void setURI(const char uri[]) { + fURI.set(uri); + } + + /** Copy a URI string to this pixelref + */ + void setURI(const char uri[], size_t len) { fURI.set(uri, len); } diff --git a/include/graphics/SkProxyCanvas.h b/include/graphics/SkProxyCanvas.h new file mode 100644 index 0000000..1bc411a --- /dev/null +++ b/include/graphics/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/graphics/SkScalerContext.h b/include/graphics/SkScalerContext.h index 4b57f63..ec2cd0d 100644 --- a/include/graphics/SkScalerContext.h +++ b/include/graphics/SkScalerContext.h @@ -89,7 +89,10 @@ struct SkGlyph { kSubBits = 2, kSubMask = ((1 << kSubBits) - 1), kSubShift = 24, // must be large enough for glyphs and unichars - kCodeMask = ((1 << kSubShift) - 1) + kCodeMask = ((1 << kSubShift) - 1), + // relative offsets for X and Y subpixel bits + kSubShiftX = kSubBits, + kSubShiftY = 0 }; static unsigned ID2Code(uint32_t id) { @@ -97,11 +100,11 @@ struct SkGlyph { } static unsigned ID2SubX(uint32_t id) { - return id >> (kSubShift + kSubBits); + return id >> (kSubShift + kSubShiftX); } static unsigned ID2SubY(uint32_t id) { - return (id >> kSubShift) & kSubMask; + return (id >> (kSubShift + kSubShiftY)) & kSubMask; } static unsigned FixedToSub(SkFixed n) { @@ -121,7 +124,9 @@ struct SkGlyph { SkASSERT(code <= kCodeMask); x = FixedToSub(x); y = FixedToSub(y); - return (x << (kSubShift + kSubBits)) | (y << kSubShift) | code; + return (x << (kSubShift + kSubShiftX)) | + (y << (kSubShift + kSubShiftY)) | + code; } void toMask(SkMask* mask) const; diff --git a/libcorecg/Android.mk b/libcorecg/Android.mk index e407b64..bc862ce 100644 --- a/libcorecg/Android.mk +++ b/libcorecg/Android.mk @@ -15,9 +15,12 @@ LOCAL_SRC_FILES:= \ SkMath.cpp \ SkMatrix.cpp \ SkMemory_stdlib.cpp \ + SkPageFlipper.cpp \ SkPoint.cpp \ SkRect.cpp \ - SkRegion.cpp + SkRegion.cpp \ + SkString.cpp \ + SkUtils.cpp \ LOCAL_SHARED_LIBRARIES := \ libcutils \ diff --git a/libcorecg/SkDebug_stdio.cpp b/libcorecg/SkDebug_stdio.cpp index 74e60e6..c8a0d81 100644 --- a/libcorecg/SkDebug_stdio.cpp +++ b/libcorecg/SkDebug_stdio.cpp @@ -42,7 +42,7 @@ void Android_SkDebugf(const char* file, int line, const char* function, va_end(args); } -#elif defined(SK_DEBUG) +#else #include <stdarg.h> #include <stdio.h> diff --git a/libcorecg/SkMatrix.cpp b/libcorecg/SkMatrix.cpp index 81e69df..893aea1 100644 --- a/libcorecg/SkMatrix.cpp +++ b/libcorecg/SkMatrix.cpp @@ -18,6 +18,7 @@ #include "SkMatrix.h" #include "Sk64.h" #include "SkFloatBits.h" +#include "SkString.h" #ifdef SK_SCALAR_IS_FLOAT #define kMatrix22Elem SK_Scalar1 @@ -645,11 +646,15 @@ bool SkMatrix::setConcat(const SkMatrix& a, const SkMatrix& b) { } bool SkMatrix::preConcat(const SkMatrix& mat) { - return this->setConcat(*this, mat); + // check for identity first, so we don't do a needless copy of ourselves + // to ourselves inside setConcat() + return mat.isIdentity() || this->setConcat(*this, mat); } bool SkMatrix::postConcat(const SkMatrix& mat) { - return this->setConcat(mat, *this); + // check for identity first, so we don't do a needless copy of ourselves + // to ourselves inside setConcat() + return mat.isIdentity() || this->setConcat(mat, *this); } /////////////////////////////////////////////////////////////////////////////// @@ -669,7 +674,9 @@ bool SkMatrix::postConcat(const SkMatrix& mat) { det = (double)mat[SkMatrix::kMScaleX] * mat[SkMatrix::kMScaleY] - (double)mat[SkMatrix::kMSkewX] * mat[SkMatrix::kMSkewY]; } - if (SkScalarNearlyZero((float)det)) { + // Since the determinant is on the order of the square of the matrix members, + // compare to the square of the default nearly-zero constant + if (SkScalarNearlyZero((float)det, SK_ScalarNearlyZero * SK_ScalarNearlyZero)) { return 0; } return (float)(1.0 / det); @@ -1576,28 +1583,26 @@ bool SkMatrix::setPolyToPoly(const SkPoint src[], const SkPoint dst[], /////////////////////////////////////////////////////////////////////////////// void SkMatrix::dump() const { - // ensure the fTypeMask is up2date - (void)this->getType(); -#ifdef SK_DEBUG - int mask = this->computeTypeMask(); - SkASSERT(mask == fTypeMask); -#endif + SkString str; + this->toDumpString(&str); + SkDebugf("%s\n", str.c_str()); +} +void SkMatrix::toDumpString(SkString* str) const { #ifdef SK_CAN_USE_FLOAT - SkDebugf("[%8.4f %8.4f %8.4f] [%8.4f %8.4f %8.4f] [%8.4f %8.4f %8.4f] %x\n", + str->printf("[%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f][%8.4f %8.4f %8.4f]", #ifdef SK_SCALAR_IS_FLOAT fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5], - fMat[6], fMat[7], fMat[8], fTypeMask); + fMat[6], fMat[7], fMat[8]); #else SkFixedToFloat(fMat[0]), SkFixedToFloat(fMat[1]), SkFixedToFloat(fMat[2]), SkFixedToFloat(fMat[3]), SkFixedToFloat(fMat[4]), SkFixedToFloat(fMat[5]), - SkFractToFloat(fMat[6]), SkFractToFloat(fMat[7]), SkFractToFloat(fMat[8]), - fTypeMask); + SkFractToFloat(fMat[6]), SkFractToFloat(fMat[7]), SkFractToFloat(fMat[8])); #endif #else // can't use float - SkDebugf("[%x %x %x]\n[%x %x %x]\n[%x %x %x] %x\n", - fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5], - fMat[6], fMat[7], fMat[8], fTypeMask); + str->printf("[%x %x %x][%x %x %x][%x %x %x]", + fMat[0], fMat[1], fMat[2], fMat[3], fMat[4], fMat[5], + fMat[6], fMat[7], fMat[8]); #endif } diff --git a/libcorecg/SkPageFlipper.cpp b/libcorecg/SkPageFlipper.cpp new file mode 100644 index 0000000..526ba09 --- /dev/null +++ b/libcorecg/SkPageFlipper.cpp @@ -0,0 +1,85 @@ +/* + * 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. + */ + +#include "SkPageFlipper.h" + +SkPageFlipper::SkPageFlipper() { + fWidth = 0; + fHeight = 0; + fDirty0 = &fDirty0Storage; + fDirty1 = &fDirty1Storage; + + fDirty0->setEmpty(); + fDirty1->setEmpty(); +} + +SkPageFlipper::SkPageFlipper(int width, int height) { + fWidth = width; + fHeight = height; + fDirty0 = &fDirty0Storage; + fDirty1 = &fDirty1Storage; + + fDirty0->setRect(0, 0, width, height); + fDirty1->setEmpty(); +} + +void SkPageFlipper::resize(int width, int height) { + fWidth = width; + fHeight = height; + + // this is the opposite of the constructors + fDirty1->setRect(0, 0, width, height); + fDirty0->setEmpty(); +} + +void SkPageFlipper::inval() { + fDirty1->setRect(0, 0, fWidth, fHeight); +} + +void SkPageFlipper::inval(const SkIRect& rect) { + SkIRect r; + r.set(0, 0, fWidth, fHeight); + if (r.intersect(rect)) { + fDirty1->op(r, SkRegion::kUnion_Op); + } +} + +void SkPageFlipper::inval(const SkRegion& rgn) { + SkRegion r; + r.setRect(0, 0, fWidth, fHeight); + if (r.op(rgn, SkRegion::kIntersect_Op)) { + fDirty1->op(r, SkRegion::kUnion_Op); + } +} + +void SkPageFlipper::inval(const SkRect& rect, bool antialias) { + SkIRect r; + rect.round(&r); + if (antialias) { + r.inset(-1, -1); + } + this->inval(r); +} + +const SkRegion& SkPageFlipper::update(SkRegion* copyBits) { + // Copy over anything new from page0 that isn't dirty in page1 + copyBits->op(*fDirty0, *fDirty1, SkRegion::kDifference_Op); + SkTSwap<SkRegion*>(fDirty0, fDirty1); + fDirty1->setEmpty(); + return *fDirty0; +} + + diff --git a/libcorecg/SkRect.cpp b/libcorecg/SkRect.cpp index b679a26..d602754 100644 --- a/libcorecg/SkRect.cpp +++ b/libcorecg/SkRect.cpp @@ -1,19 +1,18 @@ -/* libs/corecg/SkRect.cpp -** -** Copyright 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. -*/ +/* + * 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. + */ #include "SkRect.h" @@ -67,17 +66,33 @@ void SkRect::set(const SkPoint pts[], int count) { SkASSERT((pts && count > 0) || count == 0); - if (count <= 0) - memset(this, 0, sizeof(SkRect)); - else - { + if (count <= 0) { + bzero(this, sizeof(SkRect)); + } else { +#ifdef SK_SCALAR_SLOW_COMPARES + int32_t l, t, r, b; + + l = r = SkScalarAs2sCompliment(pts[0].fX); + t = b = SkScalarAs2sCompliment(pts[0].fY); + + for (int i = 1; i < count; i++) { + int32_t x = SkScalarAs2sCompliment(pts[i].fX); + int32_t y = SkScalarAs2sCompliment(pts[i].fY); + + if (x < l) l = x; else if (x > r) r = x; + if (y < t) t = y; else if (y > b) b = y; + } + this->set(Sk2sComplimentAsScalar(l), + Sk2sComplimentAsScalar(t), + Sk2sComplimentAsScalar(r), + Sk2sComplimentAsScalar(b)); +#else SkScalar l, t, r, b; l = r = pts[0].fX; t = b = pts[0].fY; - for (int i = 1; i < count; i++) - { + for (int i = 1; i < count; i++) { SkScalar x = pts[i].fX; SkScalar y = pts[i].fY; @@ -85,6 +100,7 @@ void SkRect::set(const SkPoint pts[], int count) if (y < t) t = y; else if (y > b) b = y; } this->set(l, t, r, b); +#endif } } diff --git a/libcorecg/SkRegion.cpp b/libcorecg/SkRegion.cpp index 75220ad..b48f3bb 100644 --- a/libcorecg/SkRegion.cpp +++ b/libcorecg/SkRegion.cpp @@ -430,6 +430,46 @@ const SkRegion::RunType* SkRegion::getRuns(RunType tmpStorage[], int* count) con ///////////////////////////////////////////////////////////////////////////////////// +bool SkRegion::intersects(const SkIRect& r) const { + if (this->isEmpty() || r.isEmpty()) { + return false; + } + + if (!SkIRect::Intersects(fBounds, r)) { + return false; + } + + if (this->isRect()) { + return true; + } + + // we are complex + SkRegion tmp; + return tmp.op(*this, r, kIntersect_Op); +} + +bool SkRegion::intersects(const SkRegion& rgn) const { + if (this->isEmpty() || rgn.isEmpty()) { + return false; + } + + if (!SkIRect::Intersects(fBounds, rgn.fBounds)) { + return false; + } + + if (this->isRect() && rgn.isRect()) { + return true; + } + + // one or both of us is complex + // TODO: write a faster version that aborts as soon as we write the first + // non-empty span, to avoid build the entire result + SkRegion tmp; + return tmp.op(*this, rgn, kIntersect_Op); +} + +///////////////////////////////////////////////////////////////////////////////////// + int operator==(const SkRegion& a, const SkRegion& b) { SkDEBUGCODE(a.validate();) @@ -844,6 +884,43 @@ static int operate( const SkRegion::RunType a_runs[], return oper.flush(); } +/////////////////////////////////////////////////////////////////////////////// + +/* Given count RunTypes in a complex region, return the worst case number of + logical intervals that represents (i.e. number of rects that would be + returned from the iterator). + + We could just return count/2, since there must be at least 2 values per + interval, but we can first trim off the const overhead of the initial TOP + value, plus the final BOTTOM + 2 sentinels. + */ +static int count_to_intervals(int count) { + SkASSERT(count >= 6); // a single rect is 6 values + return (count - 4) >> 1; +} + +/* Given a number of intervals, what is the worst case representation of that + many intervals? + + Worst case (from a storage perspective), is a vertical stack of single + intervals: TOP + N * (BOTTOM LEFT RIGHT SENTINEL) + SENTINEL + */ +static int intervals_to_count(int intervals) { + return 1 + intervals * 4 + 1; +} + +/* Given the counts of RunTypes in two regions, return the worst-case number + of RunTypes need to store the result after a region-op. + */ +static int compute_worst_case_count(int a_count, int b_count) { + int a_intervals = count_to_intervals(a_count); + int b_intervals = count_to_intervals(b_count); + // Our heuristic worst case is ai * (bi + 1) + bi * (ai + 1) + int intervals = 2 * a_intervals * b_intervals + a_intervals + b_intervals; + // convert back to number of RunType values + return intervals_to_count(intervals); +} + bool SkRegion::op(const SkRegion& rgnaOrig, const SkRegion& rgnbOrig, Op op) { SkDEBUGCODE(this->validate();) @@ -916,7 +993,7 @@ bool SkRegion::op(const SkRegion& rgnaOrig, const SkRegion& rgnbOrig, Op op) const RunType* a_runs = rgna->getRuns(tmpA, &a_count); const RunType* b_runs = rgnb->getRuns(tmpB, &b_count); - int dstCount = 3 * SkMax32(a_count, b_count); + int dstCount = compute_worst_case_count(a_count, b_count); SkAutoSTMalloc<32, RunType> array(dstCount); int count = operate(a_runs, b_runs, array.get(), op); @@ -1246,3 +1323,19 @@ bool SkRegion::Spanerator::next(int* left, int* right) return true; } +/////////////////////////////////////////////////////////////////////////////// + +#ifdef SK_DEBUG + +bool SkRegion::debugSetRuns(const RunType runs[], int count) { + // we need to make a copy, since the real method may modify the array, and + // so it cannot be const. + + SkAutoTArray<RunType> storage(count); + memcpy(storage.get(), runs, count * sizeof(RunType)); + return this->setRuns(storage.get(), count); +} + +#endif + + diff --git a/libsgl/sgl/SkString.cpp b/libcorecg/SkString.cpp index c37453d..2e5d946 100644 --- a/libsgl/sgl/SkString.cpp +++ b/libcorecg/SkString.cpp @@ -107,7 +107,10 @@ char* SkStrAppendScalar(char string[], SkScalar value) const uint16_t* tens = gTens; x = SkFixedRound(frac * 10000); - SkASSERT(x < 10000); + SkASSERT(x <= 10000); + if (x == 10000) { + x -= 1; + } *string++ = '.'; do { unsigned powerOfTen = *tens++; @@ -467,34 +470,48 @@ void SkString::insertScalar(size_t offset, SkScalar value) /////////////////////////////////////////////////////////////////////////// -//#include <stdarg.h> -#if defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX) - #include <stdio.h> -#endif - -void SkString::printf(const char format[], ...) -{ - static const size_t kBufferSize = 100; +#include <stdio.h> - char buffer[kBufferSize + 1]; +// number of bytes (on the stack) to receive the printf result +static const size_t kBufferSize = 256; #ifdef SK_BUILD_FOR_WIN - va_list args; - va_start(args, format); - _vsnprintf(buffer, kBufferSize, format, args); - va_end(args); -#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX) - va_list args; - va_start(args, format); - vsnprintf(buffer, kBufferSize, format, args); - va_end(args); + #define VSNPRINTF _vsnprintf #else - buffer[0] = 0; + #define VSNPRINTF vsnprintf #endif +#define ARGS_TO_BUFFER(format, buffer, size) \ + do { \ + va_list args; \ + va_start(args, format); \ + VSNPRINTF(buffer, size, format, args); \ + va_end(args); \ + } while (0) + +void SkString::printf(const char format[], ...) { + char buffer[kBufferSize]; + ARGS_TO_BUFFER(format, buffer, kBufferSize); + this->set(buffer, strlen(buffer)); } +void SkString::appendf(const char format[], ...) { + char buffer[kBufferSize]; + ARGS_TO_BUFFER(format, buffer, kBufferSize); + + this->append(buffer, strlen(buffer)); +} + +void SkString::prependf(const char format[], ...) { + char buffer[kBufferSize]; + ARGS_TO_BUFFER(format, buffer, kBufferSize); + + this->prepend(buffer, strlen(buffer)); +} + +#undef VSNPRINTF + /////////////////////////////////////////////////////////////////////////// void SkString::remove(size_t offset, size_t length) diff --git a/libsgl/sgl/SkUtils.cpp b/libcorecg/SkUtils.cpp index 4f5ba6e..20f7ddc 100644 --- a/libsgl/sgl/SkUtils.cpp +++ b/libcorecg/SkUtils.cpp @@ -268,7 +268,7 @@ size_t SkUTF8_FromUnichar(SkUnichar uni, char utf8[]) SkDEBUGCODE(SkUnichar orig = uni;) - while (uni > 0x3F) + while (uni > 0x7F >> count) { *p++ = (char)(0x80 | (uni & 0x3F)); uni >>= 6; @@ -545,8 +545,15 @@ void SkUtils::UnitTest() SkUnichar fUni; } gTest[] = { { "a", 'a' }, + { "\x7f", 0x7f }, + { "\xC2\x80", 0x80 }, { "\xC3\x83", (3 << 6) | 3 }, + { "\xDF\xBF", 0x7ff }, + { "\xE0\xA0\x80", 0x800 }, + { "\xE0\xB0\xB8", 0xC38 }, { "\xE3\x83\x83", (3 << 12) | (3 << 6) | 3 }, + { "\xEF\xBF\xBF", 0xFFFF }, + { "\xF0\x90\x80\x80", 0x10000 }, { "\xF3\x83\x83\x83", (3 << 18) | (3 << 12) | (3 << 6) | 3 } }; diff --git a/libsgl/Android.mk b/libsgl/Android.mk index a279c76..17b7d32 100644 --- a/libsgl/Android.mk +++ b/libsgl/Android.mk @@ -17,22 +17,20 @@ LOCAL_SRC_FILES:= \ effects/SkCornerPathEffect.cpp \ effects/SkDashPathEffect.cpp \ effects/SkDiscretePathEffect.cpp \ + effects/SkDumpCanvas.cpp \ effects/SkEmbossMask.cpp \ effects/SkEmbossMaskFilter.cpp \ effects/SkGradientShader.cpp \ + effects/SkLayerDrawLooper.cpp \ effects/SkLayerRasterizer.cpp \ effects/SkNinePatch.cpp \ effects/SkPaintFlagsDrawFilter.cpp \ effects/SkPixelXorXfermode.cpp \ + effects/SkProxyCanvas.cpp \ effects/SkShaderExtras.cpp \ effects/SkTransparentShader.cpp \ - gl/SkGL.cpp \ - gl/SkGLCanvas.cpp \ - gl/SkGLDevice.cpp \ - gl/SkGLDevice_SWLayer.cpp \ - gl/SkGLTextCache.cpp \ - gl/SkTextureCache.cpp \ images/bmpdecoderhelper.cpp \ + images/SkFDStream.cpp \ images/SkImageDecoder.cpp \ images/SkImageDecoder_libbmp.cpp \ images/SkImageDecoder_libgif.cpp \ @@ -46,9 +44,12 @@ LOCAL_SRC_FILES:= \ images/SkMMapStream.cpp \ images/SkMovie.cpp \ images/SkMovie_gif.cpp \ + images/SkFlipPixelRef.cpp \ images/SkScaledBitmapSampler.cpp \ images/SkStream.cpp \ images/SkCreateRLEPixelRef.cpp \ + picture/SkPathHeap.cpp \ + picture/SkPicture.cpp \ picture/SkPictureFlat.cpp \ picture/SkPicturePlayback.cpp \ picture/SkPictureRecord.cpp \ @@ -100,7 +101,6 @@ LOCAL_SRC_FILES:= \ sgl/SkPath.cpp \ sgl/SkPathEffect.cpp \ sgl/SkPathMeasure.cpp \ - sgl/SkPicture.cpp \ sgl/SkPixelRef.cpp \ sgl/SkProcSpriteBlitter.cpp \ sgl/SkPtrRecorder.cpp \ @@ -116,13 +116,11 @@ LOCAL_SRC_FILES:= \ sgl/SkShader.cpp \ sgl/SkSpriteBlitter_ARGB32.cpp \ sgl/SkSpriteBlitter_RGB16.cpp \ - sgl/SkString.cpp \ sgl/SkStroke.cpp \ sgl/SkStrokerPriv.cpp \ sgl/SkTSearch.cpp \ sgl/SkTypeface.cpp \ sgl/SkUnPreMultiply.cpp \ - sgl/SkUtils.cpp \ sgl/SkXfermode.cpp \ sgl/SkWriter32.cpp \ xml/SkXMLPullParser.cpp @@ -132,7 +130,6 @@ LOCAL_SHARED_LIBRARIES := \ libutils \ libcorecg \ libexpat \ - libGLES_CM \ libz LOCAL_STATIC_LIBRARIES := \ @@ -158,8 +155,49 @@ LOCAL_C_INCLUDES += \ LOCAL_CFLAGS += -fpic -fstrict-aliasing +ifeq ($(NO_FALLBACK_FONT),true) + LOCAL_CFLAGS += -DNO_FALLBACK_FONT +endif + LOCAL_LDLIBS += -lpthread LOCAL_MODULE:= libsgl include $(BUILD_SHARED_LIBRARY) + +# +# Build the skia-opengl glue library +# + +include $(CLEAR_VARS) + +LOCAL_PRELINK_MODULE := false + +LOCAL_ARM_MODE := arm + +LOCAL_SRC_FILES:= \ + gl/SkGL.cpp \ + gl/SkGLCanvas.cpp \ + gl/SkGLDevice.cpp \ + gl/SkGLDevice_SWLayer.cpp \ + gl/SkGLTextCache.cpp \ + gl/SkTextureCache.cpp + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libutils \ + libsgl \ + libcorecg \ + libGLES_CM + +LOCAL_C_INCLUDES += \ + $(LOCAL_PATH)/sgl \ + $(call include-path-for, graphics corecg) + +LOCAL_CFLAGS += -fpic -fstrict-aliasing + +LOCAL_LDLIBS += -lpthread + +LOCAL_MODULE:= libskiagl + +include $(BUILD_SHARED_LIBRARY) diff --git a/libsgl/effects/SkBlurDrawLooper.cpp b/libsgl/effects/SkBlurDrawLooper.cpp index 61b69eb..6ad0136 100644 --- a/libsgl/effects/SkBlurDrawLooper.cpp +++ b/libsgl/effects/SkBlurDrawLooper.cpp @@ -84,3 +84,8 @@ void SkBlurDrawLooper::restore() } } +/////////////////////////////////////////////////////////////////////////////// + +static SkFlattenable::Registrar gReg("SkBlurDrawLooper", + SkBlurDrawLooper::CreateProc); + diff --git a/libsgl/effects/SkBlurMaskFilter.cpp b/libsgl/effects/SkBlurMaskFilter.cpp index 4201371..2db60a5 100644 --- a/libsgl/effects/SkBlurMaskFilter.cpp +++ b/libsgl/effects/SkBlurMaskFilter.cpp @@ -34,11 +34,12 @@ public: // This method is not exported to java. virtual void flatten(SkFlattenableWriteBuffer&); + static SkFlattenable* CreateProc(SkFlattenableReadBuffer&); + private: SkScalar fRadius; SkBlurMaskFilter::BlurStyle fBlurStyle; - static SkFlattenable* CreateProc(SkFlattenableReadBuffer&); SkBlurMaskFilterImpl(SkFlattenableReadBuffer&); typedef SkMaskFilter INHERITED; @@ -115,3 +116,8 @@ void SkBlurMaskFilterImpl::flatten(SkFlattenableWriteBuffer& buffer) buffer.write32(fBlurStyle); } +/////////////////////////////////////////////////////////////////////////////// + +static SkFlattenable::Registrar gReg("SkBlurMaskFilter", + SkBlurMaskFilterImpl::CreateProc); + diff --git a/libsgl/effects/SkDumpCanvas.cpp b/libsgl/effects/SkDumpCanvas.cpp new file mode 100644 index 0000000..fb203ef --- /dev/null +++ b/libsgl/effects/SkDumpCanvas.cpp @@ -0,0 +1,398 @@ +#include "SkDumpCanvas.h" +#include "SkPixelRef.h" +#include "SkString.h" +#include <stdarg.h> + +// needed just to know that these are all subclassed from SkFlattenable +#include "SkShader.h" +#include "SkPathEffect.h" +#include "SkXfermode.h" +#include "SkColorFilter.h" +#include "SkPathEffect.h" +#include "SkMaskFilter.h" + +static void toString(const SkRect& r, SkString* str) { + str->printf("[(%g %g) %g %g]", + SkScalarToFloat(r.fLeft), SkScalarToFloat(r.fTop), + SkScalarToFloat(r.width()), SkScalarToFloat(r.height())); +} + +static void toString(const SkIRect& r, SkString* str) { + str->printf("[(%d %d) %d %d]", r.fLeft, r.fTop, r.width(), r.height()); +} + +static void toString(const SkPath& path, SkString* str) { + if (path.isEmpty()) { + str->set("path:empty"); + } else { + SkRect bounds; + path.computeBounds(&bounds, SkPath::kFast_BoundsType); + toString(bounds, str); + str->append("]"); + str->prepend("path:["); + } +} + +static const char* toString(SkRegion::Op op) { + static const char* gOpNames[] = { + "DIFF", "SECT", "UNION", "XOR", "RDIFF", "REPLACE" + }; + return gOpNames[op]; +} + +static void toString(const SkRegion& rgn, SkString* str) { + toString(rgn.getBounds(), str); + str->prepend("Region:["); + str->append("]"); + if (rgn.isComplex()) { + str->append(".complex"); + } +} + +static const char* toString(SkCanvas::VertexMode vm) { + static const char* gVMNames[] = { + "TRIANGLES", "STRIP", "FAN" + }; + return gVMNames[vm]; +} + +static const char* toString(SkCanvas::PointMode pm) { + static const char* gPMNames[] = { + "POINTS", "LINES", "POLYGON" + }; + return gPMNames[pm]; +} + +static const char* toString(SkBitmap::Config config) { + static const char* gConfigNames[] = { + "NONE", "A1", "A8", "INDEX8", "565", "4444", "8888", "RLE" + }; + return gConfigNames[config]; +} + +static void toString(const SkBitmap& bm, SkString* str) { + str->printf("bitmap:[%d %d] %s", bm.width(), bm.height(), + toString(bm.config())); + + SkPixelRef* pr = bm.pixelRef(); + if (NULL == pr) { + // show null or the explicit pixel address (rare) + str->appendf(" pixels:%p", bm.getPixels()); + } else { + const char* uri = pr->getURI(); + if (uri) { + str->appendf(" uri:\"%s\"", uri); + } else { + str->appendf(" pixelref:%p", pr); + } + } +} + +static void toString(const void* text, size_t len, SkPaint::TextEncoding enc, + SkString* str) { + switch (enc) { + case SkPaint::kUTF8_TextEncoding: + str->printf("\"%.*s\"%s", SkMax32(len, 32), text, + len > 32 ? "..." : ""); + break; + case SkPaint::kUTF16_TextEncoding: + str->printf("\"%.*S\"%s", SkMax32(len, 32), text, + len > 64 ? "..." : ""); + break; + case SkPaint::kGlyphID_TextEncoding: + str->set("<glyphs>"); + break; + } +} + +/////////////////////////////////////////////////////////////////////////////// + +SkDumpCanvas::SkDumpCanvas(Dumper* dumper) { + dumper->safeRef(); + fDumper = dumper; + + static const int WIDE_OPEN = 16384; + SkBitmap emptyBitmap; + + emptyBitmap.setConfig(SkBitmap::kNo_Config, WIDE_OPEN, WIDE_OPEN); + this->setBitmapDevice(emptyBitmap); +} + +SkDumpCanvas::~SkDumpCanvas() { + fDumper->safeUnref(); +} + +void SkDumpCanvas::dump(Verb verb, const SkPaint* paint, + const char format[], ...) { + static const size_t BUFFER_SIZE = 1024; + + char buffer[BUFFER_SIZE]; + va_list args; + va_start(args, format); + vsnprintf(buffer, BUFFER_SIZE, format, args); + va_end(args); + + if (fDumper) { + fDumper->dump(this, verb, buffer, paint); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +int SkDumpCanvas::save(SaveFlags flags) { + this->dump(kSave_Verb, NULL, "save(0x%X)", flags); + return this->INHERITED::save(flags); +} + +int SkDumpCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, + SaveFlags flags) { + this->dump(kSave_Verb, paint, "saveLayer(0x%X)", flags); + return this->INHERITED::saveLayer(bounds, paint, flags); +} + +void SkDumpCanvas::restore() { + this->INHERITED::restore(); + this->dump(kRestore_Verb, NULL, "restore"); +} + +bool SkDumpCanvas::translate(SkScalar dx, SkScalar dy) { + this->dump(kMatrix_Verb, NULL, "translate(%g %g)", + SkScalarToFloat(dx), SkScalarToFloat(dy)); + return this->INHERITED::translate(dx, dy); +} + +bool SkDumpCanvas::scale(SkScalar sx, SkScalar sy) { + this->dump(kMatrix_Verb, NULL, "scale(%g %g)", + SkScalarToFloat(sx), SkScalarToFloat(sy)); + return this->INHERITED::scale(sx, sy); +} + +bool SkDumpCanvas::rotate(SkScalar degrees) { + this->dump(kMatrix_Verb, NULL, "rotate(%g)", SkScalarToFloat(degrees)); + return this->INHERITED::rotate(degrees); +} + +bool SkDumpCanvas::skew(SkScalar sx, SkScalar sy) { + this->dump(kMatrix_Verb, NULL, "skew(%g %g)", + SkScalarToFloat(sx), SkScalarToFloat(sy)); + return this->INHERITED::skew(sx, sy); +} + +bool SkDumpCanvas::concat(const SkMatrix& matrix) { + SkString str; + matrix.toDumpString(&str); + this->dump(kMatrix_Verb, NULL, "concat(%s)", str.c_str()); + return this->INHERITED::concat(matrix); +} + +void SkDumpCanvas::setMatrix(const SkMatrix& matrix) { + SkString str; + matrix.toDumpString(&str); + this->dump(kMatrix_Verb, NULL, "setMatrix(%s)", str.c_str()); + this->INHERITED::setMatrix(matrix); +} + +/////////////////////////////////////////////////////////////////////////////// + +bool SkDumpCanvas::clipRect(const SkRect& rect, SkRegion::Op op) { + SkString str; + toString(rect, &str); + this->dump(kClip_Verb, NULL, "clipRect(%s %s)", str.c_str(), toString(op)); + return this->INHERITED::clipRect(rect, op); +} + +bool SkDumpCanvas::clipPath(const SkPath& path, SkRegion::Op op) { + SkString str; + toString(path, &str); + this->dump(kClip_Verb, NULL, "clipPath(%s %s)", str.c_str(), toString(op)); + return this->INHERITED::clipPath(path, op); +} + +bool SkDumpCanvas::clipRegion(const SkRegion& deviceRgn, SkRegion::Op op) { + SkString str; + toString(deviceRgn, &str); + this->dump(kClip_Verb, NULL, "clipRegion(%s %s)", str.c_str(), + toString(op)); + return this->INHERITED::clipRegion(deviceRgn, op); +} + +/////////////////////////////////////////////////////////////////////////////// + +void SkDumpCanvas::drawPaint(const SkPaint& paint) { + this->dump(kDrawPaint_Verb, &paint, "drawPaint()"); +} + +void SkDumpCanvas::drawPoints(PointMode mode, size_t count, + const SkPoint pts[], const SkPaint& paint) { + this->dump(kDrawPoints_Verb, &paint, "drawPoints(%s, %d)", toString(mode), + count); +} + +void SkDumpCanvas::drawRect(const SkRect& rect, const SkPaint& paint) { + SkString str; + toString(rect, &str); + this->dump(kDrawRect_Verb, &paint, "drawRect(%s)", str.c_str()); +} + +void SkDumpCanvas::drawPath(const SkPath& path, const SkPaint& paint) { + SkString str; + toString(path, &str); + this->dump(kDrawPath_Verb, &paint, "drawPath(%s)", str.c_str()); +} + +void SkDumpCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y, + const SkPaint* paint) { + SkString str; + toString(bitmap, &str); + this->dump(kDrawBitmap_Verb, paint, "drawBitmap(%s (%g %g))", str.c_str(), + SkScalarToFloat(x), SkScalarToFloat(y)); +} + +void SkDumpCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, + const SkRect& dst, const SkPaint* paint) { + SkString bs, rs; + toString(bitmap, &bs); + toString(dst, &rs); + // show the src-rect only if its not everything + if (src && (src->fLeft > 0 || src->fTop > 0 || + src->fRight < bitmap.width() || + src->fBottom < bitmap.height())) { + SkString ss; + toString(*src, &ss); + rs.prependf("%s ", ss.c_str()); + } + + this->dump(kDrawBitmap_Verb, paint, "drawBitmapRect(%s %s)", + bs.c_str(), rs.c_str()); +} + +void SkDumpCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m, + const SkPaint* paint) { + SkString bs, ms; + toString(bitmap, &bs); + m.toDumpString(&ms); + this->dump(kDrawBitmap_Verb, paint, "drawBitmapMatrix(%s %s)", + bs.c_str(), ms.c_str()); +} + +void SkDumpCanvas::drawSprite(const SkBitmap& bitmap, int x, int y, + const SkPaint* paint) { + SkString str; + toString(bitmap, &str); + this->dump(kDrawBitmap_Verb, paint, "drawSprite(%s (%d %d))", str.c_str(), + x, y); +} + +void SkDumpCanvas::drawText(const void* text, size_t byteLength, SkScalar x, + SkScalar y, const SkPaint& paint) { + SkString str; + toString(text, byteLength, paint.getTextEncoding(), &str); + this->dump(kDrawText_Verb, &paint, "drawText(%s [%d] (%g %g))", str.c_str(), + byteLength, SkScalarToFloat(x), SkScalarToFloat(y)); +} + +void SkDumpCanvas::drawPosText(const void* text, size_t byteLength, + const SkPoint pos[], const SkPaint& paint) { + SkString str; + toString(text, byteLength, paint.getTextEncoding(), &str); + this->dump(kDrawText_Verb, &paint, "drawPosText(%s [%d] (%g %g ...))", + str.c_str(), byteLength, SkScalarToFloat(pos[0].fX), + SkScalarToFloat(pos[0].fY)); +} + +void SkDumpCanvas::drawPosTextH(const void* text, size_t byteLength, + const SkScalar xpos[], SkScalar constY, + const SkPaint& paint) { + SkString str; + toString(text, byteLength, paint.getTextEncoding(), &str); + this->dump(kDrawText_Verb, &paint, "drawPosTextH(%s [%d] (%g %g ...))", + str.c_str(), byteLength, SkScalarToFloat(xpos[0]), + SkScalarToFloat(constY)); +} + +void SkDumpCanvas::drawTextOnPath(const void* text, size_t byteLength, + const SkPath& path, const SkMatrix* matrix, + const SkPaint& paint) { + SkString str; + toString(text, byteLength, paint.getTextEncoding(), &str); + this->dump(kDrawText_Verb, &paint, "drawTextOnPath(%s [%d])", + str.c_str(), byteLength); +} + +void SkDumpCanvas::drawPicture(SkPicture& picture) { + this->dump(kDrawPicture_Verb, NULL, "drawPicture(%p)", &picture); +} + +void SkDumpCanvas::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) { + this->dump(kDrawVertices_Verb, &paint, "drawVertices(%s [%d] [%g %g ...]", + toString(vmode), vertexCount, SkScalarToFloat(vertices[0].fX), + SkScalarToFloat(vertices[0].fY)); +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +SkFormatDumper::SkFormatDumper(void (*proc)(const char*, void*), void* refcon) { + fProc = proc; + fRefcon = refcon; +} + +static void appendPtr(SkString* str, const void* ptr, const char name[]) { + if (ptr) { + str->appendf(" %s:%p", name, ptr); + } +} + +static void appendFlattenable(SkString* str, const SkFlattenable* ptr, + const char name[]) { + if (ptr) { + SkString info; + if (ptr->toDumpString(&info)) { + str->appendf(" %s", info.c_str()); + } else { + str->appendf(" %s:%p", name, ptr); + } + } +} + +void SkFormatDumper::dump(SkDumpCanvas* canvas, SkDumpCanvas::Verb verb, + const char str[], const SkPaint* p) { + SkString msg, tab; + const int level = canvas->getSaveCount() - 1; + SkASSERT(level >= 0); + for (int i = 0; i < level; i++) { + tab.append("\t"); + } + msg.printf("%s%s", tab.c_str(), str); + + if (p) { + msg.appendf(" color:0x%08X flags:%X", p->getColor(), p->getFlags()); + appendFlattenable(&msg, p->getShader(), "shader"); + appendFlattenable(&msg, p->getXfermode(), "xfermode"); + appendFlattenable(&msg, p->getPathEffect(), "pathEffect"); + appendFlattenable(&msg, p->getMaskFilter(), "maskFilter"); + appendFlattenable(&msg, p->getPathEffect(), "pathEffect"); + appendFlattenable(&msg, p->getColorFilter(), "filter"); + + if (SkDumpCanvas::kDrawText_Verb == verb) { + msg.appendf(" textSize:%g", SkScalarToFloat(p->getTextSize())); + appendPtr(&msg, p->getTypeface(), "typeface"); + } + } + + fProc(msg.c_str(), fRefcon); +} + +/////////////////////////////////////////////////////////////////////////////// + +static void dumpToDebugf(const char text[], void*) { + SkDebugf("%s\n", text); +} + +SkDebugfDumper::SkDebugfDumper() : INHERITED(dumpToDebugf, NULL) {} + + diff --git a/libsgl/effects/SkGradientShader.cpp b/libsgl/effects/SkGradientShader.cpp index 9b132e5..a1674cb 100644 --- a/libsgl/effects/SkGradientShader.cpp +++ b/libsgl/effects/SkGradientShader.cpp @@ -1502,11 +1502,26 @@ void Sweep_Gradient::shadeSpan16(int x, int y, uint16_t dstC[], int count) /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// +// assumes colors is SkColor* and pos is SkScalar* +#define EXPAND_1_COLOR(count) \ + SkColor tmp[2]; \ + do { \ + if (1 == count) { \ + tmp[0] = tmp[1] = colors[0]; \ + colors = tmp; \ + pos = NULL; \ + count = 2; \ + } \ + } while (0) + SkShader* SkGradientShader::CreateLinear( const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int colorCount, SkShader::TileMode mode, SkUnitMapper* mapper) { - SkASSERT(pts && colors && colorCount >= 2); + if (NULL == pts || NULL == colors || colorCount < 1) { + return NULL; + } + EXPAND_1_COLOR(colorCount); return SkNEW_ARGS(Linear_Gradient, (pts, colors, pos, colorCount, mode, mapper)); } @@ -1515,7 +1530,10 @@ SkShader* SkGradientShader::CreateRadial( const SkPoint& center, SkScalar radi const SkColor colors[], const SkScalar pos[], int colorCount, SkShader::TileMode mode, SkUnitMapper* mapper) { - SkASSERT(radius > 0 && colors && colorCount >= 2); + if (radius <= 0 || NULL == colors || colorCount < 1) { + return NULL; + } + EXPAND_1_COLOR(colorCount); return SkNEW_ARGS(Radial_Gradient, (center, radius, colors, pos, colorCount, mode, mapper)); } @@ -1525,8 +1543,11 @@ SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, const SkScalar pos[], int count, SkUnitMapper* mapper) { - SkASSERT(colors && count >= 2); - + if (NULL == colors || count < 1) { + return NULL; + } + EXPAND_1_COLOR(count); + return SkNEW_ARGS(Sweep_Gradient, (cx, cy, colors, pos, count, mapper)); } diff --git a/libsgl/effects/SkLayerDrawLooper.cpp b/libsgl/effects/SkLayerDrawLooper.cpp new file mode 100644 index 0000000..f2d8ba8 --- /dev/null +++ b/libsgl/effects/SkLayerDrawLooper.cpp @@ -0,0 +1,130 @@ +#include "SkCanvas.h" +#include "SkLayerDrawLooper.h" +#include "SkPaint.h" + +SkLayerDrawLooper::SkLayerDrawLooper() { + fRecs = NULL; + fCount = 0; +} + +SkLayerDrawLooper::~SkLayerDrawLooper() { + Rec* rec = fRecs; + while (rec) { + Rec* next = rec->fNext; + SkDELETE(rec); + rec = next; + } +} + +SkPaint* SkLayerDrawLooper::addLayer(SkScalar dx, SkScalar dy) { + fCount += 1; + + Rec* rec = SkNEW(Rec); + rec->fNext = fRecs; + rec->fOffset.set(dx, dy); + fRecs = rec; + + return &rec->fPaint; +} + +void SkLayerDrawLooper::init(SkCanvas* canvas, SkPaint* paint) { + fIter.fSavedPaint = *paint; + fIter.fPaint = paint; + fIter.fCanvas = canvas; + fIter.fRec = fRecs; + canvas->save(SkCanvas::kMatrix_SaveFlag); +} + +bool SkLayerDrawLooper::next() { + Rec* rec = fIter.fRec; + if (rec) { + *fIter.fPaint = rec->fPaint; + fIter.fCanvas->restore(); + fIter.fCanvas->save(SkCanvas::kMatrix_SaveFlag); + fIter.fCanvas->translate(rec->fOffset.fX, rec->fOffset.fY); + + fIter.fRec = rec->fNext; + return true; + } + return false; +} + +void SkLayerDrawLooper::restore() { + fIter.fCanvas->restore(); + *fIter.fPaint = fIter.fSavedPaint; +} + +SkLayerDrawLooper::Rec* SkLayerDrawLooper::Rec::Reverse(Rec* head) { + Rec* rec = head; + Rec* prev = NULL; + while (rec) { + Rec* next = rec->fNext; + rec->fNext = prev; + prev = rec; + rec = next; + } + return prev; +} + +/////////////////////////////////////////////////////////////////////////////// + +void SkLayerDrawLooper::flatten(SkFlattenableWriteBuffer& buffer) { + this->INHERITED::flatten(buffer); + +#ifdef SK_DEBUG + { + Rec* rec = fRecs; + int count = 0; + while (rec) { + rec = rec->fNext; + count += 1; + } + SkASSERT(count == fCount); + } +#endif + + buffer.writeInt(fCount); + + Rec* rec = fRecs; + for (int i = 0; i < fCount; i++) { + buffer.writeScalar(rec->fOffset.fX); + buffer.writeScalar(rec->fOffset.fY); + rec->fPaint.flatten(buffer); + rec = rec->fNext; + } +} + +SkLayerDrawLooper::SkLayerDrawLooper(SkFlattenableReadBuffer& buffer) + : INHERITED(buffer) { + fRecs = NULL; + fCount = 0; + + int count = buffer.readInt(); + + for (int i = 0; i < count; i++) { + SkScalar dx = buffer.readScalar(); + SkScalar dy = buffer.readScalar(); + this->addLayer(dx, dy)->unflatten(buffer); + } + SkASSERT(count == fCount); + + // we're in reverse order, so fix it now + fRecs = Rec::Reverse(fRecs); + +#ifdef SK_DEBUG + { + Rec* rec = fRecs; + int n = 0; + while (rec) { + rec = rec->fNext; + n += 1; + } + SkASSERT(count == n); + } +#endif +} + +/////////////////////////////////////////////////////////////////////////////// + +static SkFlattenable::Registrar gReg("SkLayerDrawLooper", + SkLayerDrawLooper::CreateProc); diff --git a/libsgl/effects/SkProxyCanvas.cpp b/libsgl/effects/SkProxyCanvas.cpp new file mode 100644 index 0000000..2a02b45 --- /dev/null +++ b/libsgl/effects/SkProxyCanvas.cpp @@ -0,0 +1,162 @@ +#include "SkProxyCanvas.h" + +SkProxyCanvas::SkProxyCanvas(SkCanvas* proxy) : fProxy(proxy) { + fProxy->safeRef(); +} + +SkProxyCanvas::~SkProxyCanvas() { + fProxy->safeUnref(); +} + +void SkProxyCanvas::setProxy(SkCanvas* proxy) { + SkRefCnt_SafeAssign(fProxy, proxy); +} + +///////////////////////////////// Overrides /////////// + +bool SkProxyCanvas::getViewport(SkIPoint* size) const { + return fProxy->getViewport(size); +} + +bool SkProxyCanvas::setViewport(int x, int y) { + return fProxy->setViewport(x, y); +} + +SkDevice* SkProxyCanvas::setBitmapDevice(const SkBitmap& bitmap) { + return fProxy->setBitmapDevice(bitmap); +} + +int SkProxyCanvas::save(SaveFlags flags) { + return fProxy->save(flags); +} + +int SkProxyCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, + SaveFlags flags) { + return fProxy->saveLayer(bounds, paint, flags); +} + +void SkProxyCanvas::restore() { + fProxy->restore(); +} + +bool SkProxyCanvas::translate(SkScalar dx, SkScalar dy) { + return fProxy->translate(dx, dy); +} + +bool SkProxyCanvas::scale(SkScalar sx, SkScalar sy) { + return fProxy->scale(sx, sy); +} + +bool SkProxyCanvas::rotate(SkScalar degrees) { + return fProxy->rotate(degrees); +} + +bool SkProxyCanvas::skew(SkScalar sx, SkScalar sy) { + return fProxy->skew(sx, sy); +} + +bool SkProxyCanvas::concat(const SkMatrix& matrix) { + return fProxy->concat(matrix); +} + +void SkProxyCanvas::setMatrix(const SkMatrix& matrix) { + fProxy->setMatrix(matrix); +} + +bool SkProxyCanvas::clipRect(const SkRect& rect, SkRegion::Op op) { + return fProxy->clipRect(rect, op); +} + +bool SkProxyCanvas::clipPath(const SkPath& path, SkRegion::Op op) { + return fProxy->clipPath(path, op); +} + +bool SkProxyCanvas::clipRegion(const SkRegion& deviceRgn, SkRegion::Op op) { + return fProxy->clipRegion(deviceRgn, op); +} + +void SkProxyCanvas::drawPaint(const SkPaint& paint) { + fProxy->drawPaint(paint); +} + +void SkProxyCanvas::drawPoints(PointMode mode, size_t count, + const SkPoint pts[], const SkPaint& paint) { + fProxy->drawPoints(mode, count, pts, paint); +} + +void SkProxyCanvas::drawRect(const SkRect& rect, const SkPaint& paint) { + fProxy->drawRect(rect, paint); +} + +void SkProxyCanvas::drawPath(const SkPath& path, const SkPaint& paint) { + fProxy->drawPath(path, paint); +} + +void SkProxyCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y, + const SkPaint* paint) { + fProxy->drawBitmap(bitmap, x, y, paint); +} + +void SkProxyCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, + const SkRect& dst, const SkPaint* paint) { + fProxy->drawBitmapRect(bitmap, src, dst, paint); +} + +void SkProxyCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m, + const SkPaint* paint) { + fProxy->drawBitmapMatrix(bitmap, m, paint); +} + +void SkProxyCanvas::drawSprite(const SkBitmap& bitmap, int x, int y, + const SkPaint* paint) { + fProxy->drawSprite(bitmap, x, y, paint); +} + +void SkProxyCanvas::drawText(const void* text, size_t byteLength, SkScalar x, + SkScalar y, const SkPaint& paint) { + fProxy->drawText(text, byteLength, x, y, paint); +} + +void SkProxyCanvas::drawPosText(const void* text, size_t byteLength, + const SkPoint pos[], const SkPaint& paint) { + fProxy->drawPosText(text, byteLength, pos, paint); +} + +void SkProxyCanvas::drawPosTextH(const void* text, size_t byteLength, + const SkScalar xpos[], SkScalar constY, + const SkPaint& paint) { + fProxy->drawPosTextH(text, byteLength, xpos, constY, paint); +} + +void SkProxyCanvas::drawTextOnPath(const void* text, size_t byteLength, + const SkPath& path, const SkMatrix* matrix, + const SkPaint& paint) { + fProxy->drawTextOnPath(text, byteLength, path, matrix, paint); +} + +void SkProxyCanvas::drawPicture(SkPicture& picture) { + fProxy->drawPicture(picture); +} + +void SkProxyCanvas::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) { + fProxy->drawVertices(vmode, vertexCount, vertices, texs, colors, + xmode, indices, indexCount, paint); +} + +SkBounder* SkProxyCanvas::setBounder(SkBounder* bounder) { + return fProxy->setBounder(bounder); +} + +SkDrawFilter* SkProxyCanvas::setDrawFilter(SkDrawFilter* filter) { + return fProxy->setDrawFilter(filter); +} + +SkDevice* SkProxyCanvas::createDevice(SkBitmap::Config config, int width, + int height, bool isOpaque, bool isForLayer) { + return fProxy->createDevice(config, width, height, isOpaque, isForLayer); +} + diff --git a/libsgl/images/SkFDStream.cpp b/libsgl/images/SkFDStream.cpp new file mode 100644 index 0000000..db4a51a --- /dev/null +++ b/libsgl/images/SkFDStream.cpp @@ -0,0 +1,85 @@ +#include "SkStream.h" +#include <unistd.h> + +//#define TRACE_FDSTREAM + +SkFDStream::SkFDStream(int fileDesc, bool closeWhenDone) + : fFD(fileDesc), fCloseWhenDone(closeWhenDone) { +} + +SkFDStream::~SkFDStream() { + if (fFD >= 0 && fCloseWhenDone) { + ::close(fFD); + } +} + +bool SkFDStream::rewind() { + if (fFD >= 0) { + off_t value = ::lseek(fFD, 0, SEEK_SET); +#ifdef TRACE_FDSTREAM + if (value) { + SkDebugf("xxxxxxxxxxxxxx rewind failed %d\n", value); + } +#endif + return value == 0; + } + return false; +} + +size_t SkFDStream::read(void* buffer, size_t size) { + if (fFD >= 0) { + if (buffer == NULL && size == 0) { // request total size + off_t curr = ::lseek(fFD, 0, SEEK_CUR); + if (curr < 0) { +#ifdef TRACE_FDSTREAM + SkDebugf("xxxxxxxxxxxxx lseek failed 0 CURR\n"); +#endif + return 0; // error + } + off_t size = ::lseek(fFD, 0, SEEK_END); + if (size < 0) { +#ifdef TRACE_FDSTREAM + SkDebugf("xxxxxxxxxxxxx lseek failed 0 END\n"); +#endif + size = 0; // error + } + if (::lseek(fFD, curr, SEEK_SET) != curr) { + // can't restore, error +#ifdef TRACE_FDSTREAM + SkDebugf("xxxxxxxxxxxxx lseek failed %d SET\n", curr); +#endif + return 0; + } + return size; + } else if (NULL == buffer) { // skip + off_t oldCurr = ::lseek(fFD, 0, SEEK_CUR); + if (oldCurr < 0) { +#ifdef TRACE_FDSTREAM + SkDebugf("xxxxxxxxxxxxx lseek1 failed %d CUR\n", oldCurr); +#endif + return 0; // error; + } + off_t newCurr = ::lseek(fFD, size, SEEK_CUR); + if (newCurr < 0) { +#ifdef TRACE_FDSTREAM + SkDebugf("xxxxxxxxxxxxx lseek2 failed %d CUR\n", newCurr); +#endif + return 0; // error; + } + // return the actual amount we skipped + return newCurr - oldCurr; + } else { // read + ssize_t actual = ::read(fFD, buffer, size); + // our API can't return an error, so we return 0 + if (actual < 0) { +#ifdef TRACE_FDSTREAM + SkDebugf("xxxxxxxxxxxxx read failed %d actual %d\n", size, actual); +#endif + actual = 0; + } + return actual; + } + } + return 0; +} + diff --git a/libsgl/images/SkFlipPixelRef.cpp b/libsgl/images/SkFlipPixelRef.cpp new file mode 100644 index 0000000..95403cc --- /dev/null +++ b/libsgl/images/SkFlipPixelRef.cpp @@ -0,0 +1,127 @@ +#include "SkFlipPixelRef.h" +#include "SkFlattenable.h" +#include "SkRegion.h" + +SkFlipPixelRef::SkFlipPixelRef(SkBitmap::Config config, int width, int height) +: fFlipper(width, height) { + fConfig = config; + fSize = SkBitmap::ComputeSize(config, width, height); + fStorage = sk_malloc_throw(fSize << 1); + fPage0 = fStorage; + fPage1 = (char*)fStorage + fSize; +} + +SkFlipPixelRef::~SkFlipPixelRef() { + sk_free(fStorage); +} + +const SkRegion& SkFlipPixelRef::beginUpdate(SkBitmap* device) { + void* writeAddr; + const void* readAddr; + this->getFrontBack(&readAddr, &writeAddr); + + device->setConfig(fConfig, fFlipper.width(), fFlipper.height()); + device->setPixels(writeAddr); + + SkRegion copyBits; + const SkRegion& dirty = fFlipper.update(©Bits); + + SkFlipPixelRef::CopyBitsFromAddr(*device, copyBits, readAddr); + return dirty; +} + +void SkFlipPixelRef::endUpdate() { + this->swapPages(); +} + +/////////////////////////////////////////////////////////////////////////////// + +void* SkFlipPixelRef::onLockPixels(SkColorTable** ct) { + fMutex.acquire(); + *ct = NULL; + return fPage0; +} + +void SkFlipPixelRef::onUnlockPixels() { + fMutex.release(); +} + +void SkFlipPixelRef::swapPages() { + fMutex.acquire(); + SkTSwap<void*>(fPage0, fPage1); + fMutex.release(); +} + +void SkFlipPixelRef::flatten(SkFlattenableWriteBuffer& buffer) const { + this->INHERITED::flatten(buffer); + + buffer.write32(fSize); + // only need to write page0 + buffer.writePad(fPage0, fSize); +} + +SkFlipPixelRef::SkFlipPixelRef(SkFlattenableReadBuffer& buffer) + : INHERITED(buffer, NULL) { + fSize = buffer.readU32(); + fStorage = sk_malloc_throw(fSize << 1); + fPage0 = fStorage; + fPage1 = (char*)fStorage + fSize; + buffer.read(fPage0, fSize); +} + +SkPixelRef* SkFlipPixelRef::Create(SkFlattenableReadBuffer& buffer) { + return SkNEW_ARGS(SkFlipPixelRef, (buffer)); +} + +static SkPixelRef::Registrar::Registrar reg("SkFlipPixelRef", + SkFlipPixelRef::Create); + +/////////////////////////////////////////////////////////////////////////////// + +static void copyRect(const SkBitmap& dst, const SkIRect& rect, + const void* srcAddr, int shift) { + const size_t offset = rect.fTop * dst.rowBytes() + (rect.fLeft << shift); + char* dstP = static_cast<char*>(dst.getPixels()) + offset; + const char* srcP = static_cast<const char*>(srcAddr) + offset; + const size_t rb = dst.rowBytes(); + const size_t bytes = rect.width() << shift; + + int height = rect.height(); + while (--height >= 0) { + memcpy(dstP, srcP, bytes); + dstP += rb; + srcP += rb; + } +} + +static int getShift(SkBitmap::Config config) { + switch (config) { + case SkBitmap::kARGB_8888_Config: + return 2; + case SkBitmap::kRGB_565_Config: + case SkBitmap::kARGB_4444_Config: + return 1; + case SkBitmap::kIndex8_Config: + case SkBitmap::kA8_Config: + return 0; + default: + return -1; // signal not supported + } +} + +void SkFlipPixelRef::CopyBitsFromAddr(const SkBitmap& dst, const SkRegion& clip, + const void* srcAddr) { + const int shift = getShift(dst.config()); + if (shift < 0) { + return; + } + + const SkIRect bounds = {0, 0, dst.width(), dst.height()}; + SkRegion::Cliperator iter(clip, bounds); + + while (!iter.done()) { + copyRect(dst, iter.rect(), srcAddr, shift); + iter.next(); + } +} + diff --git a/libsgl/images/SkImageDecoder.cpp b/libsgl/images/SkImageDecoder.cpp index 405b660..18b52d6 100644 --- a/libsgl/images/SkImageDecoder.cpp +++ b/libsgl/images/SkImageDecoder.cpp @@ -16,6 +16,8 @@ */ #include "SkImageDecoder.h" +#include "SkBitmap.h" +#include "SkPixelRef.h" #include "SkStream.h" #include "SkTemplates.h" @@ -118,8 +120,13 @@ bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm, SkASSERT(bm); SkFILEStream stream(file); - return stream.isValid() && - SkImageDecoder::DecodeStream(&stream, bm, pref, mode); + if (stream.isValid()) { + if (SkImageDecoder::DecodeStream(&stream, bm, pref, mode)) { + bm->pixelRef()->setURI(file); + } + return true; + } + return false; } bool SkImageDecoder::DecodeMemory(const void* buffer, size_t size, SkBitmap* bm, @@ -167,5 +174,17 @@ bool SkImageEncoder::encodeFile(const char file[], const SkBitmap& bm, return this->onEncode(&stream, bm, quality); } +bool SkImageEncoder::EncodeFile(const char file[], const SkBitmap& bm, Type t, + int quality) { + SkAutoTDelete<SkImageEncoder> enc(SkImageEncoder::Create(t)); + return enc.get() && enc.get()->encodeFile(file, bm, quality); +} + +bool SkImageEncoder::EncodeStream(SkWStream* stream, const SkBitmap& bm, Type t, + int quality) { + SkAutoTDelete<SkImageEncoder> enc(SkImageEncoder::Create(t)); + return enc.get() && enc.get()->encodeStream(stream, bm, quality); +} + #endif diff --git a/libsgl/images/SkImageDecoder_libgif.cpp b/libsgl/images/SkImageDecoder_libgif.cpp index 9353c37..519366a 100644 --- a/libsgl/images/SkImageDecoder_libgif.cpp +++ b/libsgl/images/SkImageDecoder_libgif.cpp @@ -114,9 +114,9 @@ void CheckFreeExtension(SavedImage* Image) { // return NULL on failure static const ColorMapObject* find_colormap(const GifFileType* gif) { - const ColorMapObject* cmap = gif->SColorMap; + const ColorMapObject* cmap = gif->Image.ColorMap; if (NULL == cmap) { - cmap = gif->Image.ColorMap; + cmap = gif->SColorMap; } // some sanity checks if ((unsigned)cmap->ColorCount > 256 || @@ -145,11 +145,20 @@ static int find_transpIndex(const SavedImage& image, int colorCount) { return transpIndex; } +static bool error_return(GifFileType* gif, const SkBitmap& bm, + const char msg[]) { +#if 0 + SkDebugf("libgif error <%s> bitmap [%d %d] pixels %p colortable %p\n", + msg, bm.width(), bm.height(), bm.getPixels(), bm.getColorTable()); +#endif + return false; +} + bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, SkBitmap::Config prefConfig, Mode mode) { GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc); if (NULL == gif) { - return false; + return error_return(gif, *bm, "DGifOpen"); } SkAutoTCallIProc<GifFileType, DGifCloseFile> acp(gif); @@ -165,17 +174,17 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, do { if (DGifGetRecordType(gif, &recType) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "DGifGetRecordType"); } switch (recType) { case IMAGE_DESC_RECORD_TYPE: { if (DGifGetImageDesc(gif) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "IMAGE_DESC_RECORD_TYPE"); } if (gif->ImageCount < 1) { // sanity check - return false; + return error_return(gif, *bm, "ImageCount < 1"); } width = gif->SWidth; @@ -183,7 +192,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, if (width <= 0 || height <= 0 || !this->chooseFromOneChoice(SkBitmap::kIndex8_Config, width, height)) { - return false; + return error_return(gif, *bm, "chooseFromOneChoice"); } bm->setConfig(SkBitmap::kIndex8_Config, width, height); @@ -197,7 +206,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, if ( (desc.Top | desc.Left) < 0 || desc.Left + desc.Width > width || desc.Top + desc.Height > height) { - return false; + return error_return(gif, *bm, "TopLeft"); } // now we decode the colortable @@ -205,7 +214,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, { const ColorMapObject* cmap = find_colormap(gif); if (NULL == cmap) { - return false; + return error_return(gif, *bm, "null cmap"); } colorCount = cmap->ColorCount; @@ -226,7 +235,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, SkAutoUnref aurts(ctable); if (!this->allocPixelRef(bm, ctable)) { - return false; + return error_return(gif, *bm, "allocPixelRef"); } } @@ -241,7 +250,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, // abort if either inner dimension is <= 0 if (innerWidth <= 0 || innerHeight <= 0) { - return false; + return error_return(gif, *bm, "non-pos inner width/height"); } // are we only a subset of the total bounds? @@ -266,7 +275,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, { uint8_t* row = scanline + iter.currY() * rowBytes; if (DGifGetLine(gif, row, innerWidth) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "interlace DGifGetLine"); } iter.next(); } @@ -276,7 +285,7 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, // easy, non-interlace case for (int y = 0; y < innerHeight; y++) { if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "DGifGetLine"); } scanline += rowBytes; } @@ -287,17 +296,17 @@ bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, case EXTENSION_RECORD_TYPE: if (DGifGetExtension(gif, &temp_save.Function, &extData) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "DGifGetExtension"); } while (extData != NULL) { /* Create an extension block with our data */ if (AddExtensionBlock(&temp_save, extData[0], &extData[1]) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "AddExtensionBlock"); } if (DGifGetExtensionNext(gif, &extData) == GIF_ERROR) { - return false; + return error_return(gif, *bm, "DGifGetExtensionNext"); } temp_save.Function = 0; } diff --git a/libsgl/images/SkImageDecoder_libico.cpp b/libsgl/images/SkImageDecoder_libico.cpp index 6407f86..b179a6b 100644 --- a/libsgl/images/SkImageDecoder_libico.cpp +++ b/libsgl/images/SkImageDecoder_libico.cpp @@ -82,6 +82,20 @@ static void editPixelBit32(const int pixelNo, const unsigned char* buf, const int xorOffset, int& x, int y, const int w, SkBitmap* bm, int alphaByte, int m, int shift, SkPMColor* colors); + +static int calculateRowBytesFor8888(int w, int bitCount) +{ + // Default rowBytes is w << 2 for kARGB_8888 + // In the case of a 4 bit image with an odd width, we need to add some + // so we can go off the end of the drawn bitmap. + // Add 4 to ensure that it is still a multiple of 4. + if (4 == bitCount && (w & 0x1)) { + return (w + 1) << 2; + } + // Otherwise return 0, which will allow it to be calculated automatically. + return 0; +} + bool SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, SkBitmap::Config pref, Mode mode) { @@ -241,11 +255,8 @@ bool SkICOImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, //FIXME: what is the tradeoff in size? //if the andbitmap (mask) is all zeroes, then we can easily do an index bitmap //however, with small images with large colortables, maybe it's better to still do argb_8888 - //default rowBytes is w << 2 for kARGB_8888 - //i'm adding one - it's only truly necessary in the case that w is odd and we are four bit - //so we can go off the end of the drawn bitmap - //FIXME: need to test with an odd width bitmap that is 4bit - bm->setConfig(SkBitmap::kARGB_8888_Config, w, h, (w << 2) + (0x1 & w & (bitCount >> 2))); + + bm->setConfig(SkBitmap::kARGB_8888_Config, w, h, calculateRowBytesFor8888(w, bitCount)); if (SkImageDecoder::kDecodeBounds_Mode == mode) { delete[] colors; @@ -298,7 +309,12 @@ static void editPixelBit1(const int pixelNo, const unsigned char* buf, int byte = readByte(buf, xorOffset + (pixelNo >> 3)); int colorBit; int alphaBit; + // Read all of the bits in this byte. int i = x + 8; + // Pin to the width so we do not write outside the bounds of + // our color table. + i = i > w ? w : i; + // While loop to check all 8 bits individually. while (x < i) { diff --git a/libsgl/images/SkImageDecoder_libjpeg.cpp b/libsgl/images/SkImageDecoder_libjpeg.cpp index e0702c2..492de23 100644 --- a/libsgl/images/SkImageDecoder_libjpeg.cpp +++ b/libsgl/images/SkImageDecoder_libjpeg.cpp @@ -51,7 +51,20 @@ protected: }; SkImageDecoder* SkImageDecoder_JPEG_Factory(SkStream* stream) { - // !!! unimplemented; rely on PNG test first for now + static const char gHeader[] = { 0xFF, 0xD8, 0xFF }; + static const size_t HEADER_SIZE = sizeof(gHeader); + + char buffer[HEADER_SIZE]; + size_t len = stream->read(buffer, HEADER_SIZE); + + if (len != HEADER_SIZE) { + return NULL; // can't read enough + } + + if (memcmp(buffer, gHeader, HEADER_SIZE)) { + return NULL; + } + return SkNEW(SkJPEGImageDecoder); } @@ -140,7 +153,7 @@ static void sk_skip_input_data(j_decompress_ptr cinfo, long num_bytes) { if (bytesToSkip > 0) { size_t bytes = src->fStream->skip(bytesToSkip); if (bytes != (size_t)bytesToSkip) { - SkDebugf("xxxxxxxxxxxxxx failure to skip request %d actual %d\n", bytesToSkip, bytes); +// SkDebugf("xxxxxxxxxxxxxx failure to skip request %d actual %d\n", bytesToSkip, bytes); cinfo->err->error_exit((j_common_ptr)cinfo); } src->next_input_byte = (const JOCTET*)src->fBuffer; @@ -241,13 +254,28 @@ static void sk_error_exit(j_common_ptr cinfo) { /////////////////////////////////////////////////////////////////////////////// -static void skip_src_rows(jpeg_decompress_struct* cinfo, void* buffer, +static bool skip_src_rows(jpeg_decompress_struct* cinfo, void* buffer, int count) { for (int i = 0; i < count; i++) { JSAMPLE* rowptr = (JSAMPLE*)buffer; int row_count = jpeg_read_scanlines(cinfo, &rowptr, 1); - SkASSERT(row_count == 1); + if (row_count != 1) { + return false; + } } + return true; +} + +// This guy exists just to aid in debugging, as it allows debuggers to just +// set a break-point in one place to see all error exists. +static bool return_false(const jpeg_decompress_struct& cinfo, + const SkBitmap& bm, const char msg[]) { +#if 0 + SkDebugf("libjpeg error %d <%s> from %s [%d %d]", cinfo.err->msg_code, + cinfo.err->jpeg_message_table[cinfo.err->msg_code], msg, + bm.width(), bm.height()); +#endif + return false; // must always return false } bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, @@ -269,16 +297,7 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, // All objects need to be instantiated before this setjmp call so that // they will be cleaned up properly if an error occurs. if (setjmp(sk_err.fJmpBuf)) { - int code = sk_err.msg_code; - if (code != JERR_TOO_LITTLE_DATA) { - if ((unsigned)code <= (unsigned)sk_err.last_jpeg_message) { - SkDebugf("xxxxxxxxxxx jpeg error %d %s\n", code, - sk_err.jpeg_message_table[code]); - } else { - SkDebugf("xxxxxxxxxxxxxxxxxxxxx jpeg error %d\n", code); - } - } - return false; + return return_false(cinfo, *bm, "setjmp"); } jpeg_create_decompress(&cinfo); @@ -287,7 +306,10 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, //jpeg_stdio_src(&cinfo, file); cinfo.src = &sk_stream; - jpeg_read_header(&cinfo, true); + int status = jpeg_read_header(&cinfo, true); + if (status != JPEG_HEADER_OK) { + return return_false(cinfo, *bm, "read_header"); + } /* Try to fulfill the requested sampleSize. Since jpeg can do it (when it can) much faster that we, just use their num/denom api to approximate @@ -342,7 +364,9 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, after jpeg_read_header(). To see the scaled dimensions, we have to call jpeg_start_decompress(), and then read output_width and output_height. */ - jpeg_start_decompress(&cinfo); + if (!jpeg_start_decompress(&cinfo)) { + return return_false(cinfo, *bm, "start_decompress"); + } /* If we need to better match the request, we might examine the image and output dimensions, and determine if the downsampling jpeg provided is @@ -357,7 +381,7 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, // should we allow the Chooser (if present) to pick a config for us??? if (!this->chooseFromOneChoice(config, cinfo.output_width, cinfo.output_height)) { - return false; + return return_false(cinfo, *bm, "chooseFromOneChoice"); } #ifdef ANDROID_RGB @@ -375,32 +399,27 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, if (SkImageDecoder::kDecodeBounds_Mode == mode) { return true; } -#if 0 - if (bm->getSize() > 20*1024) { - SkDebugf("------------------- bm1 size %d [%d %d] %d\n", bm->getSize(), bm->width(), bm->height(), bm->config()); - } -#endif if (!this->allocPixelRef(bm, NULL)) { - SkDebugf("xxxxxxxxxxxxxxxxxxxx allocPixelRef failed\n"); - return false; + return return_false(cinfo, *bm, "allocPixelRef"); } SkAutoLockPixels alp(*bm); JSAMPLE* rowptr = (JSAMPLE*)bm->getPixels(); INT32 const bpr = bm->rowBytes(); - bool success = true; while (cinfo.output_scanline < cinfo.output_height) { int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1); // if row_count == 0, then we didn't get a scanline, so abort. // if we supported partial images, we might return true in this case - if (0 == row_count || this->shouldCancelDecode()) { - success = false; - break; + if (0 == row_count) { + return return_false(cinfo, *bm, "read_scanlines"); + } + if (this->shouldCancelDecode()) { + return return_false(cinfo, *bm, "shouldCancelDecode"); } rowptr += bpr; } jpeg_finish_decompress(&cinfo); - return success; + return true; } #endif @@ -418,9 +437,7 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, JCS_GRAYSCALE == cinfo.out_color_space) { sc = SkScaledBitmapSampler::kGray; } else { - SkDebugf("SkJPEGImageDecoder: unsupported jpeg colorspace %d with %d components\n", - cinfo.jpeg_color_space, cinfo.num_components); - return false; + return return_false(cinfo, *bm, "jpeg colorspace"); } SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, @@ -434,43 +451,52 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, return true; } if (!this->allocPixelRef(bm, NULL)) { - SkDebugf("xxxxxxxxxxxxxxxxxxxx allocPixelRef failed\n"); - return false; + return return_false(cinfo, *bm, "allocPixelRef"); } SkAutoLockPixels alp(*bm); if (!sampler.begin(bm, sc, this->getDitherImage())) { - SkDebugf("xxxxxxxxxxxxxxxxxxxx sampler.begin failed\n"); - return false; + return return_false(cinfo, *bm, "sampler.begin"); } uint8_t* srcRow = (uint8_t*)srcStorage.alloc(cinfo.output_width * 4); - skip_src_rows(&cinfo, srcRow, sampler.srcY0()); - bool success = true; + // Possibly skip initial rows [sampler.srcY0] + if (!skip_src_rows(&cinfo, srcRow, sampler.srcY0())) { + return return_false(cinfo, *bm, "skip rows"); + } + + // now loop through scanlines until y == bm->height() - 1 for (int y = 0;; y++) { JSAMPLE* rowptr = (JSAMPLE*)srcRow; int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1); - if (0 == row_count || this->shouldCancelDecode()) { - success = false; - break; + if (0 == row_count) { + return return_false(cinfo, *bm, "read_scanlines"); + } + if (this->shouldCancelDecode()) { + return return_false(cinfo, *bm, "shouldCancelDecode"); } sampler.next(srcRow); if (bm->height() - 1 == y) { + // we're done break; } - skip_src_rows(&cinfo, srcRow, sampler.srcDY() - 1); + + if (!skip_src_rows(&cinfo, srcRow, sampler.srcDY() - 1)) { + return return_false(cinfo, *bm, "skip rows"); + } } - // ??? If I don't do this, I get an error from finish_decompress - if (success) { - skip_src_rows(&cinfo, srcRow, cinfo.output_height - cinfo.output_scanline); + // we formally skip the rest, so we don't get a complaint from libjpeg + if (!skip_src_rows(&cinfo, srcRow, + cinfo.output_height - cinfo.output_scanline)) { + return return_false(cinfo, *bm, "skip rows"); } jpeg_finish_decompress(&cinfo); // SkDebugf("------------------- bm2 size %d [%d %d] %d\n", bm->getSize(), bm->width(), bm->height(), bm->config()); - return success; + return true; } /////////////////////////////////////////////////////////////////////////////// diff --git a/libsgl/images/SkImageDecoder_libpng.cpp b/libsgl/images/SkImageDecoder_libpng.cpp index 017e9cd..862ebf1 100644 --- a/libsgl/images/SkImageDecoder_libpng.cpp +++ b/libsgl/images/SkImageDecoder_libpng.cpp @@ -543,8 +543,19 @@ static void transform_scanline_4444(const char* SK_RESTRICT src, int width, } } +static void transform_scanline_index8(const char* SK_RESTRICT src, int width, + char* SK_RESTRICT dst) { + memcpy(dst, src, width); +} + static transform_scanline_proc choose_proc(SkBitmap::Config config, bool hasAlpha) { + // we don't care about search on alpha if we're kIndex8, since only the + // colortable packing cares about that distinction, not the pixels + if (SkBitmap::kIndex8_Config == config) { + hasAlpha = false; // we store false in the table entries for kIndex8 + } + static const struct { SkBitmap::Config fConfig; bool fHasAlpha; @@ -555,6 +566,7 @@ static transform_scanline_proc choose_proc(SkBitmap::Config config, { SkBitmap::kARGB_8888_Config, true, transform_scanline_8888 }, { SkBitmap::kARGB_4444_Config, false, transform_scanline_444 }, { SkBitmap::kARGB_4444_Config, true, transform_scanline_4444 }, + { SkBitmap::kIndex8_Config, false, transform_scanline_index8 }, }; for (int i = SK_ARRAY_COUNT(gMap) - 1; i >= 0; --i) { @@ -566,6 +578,78 @@ static transform_scanline_proc choose_proc(SkBitmap::Config config, return NULL; } +// return the minimum legal bitdepth (by png standards) for this many colortable +// entries. SkBitmap always stores in 8bits per pixel, but for colorcount <= 16, +// we can use fewer bits per in png +static int computeBitDepth(int colorCount) { +#if 0 + int bits = SkNextLog2(colorCount); + SkASSERT(bits >= 1 && bits <= 8); + // now we need bits itself to be a power of 2 (e.g. 1, 2, 4, 8) + return SkNextPow2(bits); +#else + // for the moment, we don't know how to pack bitdepth < 8 + return 8; +#endif +} + +/* Pack palette[] with the corresponding colors, and if hasAlpha is true, also + pack trans[] and return the number of trans[] entries written. If hasAlpha + is false, the return value will always be 0. + + Note: this routine takes care of unpremultiplying the RGB values when we + have alpha in the colortable, since png doesn't support premul colors +*/ +static int pack_palette(SkColorTable* ctable, png_color* SK_RESTRICT palette, + png_byte* SK_RESTRICT trans, bool hasAlpha) { + SkAutoLockColors alc(ctable); + const SkPMColor* SK_RESTRICT colors = alc.colors(); + const int ctCount = ctable->count(); + int i, num_trans = 0; + + if (hasAlpha) { + /* first see if we have some number of fully opaque at the end of the + ctable. PNG allows num_trans < num_palette, but all of the trans + entries must come first in the palette. If I was smarter, I'd + reorder the indices and ctable so that all non-opaque colors came + first in the palette. But, since that would slow down the encode, + I'm leaving the indices and ctable order as is, and just looking + at the tail of the ctable for opaqueness. + */ + num_trans = ctCount; + for (i = ctCount - 1; i >= 0; --i) { + if (SkGetPackedA32(colors[i]) != 0xFF) { + break; + } + num_trans -= 1; + } + + const SkUnPreMultiply::Scale* SK_RESTRICT table = + SkUnPreMultiply::GetScaleTable(); + + for (i = 0; i < num_trans; i++) { + const SkPMColor c = *colors++; + const unsigned a = SkGetPackedA32(c); + const SkUnPreMultiply::Scale s = table[a]; + trans[i] = a; + palette[i].red = SkUnPreMultiply::ApplyScale(s, SkGetPackedR32(c)); + palette[i].green = SkUnPreMultiply::ApplyScale(s,SkGetPackedG32(c)); + palette[i].blue = SkUnPreMultiply::ApplyScale(s, SkGetPackedB32(c)); + } + // now fall out of this if-block to use common code for the trailing + // opaque entries + } + + // these (remaining) entries are opaque + for (i = num_trans; i < ctCount; i++) { + SkPMColor c = *colors++; + palette[i].red = SkGetPackedR32(c); + palette[i].green = SkGetPackedG32(c); + palette[i].blue = SkGetPackedB32(c); + } + return num_trans; +} + class SkPNGImageEncoder : public SkImageEncoder { protected: virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality); @@ -576,20 +660,25 @@ bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, SkBitmap::Config config = bitmap.getConfig(); const bool hasAlpha = !bitmap.isOpaque(); + int colorType = PNG_COLOR_MASK_COLOR; + int bitDepth = 8; // default for color png_color_8 sig_bit; switch (config) { + case SkBitmap::kIndex8_Config: + colorType |= PNG_COLOR_MASK_PALETTE; + // fall through to the ARGB_8888 case case SkBitmap::kARGB_8888_Config: sig_bit.red = 8; sig_bit.green = 8; sig_bit.blue = 8; - sig_bit.alpha = hasAlpha ? 8 : 0; + sig_bit.alpha = 8; break; case SkBitmap::kARGB_4444_Config: sig_bit.red = 4; sig_bit.green = 4; sig_bit.blue = 4; - sig_bit.alpha = hasAlpha ? 4 : 0; + sig_bit.alpha = 4; break; case SkBitmap::kRGB_565_Config: sig_bit.red = 5; @@ -598,18 +687,34 @@ bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, sig_bit.alpha = 0; break; default: -#if 0 - SkDEBUGF(("SkPNGImageEncoder::onEncode can't encode %d config\n", - config)); -#endif return false; } - + + if (hasAlpha) { + // don't specify alpha if we're a palette, even if our ctable has alpha + if (!(colorType & PNG_COLOR_MASK_PALETTE)) { + colorType |= PNG_COLOR_MASK_ALPHA; + } + } else { + sig_bit.alpha = 0; + } + SkAutoLockPixels alp(bitmap); - if (NULL == bitmap.getPixels()) { + // readyToDraw checks for pixels (and colortable if that is required) + if (!bitmap.readyToDraw()) { return false; } - + + // we must do this after we have locked the pixels + SkColorTable* ctable = bitmap.getColorTable(); + if (NULL != ctable) { + if (ctable->count() == 0) { + return false; + } + // check if we can store in fewer than 8 bits + bitDepth = computeBitDepth(ctable->count()); + } + png_structp png_ptr; png_infop info_ptr; @@ -644,8 +749,8 @@ bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED */ - png_set_IHDR(png_ptr, info_ptr, bitmap.width(), bitmap.height(), 8, - hasAlpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB, + png_set_IHDR(png_ptr, info_ptr, bitmap.width(), bitmap.height(), + bitDepth, colorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); @@ -677,15 +782,6 @@ bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, png_write_end(png_ptr, info_ptr); -#if 0 - /* If you png_malloced a palette, free it here (don't free info_ptr->palette, - as recommended in versions 1.0.5m and earlier of this example; if - libpng mallocs info_ptr->palette, libpng will free it). If you - allocated it with malloc() instead of png_malloc(), use free() instead - of png_free(). */ - png_free(png_ptr, palette); -#endif - /* clean up after the write, and free any memory allocated */ png_destroy_write_struct(&png_ptr, &info_ptr); return true; diff --git a/libsgl/images/SkImageRef.cpp b/libsgl/images/SkImageRef.cpp index bd7a07d..90c37b6 100644 --- a/libsgl/images/SkImageRef.cpp +++ b/libsgl/images/SkImageRef.cpp @@ -98,10 +98,10 @@ bool SkImageRef::prepareBitmap(SkImageDecoder::Mode mode) { #ifdef DUMP_IMAGEREF_LIFECYCLE if (NULL == codec) { - SkDebugf("--- ImageRef: <%s> failed to find codec\n", fName.c_str()); + SkDebugf("--- ImageRef: <%s> failed to find codec\n", this->getURI()); } else { SkDebugf("--- ImageRef: <%s> failed in codec for %d mode\n", - fName.c_str(), mode); + this->getURI(), mode); } #endif fErrorInDecoding = true; diff --git a/libsgl/images/SkImageRefPool.cpp b/libsgl/images/SkImageRefPool.cpp index fa3ef8a..e322507 100644 --- a/libsgl/images/SkImageRefPool.cpp +++ b/libsgl/images/SkImageRefPool.cpp @@ -23,7 +23,7 @@ void SkImageRefPool::setRAMBudget(size_t size) { void SkImageRefPool::justAddedPixels(SkImageRef* ref) { #ifdef DUMP_IMAGEREF_LIFECYCLE SkDebugf("=== ImagePool: add pixels %s [%d %d %d] bytes=%d heap=%d\n", - ref->fName.c_str(), + ref->getURI(), ref->fBitmap.width(), ref->fBitmap.height(), ref->fBitmap.bytesPerPixel(), ref->fBitmap.getSize(), (int)fRAMUsed); @@ -59,7 +59,7 @@ void SkImageRefPool::setRAMUsed(size_t limit) { #ifdef DUMP_IMAGEREF_LIFECYCLE SkDebugf("=== ImagePool: purge %s [%d %d %d] bytes=%d heap=%d\n", - ref->fName.c_str(), + ref->getURI(), ref->fBitmap.width(), ref->fBitmap.height(), ref->fBitmap.bytesPerPixel(), (int)size, (int)fRAMUsed); @@ -177,7 +177,7 @@ void SkImageRefPool::dump() const { SkDebugf(" [%3d %3d %d] ram=%d data=%d locks=%d %s\n", ref->fBitmap.width(), ref->fBitmap.height(), ref->fBitmap.config(), ref->ramUsed(), (int)ref->fStream->getLength(), - ref->getLockCount(), ref->fName.c_str()); + ref->getLockCount(), ref->getURI()); ref = ref->fNext; } diff --git a/libsgl/images/SkMovie.cpp b/libsgl/images/SkMovie.cpp index 4b8f16a..7186ed5 100644 --- a/libsgl/images/SkMovie.cpp +++ b/libsgl/images/SkMovie.cpp @@ -77,20 +77,24 @@ const SkBitmap& SkMovie::bitmap() #include "SkStream.h" +SkMovie* SkMovie::DecodeMemory(const void* data, size_t length) { + SkMemoryStream stream(data, length, false); + return SkMovie::DecodeStream(&stream); +} + SkMovie* SkMovie::DecodeFile(const char path[]) { SkMovie* movie = NULL; - // since the movie might hold onto the stream - // we dynamically allocate it and then unref() - SkFILEStream* stream = new SkFILEStream(path); - if (stream->isValid()) - movie = SkMovie::DecodeStream(stream); + SkFILEStream stream(path); + if (stream.isValid()) { + movie = SkMovie::DecodeStream(&stream); + } #ifdef SK_DEBUG - else + else { SkDebugf("Movie file not found <%s>\n", path); + } #endif - stream->unref(); return movie; } diff --git a/libsgl/images/SkMovie_gif.cpp b/libsgl/images/SkMovie_gif.cpp index c7db017..ca9c812 100644 --- a/libsgl/images/SkMovie_gif.cpp +++ b/libsgl/images/SkMovie_gif.cpp @@ -25,8 +25,6 @@ class SkGIFMovie : public SkMovie { public: - // we do NOT hold onto the stream, so it is OK if it is on the - // stack of the caller SkGIFMovie(SkStream* stream); virtual ~SkGIFMovie(); @@ -40,7 +38,7 @@ private: SavedImage* fCurrSavedImage; }; -SkMovie* SkMovie_GIF_StreamFactory(SkStream* stream) { +SkMovie* SkMovie_GIF_Factory(SkStream* stream) { char buf[GIF_STAMP_LEN]; if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) { if (memcmp(GIF_STAMP, buf, GIF_STAMP_LEN) == 0 || @@ -53,14 +51,6 @@ SkMovie* SkMovie_GIF_StreamFactory(SkStream* stream) { return NULL; } -SkMovie* SkMovie_GIF_MemoryFactory(const void* data, size_t length) { - if (length > GIF_STAMP_LEN && !memcmp(GIF_STAMP, data, GIF_STAMP_LEN)) { - SkMemoryStream stream(data, length); - return SkNEW_ARGS(SkGIFMovie, (&stream)); - } - return NULL; -} - static int Decode(GifFileType* fileType, GifByteType* out, int size) { SkStream* stream = (SkStream*) fileType->UserData; return (int) stream->read(out, size); diff --git a/libsgl/images/SkStream.cpp b/libsgl/images/SkStream.cpp index d24b2dc..b199a1b 100644 --- a/libsgl/images/SkStream.cpp +++ b/libsgl/images/SkStream.cpp @@ -20,8 +20,6 @@ #include "SkString.h" #include "SkOSFile.h" -#include <unistd.h> - SkStream::~SkStream() {} const char* SkStream::getFileName() @@ -252,90 +250,6 @@ size_t SkFILEStream::read(void* buffer, size_t size) //////////////////////////////////////////////////////////////////////////// -//#define TRACE_FDSTREAM - -SkFDStream::SkFDStream(int fileDesc, bool closeWhenDone) - : fFD(fileDesc), fCloseWhenDone(closeWhenDone) { -} - -SkFDStream::~SkFDStream() { - if (fFD >= 0 && fCloseWhenDone) { - ::close(fFD); - } -} - -bool SkFDStream::rewind() { - if (fFD >= 0) { - off_t value = ::lseek(fFD, 0, SEEK_SET); -#ifdef TRACE_FDSTREAM - if (value) { - SkDebugf("xxxxxxxxxxxxxx rewind failed %d\n", value); - } -#endif - return value == 0; - } - return false; -} - -size_t SkFDStream::read(void* buffer, size_t size) { - if (fFD >= 0) { - if (buffer == NULL && size == 0) { // request total size - off_t curr = ::lseek(fFD, 0, SEEK_CUR); - if (curr < 0) { -#ifdef TRACE_FDSTREAM - SkDebugf("xxxxxxxxxxxxx lseek failed 0 CURR\n"); -#endif - return 0; // error - } - off_t size = ::lseek(fFD, 0, SEEK_END); - if (size < 0) { -#ifdef TRACE_FDSTREAM - SkDebugf("xxxxxxxxxxxxx lseek failed 0 END\n"); -#endif - size = 0; // error - } - if (::lseek(fFD, curr, SEEK_SET) != curr) { - // can't restore, error -#ifdef TRACE_FDSTREAM - SkDebugf("xxxxxxxxxxxxx lseek failed %d SET\n", curr); -#endif - return 0; - } - return size; - } else if (NULL == buffer) { // skip - off_t oldCurr = ::lseek(fFD, 0, SEEK_CUR); - if (oldCurr < 0) { -#ifdef TRACE_FDSTREAM - SkDebugf("xxxxxxxxxxxxx lseek1 failed %d CUR\n", oldCurr); -#endif - return 0; // error; - } - off_t newCurr = ::lseek(fFD, size, SEEK_CUR); - if (newCurr < 0) { -#ifdef TRACE_FDSTREAM - SkDebugf("xxxxxxxxxxxxx lseek2 failed %d CUR\n", newCurr); -#endif - return 0; // error; - } - // return the actual amount we skipped - return newCurr - oldCurr; - } else { // read - ssize_t actual = ::read(fFD, buffer, size); - // our API can't return an error, so we return 0 - if (actual < 0) { -#ifdef TRACE_FDSTREAM - SkDebugf("xxxxxxxxxxxxx read failed %d actual %d\n", size, actual); -#endif - actual = 0; - } - return actual; - } - } - return 0; -} - -//////////////////////////////////////////////////////////////////////// - SkMemoryStream::SkMemoryStream() { fWeOwnTheData = false; @@ -489,19 +403,31 @@ const char* SkBufferStream::getFileName() // #define SK_TRACE_BUFFERSTREAM #endif -size_t SkBufferStream::read(void* buffer, size_t size) -{ +size_t SkBufferStream::read(void* buffer, size_t size) { #ifdef SK_TRACE_BUFFERSTREAM SkDebugf("Request %d", size); #endif - if (buffer == NULL && size == 0) + if (buffer == NULL && size == 0) { return fProxy->read(buffer, size); // requesting total size + } - if (buffer == NULL || size == 0) - { - fBufferOffset += size; - return fProxy->read(buffer, size); + if (0 == size) { + return 0; + } + + // skip size bytes + if (NULL == buffer) { + size_t remaining = fBufferSize - fBufferOffset; + if (remaining >= size) { + fBufferOffset += size; + return size; + } + // if we get here, we are being asked to skip beyond our current buffer + // so reset our offset to force a read next time, and skip the diff + // in our proxy + fBufferOffset = fOrigBufferSize; + return remaining + fProxy->read(NULL, size - remaining); } size_t s = size; diff --git a/libsgl/picture/SkPathHeap.cpp b/libsgl/picture/SkPathHeap.cpp new file mode 100644 index 0000000..f6dae5d --- /dev/null +++ b/libsgl/picture/SkPathHeap.cpp @@ -0,0 +1,55 @@ +#include "SkPathHeap.h" +#include "SkPath.h" +#include "SkStream.h" +#include "SkFlattenable.h" +#include <new> + +#define kPathCount 64 + +SkPathHeap::SkPathHeap() : fHeap(kPathCount * sizeof(SkPath)) { +} + +SkPathHeap::SkPathHeap(SkFlattenableReadBuffer& buffer) + : fHeap(kPathCount * sizeof(SkPath)) { + int count = buffer.readS32(); + + fPaths.setCount(count); + SkPath** ptr = fPaths.begin(); + SkPath* p = (SkPath*)fHeap.allocThrow(count * sizeof(SkPath)); + + for (int i = 0; i < count; i++) { + new (p) SkPath; + p->unflatten(buffer); + *ptr++ = p; // record the pointer + p++; // move to the next storage location + } +} + +SkPathHeap::~SkPathHeap() { + SkPath** iter = fPaths.begin(); + SkPath** stop = fPaths.end(); + while (iter < stop) { + (*iter)->~SkPath(); + iter++; + } +} + +int SkPathHeap::append(const SkPath& path) { + SkPath* p = (SkPath*)fHeap.allocThrow(sizeof(SkPath)); + new (p) SkPath(path); + *fPaths.append() = p; + return fPaths.count(); +} + +void SkPathHeap::flatten(SkFlattenableWriteBuffer& buffer) const { + int count = fPaths.count(); + + buffer.write32(count); + SkPath** iter = fPaths.begin(); + SkPath** stop = fPaths.end(); + while (iter < stop) { + (*iter)->flatten(buffer); + iter++; + } +} + diff --git a/libsgl/picture/SkPathHeap.h b/libsgl/picture/SkPathHeap.h new file mode 100644 index 0000000..b8f3bd3 --- /dev/null +++ b/libsgl/picture/SkPathHeap.h @@ -0,0 +1,37 @@ +#ifndef SkPathHeap_DEFINED +#define SkPathHeap_DEFINED + +#include "SkRefCnt.h" +#include "SkChunkAlloc.h" +#include "SkTDArray.h" + +class SkPath; +class SkFlattenableReadBuffer; +class SkFlattenableWriteBuffer; + +class SkPathHeap : public SkRefCnt { +public: + SkPathHeap(); + SkPathHeap(SkFlattenableReadBuffer&); + virtual ~SkPathHeap(); + + // called during picture-record + int append(const SkPath&); + + // called during picture-playback + int count() const { return fPaths.count(); } + const SkPath& operator[](int index) const { + return *fPaths[index]; + } + + void flatten(SkFlattenableWriteBuffer&) const; + +private: + // we store the paths in the heap (placement new) + SkChunkAlloc fHeap; + // we just store ptrs into fHeap here + SkTDArray<SkPath*> fPaths; +}; + +#endif + diff --git a/libsgl/sgl/SkPicture.cpp b/libsgl/picture/SkPicture.cpp index 96deadd..07cb0a6 100644 --- a/libsgl/sgl/SkPicture.cpp +++ b/libsgl/picture/SkPicture.cpp @@ -236,3 +236,11 @@ void SkPicture::serialize(SkWStream* stream) const { } } +void SkPicture::abortPlayback() { + if (NULL == fPlayback) { + return; + } + fPlayback->abort(); +} + + diff --git a/libsgl/picture/SkPictureFlat.cpp b/libsgl/picture/SkPictureFlat.cpp index ba7119e..e221e55 100644 --- a/libsgl/picture/SkPictureFlat.cpp +++ b/libsgl/picture/SkPictureFlat.cpp @@ -206,15 +206,6 @@ void SkFlatPaint::dump() const { } #endif -SkFlatPath* SkFlatPath::Flatten(SkChunkAlloc* heap, const SkPath& path, int index) { - SkFlattenableWriteBuffer buffer(1024); - path.flatten(buffer); - uint32_t size = buffer.size(); - SkFlatPath* result = (SkFlatPath*) INHERITED::Alloc(heap, size, index); - buffer.flatten(&result->fPathData); - return result; -} - SkFlatRegion* SkFlatRegion::Flatten(SkChunkAlloc* heap, const SkRegion& region, int index) { uint32_t size = region.flatten(NULL); SkFlatRegion* result = (SkFlatRegion*) INHERITED::Alloc(heap, size, index); diff --git a/libsgl/picture/SkPictureFlat.h b/libsgl/picture/SkPictureFlat.h index b4ce899..9e7fc5e 100644 --- a/libsgl/picture/SkPictureFlat.h +++ b/libsgl/picture/SkPictureFlat.h @@ -24,11 +24,12 @@ enum DrawType { DRAW_POINTS, DRAW_POS_TEXT, DRAW_POS_TEXT_H, - DRAW_RECT_GENERAL, - DRAW_RECT_SIMPLE, + DRAW_POS_TEXT_H_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT_H + DRAW_RECT, DRAW_SPRITE, DRAW_TEXT, DRAW_TEXT_ON_PATH, + DRAW_TEXT_TOP_BOTTOM, // fast variant of DRAW_TEXT DRAW_VERTICES, RESTORE, ROTATE, @@ -183,26 +184,6 @@ private: typedef SkFlatData INHERITED; }; -class SkFlatPath : public SkFlatData { -public: - static SkFlatPath* Flatten(SkChunkAlloc* heap, const SkPath& path, int index); - - void unflatten(SkPath* path) const { - SkFlattenableReadBuffer buffer(fPathData); - path->unflatten(buffer); - } - -#ifdef SK_DEBUG_VALIDATE - void validate() const { - // to be written - } -#endif - -private: - char fPathData[1]; - typedef SkFlatData INHERITED; -}; - class SkFlatRegion : public SkFlatData { public: static SkFlatRegion* Flatten(SkChunkAlloc* heap, const SkRegion& region, int index); diff --git a/libsgl/picture/SkPicturePlayback.cpp b/libsgl/picture/SkPicturePlayback.cpp index 6c6cd2f..64f8f1c 100644 --- a/libsgl/picture/SkPicturePlayback.cpp +++ b/libsgl/picture/SkPicturePlayback.cpp @@ -102,16 +102,8 @@ SkPicturePlayback::SkPicturePlayback(const SkPictureRecord& record) { } } - const SkTDArray<const SkFlatPath* >& paths = record.getPaths(); - fPathCount = paths.count(); - if (fPathCount > 0) { - fPaths = SkNEW_ARRAY(SkPath, fPathCount); - for (const SkFlatPath** flatPathPtr = paths.begin(); - flatPathPtr != paths.end(); flatPathPtr++) { - const SkFlatPath* flatPath = *flatPathPtr; - flatPath->unflatten(&fPaths[flatPath->index() - 1]); - } - } + fPathHeap = record.fPathHeap; + fPathHeap->safeRef(); const SkTDArray<SkPicture* >& pictures = record.getPictureRefs(); fPictureCount = pictures.count(); @@ -185,11 +177,8 @@ SkPicturePlayback::SkPicturePlayback(const SkPicturePlayback& src) { fPaints[i] = src.fPaints[i]; } - fPathCount = src.fPathCount; - fPaths = SkNEW_ARRAY(SkPath, fPathCount); - for (i = 0; i < fPathCount; i++) { - fPaths[i] = src.fPaths[i]; - } + fPathHeap = src.fPathHeap; + fPathHeap->safeRef(); fPictureCount = src.fPictureCount; fPictureRefs = SkNEW_ARRAY(SkPicture*, fPictureCount); @@ -209,10 +198,10 @@ void SkPicturePlayback::init() { fBitmaps = NULL; fMatrices = NULL; fPaints = NULL; - fPaths = NULL; + fPathHeap = NULL; fPictureRefs = NULL; fRegions = NULL; - fBitmapCount = fMatrixCount = fPaintCount = fPathCount = fPictureCount = + fBitmapCount = fMatrixCount = fPaintCount = fPictureCount = fRegionCount = 0; fFactoryPlayback = NULL; @@ -224,8 +213,9 @@ SkPicturePlayback::~SkPicturePlayback() { SkDELETE_ARRAY(fBitmaps); SkDELETE_ARRAY(fMatrices); SkDELETE_ARRAY(fPaints); - SkDELETE_ARRAY(fPaths); SkDELETE_ARRAY(fRegions); + + fPathHeap->safeUnref(); for (int i = 0; i < fPictureCount; i++) { fPictureRefs[i]->unref(); @@ -241,7 +231,7 @@ void SkPicturePlayback::dumpSize() const { fBitmapCount, fBitmapCount * sizeof(SkBitmap), fMatrixCount, fMatrixCount * sizeof(SkMatrix), fPaintCount, fPaintCount * sizeof(SkPaint), - fPathCount, + fPathHeap ? fPathHeap->count() : 0, fRegionCount); } @@ -341,9 +331,12 @@ void SkPicturePlayback::serialize(SkWStream* stream) const { fPaints[i].flatten(buffer); } - writeTagSize(buffer, PICT_PATH_TAG, fPathCount); - for (i = 0; i < fPathCount; i++) { - fPaths[i].flatten(buffer); + { + int count = fPathHeap ? fPathHeap->count() : 0; + writeTagSize(buffer, PICT_PATH_TAG, count); + if (count > 0) { + fPathHeap->flatten(buffer); + } } writeTagSize(buffer, PICT_REGION_TAG, fRegionCount); @@ -449,10 +442,11 @@ SkPicturePlayback::SkPicturePlayback(SkStream* stream) { fPaints[i].unflatten(buffer); } - fPathCount = readTagSize(buffer, PICT_PATH_TAG); - fPaths = SkNEW_ARRAY(SkPath, fPathCount); - for (i = 0; i < fPathCount; i++) { - fPaths[i].unflatten(buffer); + { + int count = readTagSize(buffer, PICT_PATH_TAG); + if (count > 0) { + fPathHeap = SkNEW_ARGS(SkPathHeap, (buffer)); + } } fRegionCount = readTagSize(buffer, PICT_REGION_TAG); @@ -474,8 +468,6 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { TextContainer text; fReader.rewind(); - bool clipBoundsDirty = true; - SkRect clipBounds; while (!fReader.eof()) { switch (fReader.readInt()) { @@ -488,7 +480,6 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { //SkDebugf("---- skip clipPath for %d bytes\n", offsetToRestore - fReader.offset()); fReader.setOffset(offsetToRestore); } - clipBoundsDirty = true; } break; case CLIP_REGION: { const SkRegion& region = getRegion(); @@ -498,7 +489,6 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { //SkDebugf("---- skip clipDeviceRgn for %d bytes\n", offsetToRestore - fReader.offset()); fReader.setOffset(offsetToRestore); } - clipBoundsDirty = true; } break; case CLIP_RECT: { const SkRect* rect = fReader.skipRect(); @@ -508,11 +498,9 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { //SkDebugf("---- skip clipRect for %d bytes\n", offsetToRestore - fReader.offset()); fReader.setOffset(offsetToRestore); } - clipBoundsDirty = true; } break; case CONCAT: canvas.concat(*getMatrix()); - clipBoundsDirty = true; break; case DRAW_BITMAP: { const SkPaint* paint = getPaint(); @@ -538,8 +526,7 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { break; case DRAW_PATH: { const SkPaint& paint = *getPaint(); - const SkPath& path = getPath(); - canvas.drawPath(path, paint); + canvas.drawPath(getPath(), paint); } break; case DRAW_PICTURE: canvas.drawPicture(getPicture()); @@ -561,43 +548,29 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { case DRAW_POS_TEXT_H: { const SkPaint& paint = *getPaint(); getText(&text); - size_t points = getInt(); - size_t byteLength = text.length(); - const SkScalar* xpos = (const SkScalar*)fReader.skip((3 + points) * sizeof(SkScalar)); + size_t xCount = getInt(); + const SkScalar constY = getScalar(); + const SkScalar* xpos = (const SkScalar*)fReader.skip(xCount * sizeof(SkScalar)); + canvas.drawPosTextH(text.text(), text.length(), xpos, constY, + paint); + } break; + case DRAW_POS_TEXT_H_TOP_BOTTOM: { + const SkPaint& paint = *getPaint(); + getText(&text); + size_t xCount = getInt(); + const SkScalar* xpos = (const SkScalar*)fReader.skip((3 + xCount) * sizeof(SkScalar)); const SkScalar top = *xpos++; const SkScalar bottom = *xpos++; const SkScalar constY = *xpos++; - // would be nice to do this before we load the other fields - // (especially the text block). To do that we'd need to record - // the number of bytes to skip... - if (clipBoundsDirty) { - if (!canvas.getClipBounds(&clipBounds)) { - clipBounds.setEmpty(); - } - clipBoundsDirty = false; - } - if (top < clipBounds.fBottom && bottom > clipBounds.fTop) { - canvas.drawPosTextH(text.text(), byteLength, xpos, constY, - paint); + if (!canvas.quickRejectY(top, bottom, SkCanvas::kAA_EdgeType)) { + canvas.drawPosTextH(text.text(), text.length(), xpos, + constY, paint); } } break; - case DRAW_RECT_GENERAL: { + case DRAW_RECT: { const SkPaint& paint = *getPaint(); canvas.drawRect(*fReader.skipRect(), paint); } break; - case DRAW_RECT_SIMPLE: { - const SkPaint& paint = *getPaint(); - const SkRect* rect = fReader.skipRect(); - if (clipBoundsDirty) { - if (!canvas.getClipBounds(&clipBounds)) { - clipBounds.setEmpty(); - } - clipBoundsDirty = false; - } - if (SkRect::Intersects(clipBounds, *rect)) { - canvas.drawRect(*rect, paint); - } - } break; case DRAW_SPRITE: { const SkPaint* paint = getPaint(); const SkBitmap& bitmap = getBitmap(); @@ -608,18 +581,20 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { case DRAW_TEXT: { const SkPaint& paint = *getPaint(); getText(&text); + SkScalar x = getScalar(); + SkScalar y = getScalar(); + canvas.drawText(text.text(), text.length(), x, y, paint); + } break; + case DRAW_TEXT_TOP_BOTTOM: { + const SkPaint& paint = *getPaint(); + getText(&text); const SkScalar* ptr = (const SkScalar*)fReader.skip(4 * sizeof(SkScalar)); // ptr[0] == x // ptr[1] == y // ptr[2] == top // ptr[3] == bottom - if (clipBoundsDirty) { - if (!canvas.getClipBounds(&clipBounds)) { - clipBounds.setEmpty(); - } - clipBoundsDirty = false; - } - if (ptr[2] < clipBounds.fBottom && ptr[3] > clipBounds.fTop) { + if (!canvas.quickRejectY(ptr[2], ptr[3], + SkCanvas::kAA_EdgeType)) { canvas.drawText(text.text(), text.length(), ptr[0], ptr[1], paint); } @@ -661,11 +636,9 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { } break; case RESTORE: canvas.restore(); - clipBoundsDirty = true; break; case ROTATE: canvas.rotate(getScalar()); - clipBoundsDirty = true; break; case SAVE: canvas.save((SkCanvas::SaveFlags) getInt()); @@ -679,19 +652,16 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { SkScalar sx = getScalar(); SkScalar sy = getScalar(); canvas.scale(sx, sy); - clipBoundsDirty = true; } break; case SKEW: { SkScalar sx = getScalar(); SkScalar sy = getScalar(); canvas.skew(sx, sy); - clipBoundsDirty = true; } break; case TRANSLATE: { SkScalar dx = getScalar(); SkScalar dy = getScalar(); canvas.translate(dx, dy); - clipBoundsDirty = true; } break; default: SkASSERT(0); @@ -701,6 +671,10 @@ void SkPicturePlayback::draw(SkCanvas& canvas) { // this->dumpSize(); } +void SkPicturePlayback::abort() { + fReader.skip(fReader.size() - fReader.offset()); +} + /////////////////////////////////////////////////////////////////////////////// #if 0 @@ -1212,8 +1186,7 @@ void SkPicturePlayback::dumpStream() { DUMP_SCALAR(constY); DUMP_POINT_ARRAY(points); } break; - case DRAW_RECT_GENERAL: - case DRAW_RECT_SIMPLE: { + case DRAW_RECT: { DUMP_PTR(SkPaint, getPaint()); DUMP_RECT(rect); } break; diff --git a/libsgl/picture/SkPicturePlayback.h b/libsgl/picture/SkPicturePlayback.h index 7e99bd0..b4e69ca 100644 --- a/libsgl/picture/SkPicturePlayback.h +++ b/libsgl/picture/SkPicturePlayback.h @@ -8,6 +8,7 @@ #include "SkMatrix.h" #include "SkPaint.h" #include "SkPath.h" +#include "SkPathHeap.h" #include "SkRegion.h" #include "SkPictureFlat.h" @@ -29,6 +30,10 @@ public: void serialize(SkWStream*) const; void dumpSize() const; + + // Can be called in the middle of playback (the draw() call). WIll abort the + // drawing and return from draw() after the "current" op code is done + void abort(); private: @@ -59,9 +64,7 @@ private: } const SkPath& getPath() { - int index = getInt(); - SkASSERT(index > 0 && index <= fPathCount); - return fPaths[index - 1]; + return (*fPathHeap)[getInt() - 1]; } SkPicture& getPicture() { @@ -143,14 +146,13 @@ public: #endif private: + SkPathHeap* fPathHeap; // reference counted SkBitmap* fBitmaps; int fBitmapCount; SkMatrix* fMatrices; int fMatrixCount; SkPaint* fPaints; int fPaintCount; - SkPath* fPaths; - int fPathCount; SkRegion* fRegions; int fRegionCount; mutable SkFlattenableReadBuffer fReader; diff --git a/libsgl/picture/SkPictureRecord.cpp b/libsgl/picture/SkPictureRecord.cpp index 718526b..6e7c645 100644 --- a/libsgl/picture/SkPictureRecord.cpp +++ b/libsgl/picture/SkPictureRecord.cpp @@ -6,7 +6,7 @@ SkPictureRecord::SkPictureRecord() : fHeap(HEAP_BLOCK_SIZE), fWriter(MIN_WRITER_SIZE) { - fBitmapIndex = fMatrixIndex = fPaintIndex = fPathIndex = fRegionIndex = 1; + fBitmapIndex = fMatrixIndex = fPaintIndex = fRegionIndex = 1; #ifdef SK_DEBUG_SIZE fPointBytes = fRectBytes = fTextBytes = 0; fPointWrites = fRectWrites = fTextWrites = 0; @@ -14,6 +14,8 @@ SkPictureRecord::SkPictureRecord() : fRestoreOffsetStack.setReserve(32); fRestoreOffsetStack.push(0); + + fPathHeap = NULL; // lazy allocate } SkPictureRecord::~SkPictureRecord() { @@ -158,17 +160,8 @@ void SkPictureRecord::drawPoints(PointMode mode, size_t count, const SkPoint pts validate(); } -// return true if geometry drawn with this paint will just be filled -// i.e. its bounding rect will not be larger than the original geometry -static bool is_simple_fill(const SkPaint& paint) { - return paint.getStyle() == SkPaint::kFill_Style && - paint.getPathEffect() == NULL && - paint.getMaskFilter() == NULL && - paint.getRasterizer() == NULL; -} - void SkPictureRecord::drawRect(const SkRect& rect, const SkPaint& paint) { - addDraw(is_simple_fill(paint) ? DRAW_RECT_SIMPLE : DRAW_RECT_GENERAL); + addDraw(DRAW_RECT); addPaint(paint); addRect(rect); validate(); @@ -224,18 +217,29 @@ void SkPictureRecord::addFontMetricsTopBottom(const SkPaint& paint, SkScalar baselineY) { SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); - addScalar(metrics.fTop + baselineY); - addScalar(metrics.fBottom + baselineY); + SkRect bounds; + // construct a rect so we can see any adjustments from the paint. + // we use 0,1 for left,right, just so the rect isn't empty + bounds.set(0, metrics.fTop + baselineY, + SK_Scalar1, metrics.fBottom + baselineY); + (void)paint.computeFastBounds(bounds, &bounds); + // now record the top and bottom + addScalar(bounds.fTop); + addScalar(bounds.fBottom); } void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y, const SkPaint& paint) { - addDraw(DRAW_TEXT); + bool fast = paint.canComputeFastBounds(); + + addDraw(fast ? DRAW_TEXT_TOP_BOTTOM : DRAW_TEXT); addPaint(paint); addText(text, byteLength); addScalar(x); addScalar(y); - addFontMetricsTopBottom(paint, y); + if (fast) { + addFontMetricsTopBottom(paint, y); + } validate(); } @@ -257,7 +261,13 @@ void SkPictureRecord::drawPosText(const void* text, size_t byteLength, } } - addDraw(canUseDrawH ? DRAW_POS_TEXT_H : DRAW_POS_TEXT); + bool fast = canUseDrawH && paint.canComputeFastBounds(); + + if (fast) { + addDraw(DRAW_POS_TEXT_H_TOP_BOTTOM); + } else { + addDraw(canUseDrawH ? DRAW_POS_TEXT_H : DRAW_POS_TEXT); + } addPaint(paint); addText(text, byteLength); addInt(points); @@ -266,7 +276,9 @@ void SkPictureRecord::drawPosText(const void* text, size_t byteLength, size_t start = fWriter.size(); #endif if (canUseDrawH) { - addFontMetricsTopBottom(paint, pos[0].fY); + if (fast) { + addFontMetricsTopBottom(paint, pos[0].fY); + } addScalar(pos[0].fY); SkScalar* xptr = (SkScalar*)fWriter.reserve(points * sizeof(SkScalar)); for (size_t index = 0; index < points; index++) @@ -289,7 +301,9 @@ void SkPictureRecord::drawPosTextH(const void* text, size_t byteLength, if (0 == points) return; - addDraw(DRAW_POS_TEXT_H); + bool fast = paint.canComputeFastBounds(); + + addDraw(fast ? DRAW_POS_TEXT_H_TOP_BOTTOM : DRAW_POS_TEXT_H); addPaint(paint); addText(text, byteLength); addInt(points); @@ -297,7 +311,9 @@ void SkPictureRecord::drawPosTextH(const void* text, size_t byteLength, #ifdef SK_DEBUG_SIZE size_t start = fWriter.size(); #endif - addFontMetricsTopBottom(paint, constY); + if (fast) { + addFontMetricsTopBottom(paint, constY); + } addScalar(constY); fWriter.writeMul4(xpos, points * sizeof(SkScalar)); #ifdef SK_DEBUG_SIZE @@ -361,10 +377,12 @@ void SkPictureRecord::drawVertices(VertexMode vmode, int vertexCount, /////////////////////////////////////////////////////////////////////////////// void SkPictureRecord::reset() { + fPathHeap->safeUnref(); + fPathHeap = NULL; + fBitmaps.reset(); fMatrices.reset(); fPaints.reset(); - fPaths.reset(); fPictureRefs.unrefAll(); fRegions.reset(); fWriter.reset(); @@ -398,7 +416,10 @@ void SkPictureRecord::addPaintPtr(const SkPaint* paint) { } void SkPictureRecord::addPath(const SkPath& path) { - addInt(find(fPaths, path)); + if (NULL == fPathHeap) { + fPathHeap = SkNEW(SkPathHeap); + } + addInt(fPathHeap->append(path)); } void SkPictureRecord::addPicture(SkPicture& picture) { @@ -518,17 +539,6 @@ int SkPictureRecord::find(SkTDArray<const SkFlatPaint* >& paints, const SkPaint* return fPaintIndex++; } -int SkPictureRecord::find(SkTDArray<const SkFlatPath* >& paths, const SkPath& path) { - SkFlatPath* flat = SkFlatPath::Flatten(&fHeap, path, fPathIndex); - int index = SkTSearch<SkFlatData>((const SkFlatData**) paths.begin(), - paths.count(), (SkFlatData*) flat, sizeof(flat), &SkFlatData::Compare); - if (index >= 0) - return paths[index]->index(); - index = ~index; - *paths.insert(index) = flat; - return fPathIndex++; -} - int SkPictureRecord::find(SkTDArray<const SkFlatRegion* >& regions, const SkRegion& region) { SkFlatRegion* flat = SkFlatRegion::Flatten(&fHeap, region, fRegionIndex); int index = SkTSearch<SkFlatData>((const SkFlatData**) regions.begin(), diff --git a/libsgl/picture/SkPictureRecord.h b/libsgl/picture/SkPictureRecord.h index 350040e..d25d23a 100644 --- a/libsgl/picture/SkPictureRecord.h +++ b/libsgl/picture/SkPictureRecord.h @@ -3,6 +3,7 @@ #include "SkCanvas.h" #include "SkFlattenable.h" +#include "SkPathHeap.h" #include "SkPicture.h" #include "SkPictureFlat.h" #include "SkTemplates.h" @@ -65,9 +66,6 @@ public: const SkTDArray<const SkFlatPaint* >& getPaints() const { return fPaints; } - const SkTDArray<const SkFlatPath* >& getPaths() const { - return fPaths; - } const SkTDArray<SkPicture* >& getPictureRefs() const { return fPictureRefs; } @@ -117,7 +115,6 @@ private: int find(SkTDArray<const SkFlatMatrix* >& matrices, const SkMatrix* matrix); int find(SkTDArray<const SkFlatPaint* >& paints, const SkPaint* paint); - int find(SkTDArray<const SkFlatPath* >& paths, const SkPath& path); int find(SkTDArray<const SkFlatRegion* >& regions, const SkRegion& region); #ifdef SK_DEBUG_DUMP @@ -162,10 +159,9 @@ private: SkTDArray<const SkFlatMatrix* > fMatrices; int fPaintIndex; SkTDArray<const SkFlatPaint* > fPaints; - int fPathIndex; - SkTDArray<const SkFlatPath* > fPaths; int fRegionIndex; SkTDArray<const SkFlatRegion* > fRegions; + SkPathHeap* fPathHeap; // reference counted SkWriter32 fWriter; // we ref each item in this array diff --git a/libsgl/ports/SkFontHost_FreeType.cpp b/libsgl/ports/SkFontHost_FreeType.cpp index 85f8d62..5855eec 100644 --- a/libsgl/ports/SkFontHost_FreeType.cpp +++ b/libsgl/ports/SkFontHost_FreeType.cpp @@ -372,6 +372,13 @@ SkScalerContext_FreeType::~SkScalerContext_FreeType() { this face with other context (at different sizes). */ FT_Error SkScalerContext_FreeType::setupSize() { + /* In the off-chance that a font has been removed, we want to error out + right away, so call resolve just to be sure. + + TODO: perhaps we can skip this, by walking the global font cache and + killing all of the contexts when we know that a given fontID is going + away... + */ if (SkFontHost::ResolveTypeface(fRec.fFontID) == NULL) { return (FT_Error)-1; } @@ -484,10 +491,11 @@ void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) { if (kSubpixel_Hints == fRec.fHints) { int dx = glyph->getSubXFixed() >> 10; int dy = glyph->getSubYFixed() >> 10; + // negate dy since freetype-y-goes-up and skia-y-goes-down bbox.xMin += dx; - bbox.yMin += dy; + bbox.yMin -= dy; bbox.xMax += dx; - bbox.yMax += dy; + bbox.yMax -= dy; } bbox.xMin &= ~63; @@ -559,6 +567,8 @@ void SkScalerContext_FreeType::generateImage(const SkGlyph& glyph) { if (kSubpixel_Hints == fRec.fHints) { dx = glyph.getSubXFixed() >> 10; dy = glyph.getSubYFixed() >> 10; + // negate dy since freetype-y-goes-up and skia-y-goes-down + dy = -dy; } FT_Outline_Get_CBox(outline, &bbox); /* @@ -694,13 +704,6 @@ void SkScalerContext_FreeType::generatePath(const SkGlyph& glyph, path->close(); } -static void map_y_to_pt(const FT_Matrix& mat, SkFixed y, SkPoint* pt) { - SkFixed x = SkFixedMul(mat.xy, y); - y = SkFixedMul(mat.yy, y); - - pt->set(SkFixedToScalar(x), SkFixedToScalar(y)); -} - void SkScalerContext_FreeType::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) { if (NULL == mx && NULL == my) { diff --git a/libsgl/ports/SkFontHost_android.cpp b/libsgl/ports/SkFontHost_android.cpp index 665c788..0922e7b 100644 --- a/libsgl/ports/SkFontHost_android.cpp +++ b/libsgl/ports/SkFontHost_android.cpp @@ -418,7 +418,11 @@ static const FontInitRec gSystemFonts[] = { { "DroidSerif-Italic.ttf", NULL }, { "DroidSerif-BoldItalic.ttf", NULL }, { "DroidSansMono.ttf", gMonoNames }, +#ifdef NO_FALLBACK_FONT + { "DroidSans.ttf", gFBNames } +#else { "DroidSansFallback.ttf", gFBNames } +#endif }; #define DEFAULT_NAMES gSansNames diff --git a/libsgl/ports/SkFontHost_linux.cpp b/libsgl/ports/SkFontHost_linux.cpp new file mode 100644 index 0000000..f75718d --- /dev/null +++ b/libsgl/ports/SkFontHost_linux.cpp @@ -0,0 +1,604 @@ +/* libs/graphics/ports/SkFontHost_android.cpp + ** + ** Copyright 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. + */ + +#include "SkFontHost.h" +#include "SkDescriptor.h" +#include "SkMMapStream.h" +#include "SkOSFile.h" +#include "SkPaint.h" +#include "SkString.h" +#include "SkStream.h" +#include "SkThread.h" +#include "SkTSearch.h" +#include <stdio.h> + +#define FONT_CACHE_MEMORY_BUDGET (1 * 1024 * 1024) + +#ifndef SK_FONT_FILE_PREFIX + #define SK_FONT_FILE_PREFIX "/usr/share/fonts/truetype/msttcorefonts/" +#endif + +SkTypeface::Style find_name_and_style(SkStream* stream, SkString* name); + +static void GetFullPathForSysFonts(SkString* full, const char name[]) +{ + full->append(SK_FONT_FILE_PREFIX); + full->append(name); +} + +/////////////////////////////////////////////////////////////////////////////// + +struct FamilyRec; + +/* This guy holds a mapping of a name -> family, used for looking up fonts. + Since it is stored in a stretchy array that doesn't preserve object + semantics, we don't use constructor/destructors, but just have explicit + helpers to manage our internal bookkeeping. + */ +struct NameFamilyPair { + const char* fName; // we own this + FamilyRec* fFamily; // we don't own this, we just reference it + + void construct(const char name[], FamilyRec* family) + { + fName = strdup(name); + fFamily = family; // we don't own this, so just record the referene + } + void destruct() + { + free((char*)fName); + // we don't own family, so just ignore our reference + } +}; + +// we use atomic_inc to grow this for each typeface we create +static int32_t gUniqueFontID; + +// this is the mutex that protects these globals +static SkMutex gFamilyMutex; +static FamilyRec* gFamilyHead; +static SkTDArray<NameFamilyPair> gNameList; + +struct FamilyRec { + FamilyRec* fNext; + SkTypeface* fFaces[4]; + + FamilyRec() + { + fNext = gFamilyHead; + memset(fFaces, 0, sizeof(fFaces)); + gFamilyHead = this; + } +}; + +static SkTypeface* find_best_face(const FamilyRec* family, + SkTypeface::Style style) +{ + SkTypeface* const* faces = family->fFaces; + + if (faces[style] != NULL) { // exact match + return faces[style]; + } + // look for a matching bold + style = (SkTypeface::Style)(style ^ SkTypeface::kItalic); + if (faces[style] != NULL) { + return faces[style]; + } + // look for the plain + if (faces[SkTypeface::kNormal] != NULL) { + return faces[SkTypeface::kNormal]; + } + // look for anything + for (int i = 0; i < 4; i++) { + if (faces[i] != NULL) { + return faces[i]; + } + } + // should never get here, since the faces list should not be empty + SkASSERT(!"faces list is empty"); + return NULL; +} + +static FamilyRec* find_family(const SkTypeface* member) +{ + FamilyRec* curr = gFamilyHead; + while (curr != NULL) { + for (int i = 0; i < 4; i++) { + if (curr->fFaces[i] == member) { + return curr; + } + } + curr = curr->fNext; + } + return NULL; +} + +static SkTypeface* resolve_uniqueID(uint32_t uniqueID) +{ + FamilyRec* curr = gFamilyHead; + while (curr != NULL) { + for (int i = 0; i < 4; i++) { + SkTypeface* face = curr->fFaces[i]; + if (face != NULL && face->uniqueID() == uniqueID) { + return face; + } + } + curr = curr->fNext; + } + return NULL; +} + +/* Remove reference to this face from its family. If the resulting family + is empty (has no faces), return that family, otherwise return NULL + */ +static FamilyRec* remove_from_family(const SkTypeface* face) +{ + FamilyRec* family = find_family(face); + SkASSERT(family->fFaces[face->style()] == face); + family->fFaces[face->style()] = NULL; + + for (int i = 0; i < 4; i++) { + if (family->fFaces[i] != NULL) { // family is non-empty + return NULL; + } + } + return family; // return the empty family +} + +// maybe we should make FamilyRec be doubly-linked +static void detach_and_delete_family(FamilyRec* family) +{ + FamilyRec* curr = gFamilyHead; + FamilyRec* prev = NULL; + + while (curr != NULL) { + FamilyRec* next = curr->fNext; + if (curr == family) { + if (prev == NULL) { + gFamilyHead = next; + } else { + prev->fNext = next; + } + SkDELETE(family); + return; + } + prev = curr; + curr = next; + } + SkASSERT(!"Yikes, couldn't find family in our list to remove/delete"); +} + +static FamilyRec* find_familyrec(const char name[]) { + const NameFamilyPair* list = gNameList.begin(); + int index = SkStrLCSearch(&list[0].fName, gNameList.count(), name, + sizeof(list[0])); + return index >= 0 ? list[index].fFamily : NULL; +} + +static SkTypeface* find_typeface(const char name[], SkTypeface::Style style) { + FamilyRec* rec = find_familyrec(name); + return rec ? find_best_face(rec, style) : NULL; +} + +static SkTypeface* find_typeface(const SkTypeface* familyMember, + SkTypeface::Style style) +{ + const FamilyRec* family = find_family(familyMember); + return family ? find_best_face(family, style) : NULL; +} + +static void add_name(const char name[], FamilyRec* family) +{ + SkAutoAsciiToLC tolc(name); + name = tolc.lc(); + + NameFamilyPair* list = gNameList.begin(); + int count = gNameList.count(); + + int index = SkStrLCSearch(&list[0].fName, count, name, sizeof(list[0])); + + if (index < 0) { + list = gNameList.insert(~index); + list->construct(name, family); + } +} + +static void remove_from_names(FamilyRec* emptyFamily) +{ +#ifdef SK_DEBUG + for (int i = 0; i < 4; i++) { + SkASSERT(emptyFamily->fFaces[i] == NULL); + } +#endif + + SkTDArray<NameFamilyPair>& list = gNameList; + + // must go backwards when removing + for (int i = list.count() - 1; i >= 0; --i) { + NameFamilyPair* pair = &list[i]; + if (pair->fFamily == emptyFamily) { + pair->destruct(); + list.remove(i); + } + } +} + +/////////////////////////////////////////////////////////////////////////////// + +class FamilyTypeface : public SkTypeface { +public: + FamilyTypeface(Style style, bool sysFont, FamilyRec* family) + : SkTypeface(style, sk_atomic_inc(&gUniqueFontID) + 1) + { + fIsSysFont = sysFont; + + SkAutoMutexAcquire ac(gFamilyMutex); + + if (NULL == family) { + family = SkNEW(FamilyRec); + } + family->fFaces[style] = this; + fFamilyRec = family; // just record it so we can return it if asked + } + + virtual ~FamilyTypeface() + { + SkAutoMutexAcquire ac(gFamilyMutex); + + // remove us from our family. If the family is now empty, we return + // that and then remove that family from the name list + FamilyRec* family = remove_from_family(this); + if (NULL != family) { + remove_from_names(family); + detach_and_delete_family(family); + } + } + + bool isSysFont() const { return fIsSysFont; } + FamilyRec* getFamily() const { return fFamilyRec; } + + virtual SkStream* openStream() = 0; + virtual void closeStream(SkStream*) = 0; + virtual const char* getUniqueString() const = 0; + +private: + FamilyRec* fFamilyRec; // we don't own this, just point to it + bool fIsSysFont; + + typedef SkTypeface INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +class StreamTypeface : public FamilyTypeface { +public: + StreamTypeface(Style style, bool sysFont, FamilyRec* family, + SkStream* stream) + : INHERITED(style, sysFont, family) + { + fStream = stream; + } + virtual ~StreamTypeface() + { + SkDELETE(fStream); + } + + // overrides + virtual SkStream* openStream() { return fStream; } + virtual void closeStream(SkStream*) {} + virtual const char* getUniqueString() const { return NULL; } + +private: + SkStream* fStream; + + typedef FamilyTypeface INHERITED; +}; + +class FileTypeface : public FamilyTypeface { +public: + FileTypeface(Style style, bool sysFont, FamilyRec* family, + const char path[]) + : INHERITED(style, sysFont, family) { + fPath.set(path); + } + + // overrides + virtual SkStream* openStream() + { + SkStream* stream = SkNEW_ARGS(SkMMAPStream, (fPath.c_str())); + + // check for failure + if (stream->getLength() <= 0) { + SkDELETE(stream); + // maybe MMAP isn't supported. try FILE + stream = SkNEW_ARGS(SkFILEStream, (fPath.c_str())); + if (stream->getLength() <= 0) { + SkDELETE(stream); + stream = NULL; + } + } + return stream; + } + virtual void closeStream(SkStream* stream) + { + SkDELETE(stream); + } + virtual const char* getUniqueString() const { + const char* str = strrchr(fPath.c_str(), '/'); + if (str) { + str += 1; // skip the '/' + } + return str; + } + +private: + SkString fPath; + + typedef FamilyTypeface INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static bool get_name_and_style(const char path[], SkString* name, + SkTypeface::Style* style) +{ + SkMMAPStream stream(path); + if (stream.getLength() > 0) { + *style = find_name_and_style(&stream, name); + return true; + } + else { + SkFILEStream stream(path); + if (stream.getLength() > 0) { + *style = find_name_and_style(&stream, name); + return true; + } + } + + SkDebugf("---- failed to open <%s> as a font\n", path); + return false; +} + +// these globals are assigned (once) by load_system_fonts() +static SkTypeface* gFallBackTypeface; +static FamilyRec* gDefaultFamily; +static SkTypeface* gDefaultNormal; + +static void load_system_fonts() +{ + // check if we've already be called + if (NULL != gDefaultNormal) { + return; + } + + SkOSFile::Iter iter(SK_FONT_FILE_PREFIX, ".ttf"); + SkString name; + + while (iter.next(&name, false)) { + SkString filename; + GetFullPathForSysFonts(&filename, name.c_str()); +// while (filename.size() == 0) { filename.set("/usr/share/fonts/truetype/msttcorefonts/Arial.ttf"); + + SkString realname; + SkTypeface::Style style; + + if (!get_name_and_style(filename.c_str(), &realname, &style)) { + SkDebugf("------ can't load <%s> as a font\n", filename.c_str()); + continue; + } + +// SkDebugf("font: <%s> %d <%s>\n", realname.c_str(), style, filename.c_str()); + + FamilyRec* family = find_familyrec(realname.c_str()); + // this constructor puts us into the global gFamilyHead llist + FamilyTypeface* tf = SkNEW_ARGS(FileTypeface, + (style, + true, // system-font (cannot delete) + family, // what family to join + filename.c_str()) // filename + ); + + if (NULL == family) { + add_name(realname.c_str(), tf->getFamily()); + } + } + + // do this after all fonts are loaded. This is our default font, and it + // acts as a sentinel so we only execute load_system_fonts() once + static const char* gDefaultNames[] = { + "Arial", "Verdana", "Times New Roman", NULL + }; + const char** names = gDefaultNames; + while (*names) { + SkTypeface* tf = find_typeface(*names++, SkTypeface::kNormal); + if (tf) { + gDefaultNormal = tf; + break; + } + } + // check if we found *something* + if (NULL == gDefaultNormal) { + if (NULL == gFamilyHead) { + sk_throw(); + } + for (int i = 0; i < 4; i++) { + if ((gDefaultNormal = gFamilyHead->fFaces[i]) != NULL) { + break; + } + } + } + if (NULL == gDefaultNormal) { + sk_throw(); + } + gFallBackTypeface = gDefaultNormal; + gDefaultFamily = find_family(gDefaultNormal); + +// SkDebugf("---- default %p head %p family %p\n", gDefaultNormal, gFamilyHead, gDefaultFamily); +} + +/////////////////////////////////////////////////////////////////////////////// + +void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) { +#if 0 + const char* name = ((FamilyTypeface*)face)->getUniqueString(); + + stream->write8((uint8_t)face->getStyle()); + + if (NULL == name || 0 == *name) { + stream->writePackedUInt(0); + // SkDebugf("--- fonthost serialize null\n"); + } else { + uint32_t len = strlen(name); + stream->writePackedUInt(len); + stream->write(name, len); + // SkDebugf("--- fonthost serialize <%s> %d\n", name, face->getStyle()); + } +#endif + sk_throw(); +} + +SkTypeface* SkFontHost::Deserialize(SkStream* stream) { +#if 0 + load_system_fonts(); + + int style = stream->readU8(); + + int len = stream->readPackedUInt(); + if (len > 0) { + SkString str; + str.resize(len); + stream->read(str.writable_str(), len); + + const FontInitRec* rec = gSystemFonts; + for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) { + if (strcmp(rec[i].fFileName, str.c_str()) == 0) { + // backup until we hit the fNames + for (int j = i; j >= 0; --j) { + if (rec[j].fNames != NULL) { + return SkFontHost::FindTypeface(NULL, rec[j].fNames[0], + (SkTypeface::Style)style); + } + } + } + } + } + return SkFontHost::FindTypeface(NULL, NULL, (SkTypeface::Style)style); +#endif + sk_throw(); +} + +/////////////////////////////////////////////////////////////////////////////// + +SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace, + const char familyName[], + SkTypeface::Style style) +{ + load_system_fonts(); + + SkAutoMutexAcquire ac(gFamilyMutex); + + // clip to legal style bits + style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic); + + SkTypeface* tf = NULL; + + if (NULL != familyFace) { + tf = find_typeface(familyFace, style); + } else if (NULL != familyName) { + // SkDebugf("======= familyName <%s>\n", familyName); + tf = find_typeface(familyName, style); + } + + if (NULL == tf) { + tf = find_best_face(gDefaultFamily, style); + } + + return tf; +} + +SkTypeface* SkFontHost::ResolveTypeface(uint32_t fontID) +{ + SkAutoMutexAcquire ac(gFamilyMutex); + + return resolve_uniqueID(fontID); +} + +SkStream* SkFontHost::OpenStream(uint32_t fontID) +{ + + FamilyTypeface* tf = (FamilyTypeface*)SkFontHost::ResolveTypeface(fontID); + SkStream* stream = tf ? tf->openStream() : NULL; + + if (NULL == stream || stream->getLength() == 0) { + delete stream; + stream = NULL; + } + return stream; +} + +void SkFontHost::CloseStream(uint32_t fontID, SkStream* stream) +{ + FamilyTypeface* tf = (FamilyTypeface*)SkFontHost::ResolveTypeface(fontID); + if (NULL != tf) { + tf->closeStream(stream); + } +} + +SkScalerContext* SkFontHost::CreateFallbackScalerContext( + const SkScalerContext::Rec& rec) +{ + load_system_fonts(); + + SkAutoDescriptor ad(sizeof(rec) + SkDescriptor::ComputeOverhead(1)); + SkDescriptor* desc = ad.getDesc(); + + desc->init(); + SkScalerContext::Rec* newRec = + (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag, + sizeof(rec), &rec); + newRec->fFontID = gFallBackTypeface->uniqueID(); + desc->computeChecksum(); + + return SkFontHost::CreateScalerContext(desc); +} + +/////////////////////////////////////////////////////////////////////////////// + +SkTypeface* SkFontHost::CreateTypeface(SkStream* stream) +{ + if (NULL == stream || stream->getLength() <= 0) { + SkDELETE(stream); + return NULL; + } + + SkString name; + SkTypeface::Style style = find_name_and_style(stream, &name); + + return SkNEW_ARGS(StreamTypeface, (style, false, NULL, stream)); +} + +/////////////////////////////////////////////////////////////////////////////// + +size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) +{ + if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET) + return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET; + else + return 0; // nothing to do +} + diff --git a/libsgl/ports/SkFontHost_mac.cpp b/libsgl/ports/SkFontHost_mac.cpp new file mode 100755 index 0000000..af44cf5 --- /dev/null +++ b/libsgl/ports/SkFontHost_mac.cpp @@ -0,0 +1,563 @@ +/*
+ ** Copyright 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.
+*/
+
+#include "SkFontHost.h"
+#include "SkDescriptor.h"
+
+// Give 1MB font cache budget
+#define FONT_CACHE_MEMORY_BUDGET (1024 * 1024)
+
+const char* gDefaultfont = "Arial"; // hard code for now
+static SkMutex gFTMutex;
+
+inline SkPoint F32PtToSkPoint(const Float32Point p)
+{
+ SkPoint sp = { SkFloatToFixed(p.x),SkFloatToFixed(p.y) };
+ return sp;
+}
+
+static inline uint32_t _rotl(uint32_t v, uint32_t r)
+{
+ return (v << r | v >> (32 - r));
+}
+
+// This will generate a unique ID based on the fontname + fontstyle
+// and also used by upper layer
+uint32_t FontFaceChecksum(const char *name,SkTypeface::Style style)
+{
+ if (!name) return style;
+
+ char* q = (char*)name;
+
+ // From "Performance in Practice of String Hashing Functions"
+ // Ramakrishna & Zobel
+ const uint32_t L = 5;
+ const uint32_t R = 2;
+
+ uint32_t h = 0x12345678;
+ while (*q) {
+ uint32_t ql = tolower(*q);
+ h ^= ((h << L) + (h >> R) + ql);
+ q ++;
+ }
+
+ // add style
+ h = _rotl(h, 3) ^ style;
+
+ return h;
+}
+
+#pragma mark -
+struct SkFaceRec {
+ SkFaceRec* fNext;
+ uint32_t fRefCnt;
+ ATSUFontID fFontID;
+ ATSUStyle fStyle;
+
+ SkFaceRec() : fFontID(0), fRefCnt(0), fStyle(NULL) {};
+
+ ~SkFaceRec() {
+ if (fStyle) {
+ ::ATSUDisposeStyle(fStyle);
+ fStyle = NULL;
+ }
+ }
+
+ uint32_t ref() {
+ return ++fRefCnt;
+ }
+};
+
+// Font Face list
+static SkFaceRec* gFaceRecHead = NULL;
+
+static SkFaceRec* find_ft_face(const ATSUFontID fontID) {
+ SkFaceRec* rec = gFaceRecHead;
+ while (rec) {
+ if (rec->fFontID == fontID) {
+ return rec;
+ }
+ rec = rec->fNext;
+ }
+
+ return NULL;
+}
+
+static SkFaceRec* insert_ft_face(const ATSUFontID afontID, const ATSUStyle atsuStyle) {
+ SkFaceRec* rec = find_ft_face(afontID);
+ if (rec) {
+ return rec; // found?
+ }
+
+ rec = SkNEW(SkFaceRec);
+ rec->fFontID = afontID;
+ rec->fStyle = atsuStyle;
+ rec->fNext = gFaceRecHead;
+ gFaceRecHead = rec;
+
+ return rec;
+}
+
+static void unref_ft_face(const ATSUFontID fontID) {
+
+ SkFaceRec* rec = gFaceRecHead;
+ SkFaceRec* prev = NULL;
+ while (rec) {
+ SkFaceRec* next = rec->fNext;
+ if (rec->fFontID == fontID) {
+ if (--rec->fRefCnt == 0) {
+ if (prev)
+ prev->fNext = next;
+ else
+ gFaceRecHead = next;
+
+ SkDELETE(rec);
+ }
+ return;
+ }
+ prev = rec;
+ rec = next;
+ }
+ SkASSERT("shouldn't get here, face not in list");
+}
+
+#pragma mark -
+
+// have to do this because SkTypeface::SkTypeface() is protected
+class SkTypeface_Mac : public SkTypeface {
+public:
+ SkTypeface_Mac(SkTypeface::Style style, uint32_t id) : SkTypeface(style, id) {}
+
+ ~SkTypeface_Mac() {}
+};
+
+#pragma mark -
+
+static SkTypeface* CreateTypeface_(const char *name, const SkTypeface::Style style) {
+
+ OSStatus err;
+ ATSUStyle atsuStyle;
+ ::ATSUCreateStyle(&atsuStyle);
+ if (name != NULL) {
+ static const ATSUAttributeTag fontTag = kATSUFontTag;
+ static const ByteCount fontTagSize = sizeof(ATSUFontID);
+
+ ATSUFontID fontID = 0;
+#if 1
+ err = ::ATSUFindFontFromName(
+ name,strlen(name),kFontNoNameCode, /* instead of regular, kFontFamilyName returns bold and/or italic sometimes, but why this works?? */
+ kFontMacintoshPlatform,kFontNoScriptCode,kFontNoLanguageCode,&fontID);
+#else
+ CFStringRef cfontName = CFStringCreateWithCString(NULL, name, kCFStringEncodingASCII);
+ ATSFontRef fontRef = ::ATSFontFindFromName(cfontName,kATSOptionFlagsDefault);
+ fontID = ::FMGetFontFromATSFontRef(fontRef);
+ CFRelease(cfontName);
+#endif
+ if (0 != fontID) {
+ const ATSUAttributeValuePtr values[] = { &fontID };
+ err = ::ATSUSetAttributes(atsuStyle,1,&fontTag,&fontTagSize,values);
+ }
+ else {
+ }
+ }
+ if (style != SkTypeface::kNormal) {
+ Boolean fontItalic = ((style & SkTypeface::kItalic) != 0);
+ Boolean fontBold = ((style & SkTypeface::kBold) != 0);
+ const ATSUAttributeTag tags[2] = { kATSUQDBoldfaceTag, kATSUQDItalicTag };
+ const ATSUAttributeValuePtr values[2] = { &fontBold, &fontItalic };
+ const ByteCount sizes[2] = { sizeof(Boolean), sizeof(Boolean) };
+ err = ::ATSUSetAttributes(atsuStyle,2,tags,sizes,values);
+ }
+
+ uint32_t cs = FontFaceChecksum(name,style);
+ SkTypeface_Mac* ptypeface = new SkTypeface_Mac(style,cs);
+
+ if (NULL == ptypeface) {
+ SkASSERT(false);
+ return NULL;
+ }
+
+ SkFaceRec* rec = insert_ft_face(cs, atsuStyle);
+ SkASSERT(rec);
+
+ return ptypeface;
+}
+
+static SkTypeface* CreateTypeface_(const SkFaceRec* rec, const SkTypeface::Style style) {
+
+ OSStatus err;
+ ATSUStyle atsuStyle;
+ err = ::ATSUCreateAndCopyStyle(rec->fStyle, &atsuStyle);
+
+ Boolean fontItalic = ((style & SkTypeface::kItalic) != 0);
+ Boolean fontBold = ((style & SkTypeface::kBold) != 0);
+ const ATSUAttributeTag tags[2] = { kATSUQDBoldfaceTag, kATSUQDItalicTag };
+ const ATSUAttributeValuePtr values[2] = { &fontBold, &fontItalic };
+ const ByteCount sizes[2] = { sizeof(Boolean), sizeof(Boolean) };
+ err = ::ATSUSetAttributes(atsuStyle,2,tags,sizes,values);
+
+ // get old font id and name
+ ATSUFontID fontID = 0;
+ ByteCount actual = 0;
+ err = ::ATSUGetAttribute(rec->fStyle,kATSUFontTag,sizeof(ATSUFontID),&fontID,&actual);
+
+ ByteCount actualLength = 0;
+ char *fontname = NULL;
+ err = ::ATSUFindFontName(fontID , kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode,
+ kFontNoLanguageCode , 0 , NULL , &actualLength , NULL );
+ if ( err == noErr)
+ {
+ actualLength += 1 ;
+ fontname = (char*)malloc( actualLength );
+ err = ::ATSUFindFontName(fontID, kFontFamilyName, kFontUnicodePlatform, kFontNoScriptCode,
+ kFontNoLanguageCode, actualLength, fontname , NULL, NULL);
+ }
+
+ SkTypeface_Mac* ptypeface = NULL;
+ if (fontname == NULL) {
+ ptypeface = new SkTypeface_Mac(style,rec->fFontID);
+ return ptypeface;
+ }
+ else {
+ uint32_t cs = FontFaceChecksum(fontname,style);
+ ptypeface = new SkTypeface_Mac(style, cs);
+
+ if (NULL == ptypeface) {
+ SkASSERT(false);
+ return NULL;
+ }
+
+ free(fontname);
+
+ insert_ft_face(cs,atsuStyle);
+ }
+ return ptypeface;
+}
+
+#pragma mark -
+
+class SkScalerContext_Mac : public SkScalerContext {
+public:
+ SkScalerContext_Mac(const SkDescriptor* desc);
+ virtual ~SkScalerContext_Mac();
+
+protected:
+ virtual unsigned generateGlyphCount() const;
+ virtual uint16_t generateCharToGlyph(SkUnichar uni);
+ virtual void generateAdvance(SkGlyph* glyph);
+ virtual void generateMetrics(SkGlyph* glyph);
+ virtual void generateImage(const SkGlyph& glyph);
+ virtual void generatePath(const SkGlyph& glyph, SkPath* path);
+ virtual void generateLineHeight(SkPoint* ascent, SkPoint* descent);
+ virtual void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY);
+ virtual SkDeviceContext getDC() { return NULL; } // not implemented on Mac
+
+private:
+ ATSUTextLayout fLayout;
+ ATSUStyle fStyle;
+
+ static OSStatus MoveTo(const Float32Point *pt, void *cb);
+ static OSStatus Line(const Float32Point *pt, void *cb);
+ static OSStatus Curve(const Float32Point *pt1, const Float32Point *pt2, const Float32Point *pt3, void *cb);
+ static OSStatus Close(void *cb);
+};
+
+SkScalerContext_Mac::SkScalerContext_Mac(const SkDescriptor* desc)
+ : SkScalerContext(desc), fLayout(0), fStyle(0)
+{
+ SkAutoMutexAcquire ac(gFTMutex);
+ OSStatus err;
+
+ SkFaceRec* rec = find_ft_face(fRec.fFontID);
+ if (rec) {
+ rec->ref();
+ err = ::ATSUCreateAndCopyStyle(rec->fStyle, &fStyle);
+ }
+ else {
+ SkASSERT(false);
+ // create a default
+ err = ::ATSUCreateStyle(&fStyle);
+ }
+
+ uint32_t size = SkFixedFloor(fRec.fTextSize);
+ Fixed fixedSize = IntToFixed(size);
+ static const ATSUAttributeTag sizeTag = kATSUSizeTag;
+ static const ByteCount sizeTagSize = sizeof(Fixed);
+ const ATSUAttributeValuePtr values[] = { &fixedSize };
+ err = ::ATSUSetAttributes(fStyle,1,&sizeTag,&sizeTagSize,values);
+
+ err = ::ATSUCreateTextLayout(&fLayout);
+}
+
+SkScalerContext_Mac::~SkScalerContext_Mac()
+{
+ unref_ft_face(fRec.fFontID);
+
+ ::ATSUDisposeTextLayout(fLayout);
+ ::ATSUDisposeStyle(fStyle);
+}
+
+unsigned SkScalerContext_Mac::generateGlyphCount() const
+{
+ return 0xFFFF;
+}
+
+uint16_t SkScalerContext_Mac::generateCharToGlyph(SkUnichar uni)
+{
+ SkAutoMutexAcquire ac(gFTMutex);
+
+ OSStatus err;
+ UniChar achar = uni;
+ err = ::ATSUSetTextPointerLocation(fLayout,&achar,0,1,1);
+ err = ::ATSUSetRunStyle(fLayout,fStyle,kATSUFromTextBeginning,kATSUToTextEnd);
+
+ ATSLayoutRecord *layoutPtr;
+ ItemCount count;
+ ATSGlyphRef glyph;
+
+ err = ::ATSUDirectGetLayoutDataArrayPtrFromTextLayout(fLayout,0,kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,(void**)&layoutPtr,&count);
+ glyph = layoutPtr->glyphID;
+ ::ATSUDirectReleaseLayoutDataArrayPtr(NULL,kATSUDirectDataLayoutRecordATSLayoutRecordCurrent,(void**)&layoutPtr);
+ return glyph;
+}
+
+void SkScalerContext_Mac::generateAdvance(SkGlyph* glyph) {
+ this->generateMetrics(glyph);
+}
+
+void SkScalerContext_Mac::generateMetrics(SkGlyph* glyph)
+{
+ GlyphID glyphID = glyph->fID;
+ ATSGlyphScreenMetrics metrics= { 0 };
+
+ glyph->fRsbDelta = 0;
+ glyph->fLsbDelta = 0;
+
+ OSStatus err = ATSUGlyphGetScreenMetrics(fStyle,1,&glyphID,0,true,true,&metrics);
+ if (err == noErr) {
+ glyph->fAdvanceX = SkFloatToFixed(metrics.deviceAdvance.x);
+ glyph->fAdvanceY = SkFloatToFixed(metrics.deviceAdvance.y);
+ //glyph->fWidth = metrics.width;
+ //glyph->fHeight = metrics.height;
+ glyph->fWidth = metrics.width + ceil(metrics.sideBearing.x - metrics.otherSideBearing.x);
+ glyph->fHeight = metrics.height + ceil(metrics.sideBearing.y - metrics.otherSideBearing.y) + 1;
+
+ glyph->fTop = -metrics.topLeft.y;
+ glyph->fLeft = metrics.topLeft.x;
+ }
+}
+
+void SkScalerContext_Mac::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
+ //SkASSERT(false);
+ if (mx)
+ memset(mx, 0, sizeof(SkPaint::FontMetrics));
+ if (my)
+ memset(my, 0, sizeof(SkPaint::FontMetrics));
+ return;
+}
+
+void SkScalerContext_Mac::generateImage(const SkGlyph& glyph)
+{
+ SkAutoMutexAcquire ac(gFTMutex);
+
+ GlyphID glyphID = glyph.fID;
+ ATSGlyphScreenMetrics metrics= { 0 };
+
+ SkASSERT(fLayout);
+ OSStatus err = ::ATSUGlyphGetScreenMetrics(fStyle,1,&glyphID,0,true,true,&metrics);
+
+// uint32_t w = metrics.width;
+// uint32_t h = metrics.height;
+// uint32_t pitch = (w + 3) & ~0x3;
+// if (pitch != glyph.rowBytes()) {
+// SkASSERT(false); // it's different from previously cacluated in generateMetrics(), so the size of glyph.fImage buffer is incorrect!
+// }
+
+ CGColorSpaceRef greyColorSpace = ::CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
+ CGContextRef contextRef = ::CGBitmapContextCreate((uint8_t*)glyph.fImage, glyph.fWidth, glyph.fHeight, 8, glyph.rowBytes(), greyColorSpace, kCGImageAlphaNone);
+ if (!contextRef) {
+ SkASSERT(false);
+ return;
+ }
+
+ ::CGContextSetFillColorSpace(contextRef, greyColorSpace);
+ ::CGContextSetStrokeColorSpace(contextRef, greyColorSpace);
+
+ ::CGContextSetGrayFillColor(contextRef, 0.0, 1.0);
+ ::CGContextFillRect(contextRef, ::CGRectMake(0, 0, glyph.fWidth, glyph.fHeight));
+
+ ::CGContextSetGrayFillColor(contextRef, 1.0, 1.0);
+ ::CGContextSetGrayStrokeColor(contextRef, 1.0, 1.0);
+ ::CGContextSetTextDrawingMode(contextRef, kCGTextFill);
+
+ ATSUAttributeTag tag = kATSUCGContextTag;
+ ByteCount size = sizeof(CGContextRef);
+ ATSUAttributeValuePtr value = &contextRef;
+ err = ::ATSUSetLayoutControls(fLayout,1,&tag,&size,&value);
+ err = ::ATSUDrawText(fLayout,kATSUFromTextBeginning,kATSUToTextEnd,FloatToFixed(-metrics.topLeft.x),FloatToFixed(glyph.fHeight-metrics.topLeft.y));
+ ::CGContextRelease(contextRef);
+}
+
+void SkScalerContext_Mac::generatePath(const SkGlyph& glyph, SkPath* path)
+{
+ SkAutoMutexAcquire ac(gFTMutex);
+ OSStatus err,result;
+
+ err = ::ATSUGlyphGetCubicPaths(
+ fStyle,glyph.fID,
+ &SkScalerContext_Mac::MoveTo,
+ &SkScalerContext_Mac::Line,
+ &SkScalerContext_Mac::Curve,
+ &SkScalerContext_Mac::Close,
+ path,&result);
+ SkASSERT(err == noErr);
+}
+
+void SkScalerContext_Mac::generateLineHeight(SkPoint* ascent, SkPoint* descent)
+{
+ ATSUTextMeasurement textAscent, textDescent;
+ ByteCount actual = 0;
+ OSStatus err = ::ATSUGetAttribute(fStyle,kATSULineAscentTag,sizeof(ATSUTextMeasurement),&textAscent,&actual);
+ ascent->set(0,textAscent);
+ err = ::ATSUGetAttribute(fStyle,kATSULineDescentTag,sizeof(ATSUTextMeasurement),&textDescent,&actual);
+ descent->set(0,textDescent);
+}
+
+OSStatus SkScalerContext_Mac::MoveTo(const Float32Point *pt, void *cb)
+{
+ reinterpret_cast<SkPath*>(cb)->moveTo(F32PtToSkPoint(*pt));
+ return noErr;
+}
+
+OSStatus SkScalerContext_Mac::Line(const Float32Point *pt, void *cb)
+{
+ reinterpret_cast<SkPath*>(cb)->lineTo(F32PtToSkPoint(*pt));
+ return noErr;
+}
+
+OSStatus SkScalerContext_Mac::Curve(const Float32Point *pt1, const Float32Point *pt2, const Float32Point *pt3, void *cb)
+{
+ reinterpret_cast<SkPath*>(cb)->cubicTo(F32PtToSkPoint(*pt1),F32PtToSkPoint(*pt2),F32PtToSkPoint(*pt3));
+ return noErr;
+}
+
+OSStatus SkScalerContext_Mac::Close(void *cb)
+{
+ reinterpret_cast<SkPath*>(cb)->close();
+ return noErr;
+}
+
+#pragma mark -
+
+void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
+ SkASSERT(!"SkFontHost::Serialize unimplemented");
+}
+
+SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
+ SkASSERT(!"SkFontHost::Deserialize unimplemented");
+ return NULL;
+}
+
+SkTypeface* SkFontHost::CreateTypeface(SkStream* stream) {
+
+ //Should not be used on Mac, keep linker happy
+ SkASSERT(false);
+ return CreateTypeface_(gDefaultfont,SkTypeface::kNormal);
+}
+
+SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc)
+{
+ return new SkScalerContext_Mac(desc);
+}
+
+SkScalerContext* SkFontHost::CreateFallbackScalerContext(const SkScalerContext::Rec& rec)
+{
+ SkAutoDescriptor ad(sizeof(rec) + sizeof(gDefaultfont) + SkDescriptor::ComputeOverhead(2));
+ SkDescriptor* desc = ad.getDesc();
+
+ desc->init();
+ SkScalerContext::Rec* newRec =
+ (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
+
+ CreateTypeface_(gDefaultfont,SkTypeface::kNormal);
+ newRec->fFontID = FontFaceChecksum(gDefaultfont,SkTypeface::kNormal);
+ desc->computeChecksum();
+
+ return SkFontHost::CreateScalerContext(desc);
+}
+
+
+ /** Return the closest matching typeface given either an existing family
+ (specified by a typeface in that family) or by a familyName, and a
+ requested style.
+ 1) If familyFace is null, use famillyName.
+ 2) If famillyName is null, use familyFace.
+ 3) If both are null, return the default font that best matches style
+ This MUST not return NULL.
+ */
+
+SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {
+
+ SkAutoMutexAcquire ac(gFTMutex);
+
+ // clip to legal style bits
+ style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
+
+ SkTypeface* tf = NULL;
+
+ if (NULL == familyFace && NULL == familyName) {
+ tf = CreateTypeface_(gDefaultfont,style);
+ }
+ else {
+ if (NULL != familyFace) {
+ uint32_t id = familyFace->uniqueID();
+ SkFaceRec* rec = find_ft_face(id);
+ if (!rec) {
+ SkASSERT(false);
+ tf = CreateTypeface_(gDefaultfont,style);
+ }
+ else {
+ tf = CreateTypeface_(rec,style);
+ }
+ }
+ else {
+ tf = CreateTypeface_(familyName,style);
+ }
+ }
+
+ if (NULL == tf) {
+ tf = CreateTypeface_(gDefaultfont,style);
+ }
+ return tf;
+
+}
+
+size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {
+ if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
+ return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
+ else
+ return 0; // nothing to do
+}
+
+int SkFontHost::ComputeGammaFlag(const SkPaint& paint) {
+ return 0;
+}
+
+void SkFontHost::GetGammaTables(const uint8_t* tables[2]) {
+ tables[0] = NULL; // black gamma (e.g. exp=1.4)
+ tables[1] = NULL; // white gamma (e.g. exp= 1/1.4)
+}
+
diff --git a/libsgl/ports/SkFontHost_win.cpp b/libsgl/ports/SkFontHost_win.cpp index d8c2b12..c2ee51e 100644 --- a/libsgl/ports/SkFontHost_win.cpp +++ b/libsgl/ports/SkFontHost_win.cpp @@ -1,8 +1,18 @@ -/* libs/graphics/ports/SkFontHost_win.cpp
-**
-** Copyright 2006, The Android Open Source Project -**
-*/
+/*
+ ** Copyright 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.
+ */
#include "SkString.h"
//#include "SkStream.h"
@@ -15,151 +25,273 @@ #include "windows.h"
#include "tchar.h"
-static SkMutex gFTMutex;
+// client3d has to undefine this for now
+#define CAN_USE_LOGFONT_NAME
-static LOGFONT gDefaultFont;
+static SkMutex gFTMutex;
+
+// these globals are loaded (once) by get_default_font()
+static LOGFONT gDefaultFont = {0};
static const uint16_t BUFFERSIZE = (16384 - 32);
static uint8_t glyphbuf[BUFFERSIZE];
-#ifndef SK_FONTKEY
- #define SK_FONTKEY "Windows Font Key"
-#endif
+// Give 1MB font cache budget
+#define FONT_CACHE_MEMORY_BUDGET (1024 * 1024)
-inline FIXED SkFixedToFIXED(SkFixed x) {
+static inline FIXED SkFixedToFIXED(SkFixed x) {
return *(FIXED*)(&x);
}
-class FontFaceRec_Typeface : public SkTypeface {
-public:
-#if 0
- FontFaceRec_Typeface(const LOGFONT& face) : fFace(face)
- {
- int style = 0;
- if (face.lfWeight == FW_SEMIBOLD || face.lfWeight == FW_DEMIBOLD || face.lfWeight == FW_BOLD)
- style |= SkTypeface::kBold;
- if (face.lfItalic)
- style |= SkTypeface::kItalic;
- this->setStyle((SkTypeface::Style)style);
+static inline FIXED SkScalarToFIXED(SkScalar x) {
+ return SkFixedToFIXED(SkScalarToFixed(x));
+}
+
+// This will generate a unique ID based on the fontname + fontstyle
+// and also used by upper layer
+uint32_t FontFaceChecksum(const TCHAR *q, SkTypeface::Style style)
+{
+ if (!q) return style;
+
+ // From "Performance in Practice of String Hashing Functions"
+ // Ramakrishna & Zobel
+ const uint32_t L = 5;
+ const uint32_t R = 2;
+
+ uint32_t h = 0x12345678;
+ while (*q) {
+ //uint32_t ql = tolower(*q);
+ h ^= ((h << L) + (h >> R) + *q);
+ q ++;
}
-#endif
- ~FontFaceRec_Typeface() {};
+
+ // add style
+ h = _rotl(h, 3) ^ style;
+
+ return h;
+}
- TCHAR* GetFontName() { return fFace.lfFaceName; }
+static SkTypeface::Style GetFontStyle(const LOGFONT& lf) {
+ int style = SkTypeface::kNormal;
+ if (lf.lfWeight == FW_SEMIBOLD || lf.lfWeight == FW_DEMIBOLD || lf.lfWeight == FW_BOLD)
+ style |= SkTypeface::kBold;
+ if (lf.lfItalic)
+ style |= SkTypeface::kItalic;
+
+ return (SkTypeface::Style)style;
+}
+
+struct SkFaceRec {
+ SkFaceRec* fNext;
+ uint32_t fRefCnt;
+ uint32_t fFontID; // checksum of fFace
+ LOGFONT fFace;
+
+ SkFaceRec() : fFontID(-1), fRefCnt(0) {
+ memset(&fFace, 0, sizeof(LOGFONT));
+ }
+ ~SkFaceRec() {}
+
+ uint32_t ref() {
+ return ++fRefCnt;
+ }
+};
+
+// Font Face list
+static SkFaceRec* gFaceRecHead = NULL;
- SkTypeface::Style GetFontStyle() {
- int style = SkTypeface::kNormal;
- if (fFace.lfWeight == FW_SEMIBOLD || fFace.lfWeight == FW_DEMIBOLD || fFace.lfWeight == FW_BOLD)
- style |= SkTypeface::kBold;
- if (fFace.lfItalic)
- style |= SkTypeface::kItalic;
+static SkFaceRec* find_ft_face(uint32_t fontID) {
+ SkFaceRec* rec = gFaceRecHead;
+ while (rec) {
+ if (rec->fFontID == fontID) {
+ return rec;
+ }
+ rec = rec->fNext;
+ }
+
+ return NULL;
+}
- return (SkTypeface::Style)style;
+static SkFaceRec* insert_ft_face(const LOGFONT& lf) {
+ // need a const char*
+ uint32_t id = FontFaceChecksum(&(lf.lfFaceName[0]), GetFontStyle(lf));
+ SkFaceRec* rec = find_ft_face(id);
+ if (rec) {
+ return rec; // found?
}
+
+ rec = SkNEW(SkFaceRec);
+ rec->fFontID = id;
+ memcpy(&(rec->fFace), &lf, sizeof(LOGFONT));
+ rec->fNext = gFaceRecHead;
+ gFaceRecHead = rec;
+
+ return rec;
+}
- long GetFontSize() { return fFace.lfHeight; }
+static void unref_ft_face(uint32_t fontID) {
+
+ SkFaceRec* rec = gFaceRecHead;
+ SkFaceRec* prev = NULL;
+ while (rec) {
+ SkFaceRec* next = rec->fNext;
+ if (rec->fFontID == fontID) {
+ if (--rec->fRefCnt == 0) {
+ if (prev)
+ prev->fNext = next;
+ else
+ gFaceRecHead = next;
+
+ SkDELETE(rec);
+ }
+ return;
+ }
+ prev = rec;
+ rec = next;
+ }
+ SkASSERT("shouldn't get here, face not in list");
+}
- LOGFONT fFace;
+// have to do this because SkTypeface::SkTypeface() is protected
+class FontFaceRec_Typeface : public SkTypeface {
+public:
+
+ FontFaceRec_Typeface(Style style, uint32_t id) : SkTypeface(style, id) {};
+
+ virtual ~FontFaceRec_Typeface() {};
};
-
-static const LOGFONT* get_default_font()
-{
+static const LOGFONT* get_default_font() {
// don't hardcode on Windows, Win2000, XP, Vista, and international all have different default
// and the user could change too
-
+
+ if (gDefaultFont.lfFaceName[0] != 0) {
+ return &gDefaultFont;
+ }
+
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(NONCLIENTMETRICS);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
-
+
memcpy(&gDefaultFont, &(ncm.lfMessageFont), sizeof(LOGFONT));
-
+
return &gDefaultFont;
}
-static uint32_t FontFaceChecksum(const LOGFONT& face)
-{
- uint32_t cs = 0;
- uint32_t bytesize = sizeof(LOGFONT);
- bytesize >>= 2;
- uint32_t *p32 = (uint32_t*)&face;
-
- while (bytesize) {
- bytesize --;
- cs ^= *p32;
- p32 ++;
+static SkTypeface* CreateTypeface_(const LOGFONT& lf) {
+
+ SkTypeface::Style style = GetFontStyle(lf);
+ FontFaceRec_Typeface* ptypeface = new FontFaceRec_Typeface(style, FontFaceChecksum(lf.lfFaceName, style));
+
+ if (NULL == ptypeface) {
+ SkASSERT(false);
+ return NULL;
}
-
- return cs;
+
+ SkFaceRec* rec = insert_ft_face(lf);
+ SkASSERT(rec);
+
+ return ptypeface;
}
class SkScalerContext_Windows : public SkScalerContext {
public:
SkScalerContext_Windows(const SkDescriptor* desc);
virtual ~SkScalerContext_Windows();
-
+
protected:
virtual unsigned generateGlyphCount() const;
virtual uint16_t generateCharToGlyph(SkUnichar uni);
+ virtual void generateAdvance(SkGlyph* glyph);
virtual void generateMetrics(SkGlyph* glyph);
virtual void generateImage(const SkGlyph& glyph);
virtual void generatePath(const SkGlyph& glyph, SkPath* path);
virtual void generateLineHeight(SkPoint* ascent, SkPoint* descent);
-
+ virtual void generateFontMetrics(SkPaint::FontMetrics* mX, SkPaint::FontMetrics* mY);
+ //virtual SkDeviceContext getDC() {return ddc;}
private:
- LOGFONT* plf;
+ uint32_t fFontID;
+ LOGFONT lf;
MAT2 mat22;
+ HDC ddc;
+ HFONT savefont;
+ HFONT font;
};
-SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc)
- : SkScalerContext(desc), plf(NULL)
-{
+SkScalerContext_Windows::SkScalerContext_Windows(const SkDescriptor* desc) : SkScalerContext(desc), ddc(0), font(0), savefont(0) {
SkAutoMutexAcquire ac(gFTMutex);
-
- const LOGFONT** face = (const LOGFONT**)desc->findEntry(kTypeface_SkDescriptorTag, NULL);
- plf = (LOGFONT*)*face;
- SkASSERT(plf);
-
- mat22.eM11 = SkFixedToFIXED(fRec.fPost2x2[0][0]);
- mat22.eM12 = SkFixedToFIXED(-fRec.fPost2x2[0][1]);
- mat22.eM21 = SkFixedToFIXED(fRec.fPost2x2[1][0]);
- mat22.eM22 = SkFixedToFIXED(-fRec.fPost2x2[1][1]);
+
+ fFontID = fRec.fFontID;
+ SkFaceRec* rec = find_ft_face(fRec.fFontID);
+ if (rec) {
+ rec->ref();
+ memcpy(&lf, &(rec->fFace), sizeof(LOGFONT));
+ }
+ else {
+ SkASSERT(false);
+ memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));
+ }
+
+ mat22.eM11 = SkScalarToFIXED(fRec.fPost2x2[0][0]);
+ mat22.eM12 = SkScalarToFIXED(-fRec.fPost2x2[0][1]);
+ mat22.eM21 = SkScalarToFIXED(fRec.fPost2x2[1][0]);
+ mat22.eM22 = SkScalarToFIXED(-fRec.fPost2x2[1][1]);
+
+ ddc = ::CreateCompatibleDC(NULL);
+ SetBkMode(ddc, TRANSPARENT);
+
+ lf.lfHeight = SkScalarFloor(fRec.fTextSize);
+ font = CreateFontIndirect(&lf);
+ savefont = (HFONT)SelectObject(ddc, font);
}
SkScalerContext_Windows::~SkScalerContext_Windows() {
+ unref_ft_face(fFontID);
+
+ if (ddc) {
+ ::SelectObject(ddc, savefont);
+ ::DeleteDC(ddc);
+ ddc = NULL;
+ }
+ if (font) {
+ ::DeleteObject(font);
+ }
}
unsigned SkScalerContext_Windows::generateGlyphCount() const {
return 0xFFFF;
-// return fFace->num_glyphs;
+ // return fFace->num_glyphs;
}
uint16_t SkScalerContext_Windows::generateCharToGlyph(SkUnichar uni) {
-
+
+ //uint16_t index = 0;
+ //GetGlyphIndicesW(ddc, &(uint16_t&)uni, 1, &index, 0);
+ //return index;
+
// let's just use the uni as index on Windows
return SkToU16(uni);
}
-void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
-
- HDC ddc = ::CreateCompatibleDC(NULL);
- SetBkMode(ddc, TRANSPARENT);
-
- SkASSERT(plf);
- plf->lfHeight = -SkFixedFloor(fRec.fTextSize);
+void SkScalerContext_Windows::generateAdvance(SkGlyph* glyph) {
+ this->generateMetrics(glyph);
+}
- HFONT font = CreateFontIndirect(plf);
- HFONT oldfont = (HFONT)SelectObject(ddc, font);
+void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) {
+
+ SkASSERT(ddc);
GLYPHMETRICS gm;
memset(&gm, 0, sizeof(gm));
-
+
glyph->fRsbDelta = 0;
glyph->fLsbDelta = 0;
-
+
+ UINT glyphIndexFlag = 0; //glyph->fIsCodePoint ? 0 : GGO_GLYPH_INDEX;
+ // UINT glyphIndexFlag = GGO_GLYPH_INDEX;
// Note: need to use GGO_GRAY8_BITMAP instead of GGO_METRICS because GGO_METRICS returns a smaller
// BlackBlox; we need the bigger one in case we need the image. fAdvance is the same.
- uint32_t ret = GetGlyphOutlineW(ddc, glyph->f_GlyphID, GGO_GRAY8_BITMAP, &gm, 0, NULL, &mat22);
+ uint32_t ret = GetGlyphOutlineW(ddc, glyph->getGlyphID(0), GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, 0, NULL, &mat22);
if (GDI_ERROR != ret) {
if (ret == 0) {
@@ -168,48 +300,68 @@ void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) { }
glyph->fWidth = gm.gmBlackBoxX;
glyph->fHeight = gm.gmBlackBoxY;
- glyph->fTop = gm.gmptGlyphOrigin.y - gm.gmBlackBoxY;
- glyph->fLeft = gm.gmptGlyphOrigin.x;
+ glyph->fTop = SkToS16(gm.gmptGlyphOrigin.y - gm.gmBlackBoxY);
+ glyph->fLeft = SkToS16(gm.gmptGlyphOrigin.x);
glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);
glyph->fAdvanceY = -SkIntToFixed(gm.gmCellIncY);
+ } else {
+ glyph->fWidth = 0;
}
+
+#if 0
+ char buf[1024];
+ sprintf(buf, "generateMetrics: id:%d, w=%d, h=%d, font:%s, fh:%d\n", glyph->fID, glyph->fWidth, glyph->fHeight, lf.lfFaceName, lf.lfHeight);
+ OutputDebugString(buf);
+#endif
+}
- ::SelectObject(ddc, oldfont);
- ::DeleteObject(font);
- ::DeleteDC(ddc);
+void SkScalerContext_Windows::generateFontMetrics(SkPaint::FontMetrics* mx, SkPaint::FontMetrics* my) {
+ //SkASSERT(false);
+ if (mx)
+ memset(mx, 0, sizeof(SkPaint::FontMetrics));
+ if (my)
+ memset(my, 0, sizeof(SkPaint::FontMetrics));
+ return;
}
void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) {
-
+
SkAutoMutexAcquire ac(gFTMutex);
-
- SkASSERT(plf);
-
- HDC ddc = ::CreateCompatibleDC(NULL);
- SetBkMode(ddc, TRANSPARENT);
-
- plf->lfHeight = -SkFixedFloor(fRec.fTextSize);
-
- HFONT font = CreateFontIndirect(plf);
- HFONT oldfont = (HFONT)SelectObject(ddc, font);
-
+
+ SkASSERT(ddc);
+
GLYPHMETRICS gm;
memset(&gm, 0, sizeof(gm));
-
- uint32_t total_size = GetGlyphOutlineW(ddc, glyph.f_GlyphID, GGO_GRAY8_BITMAP, &gm, 0, NULL, &mat22);
+
+#if 0
+ char buf[1024];
+ sprintf(buf, "generateImage: id:%d, w=%d, h=%d, font:%s,fh:%d\n", glyph.fID, glyph.fWidth, glyph.fHeight, lf.lfFaceName, lf.lfHeight);
+ OutputDebugString(buf);
+#endif
+
+ uint32_t bytecount = 0;
+ UINT glyphIndexFlag = 0; //glyph.fIsCodePoint ? 0 : GGO_GLYPH_INDEX;
+ // UINT glyphIndexFlag = GGO_GLYPH_INDEX;
+ uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, 0, NULL, &mat22);
if (GDI_ERROR != total_size && total_size > 0) {
uint8_t *pBuff = new uint8_t[total_size];
if (NULL != pBuff) {
- total_size = GetGlyphOutlineW(ddc, glyph.f_GlyphID, GGO_GRAY8_BITMAP, &gm, total_size, pBuff, &mat22);
-
+ total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_GRAY8_BITMAP | glyphIndexFlag, &gm, total_size, pBuff, &mat22);
+
SkASSERT(total_size != GDI_ERROR);
-
+
+ SkASSERT(glyph.fWidth == gm.gmBlackBoxX);
+ SkASSERT(glyph.fHeight == gm.gmBlackBoxY);
+
uint8_t* dst = (uint8_t*)glyph.fImage;
uint32_t pitch = (gm.gmBlackBoxX + 3) & ~0x3;
-
+ if (pitch != glyph.rowBytes()) {
+ SkASSERT(false); // glyph.fImage has different rowsize!?
+ }
+
for (int32_t y = gm.gmBlackBoxY - 1; y >= 0; y--) {
uint8_t* src = pBuff + pitch * y;
-
+
for (uint32_t x = 0; x < gm.gmBlackBoxX; x++) {
if (*src > 63) {
*dst = 0xFF;
@@ -219,233 +371,228 @@ void SkScalerContext_Windows::generateImage(const SkGlyph& glyph) { }
dst++;
src++;
+ bytecount++;
}
+ memset(dst, 0, glyph.rowBytes() - glyph.fWidth);
+ dst += glyph.rowBytes() - glyph.fWidth;
}
-
+
delete[] pBuff;
}
}
-
+
SkASSERT(GDI_ERROR != total_size && total_size >= 0);
-
- ::SelectObject(ddc, oldfont);
- ::DeleteObject(font);
- ::DeleteDC(ddc);
+
}
void SkScalerContext_Windows::generatePath(const SkGlyph& glyph, SkPath* path) {
-
+
SkAutoMutexAcquire ac(gFTMutex);
-
+
SkASSERT(&glyph && path);
-
- SkASSERT(plf);
-
+ SkASSERT(ddc);
+
path->reset();
-
- HDC ddc = ::CreateCompatibleDC(NULL);
- SetBkMode(ddc, TRANSPARENT);
-
- plf->lfHeight = -SkFixedFloor(fRec.fTextSize);
-
- HFONT font = CreateFontIndirect(plf);
- HFONT oldfont = (HFONT)SelectObject(ddc, font);
-
+
+#if 0
+ char buf[1024];
+ sprintf(buf, "generatePath: id:%d, w=%d, h=%d, font:%s,fh:%d\n", glyph.fID, glyph.fWidth, glyph.fHeight, lf.lfFaceName, lf.lfHeight);
+ OutputDebugString(buf);
+#endif
+
GLYPHMETRICS gm;
-
- uint32_t total_size = GetGlyphOutlineW(ddc, glyph.f_GlyphID, GGO_NATIVE, &gm, BUFFERSIZE, glyphbuf, &mat22);
-
- if (GDI_ERROR != total_size) {
+ UINT glyphIndexFlag = 0; //glyph.fIsCodePoint ? 0 : GGO_GLYPH_INDEX;
+ uint32_t total_size = GetGlyphOutlineW(ddc, glyph.fID, GGO_NATIVE | glyphIndexFlag, &gm, BUFFERSIZE, glyphbuf, &mat22);
+ if (GDI_ERROR != total_size) {
+
const uint8_t* cur_glyph = glyphbuf;
const uint8_t* end_glyph = glyphbuf + total_size;
-
+
while(cur_glyph < end_glyph) {
const TTPOLYGONHEADER* th = (TTPOLYGONHEADER*)cur_glyph;
-
+
const uint8_t* end_poly = cur_glyph + th->cb;
const uint8_t* cur_poly = cur_glyph + sizeof(TTPOLYGONHEADER);
-
- path->moveTo(*(SkFixed*)(&th->pfxStart.x), *(SkFixed*)(&th->pfxStart.y));
-
+
+ path->moveTo(SkFixedToScalar(*(SkFixed*)(&th->pfxStart.x)), SkFixedToScalar(*(SkFixed*)(&th->pfxStart.y)));
+
while(cur_poly < end_poly) {
const TTPOLYCURVE* pc = (const TTPOLYCURVE*)cur_poly;
-
+
if (pc->wType == TT_PRIM_LINE) {
for (uint16_t i = 0; i < pc->cpfx; i++) {
- path->lineTo(*(SkFixed*)(&pc->apfx[i].x), *(SkFixed*)(&pc->apfx[i].y));
+ path->lineTo(SkFixedToScalar(*(SkFixed*)(&pc->apfx[i].x)), SkFixedToScalar(*(SkFixed*)(&pc->apfx[i].y)));
}
}
-
+
if (pc->wType == TT_PRIM_QSPLINE) {
for (uint16_t u = 0; u < pc->cpfx - 1; u++) { // Walk through points in spline
POINTFX pnt_b = pc->apfx[u]; // B is always the current point
POINTFX pnt_c = pc->apfx[u+1];
-
+
if (u < pc->cpfx - 2) { // If not on last spline, compute C
pnt_c.x = SkFixedToFIXED(SkFixedAve(*(SkFixed*)(&pnt_b.x), *(SkFixed*)(&pnt_c.x)));
pnt_c.y = SkFixedToFIXED(SkFixedAve(*(SkFixed*)(&pnt_b.y), *(SkFixed*)(&pnt_c.y)));
}
-
- path->quadTo(*(SkFixed*)(&pnt_b.x), *(SkFixed*)(&pnt_b.y), *(SkFixed*)(&pnt_c.x), *(SkFixed*)(&pnt_c.y));
+
+ path->quadTo(SkFixedToScalar(*(SkFixed*)(&pnt_b.x)), SkFixedToScalar(*(SkFixed*)(&pnt_b.y)), SkFixedToScalar(*(SkFixed*)(&pnt_c.x)), SkFixedToScalar(*(SkFixed*)(&pnt_c.y)));
}
}
cur_poly += sizeof(uint16_t) * 2 + sizeof(POINTFX) * pc->cpfx;
}
cur_glyph += th->cb;
+ path->close();
}
}
else {
SkASSERT(false);
}
-
- path->close();
-
- ::SelectObject(ddc, oldfont);
- ::DeleteObject(font);
- ::DeleteDC(ddc);
+ //char buf[1024];
+ //sprintf(buf, "generatePath: count:%d\n", count);
+ //OutputDebugString(buf);
}
// Note: not sure this is the correct implementation
void SkScalerContext_Windows::generateLineHeight(SkPoint* ascent, SkPoint* descent) {
-
- HDC ddc = ::CreateCompatibleDC(NULL);
- SetBkMode(ddc, TRANSPARENT);
-
- SkASSERT(plf);
- plf->lfHeight = -SkFixedFloor(fRec.fTextSize);
-
- HFONT font = CreateFontIndirect(plf);
- HFONT oldfont = (HFONT)SelectObject(ddc, font);
-
+
+ SkASSERT(ddc);
+
OUTLINETEXTMETRIC otm;
-
+
uint32_t ret = GetOutlineTextMetrics(ddc, sizeof(otm), &otm);
-
+
if (sizeof(otm) == ret) {
if (ascent)
ascent->iset(0, otm.otmAscent);
if (descent)
descent->iset(0, otm.otmDescent);
}
-
- ::SelectObject(ddc, oldfont);
- ::DeleteObject(font);
- ::DeleteDC(ddc);
-
+
return;
}
-SkTypeface* SkFontHost::CreateTypeface( const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {
-
- FontFaceRec_Typeface* ptypeface = new FontFaceRec_Typeface;
-
- if (NULL == ptypeface) {
- SkASSERT(false);
- return NULL;
- }
-
- memset(&ptypeface->fFace, 0, sizeof(LOGFONT));
-
- // default
- ptypeface->fFace.lfHeight = -11; // default
- ptypeface->fFace.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
- ptypeface->fFace.lfItalic = ((style & SkTypeface::kItalic) != 0);
- ptypeface->fFace.lfQuality = PROOF_QUALITY;
-
- _tcscpy(ptypeface->fFace.lfFaceName, familyName);
-
+void SkFontHost::Serialize(const SkTypeface* face, SkWStream* stream) {
+ SkASSERT(!"SkFontHost::Serialize unimplemented");
+}
- return ptypeface;
+SkTypeface* SkFontHost::Deserialize(SkStream* stream) {
+ SkASSERT(!"SkFontHost::Deserialize unimplemented");
+ return NULL;
}
-uint32_t SkFontHost::FlattenTypeface(const SkTypeface* tface, void* buffer) {
- const LOGFONT* face;
+SkTypeface* SkFontHost::CreateTypeface(SkStream* stream) {
- if (tface)
- face = &((const FontFaceRec_Typeface*)tface)->fFace;
- else
- face = get_default_font();
-
- size_t size = sizeof(face);
-
- size += sizeof(uint32_t);
-
- if (buffer) {
- uint8_t* buf = (uint8_t*)buffer;
- memcpy(buf, &face, sizeof(face));
- uint32_t cs = FontFaceChecksum(*face);
-
- memcpy(buf+sizeof(face), &cs, sizeof(cs));
- }
-
- return size;
+ //Should not be used on Windows, keep linker happy
+ SkASSERT(false);
+ get_default_font();
+ return CreateTypeface_(gDefaultFont);
}
SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc) {
return SkNEW_ARGS(SkScalerContext_Windows, (desc));
}
-void SkFontHost::GetDescriptorKeyString(const SkDescriptor* desc, SkString* keyString) {
- const LOGFONT** face = (const LOGFONT**)desc->findEntry(kTypeface_SkDescriptorTag, NULL);
- LOGFONT*lf = (LOGFONT*)*face;
- keyString->set(SK_FONTKEY);
- if (lf) {
- keyString->append(lf->lfFaceName);
- }
-}
-
SkScalerContext* SkFontHost::CreateFallbackScalerContext(const SkScalerContext::Rec& rec) {
- const LOGFONT* face = get_default_font();
-
- SkAutoDescriptor ad(sizeof(rec) + sizeof(face) + SkDescriptor::ComputeOverhead(2));
+ get_default_font();
+
+ SkAutoDescriptor ad(sizeof(rec) + sizeof(gDefaultFont) + SkDescriptor::ComputeOverhead(2));
SkDescriptor* desc = ad.getDesc();
-
+
desc->init();
- desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
- desc->addEntry(kTypeface_SkDescriptorTag, sizeof(face), &face);
+ SkScalerContext::Rec* newRec =
+ (SkScalerContext::Rec*)desc->addEntry(kRec_SkDescriptorTag, sizeof(rec), &rec);
+
+ get_default_font();
+ CreateTypeface_(gDefaultFont);
+ newRec->fFontID = FontFaceChecksum(gDefaultFont.lfFaceName, GetFontStyle(gDefaultFont));
desc->computeChecksum();
-
+
return SkFontHost::CreateScalerContext(desc);
}
-SkStream* SkFontHost::OpenDescriptorStream(const SkDescriptor* desc, const char keyString[]) {
- SkASSERT(!"SkFontHost::OpenDescriptorStream unimplemented");
- return NULL;
-}
+/** Return the closest matching typeface given either an existing family
+ (specified by a typeface in that family) or by a familyName, and a
+ requested style.
+ 1) If familyFace is null, use famillyName.
+ 2) If famillyName is null, use familyFace.
+ 3) If both are null, return the default font that best matches style
+ This MUST not return NULL.
+ */
-uint32_t SkFontHost::TypefaceHash(const SkTypeface* face) {
+SkTypeface* SkFontHost::FindTypeface(const SkTypeface* familyFace, const char familyName[], SkTypeface::Style style) {
-// FontFaceRec_Typeface *ptypeface = dynamic_cast<FontFaceRec_Typeface*>(face);
- FontFaceRec_Typeface *ptypeface = (FontFaceRec_Typeface*)(face);
- SkASSERT(ptypeface);
+ SkAutoMutexAcquire ac(gFTMutex);
- return FontFaceChecksum(ptypeface->fFace);
-}
+#ifndef CAN_USE_LOGFONT_NAME
+ familyName = NULL;
+ familyFace = NULL;
+#endif
-bool SkFontHost::TypefaceEqual(const SkTypeface* facea, const SkTypeface* faceb) {
+ // clip to legal style bits
+ style = (SkTypeface::Style)(style & SkTypeface::kBoldItalic);
- FontFaceRec_Typeface *ptypefaceA = (FontFaceRec_Typeface*)facea;
- SkASSERT(ptypefaceA);
-
- FontFaceRec_Typeface *ptypefaceB = (FontFaceRec_Typeface*)faceb;
- SkASSERT(ptypefaceB);
+ SkTypeface* tf = NULL;
+ if (NULL == familyFace && NULL == familyName) {
+ LOGFONT lf;
+ get_default_font();
+ memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));
+ lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
+ lf.lfItalic = ((style & SkTypeface::kItalic) != 0);
+ tf = CreateTypeface_(lf);
+ } else {
+#ifdef CAN_USE_LOGFONT_NAME
+ LOGFONT lf;
+ if (NULL != familyFace) {
+ uint32_t id = familyFace->uniqueID();
+ SkFaceRec* rec = find_ft_face(id);
+ if (!rec) {
+ SkASSERT(false);
+ get_default_font();
+ memcpy(&lf, &gDefaultFont, sizeof(LOGFONT));
+ }
+ else {
+ memcpy(&lf, &(rec->fFace), sizeof(LOGFONT));
+ }
+ }
+ else {
+ memset(&lf, 0, sizeof(LOGFONT));
+
+ lf.lfHeight = -11; // default
+ lf.lfQuality = PROOF_QUALITY;
+ lf.lfCharSet = DEFAULT_CHARSET;
+
+ _tcsncpy(lf.lfFaceName, familyName, LF_FACESIZE);
+ lf.lfFaceName[LF_FACESIZE-1] = '\0';
+ }
+
+ // use the style desired
+ lf.lfWeight = (style & SkTypeface::kBold) != 0 ? FW_BOLD : FW_NORMAL ;
+ lf.lfItalic = ((style & SkTypeface::kItalic) != 0);
+ tf = CreateTypeface_(lf);
+#endif
+ }
- if (_tcscmp(ptypefaceA->GetFontName(), ptypefaceB->GetFontName())) return false;
- if (ptypefaceA->GetFontStyle() != ptypefaceB->GetFontStyle()) return false;
- if (ptypefaceA->GetFontSize() != ptypefaceB->GetFontSize()) return false;
+ if (NULL == tf) {
+ get_default_font();
+ tf = CreateTypeface_(gDefaultFont);
+ }
+ return tf;
+}
- return true;
+size_t SkFontHost::ShouldPurgeFontCache(size_t sizeAllocatedSoFar) {
+ if (sizeAllocatedSoFar > FONT_CACHE_MEMORY_BUDGET)
+ return sizeAllocatedSoFar - FONT_CACHE_MEMORY_BUDGET;
+ else
+ return 0; // nothing to do
}
-int SkFontHost::ComputeGammaFlag(const SkPaint& paint)
-{
+int SkFontHost::ComputeGammaFlag(const SkPaint& paint) {
return 0;
}
-void SkFontHost::GetGammaTables(const uint8_t* tables[2])
-{
+void SkFontHost::GetGammaTables(const uint8_t* tables[2]) {
tables[0] = NULL; // black gamma (e.g. exp=1.4)
tables[1] = NULL; // white gamma (e.g. exp= 1/1.4)
}
diff --git a/libsgl/ports/SkImageDecoder_Factory.cpp b/libsgl/ports/SkImageDecoder_Factory.cpp index 791c344..d0053cf 100644 --- a/libsgl/ports/SkImageDecoder_Factory.cpp +++ b/libsgl/ports/SkImageDecoder_Factory.cpp @@ -39,7 +39,6 @@ static const CodecFormat gPairs[] = { { SkImageDecoder_ICO_Factory, SkImageDecoder::kICO_Format }, { SkImageDecoder_WBMP_Factory, SkImageDecoder::kWBMP_Format }, { SkImageDecoder_BMP_Factory, SkImageDecoder::kBMP_Format }, - // jpeg must be last, as it doesn't have a good sniffer yet { SkImageDecoder_JPEG_Factory, SkImageDecoder::kJPEG_Format } }; @@ -65,25 +64,17 @@ bool SkImageDecoder::SupportsFormat(Format format) { ///////////////////////////////////////////////////////////////////////// -// the movie may hold onto the stream (by calling ref()) -typedef SkMovie* (*SkMovieStreamProc)(SkStream*); -// the movie may NOT hold onto the pointer -typedef SkMovie* (*SkMovieMemoryProc)(const void*, size_t); +typedef SkMovie* (*SkMovieFactoryProc)(SkStream*); -extern SkMovie* SkMovie_GIF_StreamFactory(SkStream*); -extern SkMovie* SkMovie_GIF_MemoryFactory(const void*, size_t); +extern SkMovie* SkMovie_GIF_Factory(SkStream*); -static const SkMovieStreamProc gStreamProc[] = { - SkMovie_GIF_StreamFactory -}; - -static const SkMovieMemoryProc gMemoryProc[] = { - SkMovie_GIF_MemoryFactory +static const SkMovieFactoryProc gMovieProcs[] = { + SkMovie_GIF_Factory }; SkMovie* SkMovie::DecodeStream(SkStream* stream) { - for (unsigned i = 0; i < SK_ARRAY_COUNT(gStreamProc); i++) { - SkMovie* movie = gStreamProc[i](stream); + for (unsigned i = 0; i < SK_ARRAY_COUNT(gMovieProcs); i++) { + SkMovie* movie = gMovieProcs[i](stream); if (NULL != movie) { return movie; } @@ -92,17 +83,6 @@ SkMovie* SkMovie::DecodeStream(SkStream* stream) { return NULL; } -SkMovie* SkMovie::DecodeMemory(const void* data, size_t length) -{ - for (unsigned i = 0; i < SK_ARRAY_COUNT(gMemoryProc); i++) { - SkMovie* movie = gMemoryProc[i](data, length); - if (NULL != movie) { - return movie; - } - } - return NULL; -} - ///////////////////////////////////////////////////////////////////////// #ifdef SK_SUPPORT_IMAGE_ENCODE diff --git a/libsgl/ports/SkImageRef_ashmem.cpp b/libsgl/ports/SkImageRef_ashmem.cpp index ef5fc58..a904bae 100644 --- a/libsgl/ports/SkImageRef_ashmem.cpp +++ b/libsgl/ports/SkImageRef_ashmem.cpp @@ -37,7 +37,10 @@ SkImageRef_ashmem::SkImageRef_ashmem(SkStream* stream, SkImageRef_ashmem::~SkImageRef_ashmem() { fCT->safeUnref(); + this->closeFD(); +} +void SkImageRef_ashmem::closeFD() { if (-1 != fRec.fFD) { #ifdef DUMP_ASHMEM_LIFECYCLE SkDebugf("=== ashmem close %d\n", fRec.fFD); @@ -46,6 +49,7 @@ SkImageRef_ashmem::~SkImageRef_ashmem() { SkASSERT(fRec.fSize); munmap(fRec.fAddr, fRec.fSize); close(fRec.fFD); + fRec.fFD = -1; } } @@ -119,7 +123,7 @@ bool SkImageRef_ashmem::onDecode(SkImageDecoder* codec, SkStream* stream, return this->INHERITED::onDecode(codec, stream, bitmap, config, mode); } - AshmemAllocator alloc(&fRec, this->getName()); + AshmemAllocator alloc(&fRec, this->getURI()); codec->setAllocator(&alloc); bool success = this->INHERITED::onDecode(codec, stream, bitmap, config, @@ -136,6 +140,7 @@ bool SkImageRef_ashmem::onDecode(SkImageDecoder* codec, SkStream* stream, ashmem_unpin_region(fRec.fFD, 0, 0); fRec.fPinned = false; } + this->closeFD(); return false; } } @@ -183,13 +188,16 @@ void* SkImageRef_ashmem::onLockPixels(SkColorTable** ct) { void SkImageRef_ashmem::onUnlockPixels() { this->INHERITED::onUnlockPixels(); - SkASSERT(-1 != fRec.fFD); - SkASSERT(fRec.fAddr); - SkASSERT(fRec.fPinned); - - ashmem_unpin_region(fRec.fFD, 0, 0); - fRec.fPinned = false; + if (-1 != fRec.fFD) { + SkASSERT(fRec.fAddr); + SkASSERT(fRec.fPinned); + + ashmem_unpin_region(fRec.fFD, 0, 0); + fRec.fPinned = false; + } + // we clear this with or without an error, since we've either closed or + // unpinned the region fBitmap.setPixels(NULL, NULL); } diff --git a/libsgl/ports/SkImageRef_ashmem.h b/libsgl/ports/SkImageRef_ashmem.h index 909baea..193a01d 100644 --- a/libsgl/ports/SkImageRef_ashmem.h +++ b/libsgl/ports/SkImageRef_ashmem.h @@ -24,6 +24,8 @@ protected: virtual void onUnlockPixels(); private: + void closeFD(); + SkColorTable* fCT; SkAshmemRec fRec; diff --git a/libsgl/sgl/SkBitmap.cpp b/libsgl/sgl/SkBitmap.cpp index 3edb8c6..5ca3601 100644 --- a/libsgl/sgl/SkBitmap.cpp +++ b/libsgl/sgl/SkBitmap.cpp @@ -34,8 +34,8 @@ struct MipLevel { }; struct SkBitmap::MipMap : SkNoncopyable { - int fRefCnt; - int fLevelCount; + int32_t fRefCnt; + int fLevelCount; // MipLevel fLevel[fLevelCount]; // Pixels[] @@ -204,6 +204,20 @@ int SkBitmap::ComputeRowBytes(Config c, int width) { return rowBytes; } +Sk64 SkBitmap::ComputeSize64(Config c, int width, int height) { + Sk64 size; + size.setMul(SkBitmap::ComputeRowBytes(c, width), height); + return size; +} + +size_t SkBitmap::ComputeSize(Config c, int width, int height) { + Sk64 size = SkBitmap::ComputeSize64(c, width, height); + if (size.isNeg() || !size.is32()) { + return 0; + } + return size.get32(); +} + void SkBitmap::setConfig(Config c, int width, int height, int rowBytes) { this->freePixels(); @@ -382,8 +396,8 @@ SkMallocPixelRef::SkMallocPixelRef(SkFlattenableReadBuffer& buffer) : INHERITED( } } -static SkPixelRef::Registrar::Registrar reg("SkMallocPixelRef", - SkMallocPixelRef::Create); +static SkPixelRef::Registrar reg("SkMallocPixelRef", + SkMallocPixelRef::Create); /** We explicitly use the same allocator for our pixels that SkMask does, so that we can freely assign memory allocated by one class to the other. @@ -1226,6 +1240,7 @@ void SkBitmap::validate() const { SkASSERT(NULL == fColorTable || (unsigned)fColorTable->getRefCnt() < 10000); SkASSERT((uint8_t)ComputeBytesPerPixel((Config)fConfig) == fBytesPerPixel); +#if 0 // these asserts are not thread-correct, so disable for now if (fPixelRef) { if (fPixelLockCount > 0) { SkASSERT(fPixelRef->getLockCount() > 0); @@ -1234,6 +1249,7 @@ void SkBitmap::validate() const { SkASSERT(NULL == fColorTable); } } +#endif } #endif diff --git a/libsgl/sgl/SkBitmapProcShader.cpp b/libsgl/sgl/SkBitmapProcShader.cpp index 8685c9f..6d7d581 100644 --- a/libsgl/sgl/SkBitmapProcShader.cpp +++ b/libsgl/sgl/SkBitmapProcShader.cpp @@ -192,3 +192,40 @@ SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, static SkFlattenable::Registrar gBitmapProcShaderReg("SkBitmapProcShader", SkBitmapProcShader::CreateProc); + +/////////////////////////////////////////////////////////////////////////////// + +static const char* gTileModeName[] = { + "clamp", "repeat", "mirror" +}; + +bool SkBitmapProcShader::toDumpString(SkString* str) const { + str->printf("BitmapShader: [%d %d %d", + fRawBitmap.width(), fRawBitmap.height(), + fRawBitmap.bytesPerPixel()); + + // add the pixelref + SkPixelRef* pr = fRawBitmap.pixelRef(); + if (pr) { + const char* uri = pr->getURI(); + if (uri) { + str->appendf(" \"%s\"", uri); + } + } + + // add the (optional) matrix + { + SkMatrix m; + if (this->getLocalMatrix(&m)) { + SkString info; + m.toDumpString(&info); + str->appendf(" %s", info.c_str()); + } + } + + str->appendf(" [%s %s]]", + gTileModeName[fState.fTileModeX], + gTileModeName[fState.fTileModeY]); + return true; +} + diff --git a/libsgl/sgl/SkBitmapProcShader.h b/libsgl/sgl/SkBitmapProcShader.h index ed790c8..09d53af 100644 --- a/libsgl/sgl/SkBitmapProcShader.h +++ b/libsgl/sgl/SkBitmapProcShader.h @@ -40,6 +40,9 @@ public: return SkNEW_ARGS(SkBitmapProcShader, (buffer)); } + // override from flattenable + virtual bool toDumpString(SkString* str) const; + protected: SkBitmapProcShader(SkFlattenableReadBuffer& ); virtual void flatten(SkFlattenableWriteBuffer& ); diff --git a/libsgl/sgl/SkBitmapProcState_matrix.h b/libsgl/sgl/SkBitmapProcState_matrix.h index 1212a41..f54f8b1 100644 --- a/libsgl/sgl/SkBitmapProcState_matrix.h +++ b/libsgl/sgl/SkBitmapProcState_matrix.h @@ -25,13 +25,18 @@ static void SCALE_NOFILTER_NAME(const SkBitmapProcState& s, PREAMBLE(s); // we store y, x, x, x, x, x - // invert x+half, y+half and convert to fixed - SkFixed fx = s.fInvSy * y + s.fInvTyPlusHalf; - *xy++ = TILEY_PROCF(fx, (s.fBitmap->height() - 1)); - // invert X - SkFixed dx = s.fInvSx; - fx = dx * x + s.fInvTxPlusHalf; - unsigned maxX = s.fBitmap->width() - 1; + const unsigned maxX = s.fBitmap->width() - 1; + const SkFixed dx = s.fInvSx; + SkFixed fx; + { + SkPoint pt; + s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, + SkIntToScalar(y) + SK_ScalarHalf, &pt); + fx = SkScalarToFixed(pt.fY); + const unsigned maxY = s.fBitmap->height() - 1; + *xy++ = TILEY_PROCF(fx, maxY); + fx = SkScalarToFixed(pt.fX); + } #ifdef CHECK_FOR_DECAL // test if we don't need to apply the tile proc @@ -42,18 +47,6 @@ static void SCALE_NOFILTER_NAME(const SkBitmapProcState& s, #endif { int i; -#if 0 - uint16_t* xx = (uint16_t*)xy; - for (i = (count >> 2); i > 0; --i) { - *xx++ = TILEX_PROCF(fx, maxX); fx += dx; - *xx++ = TILEX_PROCF(fx, maxX); fx += dx; - *xx++ = TILEX_PROCF(fx, maxX); fx += dx; - *xx++ = TILEX_PROCF(fx, maxX); fx += dx; - } - for (i = (count & 3); i > 0; --i) { - *xx++ = TILEX_PROCF(fx, maxX); fx += dx; - } -#else for (i = (count >> 2); i > 0; --i) { unsigned a, b; a = TILEX_PROCF(fx, maxX); fx += dx; @@ -75,7 +68,6 @@ static void SCALE_NOFILTER_NAME(const SkBitmapProcState& s, for (i = (count & 3); i > 0; --i) { *xx++ = TILEX_PROCF(fx, maxX); fx += dx; } -#endif } } @@ -155,18 +147,24 @@ static void SCALE_FILTER_NAME(const SkBitmapProcState& s, SkASSERT(s.fInvKy == 0); PREAMBLE(s); - // compute our two Y values up front + + const unsigned maxX = s.fBitmap->width() - 1; + const SkFixed one = s.fFilterOneX; + const SkFixed dx = s.fInvSx; + SkFixed fx; + { - unsigned maxY = s.fBitmap->height() - 1; - SkFixed fy = s.fInvSy * y + s.fInvTyPlusHalf - (s.fFilterOneY >> 1); + SkPoint pt; + s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf, + SkIntToScalar(y) + SK_ScalarHalf, &pt); + const SkFixed fy = SkScalarToFixed(pt.fY) - (s.fFilterOneY >> 1); + const unsigned maxY = s.fBitmap->height() - 1; + // compute our two Y values up front *xy++ = PACK_FILTER_Y_NAME(fy, maxY, s.fFilterOneY PREAMBLE_ARG_Y); + // now initialize fx + fx = SkScalarToFixed(pt.fX) - (one >> 1); } - unsigned maxX = s.fBitmap->width() - 1; - SkFixed one = s.fFilterOneX; - SkFixed dx = s.fInvSx; - SkFixed fx = dx * x + s.fInvTxPlusHalf - (one >> 1); - #ifdef CHECK_FOR_DECAL // test if we don't need to apply the tile proc if (dx > 0 && diff --git a/libsgl/sgl/SkBlitter_4444.cpp b/libsgl/sgl/SkBlitter_4444.cpp index 22b3b7b..cce94c5 100644 --- a/libsgl/sgl/SkBlitter_4444.cpp +++ b/libsgl/sgl/SkBlitter_4444.cpp @@ -379,11 +379,14 @@ class SkARGB4444_Shader_Blitter : public SkShaderBlitter { SkBlitRow::Proc fOpaqueProc; SkBlitRow::Proc fAlphaProc; SkPMColor* fBuffer; + uint8_t* fAAExpand; public: SkARGB4444_Shader_Blitter(const SkBitmap& device, const SkPaint& paint) : INHERITED(device, paint) { - fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * (sizeof(SkPMColor))); + const int width = device.width(); + fBuffer = (SkPMColor*)sk_malloc_throw(width * sizeof(SkPMColor) + width); + fAAExpand = (uint8_t*)(fBuffer + width); (fXfermode = paint.getXfermode())->safeRef(); @@ -423,7 +426,8 @@ virtual void blitH(int x, int y, int width) virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) { - SkPMColor* span = fBuffer; + SkPMColor* SK_RESTRICT span = fBuffer; + uint8_t* SK_RESTRICT aaExpand = fAAExpand; SkPMColor16* device = fDevice.getAddr16(x, y); SkShader* shader = fShader; SkXfermode* xfer = fXfermode; @@ -439,10 +443,12 @@ virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t ru if (255 == aa) { xfer->xfer4444(device, span, count, NULL); } else { - // count is almost always 1 - for (int i = count - 1; i >= 0; --i) { - xfer->xfer4444(&device[i], &span[i], count, antialias); + const uint8_t* aaBuffer = antialias; + if (count > 1) { + memset(aaExpand, aa, count); + aaBuffer = aaExpand; } + xfer->xfer4444(device, span, count, aaBuffer); } } device += count; diff --git a/libsgl/sgl/SkCanvas.cpp b/libsgl/sgl/SkCanvas.cpp index 42e4be8..4088416 100644 --- a/libsgl/sgl/SkCanvas.cpp +++ b/libsgl/sgl/SkCanvas.cpp @@ -21,6 +21,7 @@ #include "SkDrawFilter.h" #include "SkDrawLooper.h" #include "SkPicture.h" +#include "SkScalarCompare.h" #include "SkTemplates.h" #include "SkUtils.h" #include <new> @@ -49,6 +50,14 @@ #endif /////////////////////////////////////////////////////////////////////////////// +// Helpers for computing fast bounds for quickReject tests + +static SkCanvas::EdgeType paint2EdgeType(const SkPaint* paint) { + return paint != NULL && paint->isAntiAlias() ? + SkCanvas::kAA_EdgeType : SkCanvas::kBW_EdgeType; +} + +/////////////////////////////////////////////////////////////////////////////// /* This is the record we keep for each SkDevice that the user installs. The clip/matrix/proc are fields that reflect the top of the save/restore @@ -229,6 +238,7 @@ public: fBitmap = &fDevice->accessBitmap(true); fLayerX = rec->fX; fLayerY = rec->fY; + fPaint = rec->fPaint; SkDEBUGCODE(this->validate();) fCurrLayer = rec->fNext; @@ -249,10 +259,11 @@ public: SkDevice* getDevice() const { return fDevice; } const SkMatrix& getMatrix() const { return *fMatrix; } const SkRegion& getClip() const { return *fClip; } - + const SkPaint* getPaint() const { return fPaint; } private: SkCanvas* fCanvas; const DeviceCM* fCurrLayer; + const SkPaint* fPaint; // May be null. int fLayerX; int fLayerY; SkBool8 fSkipEmptyClips; @@ -377,7 +388,8 @@ private: SkDevice* SkCanvas::init(SkDevice* device) { fBounder = NULL; - + fLocalBoundsCompareTypeDirty = true; + fMCRec = (MCRec*)fMCStack.push_back(); new (fMCRec) MCRec(NULL, 0); @@ -668,6 +680,7 @@ void SkCanvas::internalRestore() { SkASSERT(fMCStack.count() != 0); fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; // reserve our layer (if any) DeviceCM* layer = fMCRec->fLayer; // may be null @@ -750,31 +763,37 @@ void SkCanvas::drawDevice(SkDevice* device, int x, int y, bool SkCanvas::translate(SkScalar dx, SkScalar dy) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; return fMCRec->fMatrix->preTranslate(dx, dy); } bool SkCanvas::scale(SkScalar sx, SkScalar sy) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; return fMCRec->fMatrix->preScale(sx, sy); } bool SkCanvas::rotate(SkScalar degrees) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; return fMCRec->fMatrix->preRotate(degrees); } bool SkCanvas::skew(SkScalar sx, SkScalar sy) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; return fMCRec->fMatrix->preSkew(sx, sy); } bool SkCanvas::concat(const SkMatrix& matrix) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; return fMCRec->fMatrix->preConcat(matrix); } void SkCanvas::setMatrix(const SkMatrix& matrix) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; *fMCRec->fMatrix = matrix; } @@ -791,6 +810,8 @@ void SkCanvas::resetMatrix() { bool SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; + if (fMCRec->fMatrix->rectStaysRect()) { SkRect r; SkIRect ir; @@ -808,6 +829,7 @@ bool SkCanvas::clipRect(const SkRect& rect, SkRegion::Op op) { bool SkCanvas::clipPath(const SkPath& path, SkRegion::Op op) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; SkPath devPath; path.transform(*fMCRec->fMatrix, &devPath); @@ -831,24 +853,52 @@ bool SkCanvas::clipPath(const SkPath& path, SkRegion::Op op) { bool SkCanvas::clipRegion(const SkRegion& rgn, SkRegion::Op op) { fDeviceCMDirty = true; + fLocalBoundsCompareTypeDirty = true; + return fMCRec->fRegion->op(rgn, op); } -bool SkCanvas::quickReject(const SkRect& rect, EdgeType et) const { - if (fMCRec->fRegion->isEmpty() || rect.isEmpty()) { - return true; +void SkCanvas::computeLocalClipBoundsCompareType() const { + SkRect r; + + if (!this->getClipBounds(&r, kAA_EdgeType)) { + fLocalBoundsCompareType.setEmpty(); + } else { + fLocalBoundsCompareType.set(SkScalarToCompareType(r.fLeft), + SkScalarToCompareType(r.fTop), + SkScalarToCompareType(r.fRight), + SkScalarToCompareType(r.fBottom)); } +} - SkRect r; - SkIRect ir; +bool SkCanvas::quickReject(const SkRect& rect, EdgeType) const { + /* current impl ignores edgetype, and relies on + getLocalClipBoundsCompareType(), which always returns a value assuming + antialiasing (worst case) + */ - fMCRec->fMatrix->mapRect(&r, rect); - if (kAA_EdgeType == et) { - r.roundOut(&ir); - } else { - r.round(&ir); + if (fMCRec->fRegion->isEmpty()) { + return true; } - return fMCRec->fRegion->quickReject(ir); + + // check for empty user rect (horizontal) + SkScalarCompareType userL = SkScalarToCompareType(rect.fLeft); + SkScalarCompareType userR = SkScalarToCompareType(rect.fRight); + if (userL >= userR) { + return true; + } + + // check for empty user rect (vertical) + SkScalarCompareType userT = SkScalarToCompareType(rect.fTop); + SkScalarCompareType userB = SkScalarToCompareType(rect.fBottom); + if (userT >= userB) { + return true; + } + + // check if we are completely outside of the local clip bounds + const SkRectCompareType& clipR = this->getLocalClipBoundsCompareType(); + return userL >= clipR.fRight || userT >= clipR.fBottom || + userR <= clipR.fLeft || userB <= clipR.fTop; } bool SkCanvas::quickReject(const SkPath& path, EdgeType et) const { @@ -858,7 +908,7 @@ bool SkCanvas::quickReject(const SkPath& path, EdgeType et) const { if (fMCRec->fMatrix->rectStaysRect()) { SkRect r; - path.computeBounds(&r, SkPath::kExact_BoundsType); + path.computeBounds(&r, SkPath::kFast_BoundsType); return this->quickReject(r, et); } @@ -867,55 +917,38 @@ bool SkCanvas::quickReject(const SkPath& path, EdgeType et) const { SkIRect ir; path.transform(*fMCRec->fMatrix, &dstPath); - dstPath.computeBounds(&r, SkPath::kExact_BoundsType); + dstPath.computeBounds(&r, SkPath::kFast_BoundsType); + r.round(&ir); if (kAA_EdgeType == et) { - r.roundOut(&ir); - } else { - r.round(&ir); + ir.inset(-1, -1); } return fMCRec->fRegion->quickReject(ir); } bool SkCanvas::quickRejectY(SkScalar top, SkScalar bottom, EdgeType et) const { - if (fMCRec->fRegion->isEmpty() || top >= bottom) { + /* current impl ignores edgetype, and relies on + getLocalClipBoundsCompareType(), which always returns a value assuming + antialiasing (worst case) + */ + + if (fMCRec->fRegion->isEmpty()) { return true; } - const SkMatrix& matrix = *fMCRec->fMatrix; - - // if we're rotated/skewed/perspective, give up (for now) - // TODO: cache this attribute of the matrix? or specialized query method? - // TODO: if rotate=90 or 270 is common, we can handle those too... - if (matrix.getType() & ~(SkMatrix::kTranslate_Mask | - SkMatrix::kScale_Mask)) { - return false; - } - // transform top/botttom into device coordinates - const SkScalar sy = matrix[SkMatrix::kMScaleY]; - const SkScalar ty = matrix[SkMatrix::kMTransY]; - top = SkScalarMulAdd(top, sy, ty); - bottom = SkScalarMulAdd(bottom, sy, ty); - - // if the scale flipped us, flip back - if (top > bottom) { - SkTSwap<SkScalar>(top, bottom); - } - // now round based on the edge type - int ymin, ymax; - if (kAA_EdgeType == et) { - ymin = SkScalarFloor(top); - ymax = SkScalarCeil(bottom); - } else { - ymin = SkScalarRound(top); - ymax = SkScalarRound(bottom); + SkScalarCompareType userT = SkScalarAs2sCompliment(top); + SkScalarCompareType userB = SkScalarAs2sCompliment(bottom); + + // check for invalid user Y coordinates (i.e. empty) + if (userT >= userB) { + return true; } - // now compare against the bounds of the clip - const SkIRect& bounds = fMCRec->fRegion->getBounds(); - return ymin >= bounds.fBottom || ymax <= bounds.fTop; + // check if we are above or below the local clip bounds + const SkRectCompareType& clipR = this->getLocalClipBoundsCompareType(); + return userT >= clipR.fBottom || userB <= clipR.fTop; } -bool SkCanvas::getClipBounds(SkRect* bounds) const { +bool SkCanvas::getClipBounds(SkRect* bounds, EdgeType et) const { const SkRegion& clip = *fMCRec->fRegion; if (clip.isEmpty()) { if (bounds) { @@ -928,9 +961,16 @@ bool SkCanvas::getClipBounds(SkRect* bounds) const { SkMatrix inverse; SkRect r; - // TODO: should we cache the inverse (with a dirty bit)? fMCRec->fMatrix->invert(&inverse); - r.set(clip.getBounds()); + + // get the clip's bounds + const SkIRect& ibounds = clip.getBounds(); + // adjust it outwards if we are antialiasing + int inset = (kAA_EdgeType == et); + r.iset(ibounds.fLeft - inset, ibounds.fTop - inset, + ibounds.fRight + inset, ibounds.fBottom + inset); + + // invert into local coordinates inverse.mapRect(bounds, r); } return true; @@ -994,6 +1034,14 @@ void SkCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[], } void SkCanvas::drawRect(const SkRect& r, const SkPaint& paint) { + if (paint.canComputeFastBounds()) { + SkRect storage; + if (this->quickReject(paint.computeFastBounds(r, &storage), + paint2EdgeType(&paint))) { + return; + } + } + ITER_BEGIN(paint, SkDrawFilter::kRect_Type) while (iter.next()) { @@ -1004,6 +1052,15 @@ void SkCanvas::drawRect(const SkRect& r, const SkPaint& paint) { } void SkCanvas::drawPath(const SkPath& path, const SkPaint& paint) { + if (paint.canComputeFastBounds()) { + SkRect r; + path.computeBounds(&r, SkPath::kFast_BoundsType); + if (this->quickReject(paint.computeFastBounds(r, &r), + paint2EdgeType(&paint))) { + return; + } + } + ITER_BEGIN(paint, SkDrawFilter::kPath_Type) while (iter.next()) { @@ -1016,7 +1073,17 @@ void SkCanvas::drawPath(const SkPath& path, const SkPaint& paint) { void SkCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y, const SkPaint* paint) { SkDEBUGCODE(bitmap.validate();) - + + if (NULL == paint || (paint->getMaskFilter() == NULL)) { + SkRect fastBounds; + fastBounds.set(x, y, + x + SkIntToScalar(bitmap.width()), + y + SkIntToScalar(bitmap.height())); + if (this->quickReject(fastBounds, paint2EdgeType(paint))) { + return; + } + } + SkMatrix matrix; matrix.setTranslate(x, y); this->internalDrawBitmap(bitmap, matrix, paint); @@ -1029,8 +1096,7 @@ void SkCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, } // do this now, to avoid the cost of calling extract for RLE bitmaps - if (this->quickReject(dst, paint != NULL && paint->isAntiAlias() ? - kAA_EdgeType : kBW_EdgeType)) { + if (this->quickReject(dst, paint2EdgeType(paint))) { return; } @@ -1229,10 +1295,18 @@ void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, radius = 0; } - SkPath path; SkRect r; - r.set(cx - radius, cy - radius, cx + radius, cy + radius); + + if (paint.canComputeFastBounds()) { + SkRect storage; + if (this->quickReject(paint.computeFastBounds(r, &storage), + paint2EdgeType(&paint))) { + return; + } + } + + SkPath path; path.addOval(r); this->drawPath(path, paint); } @@ -1240,6 +1314,14 @@ void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, void SkCanvas::drawRoundRect(const SkRect& r, SkScalar rx, SkScalar ry, const SkPaint& paint) { if (rx > 0 && ry > 0) { + if (paint.canComputeFastBounds()) { + SkRect storage; + if (this->quickReject(paint.computeFastBounds(r, &storage), + paint2EdgeType(&paint))) { + return; + } + } + SkPath path; path.addRoundRect(r, rx, ry, SkPath::kCW_Direction); this->drawPath(path, paint); @@ -1249,6 +1331,14 @@ void SkCanvas::drawRoundRect(const SkRect& r, SkScalar rx, SkScalar ry, } void SkCanvas::drawOval(const SkRect& oval, const SkPaint& paint) { + if (paint.canComputeFastBounds()) { + SkRect storage; + if (this->quickReject(paint.computeFastBounds(oval, &storage), + paint2EdgeType(&paint))) { + return; + } + } + SkPath path; path.addOval(oval); this->drawPath(path, paint); @@ -1316,8 +1406,15 @@ const SkMatrix& SkCanvas::LayerIter::matrix() const { return fImpl->getMatrix(); } +const SkPaint& SkCanvas::LayerIter::paint() const { + const SkPaint* paint = fImpl->getPaint(); + if (NULL == paint) { + paint = &fDefaultPaint; + } + return *paint; +} + const SkRegion& SkCanvas::LayerIter::clip() const { return fImpl->getClip(); } int SkCanvas::LayerIter::x() const { return fImpl->getX(); } int SkCanvas::LayerIter::y() const { return fImpl->getY(); } - diff --git a/libsgl/sgl/SkColor.cpp b/libsgl/sgl/SkColor.cpp index 93adcd7..4256179 100644 --- a/libsgl/sgl/SkColor.cpp +++ b/libsgl/sgl/SkColor.cpp @@ -66,7 +66,9 @@ void SkRGBToHSV(U8CPU r, U8CPU g, U8CPU b, SkScalar hsv[3]) { SkASSERT(v >= 0 && v <= SK_Scalar1); if (0 == delta) { // we're a shade of gray - hsv[0] = hsv[1] = hsv[2] = v; + hsv[0] = 0; + hsv[1] = 0; + hsv[2] = v; return; } diff --git a/libsgl/sgl/SkEdge.cpp b/libsgl/sgl/SkEdge.cpp index 743737a..6efe1ba 100644 --- a/libsgl/sgl/SkEdge.cpp +++ b/libsgl/sgl/SkEdge.cpp @@ -76,8 +76,8 @@ int SkEdge::setLine(const SkPoint& p0, const SkPoint& p1, const SkIRect* clip, fX = SkFDot6ToFixed(x0 + SkFixedMul(slope, (32 - y0) & 63)); // + SK_Fixed1/2 fDX = slope; - fFirstY = SkToS16(top); - fLastY = SkToS16(bot - 1); + fFirstY = top; + fLastY = bot - 1; fCurveCount = 0; fWinding = SkToS8(winding); fCurveShift = 0; @@ -116,8 +116,8 @@ int SkEdge::updateLine(SkFixed x0, SkFixed y0, SkFixed x1, SkFixed y1) fX = SkFDot6ToFixed(x0 + SkFixedMul(slope, (32 - y0) & 63)); // + SK_Fixed1/2 fDX = slope; - fFirstY = SkToS16(top); - fLastY = SkToS16(bot - 1); + fFirstY = top; + fLastY = bot - 1; return 1; } @@ -139,11 +139,12 @@ void SkEdge::chopLineWithClip(const SkIRect& clip) /////////////////////////////////////////////////////////////////////////////// -/* We store 1<<shift in a (signed) byte, so its maximum value is 7 (e.g. 128) - Note that this limits the number of times we can subdivide a curve, but 128 - seems more than adequate. +/* We store 1<<shift in a (signed) byte, so its maximum value is 1<<6 == 64. + Note that this limits the number of lines we use to approximate a curve. + If we need to increase this, we need to store fCurveCount in something + larger than int8_t. */ -#define MAX_COEFF_SHIFT 7 +#define MAX_COEFF_SHIFT 6 static inline SkFDot6 cheap_distance(SkFDot6 dx, SkFDot6 dy) { @@ -166,7 +167,7 @@ static inline int diff_to_shift(SkFDot6 dx, SkFDot6 dy) // down by 5 should give us 1/2 pixel accuracy (assuming our dist is accurate...) // this is chosen by heuristic: make it as big as possible (to minimize segments) // ... but small enough so that our curves still look smooth - dist >>= 5; + dist = (dist + (1 << 4)) >> 5; // each subdivision (shift value) cuts this dist (error) by 1/4 return (32 - SkCLZ(dist)) >> 1; diff --git a/libsgl/sgl/SkEdge.h b/libsgl/sgl/SkEdge.h index 67a5d89..5b0cc75 100644 --- a/libsgl/sgl/SkEdge.h +++ b/libsgl/sgl/SkEdge.h @@ -32,8 +32,8 @@ struct SkEdge { SkFixed fX; SkFixed fDX; - int16_t fFirstY; - int16_t fLastY; + int32_t fFirstY; + int32_t fLastY; int8_t fCurveCount; // only used by kQuad(+) and kCubic(-) uint8_t fCurveShift; // appled to all Dx/DDx/DDDx except for fCubicDShift exception uint8_t fCubicDShift; // applied to fCDx and fCDy only in cubic diff --git a/libsgl/sgl/SkFilterProc.h b/libsgl/sgl/SkFilterProc.h index 8d90474..9af4ed5 100644 --- a/libsgl/sgl/SkFilterProc.h +++ b/libsgl/sgl/SkFilterProc.h @@ -70,7 +70,7 @@ typedef unsigned (*SkFilter32Proc)(uint32_t x00, uint32_t x01, const SkFilter32Proc* SkGetFilter32ProcTable(); -inline SkFilter32Proc SkGetFilter32Proc22(const SkFilterProc* table, +inline SkFilter32Proc SkGetFilter32Proc22(const SkFilter32Proc* table, unsigned x, unsigned y) { SkASSERT(table); @@ -81,7 +81,7 @@ inline SkFilter32Proc SkGetFilter32Proc22(const SkFilterProc* table, return table[(y << 2) | x]; } -inline const SkFilter32Proc* SkGetFilter32Proc22Row(const SkFilterProc* table, +inline const SkFilter32Proc* SkGetFilter32Proc22Row(const SkFilter32Proc* table, unsigned y) { SkASSERT(table); @@ -89,7 +89,7 @@ inline const SkFilter32Proc* SkGetFilter32Proc22Row(const SkFilterProc* table, return &table[y << 30 >> 28]; } -inline SkFilter32Proc SkGetFilter32Proc22RowProc(const SkFilterProc* row, +inline SkFilter32Proc SkGetFilter32Proc22RowProc(const SkFilter32Proc* row, unsigned x) { SkASSERT(row); diff --git a/libsgl/sgl/SkFlattenable.cpp b/libsgl/sgl/SkFlattenable.cpp index 08dd59c..3558519 100644 --- a/libsgl/sgl/SkFlattenable.cpp +++ b/libsgl/sgl/SkFlattenable.cpp @@ -257,3 +257,7 @@ const char* SkFlattenable::FactoryToName(Factory fact) { return NULL; } +bool SkFlattenable::toDumpString(SkString* str) const { + return false; +} + diff --git a/libsgl/sgl/SkGlyphCache.cpp b/libsgl/sgl/SkGlyphCache.cpp index 4efc895..6b214df 100644 --- a/libsgl/sgl/SkGlyphCache.cpp +++ b/libsgl/sgl/SkGlyphCache.cpp @@ -21,7 +21,33 @@ #include "SkTemplates.h" #define SPEW_PURGE_STATUS -#define USE_CACHE_HASHxxxxx +//#define USE_CACHE_HASH +//#define RECORD_HASH_EFFICIENCY + +/////////////////////////////////////////////////////////////////////////////// + +#ifdef RECORD_HASH_EFFICIENCY + static uint32_t gHashSuccess; + static uint32_t gHashCollision; + + static void RecordHashSuccess() { + gHashSuccess += 1; + } + + static void RecordHashCollisionIf(bool pred) { + if (pred) { + gHashCollision += 1; + + uint32_t total = gHashSuccess + gHashCollision; + SkDebugf("Font Cache Hash success rate: %d%%\n", + 100 * gHashSuccess / total); + } + } +#else + #define RecordHashSuccess() (void)0 + #define RecordHashCollisionIf(pred) (void)0 +#endif +#define RecordHashCollision() RecordHashCollisionIf(true) /////////////////////////////////////////////////////////////////////////////// @@ -140,12 +166,14 @@ const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode) { CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)]; if (rec->fID != id) { + RecordHashCollisionIf(rec->fGlyph != NULL); // this ID is based on the UniChar rec->fID = id; // this ID is based on the glyph index id = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode)); rec->fGlyph = this->lookupMetrics(id, kFull_MetricsType); } else { + RecordHashSuccess(); if (rec->fGlyph->isJustAdvance()) { fScalerContext->getMetrics(rec->fGlyph); } @@ -161,12 +189,14 @@ const SkGlyph& SkGlyphCache::getUnicharMetrics(SkUnichar charCode, CharGlyphRec* rec = &fCharToGlyphHash[ID2HashIndex(id)]; if (rec->fID != id) { + RecordHashCollisionIf(rec->fGlyph != NULL); // this ID is based on the UniChar rec->fID = id; // this ID is based on the glyph index id = SkGlyph::MakeID(fScalerContext->charToGlyphID(charCode), x, y); rec->fGlyph = this->lookupMetrics(id, kFull_MetricsType); } else { + RecordHashSuccess(); if (rec->fGlyph->isJustAdvance()) { fScalerContext->getMetrics(rec->fGlyph); } @@ -182,9 +212,11 @@ const SkGlyph& SkGlyphCache::getGlyphIDMetrics(uint16_t glyphID) { SkGlyph* glyph = fGlyphHash[index]; if (NULL == glyph || glyph->fID != id) { + RecordHashCollisionIf(glyph != NULL); glyph = this->lookupMetrics(glyphID, kFull_MetricsType); fGlyphHash[index] = glyph; } else { + RecordHashSuccess(); if (glyph->isJustAdvance()) { fScalerContext->getMetrics(glyph); } @@ -199,11 +231,13 @@ const SkGlyph& SkGlyphCache::getGlyphIDMetrics(uint16_t glyphID, uint32_t id = SkGlyph::MakeID(glyphID, x, y); unsigned index = ID2HashIndex(id); SkGlyph* glyph = fGlyphHash[index]; - + if (NULL == glyph || glyph->fID != id) { + RecordHashCollisionIf(glyph != NULL); glyph = this->lookupMetrics(id, kFull_MetricsType); fGlyphHash[index] = glyph; } else { + RecordHashSuccess(); if (glyph->isJustAdvance()) { fScalerContext->getMetrics(glyph); } diff --git a/libsgl/sgl/SkGlyphCache.h b/libsgl/sgl/SkGlyphCache.h index cc268c0..2462ea5 100644 --- a/libsgl/sgl/SkGlyphCache.h +++ b/libsgl/sgl/SkGlyphCache.h @@ -188,7 +188,7 @@ private: SkPaint::FontMetrics fFontMetricsY; enum { - kHashBits = 6, + kHashBits = 8, kHashCount = 1 << kHashBits, kHashMask = kHashCount - 1 }; diff --git a/libsgl/sgl/SkPaint.cpp b/libsgl/sgl/SkPaint.cpp index 3341f47..bb6b31e 100644 --- a/libsgl/sgl/SkPaint.cpp +++ b/libsgl/sgl/SkPaint.cpp @@ -1444,6 +1444,38 @@ bool SkPaint::getFillPath(const SkPath& src, SkPath* dst) const return width != 0; // return true if we're filled, or false if we're hairline (width == 0) } +bool SkPaint::canComputeFastBounds() const { + // use bit-or since no need for early exit + return (reinterpret_cast<uintptr_t>(this->getMaskFilter()) | + reinterpret_cast<uintptr_t>(this->getLooper()) | + reinterpret_cast<uintptr_t>(this->getRasterizer()) | + reinterpret_cast<uintptr_t>(this->getPathEffect())) == 0; +} + +const SkRect& SkPaint::computeFastBounds(const SkRect& src, + SkRect* storage) const { + SkASSERT(storage); + + if (this->getStyle() != SkPaint::kFill_Style) { + // if we're stroked, outset the rect by the radius (and join type) + SkScalar radius = SkScalarHalf(this->getStrokeWidth()); + + if (0 == radius) { // hairline + radius = SK_Scalar1; + } else if (this->getStrokeJoin() == SkPaint::kMiter_Join) { + SkScalar scale = this->getStrokeMiter(); + if (scale > SK_Scalar1) { + radius = SkScalarMul(radius, scale); + } + } + storage->set(src.fLeft - radius, src.fTop - radius, + src.fRight + radius, src.fBottom + radius); + return *storage; + } + // no adjustments needed, just return the original rect + return src; +} + //////////////////////////////////////////////////////////////////////////////////////// static bool has_thick_frame(const SkPaint& paint) diff --git a/libsgl/sgl/SkPath.cpp b/libsgl/sgl/SkPath.cpp index dd1290b..82eb980 100644 --- a/libsgl/sgl/SkPath.cpp +++ b/libsgl/sgl/SkPath.cpp @@ -19,6 +19,63 @@ #include "SkFlattenable.h" #include "SkMath.h" +//////////////////////////////////////////////////////////////////////////// + +/* This guy's constructor/destructor bracket a path editing operation. It is + used when we know the bounds of the amount we are going to add to the path + (usually a new contour, but not required). + + It captures some state about the path up front (i.e. if it already has a + cached bounds), and the if it can, it updates the cache bounds explicitly, + avoiding the need to revisit all of the points in computeBounds(). + */ +class SkAutoPathBoundsUpdate { +public: + SkAutoPathBoundsUpdate(SkPath* path, const SkRect& r) : fRect(r) { + this->init(path); + } + + SkAutoPathBoundsUpdate(SkPath* path, SkScalar left, SkScalar top, + SkScalar right, SkScalar bottom) { + fRect.set(left, top, right, bottom); + this->init(path); + } + + ~SkAutoPathBoundsUpdate() { + if (fEmpty) { + fPath->fFastBounds = fRect; + fPath->fFastBoundsIsDirty = false; + } else if (!fDirty) { + fPath->fFastBounds.join(fRect); + fPath->fFastBoundsIsDirty = false; + } + } + +private: + const SkPath* fPath; + SkRect fRect; + bool fDirty; + bool fEmpty; + + // returns true if we should proceed + void init(const SkPath* path) { + fPath = path; + fDirty = path->fFastBoundsIsDirty; + fEmpty = path->isEmpty(); + } +}; + +static void compute_fast_bounds(SkRect* bounds, const SkTDArray<SkPoint>& pts) { + if (pts.count() <= 1) { // we ignore just 1 point (moveto) + bounds->set(0, 0, 0, 0); + } else { + bounds->set(pts.begin(), pts.count()); +// SkDebugf("------- compute bounds %p %d", &pts, pts.count()); + } +} + +//////////////////////////////////////////////////////////////////////////// + /* Stores the verbs and points as they are given to us, with exceptions: - we only record "Close" if it was immediately preceeded by Line | Quad | Cubic @@ -145,24 +202,8 @@ void SkPath::computeBounds(SkRect* bounds, BoundsType bt) const { if (fFastBoundsIsDirty) { fFastBoundsIsDirty = false; - if (fPts.count() <= 1) { // we ignore just 1 point (moveto) - fFastBounds.set(0, 0, 0, 0); - } else { - fFastBounds.set(fPts.begin(), fPts.count()); - } - } -#ifdef SK_DEBUG - else { // check that our cache is correct - SkRect r; - if (fPts.count() <= 1) { // we ignore just 1 point (moveto) - r.set(0, 0, 0, 0); - } else { - r.set(fPts.begin(), fPts.count()); - } - SkASSERT(r == fFastBounds); + compute_fast_bounds(&fFastBounds, fPts); } -#endif - *bounds = fFastBounds; } @@ -286,13 +327,15 @@ void SkPath::close() { } /////////////////////////////////////////////////////////////////////////////// - + void SkPath::addRect(const SkRect& rect, Direction dir) { this->addRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, dir); } void SkPath::addRect(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, Direction dir) { + SkAutoPathBoundsUpdate apbu(this, left, top, right, bottom); + this->incReserve(5); this->moveTo(left, top); @@ -312,6 +355,8 @@ void SkPath::addRect(SkScalar left, SkScalar top, SkScalar right, void SkPath::addRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, Direction dir) { + SkAutoPathBoundsUpdate apbu(this, rect); + SkScalar w = rect.width(); SkScalar halfW = SkScalarHalf(w); SkScalar h = rect.height(); @@ -426,6 +471,7 @@ static void add_corner_arc(SkPath* path, const SkRect& rect, void SkPath::addRoundRect(const SkRect& rect, const SkScalar rad[], Direction dir) { + SkAutoPathBoundsUpdate apbu(this, rect); if (kCW_Direction == dir) { add_corner_arc(this, rect, rad[0], rad[1], 180, dir, true); @@ -442,6 +488,8 @@ void SkPath::addRoundRect(const SkRect& rect, const SkScalar rad[], } void SkPath::addOval(const SkRect& oval, Direction dir) { + SkAutoPathBoundsUpdate apbu(this, oval); + SkScalar cx = oval.centerX(); SkScalar cy = oval.centerY(); SkScalar rx = SkScalarHalf(oval.width()); @@ -469,26 +517,37 @@ void SkPath::addOval(const SkRect& oval, Direction dir) { SkScalar mx = SkScalarMul(rx, SK_ScalarRoot2Over2); SkScalar my = SkScalarMul(ry, SK_ScalarRoot2Over2); + /* + To handle imprecision in computing the center and radii, we revert to + the provided bounds when we can (i.e. use oval.fLeft instead of cx-rx) + to ensure that we don't exceed the oval's bounds *ever*, since we want + to use oval for our fast-bounds, rather than have to recompute it. + */ + const SkScalar L = oval.fLeft; // cx - rx + const SkScalar T = oval.fTop; // cy - ry + const SkScalar R = oval.fRight; // cx + rx + const SkScalar B = oval.fBottom; // cy + ry + this->incReserve(17); // 8 quads + close - this->moveTo(cx + rx, cy); + this->moveTo(R, cy); if (dir == kCCW_Direction) { - this->quadTo(cx + rx, cy - sy, cx + mx, cy - my); - this->quadTo(cx + sx, cy - ry, cx + 0, cy - ry); - this->quadTo(cx - sx, cy - ry, cx - mx, cy - my); - this->quadTo(cx - rx, cy - sy, cx - rx, cy - 0); - this->quadTo(cx - rx, cy + sy, cx - mx, cy + my); - this->quadTo(cx - sx, cy + ry, cx - 0, cy + ry); - this->quadTo(cx + sx, cy + ry, cx + mx, cy + my); - this->quadTo(cx + rx, cy + sy, cx + rx, cy + 0); + this->quadTo( R, cy - sy, cx + mx, cy - my); + this->quadTo(cx + sx, T, cx , T); + this->quadTo(cx - sx, T, cx - mx, cy - my); + this->quadTo( L, cy - sy, L, cy ); + this->quadTo( L, cy + sy, cx - mx, cy + my); + this->quadTo(cx - sx, B, cx , B); + this->quadTo(cx + sx, B, cx + mx, cy + my); + this->quadTo( R, cy + sy, R, cy ); } else { - this->quadTo(cx + rx, cy + sy, cx + mx, cy + my); - this->quadTo(cx + sx, cy + ry, cx - 0, cy + ry); - this->quadTo(cx - sx, cy + ry, cx - mx, cy + my); - this->quadTo(cx - rx, cy + sy, cx - rx, cy - 0); - this->quadTo(cx - rx, cy - sy, cx - mx, cy - my); - this->quadTo(cx - sx, cy - ry, cx + 0, cy - ry); - this->quadTo(cx + sx, cy - ry, cx + mx, cy - my); - this->quadTo(cx + rx, cy - sy, cx + rx, cy + 0); + this->quadTo( R, cy + sy, cx + mx, cy + my); + this->quadTo(cx + sx, B, cx , B); + this->quadTo(cx - sx, B, cx - mx, cy + my); + this->quadTo( L, cy + sy, L, cy ); + this->quadTo( L, cy - sy, cx - mx, cy - my); + this->quadTo(cx - sx, T, cx , T); + this->quadTo(cx + sx, T, cx + mx, cy - my); + this->quadTo( R, cy - sy, R, cy ); } #endif this->close(); @@ -548,7 +607,7 @@ void SkPath::addArc(const SkRect& oval, SkScalar startAngle, if (oval.isEmpty() || 0 == sweepAngle) { return; } - + const SkScalar kFullCircleAngle = SkIntToScalar(360); if (sweepAngle >= kFullCircleAngle || sweepAngle <= -kFullCircleAngle) { @@ -793,6 +852,7 @@ static void subdivide_cubic_to(SkPath* path, const SkPoint pts[4], } void SkPath::transform(const SkMatrix& matrix, SkPath* dst) const { + SkDEBUGCODE(this->validate();) if (dst == NULL) { dst = (SkPath*)this; } @@ -847,6 +907,7 @@ void SkPath::transform(const SkMatrix& matrix, SkPath* dst) const { dst->fFillType = fFillType; } matrix.mapPoints(dst->fPts.begin(), fPts.begin(), fPts.count()); + SkDEBUGCODE(dst->validate();) } } @@ -1212,11 +1273,18 @@ void SkPath::toString(SkString* str) const { void SkPath::validate() const { SkASSERT(this != NULL); SkASSERT((fFillType & ~3) == 0); - if (!fFastBoundsIsDirty) { - SkASSERT(fFastBounds.width() >= 0 && fFastBounds.height() >= 0); - } fPts.validate(); fVerbs.validate(); + + if (!fFastBoundsIsDirty) { + SkRect bounds; + compute_fast_bounds(&bounds, fPts); + // can't call contains(), since it returns false if the rect is empty + SkASSERT(fFastBounds.fLeft <= bounds.fLeft); + SkASSERT(fFastBounds.fTop <= bounds.fTop); + SkASSERT(fFastBounds.fRight >= bounds.fRight); + SkASSERT(fFastBounds.fBottom >= bounds.fBottom); + } } #if 0 // test to ensure that the iterator returns the same data as the path diff --git a/libsgl/sgl/SkRegion_path.cpp b/libsgl/sgl/SkRegion_path.cpp index 6f56bff..d00baf9 100644 --- a/libsgl/sgl/SkRegion_path.cpp +++ b/libsgl/sgl/SkRegion_path.cpp @@ -25,7 +25,8 @@ class SkRgnBuilder : public SkBlitter { public: virtual ~SkRgnBuilder(); - void init(int maxHeight, int maxTransitions); + // returns true if it could allocate the working storage needed + bool init(int maxHeight, int maxTransitions); void done() { if (fCurrScanline != NULL) { @@ -96,15 +97,33 @@ SkRgnBuilder::~SkRgnBuilder() { sk_free(fStorage); } -void SkRgnBuilder::init(int maxHeight, int maxTransitions) { - int count = maxHeight * (3 + maxTransitions); +bool SkRgnBuilder::init(int maxHeight, int maxTransitions) { + if ((maxHeight | maxTransitions) < 0) { + return false; + } + + Sk64 count, size; + + // compute the count with +1 and +3 slop for the working buffer + count.setMul(maxHeight + 1, 3 + maxTransitions); + if (!count.is32() || count.isNeg()) { + return false; + } + fStorageCount = count.get32(); - // add maxTransitions to have slop for working buffer - fStorageCount = count + 3 + maxTransitions; - fStorage = (SkRegion::RunType*)sk_malloc_throw(fStorageCount * sizeof(SkRegion::RunType)); + size.setMul(fStorageCount, sizeof(SkRegion::RunType)); + if (!size.is32() || size.isNeg()) { + return false; + } + + fStorage = (SkRegion::RunType*)sk_malloc_flags(size.get32(), 0); + if (NULL == fStorage) { + return false; + } fCurrScanline = NULL; // signal empty collection fPrevScanline = NULL; // signal first scanline + return true; } void SkRgnBuilder::blitH(int x, int y, int width) { @@ -275,7 +294,11 @@ bool SkRegion::setPath(const SkPath& path, const SkRegion& clip) { SkRgnBuilder builder; - builder.init(bot - top, SkMax32(pathTransitions, clipTransitions)); + if (!builder.init(bot - top, SkMax32(pathTransitions, clipTransitions))) { + // can't allocate working space, so return false + return this->setEmpty(); + } + SkScan::FillPath(path, clip, &builder); builder.done(); diff --git a/libsgl/sgl/SkScalerContext.cpp b/libsgl/sgl/SkScalerContext.cpp index accc3ab..854c4de 100644 --- a/libsgl/sgl/SkScalerContext.cpp +++ b/libsgl/sgl/SkScalerContext.cpp @@ -395,18 +395,19 @@ void SkScalerContext::getImage(const SkGlyph& origGlyph) { // check to see if we should filter the alpha channel - if (fRec.fMaskFormat != SkMask::kBW_Format && + if (NULL == fMaskFilter && + fRec.fMaskFormat != SkMask::kBW_Format && (fRec.fFlags & (kGammaForBlack_Flag | kGammaForWhite_Flag)) != 0) { const uint8_t* table = (fRec.fFlags & kGammaForBlack_Flag) ? gBlackGammaTable : gWhiteGammaTable; if (NULL != table) { - uint8_t* dst = (uint8_t*)glyph->fImage; - unsigned rowBytes = glyph->rowBytes(); + uint8_t* dst = (uint8_t*)origGlyph.fImage; + unsigned rowBytes = origGlyph.rowBytes(); - for (int y = glyph->fHeight - 1; y >= 0; --y) + for (int y = origGlyph.fHeight - 1; y >= 0; --y) { - for (int x = glyph->fWidth - 1; x >= 0; --x) + for (int x = origGlyph.fWidth - 1; x >= 0; --x) dst[x] = table[dst[x]]; dst += rowBytes; } diff --git a/libsgl/sgl/SkScan_Path.cpp b/libsgl/sgl/SkScan_Path.cpp index 0d962ba..8b58991 100644 --- a/libsgl/sgl/SkScan_Path.cpp +++ b/libsgl/sgl/SkScan_Path.cpp @@ -23,15 +23,15 @@ #include "SkRegion.h" #include "SkTemplates.h" -#define kEDGE_HEAD_Y SK_MinS16 -#define kEDGE_TAIL_Y SK_MaxS16 +#define kEDGE_HEAD_Y SK_MinS32 +#define kEDGE_TAIL_Y SK_MaxS32 #ifdef SK_DEBUG static void validate_sort(const SkEdge* edge) { int y = kEDGE_HEAD_Y; - while (edge->fFirstY != SK_MaxS16) + while (edge->fFirstY != SK_MaxS32) { edge->validate(); SkASSERT(y <= edge->fFirstY); diff --git a/libsgl/sgl/SkXfermode.cpp b/libsgl/sgl/SkXfermode.cpp index 3608b94..e8a202d 100644 --- a/libsgl/sgl/SkXfermode.cpp +++ b/libsgl/sgl/SkXfermode.cpp @@ -30,6 +30,19 @@ static SkPMColor SkFourByteInterp(SkPMColor src, SkPMColor dst, U8CPU alpha) { return SkPackARGB32(a, r, g, b); } +// idea for higher precision blends in xfer procs (and slightly faster) +// see DstATop as a probable caller +static U8CPU mulmuldiv255round(U8CPU a, U8CPU b, U8CPU c, U8CPU d) { + SkASSERT(a <= 255); + SkASSERT(b <= 255); + SkASSERT(c <= 255); + SkASSERT(d <= 255); + unsigned prod = SkMulS16(a, b) + SkMulS16(c, d) + 128; + unsigned result = (prod + (prod >> 8)) >> 8; + SkASSERT(result <= 255); + return result; +} + /////////////////////////////////////////////////////////////////////////////// bool SkXfermode::asCoeff(Coeff* src, Coeff* dst) { diff --git a/libsgl/views/SkBGViewArtist.cpp b/libsgl/views/SkBGViewArtist.cpp new file mode 100644 index 0000000..07da123 --- /dev/null +++ b/libsgl/views/SkBGViewArtist.cpp @@ -0,0 +1,24 @@ +#include "SkBGViewArtist.h" +#include "SkCanvas.h" +#include "SkParsePaint.h" + +SkBGViewArtist::SkBGViewArtist(SkColor c) +{ + fPaint.setColor(c); +} + +SkBGViewArtist::~SkBGViewArtist() +{ +} + +void SkBGViewArtist::onDraw(SkView*, SkCanvas* canvas) +{ + // only works for views that are clipped their bounds. + canvas->drawPaint(fPaint); +} + +void SkBGViewArtist::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + SkPaint_Inflate(&fPaint, dom, node); +} + diff --git a/libsgl/views/SkBorderView.cpp b/libsgl/views/SkBorderView.cpp new file mode 100644 index 0000000..3356782 --- /dev/null +++ b/libsgl/views/SkBorderView.cpp @@ -0,0 +1,87 @@ +#include "SkBorderView.h" +#include "SkAnimator.h" +#include "SkWidgetViews.h" +#include "SkSystemEventTypes.h" +#include "SkTime.h" +#include "SkStackViewLayout.h" + +SkBorderView::SkBorderView() : fTop(SkIntToScalar(0)), fLeft(SkIntToScalar(0)), + fRight(SkIntToScalar(0)), fBottom(SkIntToScalar(0)) +{ + fAnim.setHostEventSink(this); + init_skin_anim(kBorder_SkinEnum, &fAnim); +} + +SkBorderView::~SkBorderView() +{ + +} + +void SkBorderView::setSkin(const char skin[]) +{ + init_skin_anim(skin, &fAnim); +} + +/* virtual */ void SkBorderView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); +} + +/*virtual*/ void SkBorderView::onSizeChange() +{ + this->INHERITED::onSizeChange(); + SkEvent evt("user"); + evt.setString("id", "setDim"); + evt.setScalar("dimX", this->width()); + evt.setScalar("dimY", this->height()); + fAnim.doUserEvent(evt); +} + +/*virtual*/ void SkBorderView::onDraw(SkCanvas* canvas) +{ + SkPaint paint; + SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs()); + + if (diff == SkAnimator::kDifferent) + this->inval(nil); + else if (diff == SkAnimator::kPartiallyDifferent) + { + SkRect bounds; + fAnim.getInvalBounds(&bounds); + this->inval(&bounds); + } +} + +/*virtual*/ bool SkBorderView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Inval)) + { + this->inval(nil); + return true; + } + if (evt.isType("recommendDim")) + { + evt.findScalar("leftMargin", &fLeft); + evt.findScalar("rightMargin", &fRight); + evt.findScalar("topMargin", &fTop); + evt.findScalar("bottomMargin", &fBottom); + + //setup_views.cpp uses SkView::Layout instead of SkStackViewLayout + //but that gives me an error + SkStackViewLayout* layout; + fMargin.set(fLeft, fTop, fRight, fBottom); + if (this->getLayout()) + { + layout = (SkStackViewLayout*)this->getLayout(); + layout->setMargin(fMargin); + } + else + { + layout = new SkStackViewLayout; + layout->setMargin(fMargin); + this->setLayout(layout)->unref(); + } + this->invokeLayout(); + } + return this->INHERITED::onEvent(evt); +} diff --git a/libsgl/views/SkImageView.cpp b/libsgl/views/SkImageView.cpp new file mode 100644 index 0000000..f19e913 --- /dev/null +++ b/libsgl/views/SkImageView.cpp @@ -0,0 +1,296 @@ +#include "SkImageView.h" +#include "SkAnimator.h" +#include "SkBitmap.h" +#include "SkCanvas.h" +#include "SkImageDecoder.h" +#include "SkMatrix.h" +#include "SkSystemEventTypes.h" +#include "SkTime.h" + +SkImageView::SkImageView() +{ + fMatrix = nil; + fScaleType = kMatrix_ScaleType; + + fData.fAnim = nil; // handles initializing the other union values + fDataIsAnim = true; + + fUriIsValid = false; // an empty string is not valid +} + +SkImageView::~SkImageView() +{ + if (fMatrix) + sk_free(fMatrix); + + this->freeData(); +} + +void SkImageView::getUri(SkString* uri) const +{ + if (uri) + *uri = fUri; +} + +void SkImageView::setUri(const char uri[]) +{ + if (!fUri.equals(uri)) + { + fUri.set(uri); + this->onUriChange(); + } +} + +void SkImageView::setUri(const SkString& uri) +{ + if (fUri != uri) + { + fUri = uri; + this->onUriChange(); + } +} + +void SkImageView::setScaleType(ScaleType st) +{ + SkASSERT((unsigned)st <= kFitEnd_ScaleType); + + if ((ScaleType)fScaleType != st) + { + fScaleType = SkToU8(st); + if (fUriIsValid) + this->inval(nil); + } +} + +bool SkImageView::getImageMatrix(SkMatrix* matrix) const +{ + if (fMatrix) + { + SkASSERT(!fMatrix->isIdentity()); + if (matrix) + *matrix = *fMatrix; + return true; + } + else + { + if (matrix) + matrix->reset(); + return false; + } +} + +void SkImageView::setImageMatrix(const SkMatrix* matrix) +{ + bool changed = false; + + if (matrix && !matrix->isIdentity()) + { + if (fMatrix == nil) + fMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix)); + *fMatrix = *matrix; + changed = true; + } + else // set us to identity + { + if (fMatrix) + { + SkASSERT(!fMatrix->isIdentity()); + sk_free(fMatrix); + fMatrix = nil; + changed = true; + } + } + + // only redraw if we changed our matrix and we're not in scaleToFit mode + if (changed && this->getScaleType() == kMatrix_ScaleType && fUriIsValid) + this->inval(nil); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +bool SkImageView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Inval)) + { + if (fUriIsValid) + this->inval(nil); + return true; + } + return this->INHERITED::onEvent(evt); +} + +static inline SkMatrix::ScaleToFit scaleTypeToScaleToFit(SkImageView::ScaleType st) +{ + SkASSERT(st != SkImageView::kMatrix_ScaleType); + SkASSERT((unsigned)st <= SkImageView::kFitEnd_ScaleType); + + SkASSERT(SkImageView::kFitXY_ScaleType - 1 == SkMatrix::kFill_ScaleToFit); + SkASSERT(SkImageView::kFitStart_ScaleType - 1 == SkMatrix::kStart_ScaleToFit); + SkASSERT(SkImageView::kFitCenter_ScaleType - 1 == SkMatrix::kCenter_ScaleToFit); + SkASSERT(SkImageView::kFitEnd_ScaleType - 1 == SkMatrix::kEnd_ScaleToFit); + + return (SkMatrix::ScaleToFit)(st - 1); +} + +void SkImageView::onDraw(SkCanvas* canvas) +{ + SkRect src; + if (!this->getDataBounds(&src)) + { + SkDEBUGCODE(canvas->drawColor(SK_ColorRED);) + return; // nothing to draw + } + + SkAutoCanvasRestore restore(canvas, true); + SkMatrix matrix; + + if (this->getScaleType() == kMatrix_ScaleType) + (void)this->getImageMatrix(&matrix); + else + { + SkRect dst; + dst.set(0, 0, this->width(), this->height()); + matrix.setRectToRect(src, dst, scaleTypeToScaleToFit(this->getScaleType())); + } + canvas->concat(matrix); + + SkPaint paint; + + paint.setAntiAlias(true); + + if (fDataIsAnim) + { + SkMSec now = SkTime::GetMSecs(); + + SkAnimator::DifferenceType diff = fData.fAnim->draw(canvas, &paint, now); + +SkDEBUGF(("SkImageView : now = %X[%12.3f], diff = %d\n", now, now/1000., diff)); + + if (diff == SkAnimator::kDifferent) + this->inval(nil); + else if (diff == SkAnimator::kPartiallyDifferent) + { + SkRect bounds; + fData.fAnim->getInvalBounds(&bounds); + matrix.mapRect(&bounds); // get the bounds into view coordinates + this->inval(&bounds); + } + } + else + canvas->drawBitmap(*fData.fBitmap, 0, 0, &paint); +} + +void SkImageView::onInflate(const SkDOM& dom, const SkDOMNode* node) +{ + this->INHERITED::onInflate(dom, node); + + const char* src = dom.findAttr(node, "src"); + if (src) + this->setUri(src); + + int index = dom.findList(node, "scaleType", "matrix,fitXY,fitStart,fitCenter,fitEnd"); + if (index >= 0) + this->setScaleType((ScaleType)index); + + // need inflate syntax/reader for matrix +} + +///////////////////////////////////////////////////////////////////////////////////// + +void SkImageView::onUriChange() +{ + if (this->freeData()) + this->inval(nil); + fUriIsValid = true; // give ensureUriIsLoaded() a shot at the new uri +} + +bool SkImageView::freeData() +{ + if (fData.fAnim) // test is valid for all union values + { + if (fDataIsAnim) + delete fData.fAnim; + else + delete fData.fBitmap; + + fData.fAnim = nil; // valid for all union values + return true; + } + return false; +} + +bool SkImageView::getDataBounds(SkRect* bounds) +{ + SkASSERT(bounds); + + if (this->ensureUriIsLoaded()) + { + SkScalar width, height; + + if (fDataIsAnim) + { + if (SkScalarIsNaN(width = fData.fAnim->getScalar("dimensions", "x")) || + SkScalarIsNaN(height = fData.fAnim->getScalar("dimensions", "y"))) + { + // cons up fake bounds + width = this->width(); + height = this->height(); + } + } + else + { + width = SkIntToScalar(fData.fBitmap->width()); + height = SkIntToScalar(fData.fBitmap->height()); + } + bounds->set(0, 0, width, height); + return true; + } + return false; +} + +bool SkImageView::ensureUriIsLoaded() +{ + if (fData.fAnim) // test is valid for all union values + { + SkASSERT(fUriIsValid); + return true; + } + if (!fUriIsValid) + return false; + + // try to load the url + if (fUri.endsWith(".xml")) // assume it is screenplay + { + SkAnimator* anim = new SkAnimator; + + if (!anim->decodeURI(fUri.c_str())) + { + delete anim; + fUriIsValid = false; + return false; + } + anim->setHostEventSink(this); + + fData.fAnim = anim; + fDataIsAnim = true; + } + else // assume it is an image format + { + #if 0 + SkBitmap* bitmap = new SkBitmap; + + if (!SkImageDecoder::DecodeURL(fUri.c_str(), bitmap)) + { + delete bitmap; + fUriIsValid = false; + return false; + } + fData.fBitmap = bitmap; + fDataIsAnim = false; + #else + return false; + #endif + } + return true; +} + diff --git a/libsgl/views/SkListView.cpp b/libsgl/views/SkListView.cpp new file mode 100644 index 0000000..27218a9 --- /dev/null +++ b/libsgl/views/SkListView.cpp @@ -0,0 +1,895 @@ +#include "SkWidget.h" +#include "SkCanvas.h" +#include "SkEvent.h" +#include "SkKey.h" +#include "SkParsePaint.h" +#include "SkSystemEventTypes.h" + +#if 0 + +SkEvent* SkListSource::getEvent(int index) +{ + return nil; +} + +#include "SkOSFile.h" + +class SkDirListSource : public SkListSource { +public: + SkDirListSource(const char path[], const char suffix[], const char target[]) + : fPath(path), fSuffix(suffix), fTarget(target) + { + fCount = -1; + } + virtual int countRows() + { + if (fCount < 0) + { + fCount = 0; + fIter.reset(fPath.c_str(), fSuffix.c_str()); + while (fIter.next(nil)) + fCount += 1; + fIter.reset(fPath.c_str(), fSuffix.c_str()); + fIndex = 0; + } + return fCount; + } + virtual void getRow(int index, SkString* left, SkString* right) + { + (void)this->countRows(); + SkASSERT((unsigned)index < (unsigned)fCount); + + if (fIndex > index) + { + fIter.reset(fPath.c_str(), fSuffix.c_str()); + fIndex = 0; + } + + while (fIndex < index) + { + fIter.next(nil); + fIndex += 1; + } + + if (fIter.next(left)) + { + if (left) + left->remove(left->size() - fSuffix.size(), fSuffix.size()); + } + else + { + if (left) + left->reset(); + } + if (right) // only set to ">" if we know we're on a sub-directory + right->reset(); + + fIndex += 1; + } + virtual SkEvent* getEvent(int index) + { + SkASSERT((unsigned)index < (unsigned)fCount); + + SkEvent* evt = new SkEvent(); + SkString label; + + this->getRow(index, &label, nil); + evt->setString("name", label.c_str()); + + int c = fPath.c_str()[fPath.size() - 1]; + if (c != '/' && c != '\\') + label.prepend("/"); + label.prepend(fPath); + label.append(fSuffix); + evt->setString("path", label.c_str()); + evt->setS32("index", index); + evt->setS32("duration", 22); + evt->setType(fTarget); + return evt; + } + +private: + SkString fPath, fSuffix; + SkString fTarget; + SkOSFile::Iter fIter; + int fCount; + int fIndex; +}; + +SkListSource* SkListSource::CreateFromDir(const char path[], const char suffix[], const char target[]) +{ + return new SkDirListSource(path, suffix, target); +} + +////////////////////////////////////////////////////////////////// + +class SkDOMListSource : public SkListSource { +public: + enum Type { + kUnknown_Type, + kDir_Type, + kToggle_Type + }; + struct ItemRec { + SkString fLabel; + SkString fTail, fAltTail; + SkString fTarget; + Type fType; + }; + + SkDOMListSource(const SkDOM& dom, const SkDOM::Node* node) : fDirTail(">") + { + const SkDOM::Node* child = dom.getFirstChild(node, "item"); + int count = 0; + + while (child) + { + count += 1; + child = dom.getNextSibling(child, "item"); + } + + fCount = count; + fList = nil; + if (count) + { + ItemRec* rec = fList = new ItemRec[count]; + + child = dom.getFirstChild(node, "item"); + while (child) + { + rec->fLabel.set(dom.findAttr(child, "label")); + rec->fTail.set(dom.findAttr(child, "tail")); + rec->fAltTail.set(dom.findAttr(child, "alt-tail")); + rec->fTarget.set(dom.findAttr(child, "target")); + rec->fType = kUnknown_Type; + + int index = dom.findList(child, "type", "dir,toggle"); + if (index >= 0) + rec->fType = (Type)(index + 1); + + child = dom.getNextSibling(child, "item"); + rec += 1; + } + } + } + virtual ~SkDOMListSource() + { + delete[] fList; + } + virtual int countRows() + { + return fCount; + } + virtual void getRow(int index, SkString* left, SkString* right) + { + SkASSERT((unsigned)index < (unsigned)fCount); + + if (left) + *left = fList[index].fLabel; + if (right) + *right = fList[index].fType == kDir_Type ? fDirTail : fList[index].fTail; + } + virtual SkEvent* getEvent(int index) + { + SkASSERT((unsigned)index < (unsigned)fCount); + + if (fList[index].fType == kDir_Type) + { + SkEvent* evt = new SkEvent(); + evt->setType(fList[index].fTarget); + evt->setFast32(index); + return evt; + } + if (fList[index].fType == kToggle_Type) + fList[index].fTail.swap(fList[index].fAltTail); + + return nil; + } + +private: + int fCount; + ItemRec* fList; + SkString fDirTail; +}; + +SkListSource* SkListSource::CreateFromDOM(const SkDOM& dom, const SkDOM::Node* node) +{ + return new SkDOMListSource(dom, node); +} + +////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////// + +SkListView::SkListView(U32 flags) : SkWidgetView(flags) +{ + fSource = nil; + fScrollIndex = 0; + fCurrIndex = -1; + fRowHeight = SkIntToScalar(16); + fVisibleRowCount = 0; + fStrCache = nil; + + fPaint[kBG_Attr].setColor(0); + fPaint[kNormalText_Attr].setTextSize(SkIntToScalar(14)); + fPaint[kHiliteText_Attr].setTextSize(SkIntToScalar(14)); + fPaint[kHiliteText_Attr].setColor(SK_ColorWHITE); + fPaint[kHiliteCell_Attr].setColor(SK_ColorBLUE); +} + +SkListView::~SkListView() +{ + delete[] fStrCache; + fSource->safeUnref(); +} + +void SkListView::setRowHeight(SkScalar height) +{ + SkASSERT(height >= 0); + + if (fRowHeight != height) + { + fRowHeight = height; + this->inval(nil); + this->onSizeChange(); + } +} + +void SkListView::setSelection(int index) +{ + if (fCurrIndex != index) + { + this->invalSelection(); + fCurrIndex = index; + this->invalSelection(); + this->ensureSelectionIsVisible(); + + { + SkEvent evt; + evt.setType("listview-selection"); + evt.setFast32(index); + this->sendEventToParents(evt); + } + } +} + +void SkListView::moveSelectionUp() +{ + if (fSource) + { + int index = fCurrIndex; + if (index < 0) // no selection + index = fSource->countRows() - 1; + else + index = SkMax32(index - 1, 0); + this->setSelection(index); + } +} + +void SkListView::moveSelectionDown() +{ + if (fSource) + { + int index = fCurrIndex; + if (index < 0) // no selection + index = 0; + else + index = SkMin32(index + 1, fSource->countRows() - 1); + this->setSelection(index); + } +} + +void SkListView::invalSelection() +{ + SkRect r; + if (this->getRowRect(fCurrIndex, &r)) + this->inval(&r); +} + +void SkListView::ensureSelectionIsVisible() +{ + if (fSource == nil) + return; + + if ((unsigned)fCurrIndex < (unsigned)fSource->countRows()) + { + int index = this->logicalToVisualIndex(fCurrIndex); + + if ((unsigned)index >= (unsigned)fVisibleRowCount) // need to scroll + { + if (index < 0) // too high + fScrollIndex = fCurrIndex; + else + fScrollIndex = fCurrIndex - fVisibleRowCount + 1; + SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows()); + + this->dirtyStrCache(); + this->inval(nil); + } + } +} + +bool SkListView::getRowRect(int index, SkRect* r) const +{ + SkASSERT(r); + index = this->logicalToVisualIndex(index); + if (index >= 0) + { + SkScalar top = index * fRowHeight; + + if (top < this->height()) + { + if (r) + r->set(0, top, this->width(), top + fRowHeight); + return true; + } + } + return false; +} + +SkPaint& SkListView::paint(Attr attr) +{ + SkASSERT((unsigned)attr < kAttrCount); + return fPaint[attr]; +} + +SkListSource* SkListView::setListSource(SkListSource* src) +{ + if (fSource != src) + { + SkRefCnt_SafeAssign(fSource, src); + this->dirtyStrCache(); + this->ensureSelectionIsVisible(); + this->inval(nil); + } + return src; +} + +void SkListView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + canvas->drawPaint(fPaint[kBG_Attr]); + + int visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex); + if (visibleCount == 0) + return; + + this->ensureStrCache(visibleCount); + int currIndex = this->logicalToVisualIndex(fCurrIndex); + + if ((unsigned)currIndex < (unsigned)visibleCount) + { + SkAutoCanvasRestore restore(canvas, true); + SkRect r; + + canvas->translate(0, currIndex * fRowHeight); + (void)this->getRowRect(fScrollIndex, &r); + canvas->drawRect(r, fPaint[kHiliteCell_Attr]); + } + + SkPaint* p; + SkScalar y, x = SkIntToScalar(6); + SkScalar rite = this->width() - x; + + { + SkScalar ascent, descent; + fPaint[kNormalText_Attr].measureText(0, nil, &ascent, &descent); + y = SkScalarHalf(fRowHeight - descent + ascent) - ascent; + } + + for (int i = 0; i < visibleCount; i++) + { + if (i == currIndex) + p = &fPaint[kHiliteText_Attr]; + else + p = &fPaint[kNormalText_Attr]; + + p->setTextAlign(SkPaint::kLeft_Align); + canvas->drawText(fStrCache[i].c_str(), fStrCache[i].size(), x, y, *p); + p->setTextAlign(SkPaint::kRight_Align); + canvas->drawText(fStrCache[i + visibleCount].c_str(), fStrCache[i + visibleCount].size(), rite, y, *p); + canvas->translate(0, fRowHeight); + } +} + +void SkListView::onSizeChange() +{ + SkScalar count = SkScalarDiv(this->height(), fRowHeight); + int n = SkScalarFloor(count); + + // only want to show rows that are mostly visible + if (n == 0 || count - SkIntToScalar(n) > SK_Scalar1*75/100) + n += 1; + + if (fVisibleRowCount != n) + { + fVisibleRowCount = n; + this->ensureSelectionIsVisible(); + this->dirtyStrCache(); + } +} + +void SkListView::dirtyStrCache() +{ + if (fStrCache) + { + delete[] fStrCache; + fStrCache = nil; + } +} + +void SkListView::ensureStrCache(int count) +{ + if (fStrCache == nil) + { + fStrCache = new SkString[count << 1]; + + if (fSource) + for (int i = 0; i < count; i++) + fSource->getRow(i + fScrollIndex, &fStrCache[i], &fStrCache[i + count]); + } +} + +bool SkListView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Key)) + { + switch (evt.getFast32()) { + case kUp_SkKey: + this->moveSelectionUp(); + return true; + case kDown_SkKey: + this->moveSelectionDown(); + return true; + case kRight_SkKey: + case kOK_SkKey: + if (fSource && fCurrIndex >= 0) + { + SkEvent* evt = fSource->getEvent(fCurrIndex); + if (evt) + { + SkView* view = this->sendEventToParents(*evt); + delete evt; + return view != nil; + } + else // hack to make toggle work + { + this->dirtyStrCache(); + this->inval(nil); + } + } + break; + } + } + return this->INHERITED::onEvent(evt); +} + +void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + SkScalar x; + const SkDOM::Node* child; + + if (dom.findScalar(node, "row-height", &x)) + this->setRowHeight(x); + + if ((child = dom.getFirstChild(node, "hilite-paint")) != nil) + SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child); + + // look for a listsource + { + SkListSource* src = nil; + + if ((child = dom.getFirstChild(node, "file-listsource")) != nil) + { + const char* path = dom.findAttr(child, "path"); + if (path) + src = SkListSource::CreateFromDir( path, + dom.findAttr(child, "filter"), + dom.findAttr(child, "target")); + } + else if ((child = dom.getFirstChild(node, "xml-listsource")) != nil) + { + src = SkListSource::CreateFromDOM(dom, child); + } + + if (src) + { + this->setListSource(src)->unref(); + this->setSelection(0); + } + } +} + +/////////////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////////////// + +#include "SkImageDecoder.h" +#include "SkShader.h" + +class SkScrollBarView : public SkView { +public: + SkScrollBarView(const char bg[], const char fg[]) + { + fBGRef = SkBitmapRef::Decode(bg, true); + fFGRef = SkBitmapRef::Decode(fg, true); + + if (fBGRef) + this->setWidth(SkIntToScalar(fBGRef->bitmap().width())); + } + ~SkScrollBarView() + { + delete fBGRef; + delete fFGRef; + } +protected: + virtual void onDraw(SkCanvas* canvas) + { + if (fBGRef == nil) return; + + SkPaint paint; + + SkShader* shader = SkShader::CreateBitmapShader(fBGRef->bitmap(), false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode); + paint.setShader(shader)->unref(); + + canvas->drawPaint(paint); + } +private: + SkBitmapRef* fBGRef, *fFGRef; +}; + +SkGridView::SkGridView(U32 flags) : SkWidgetView(flags) +{ + fSource = nil; + fCurrIndex = -1; + fVisibleCount.set(0, 0); + + fPaint[kBG_Attr].setColor(SK_ColorWHITE); + fPaint[kHiliteCell_Attr].setColor(SK_ColorYELLOW); + fPaint[kHiliteCell_Attr].setStyle(SkPaint::kStroke_Style); + fPaint[kHiliteCell_Attr].setAntiAliasOn(true); + fPaint[kHiliteCell_Attr].setStrokeWidth(SK_Scalar1*3); + + fScrollBar = new SkScrollBarView("icons/scrollbarGrey.jpg", "icons/scrollbarBlue.jpg"); + this->attachChildToFront(fScrollBar)->unref(); + fScrollBar->setVisibleP(true); +} + +SkGridView::~SkGridView() +{ + fSource->safeUnref(); +} + +void SkGridView::getCellSize(SkPoint* size) const +{ + if (size) + *size = fCellSize; +} + +void SkGridView::setCellSize(SkScalar x, SkScalar y) +{ + SkASSERT(x >= 0 && y >= 0); + + if (!fCellSize.equals(x, y)) + { + fCellSize.set(x, y); + this->inval(nil); + } +} + +void SkGridView::setSelection(int index) +{ + if (fCurrIndex != index) + { + this->invalSelection(); + fCurrIndex = index; + this->invalSelection(); + this->ensureSelectionIsVisible(); + + // this generates the click + { + SkEvent evt; + evt.setType("listview-selection"); + evt.setFast32(index); + this->sendEventToParents(evt); + } + } +} + +void SkGridView::moveSelectionUp() +{ + if (fSource) + { + int index = fCurrIndex; + if (index < 0) // no selection + index = fSource->countRows() - 1; + else + index = SkMax32(index - 1, 0); + this->setSelection(index); + } +} + +void SkGridView::moveSelectionDown() +{ + if (fSource) + { + int index = fCurrIndex; + if (index < 0) // no selection + index = 0; + else + index = SkMin32(index + 1, fSource->countRows() - 1); + this->setSelection(index); + } +} + +void SkGridView::invalSelection() +{ + SkRect r; + if (this->getCellRect(fCurrIndex, &r)) + { + SkScalar inset = 0; + if (fPaint[kHiliteCell_Attr].getStyle() != SkPaint::kFill_Style) + inset += fPaint[kHiliteCell_Attr].getStrokeWidth() / 2; + if (fPaint[kHiliteCell_Attr].isAntiAliasOn()) + inset += SK_Scalar1; + r.inset(-inset, -inset); + this->inval(&r); + } +} + +void SkGridView::ensureSelectionIsVisible() +{ + if (fSource == nil) + return; +#if 0 + if ((unsigned)fCurrIndex < (unsigned)fSource->countRows()) + { + int index = this->logicalToVisualIndex(fCurrIndex); + + if ((unsigned)index >= (unsigned)fVisibleRowCount) // need to scroll + { + if (index < 0) // too high + fScrollIndex = fCurrIndex; + else + fScrollIndex = fCurrIndex - fVisibleRowCount + 1; + SkASSERT((unsigned)fScrollIndex < (unsigned)fSource->countRows()); + + this->dirtyStrCache(); + this->inval(nil); + } + } +#endif +} + +bool SkGridView::getCellRect(int index, SkRect* r) const +{ + if (fVisibleCount.fY == 0) + return false; + + index = this->logicalToVisualIndex(index); + if (index >= 0) + { + SkRect bounds; + int row = index / fVisibleCount.fY; + int col = index % fVisibleCount.fY; + + bounds.set(0, 0, fCellSize.fX, fCellSize.fY); + bounds.offset(col * (fCellSize.fX + SkIntToScalar(col > 0)), + row * (fCellSize.fY + SkIntToScalar(row > 0))); + + if (bounds.fTop < this->height()) + { + if (r) + *r = bounds; + return true; + } + } + return false; +} + +SkPaint& SkGridView::paint(Attr attr) +{ + SkASSERT((unsigned)attr < kAttrCount); + return fPaint[attr]; +} + +SkListSource* SkGridView::setListSource(SkListSource* src) +{ + if (fSource != src) + { + SkRefCnt_SafeAssign(fSource, src); + // this->dirtyStrCache(); + this->ensureSelectionIsVisible(); + this->inval(nil); + } + return src; +} + +#include "SkShader.h" + +static void copybits(SkCanvas* canvas, const SkBitmap& bm, const SkRect& dst, const SkPaint& paint) +{ + SkRect src; + SkMatrix matrix; + + src.set(0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height())); + if (matrix.setRectToRect(src, dst)) + { + SkPaint p(paint); + SkShader* shader = SkShader::CreateBitmapShader(bm, false, SkPaint::kNo_FilterType, SkShader::kClamp_TileMode); + p.setShader(shader)->unref(); + + shader->setLocalMatrix(matrix); + canvas->drawRect(dst, p); + } +} + +#include "SkImageDecoder.h" + +void SkGridView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + canvas->drawPaint(fPaint[kBG_Attr]); + + if (fSource == nil) + return; + +#if 0 + int visibleCount = SkMin32(fVisibleRowCount, fSource->countRows() - fScrollIndex); + if (visibleCount == 0) + return; + + this->ensureStrCache(visibleCount); + int currIndex = this->logicalToVisualIndex(fCurrIndex); +#endif + + SkPaint p; + for (int i = 0; i < fSource->countRows(); i++) + { + bool forced = false; + SkEvent* evt = fSource->getEvent(i); + SkASSERT(evt); + SkString path(evt->findString("path")); + delete evt; + + SkBitmapRef* bmr = SkBitmapRef::Decode(path.c_str(), false); + if (bmr == nil) + { + bmr = SkBitmapRef::Decode(path.c_str(), true); + if (bmr) + forced = true; + } + + if (bmr) + { + SkAutoTDelete<SkBitmapRef> autoRef(bmr); + SkRect r; + if (!this->getCellRect(i, &r)) + break; + copybits(canvas, bmr->bitmap(), r, p); + } + // only draw one forced bitmap at a time + if (forced) + { + this->inval(nil); // could inval only the remaining visible cells... + break; + } + } + + // draw the hilite + { + SkRect r; + if (fCurrIndex >= 0 && this->getCellRect(fCurrIndex, &r)) + canvas->drawRect(r, fPaint[kHiliteCell_Attr]); + } +} + +static int check_count(int n, SkScalar s) +{ + // only want to show cells that are mostly visible + if (n == 0 || s - SkIntToScalar(n) > SK_Scalar1*75/100) + n += 1; + return n; +} + +void SkGridView::onSizeChange() +{ + fScrollBar->setHeight(this->height()); + fScrollBar->setLoc(this->locX() + this->width() - fScrollBar->width(), 0); + + if (fCellSize.equals(0, 0)) + { + fVisibleCount.set(0, 0); + return; + } + + SkScalar rows = SkScalarDiv(this->height(), fCellSize.fY); + SkScalar cols = SkScalarDiv(this->width(), fCellSize.fX); + int y = SkScalarFloor(rows); + int x = SkScalarFloor(cols); + + y = check_count(y, rows); + x = check_count(x, cols); + + if (!fVisibleCount.equals(x, y)) + { + fVisibleCount.set(x, y); + this->ensureSelectionIsVisible(); + // this->dirtyStrCache(); + } +} + +bool SkGridView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Key)) + { + switch (evt.getFast32()) { + case kUp_SkKey: + this->moveSelectionUp(); + return true; + case kDown_SkKey: + this->moveSelectionDown(); + return true; + case kRight_SkKey: + case kOK_SkKey: + if (fSource && fCurrIndex >= 0) + { + SkEvent* evt = fSource->getEvent(fCurrIndex); + if (evt) + { + // augment the event with our local rect + (void)this->getCellRect(fCurrIndex, (SkRect*)evt->setScalars("local-rect", 4, nil)); + + SkView* view = this->sendEventToParents(*evt); + delete evt; + return view != nil; + } + } + break; + } + } + return this->INHERITED::onEvent(evt); +} + +void SkGridView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + SkScalar x[2]; + const SkDOM::Node* child; + + if (dom.findScalars(node, "cell-size", x, 2)) + this->setCellSize(x[0], x[1]); + + if ((child = dom.getFirstChild(node, "hilite-paint")) != nil) + SkPaint_Inflate(&this->paint(kHiliteCell_Attr), dom, child); + + // look for a listsource + { + SkListSource* src = nil; + + if ((child = dom.getFirstChild(node, "file-listsource")) != nil) + { + const char* path = dom.findAttr(child, "path"); + if (path) + src = SkListSource::CreateFromDir( path, + dom.findAttr(child, "filter"), + dom.findAttr(child, "target")); + } + else if ((child = dom.getFirstChild(node, "xml-listsource")) != nil) + { + src = SkListSource::CreateFromDOM(dom, child); + } + + if (src) + { + this->setListSource(src)->unref(); + this->setSelection(0); + } + } + this->onSizeChange(); +} + +#endif diff --git a/libsgl/views/SkListWidget.cpp b/libsgl/views/SkListWidget.cpp new file mode 100644 index 0000000..82e5d78 --- /dev/null +++ b/libsgl/views/SkListWidget.cpp @@ -0,0 +1,623 @@ +#include "SkWidgetViews.h" + +#include "SkAnimator.h" +#include "SkScrollBarView.h" + +extern void init_skin_anim(const char name[], SkAnimator*); + +struct SkListView::BindingRec { + SkString fSlotName; + int fFieldIndex; +}; + +SkListView::SkListView() +{ + fSource = nil; // our list-source + fScrollBar = nil; + fAnims = nil; // array of animators[fVisibleRowCount] + fBindings = nil; // our fields->slot array + fBindingCount = 0; // number of entries in fSlots array + fScrollIndex = 0; // number of cells to skip before first visible cell + fCurrIndex = -1; // index of "selected" cell + fVisibleRowCount = 0; // number of cells that can fit in our bounds + fAnimContentDirty = true; // true if fAnims[] have their correct content + fAnimFocusDirty = true; + + fHeights[kNormal_Height] = SkIntToScalar(16); + fHeights[kSelected_Height] = SkIntToScalar(16); + + this->setFlags(this->getFlags() | kFocusable_Mask); +} + +SkListView::~SkListView() +{ + fScrollBar->safeUnref(); + fSource->safeUnref(); + delete[] fAnims; + delete[] fBindings; +} + +void SkListView::setHasScrollBar(bool hasSB) +{ + if (hasSB != this->hasScrollBar()) + { + if (hasSB) + { + SkASSERT(fScrollBar == nil); + fScrollBar = (SkScrollBarView*)SkWidgetFactory(kScroll_WidgetEnum); + fScrollBar->setVisibleP(true); + this->attachChildToFront(fScrollBar); + fScrollBar->setHeight(this->height()); // assume it auto-sets its width + // fScrollBar->setLoc(this->getContentWidth(), 0); + fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0); + } + else + { + SkASSERT(fScrollBar); + fScrollBar->detachFromParent(); + fScrollBar->unref(); + fScrollBar = nil; + } + this->dirtyCache(kAnimContent_DirtyFlag); + } +} + +void SkListView::setSelection(int index) +{ + if (fCurrIndex != index) + { + fAnimFocusDirty = true; + this->inval(nil); + + this->invalSelection(); + fCurrIndex = index; + this->invalSelection(); + this->ensureSelectionIsVisible(); + } +} + +bool SkListView::moveSelectionUp() +{ + if (fSource) + { + int index = fCurrIndex; + if (index < 0) // no selection + index = fSource->countRecords() - 1; + else + index = SkMax32(index - 1, 0); + + if (fCurrIndex != index) + { + this->setSelection(index); + return true; + } + } + return false; +} + +bool SkListView::moveSelectionDown() +{ + if (fSource) + { + int index = fCurrIndex; + if (index < 0) // no selection + index = 0; + else + index = SkMin32(index + 1, fSource->countRecords() - 1); + + if (fCurrIndex != index) + { + this->setSelection(index); + return true; + } + } + return false; +} + +void SkListView::invalSelection() +{ + SkRect r; + if (this->getRowRect(fCurrIndex, &r)) + this->inval(&r); +} + +void SkListView::ensureSelectionIsVisible() +{ + if (fSource && (unsigned)fCurrIndex < (unsigned)fSource->countRecords()) + { + int index = this->logicalToVisualIndex(fCurrIndex); + + if ((unsigned)index >= (unsigned)fVisibleRowCount) // need to scroll + { + int newIndex; + + if (index < 0) // too high + newIndex = fCurrIndex; + else + newIndex = fCurrIndex - fVisibleRowCount + 1; + SkASSERT((unsigned)newIndex < (unsigned)fSource->countRecords()); + this->inval(nil); + + if (fScrollIndex != newIndex) + { + fScrollIndex = newIndex; + if (fScrollBar) + fScrollBar->setStart(newIndex); + this->dirtyCache(kAnimContent_DirtyFlag); + } + } + } +} + +SkScalar SkListView::getContentWidth() const +{ + SkScalar width = this->width(); + + if (fScrollBar) + { + width -= fScrollBar->width(); + if (width < 0) + width = 0; + } + return width; +} + +bool SkListView::getRowRect(int index, SkRect* r) const +{ + SkASSERT(r); + + index = this->logicalToVisualIndex(index); + if (index >= 0) + { + int selection = this->logicalToVisualIndex(fCurrIndex); + + SkScalar height = fHeights[index == selection ? kSelected_Height : kNormal_Height]; + SkScalar top = index * fHeights[kNormal_Height]; + + if (index > selection && selection >= 0) + top += fHeights[kSelected_Height] - fHeights[kNormal_Height]; + + if (top < this->height()) + { + if (r) + r->set(0, top, this->getContentWidth(), top + height); + return true; + } + } + return false; +} + +SkListSource* SkListView::setListSource(SkListSource* src) +{ + if (fSource != src) + { + SkRefCnt_SafeAssign(fSource, src); + this->ensureSelectionIsVisible(); + this->inval(nil); + + if (fScrollBar) + fScrollBar->setTotal(fSource->countRecords()); + } + return src; +} + +void SkListView::dirtyCache(unsigned dirtyFlags) +{ + if (dirtyFlags & kAnimCount_DirtyFlag) + { + delete fAnims; + fAnims = nil; + fAnimContentDirty = true; + fAnimFocusDirty = true; + } + if (dirtyFlags & kAnimContent_DirtyFlag) + { + if (!fAnimContentDirty) + { + this->inval(nil); + fAnimContentDirty = true; + } + fAnimFocusDirty = true; + } +} + +bool SkListView::ensureCache() +{ + if (fSkinName.size() == 0) + return false; + + if (fAnims == nil) + { + int n = SkMax32(1, fVisibleRowCount); + + SkASSERT(fAnimContentDirty); + fAnims = new SkAnimator[n]; + for (int i = 0; i < n; i++) + { + fAnims[i].setHostEventSink(this); + init_skin_anim(fSkinName.c_str(), &fAnims[i]); + } + + fHeights[kNormal_Height] = fAnims[0].getScalar("idleHeight", "value"); + fHeights[kSelected_Height] = fAnims[0].getScalar("focusedHeight", "value"); + + fAnimFocusDirty = true; + } + + if (fAnimContentDirty && fSource) + { + fAnimContentDirty = false; + + SkString str; + SkEvent evt("user"); + evt.setString("id", "setFields"); + evt.setS32("rowCount", fVisibleRowCount); + + SkEvent dimEvt("user"); + dimEvt.setString("id", "setDim"); + dimEvt.setScalar("dimX", this->getContentWidth()); + dimEvt.setScalar("dimY", this->height()); + + for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++) + { + evt.setS32("relativeIndex", i - fScrollIndex); + for (int j = 0; j < fBindingCount; j++) + { + fSource->getRecord(i, fBindings[j].fFieldIndex, &str); +//SkDEBUGF(("getRecord(%d,%d,%s) slot(%s)\n", i, fBindings[j].fFieldIndex, str.c_str(), fBindings[j].fSlotName.c_str())); + evt.setString(fBindings[j].fSlotName.c_str(), str.c_str()); + } + (void)fAnims[i % fVisibleRowCount].doUserEvent(evt); + (void)fAnims[i % fVisibleRowCount].doUserEvent(dimEvt); + } + fAnimFocusDirty = true; + } + + if (fAnimFocusDirty) + { +//SkDEBUGF(("service fAnimFocusDirty\n")); + fAnimFocusDirty = false; + + SkEvent focusEvt("user"); + focusEvt.setString("id", "setFocus"); + + for (int i = fScrollIndex; i < fScrollIndex + fVisibleRowCount; i++) + { + focusEvt.setS32("FOCUS", i == fCurrIndex); + (void)fAnims[i % fVisibleRowCount].doUserEvent(focusEvt); + } + } + + return true; +} + +void SkListView::ensureVisibleRowCount() +{ + SkScalar height = this->height(); + int n = 0; + + if (height > 0) + { + n = 1; + height -= fHeights[kSelected_Height]; + if (height > 0) + { + SkScalar count = SkScalarDiv(height, fHeights[kNormal_Height]); + n += SkScalarFloor(count); + if (count - SkIntToScalar(n) > SK_Scalar1*3/4) + n += 1; + + // SkDebugf("count %g, n %d\n", count/65536., n); + } + } + + if (fVisibleRowCount != n) + { + if (fScrollBar) + fScrollBar->setShown(n); + + fVisibleRowCount = n; + this->ensureSelectionIsVisible(); + this->dirtyCache(kAnimCount_DirtyFlag | kAnimContent_DirtyFlag); + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +#include "SkSystemEventTypes.h" +#include "SkTime.h" + +void SkListView::onSizeChange() +{ + this->INHERITED::onSizeChange(); + + if (fScrollBar) + fScrollBar->setLoc(this->width()-SkIntToScalar(10), 0); + + this->ensureVisibleRowCount(); +} + +void SkListView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + this->ensureVisibleRowCount(); + + int visibleCount = SkMin32(fVisibleRowCount, fSource->countRecords() - fScrollIndex); + if (visibleCount == 0 || !this->ensureCache()) + return; + +//SkDebugf("visibleCount %d scrollIndex %d currIndex %d\n", visibleCount, fScrollIndex, fCurrIndex); + + SkAutoCanvasRestore ar(canvas, true); + SkMSec now = SkTime::GetMSecs(); + SkRect bounds; + + bounds.fLeft = 0; + bounds.fRight = this->getContentWidth(); + bounds.fBottom = 0; + // assign bounds.fTop inside the loop + + // hack to reveal our bounds for debugging + if (this->hasFocus()) + canvas->drawARGB(0x11, 0, 0, 0xFF); + else + canvas->drawARGB(0x11, 0x88, 0x88, 0x88); + + for (int i = fScrollIndex; i < fScrollIndex + visibleCount; i++) + { + SkPaint paint; + SkScalar height = fHeights[i == fCurrIndex ? kSelected_Height : kNormal_Height]; + + bounds.fTop = bounds.fBottom; + bounds.fBottom += height; + + canvas->save(); + if (fAnims[i % fVisibleRowCount].draw(canvas, &paint, now) != SkAnimator::kNotDifferent) + this->inval(&bounds); + canvas->restore(); + + canvas->translate(0, height); + } +} + +bool SkListView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Key)) + { + switch (evt.getFast32()) { + case kUp_SkKey: + return this->moveSelectionUp(); + case kDown_SkKey: + return this->moveSelectionDown(); + case kRight_SkKey: + case kOK_SkKey: + this->postWidgetEvent(); + return true; + default: + break; + } + } + return this->INHERITED::onEvent(evt); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static const char gListViewEventSlot[] = "sk-listview-slot-name"; + +/*virtual*/ bool SkListView::onPrepareWidgetEvent(SkEvent* evt) +{ + if (fSource && fCurrIndex >= 0 && this->INHERITED::onPrepareWidgetEvent(evt) && + fSource->prepareWidgetEvent(evt, fCurrIndex)) + { + evt->setS32(gListViewEventSlot, fCurrIndex); + return true; + } + return false; +} + +int SkListView::GetWidgetEventListIndex(const SkEvent& evt) +{ + int32_t index; + + return evt.findS32(gListViewEventSlot, &index) ? index : -1; +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + { + bool hasScrollBar; + if (dom.findBool(node, "scrollBar", &hasScrollBar)) + this->setHasScrollBar(hasScrollBar); + } + + const SkDOM::Node* child; + + if ((child = dom.getFirstChild(node, "bindings")) != nil) + { + delete[] fBindings; + fBindings = nil; + fBindingCount = 0; + + SkListSource* listSrc = SkListSource::Factory(dom.findAttr(child, "data-fields")); + SkASSERT(listSrc); + fSkinName.set(dom.findAttr(child, "skin-slots")); + SkASSERT(fSkinName.size()); + + this->setListSource(listSrc)->unref(); + + int count = dom.countChildren(child, "bind"); + if (count > 0) + { + fBindings = new BindingRec[count]; + count = 0; // reuse this to count up to the number of valid bindings + + child = dom.getFirstChild(child, "bind"); + SkASSERT(child); + do { + const char* fieldName = dom.findAttr(child, "field"); + const char* slotName = dom.findAttr(child, "slot"); + if (fieldName && slotName) + { + fBindings[count].fFieldIndex = listSrc->findFieldIndex(fieldName); + if (fBindings[count].fFieldIndex >= 0) + fBindings[count++].fSlotName.set(slotName); + } + } while ((child = dom.getNextSibling(child, "bind")) != nil); + + fBindingCount = SkToU16(count); + if (count == 0) + { + SkDEBUGF(("SkListView::onInflate: no valid <bind> elements in <listsource>\n")); + delete[] fBindings; + } + } + this->dirtyCache(kAnimCount_DirtyFlag); + this->setSelection(0); + } +} + +///////////////////////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////// + +class SkXMLListSource : public SkListSource { +public: + SkXMLListSource(const char doc[], size_t len); + virtual ~SkXMLListSource() + { + delete[] fFields; + delete[] fRecords; + } + + virtual int countFields() { return fFieldCount; } + virtual void getFieldName(int index, SkString* field) + { + SkASSERT((unsigned)index < (unsigned)fFieldCount); + if (field) + *field = fFields[index]; + } + virtual int findFieldIndex(const char field[]) + { + for (int i = 0; i < fFieldCount; i++) + if (fFields[i].equals(field)) + return i; + return -1; + } + + virtual int countRecords() { return fRecordCount; } + virtual void getRecord(int rowIndex, int fieldIndex, SkString* data) + { + SkASSERT((unsigned)rowIndex < (unsigned)fRecordCount); + SkASSERT((unsigned)fieldIndex < (unsigned)fFieldCount); + if (data) + *data = fRecords[rowIndex * fFieldCount + fieldIndex]; + } + + virtual bool prepareWidgetEvent(SkEvent* evt, int rowIndex) + { + // hack, for testing right now. Need the xml to tell us what to jam in and where + SkString data; + + this->getRecord(rowIndex, 0, &data); + evt->setString("xml-listsource", data.c_str()); + return true; + } + +private: + SkString* fFields; // [fFieldCount] + SkString* fRecords; // [fRecordCount][fFieldCount] + int fFieldCount, fRecordCount; +}; + +#include "SkDOM.h" + +SkXMLListSource::SkXMLListSource(const char doc[], size_t len) +{ + fFieldCount = fRecordCount = 0; + fFields = fRecords = nil; + + SkDOM dom; + + const SkDOM::Node* node = dom.build(doc, len); + SkASSERT(node); + const SkDOM::Node* child; + + child = dom.getFirstChild(node, "fields"); + if (child) + { + fFieldCount = dom.countChildren(child, "field"); + fFields = new SkString[fFieldCount]; + + int n = 0; + child = dom.getFirstChild(child, "field"); + while (child) + { + fFields[n].set(dom.findAttr(child, "name")); + child = dom.getNextSibling(child, "field"); + n += 1; + } + SkASSERT(n == fFieldCount); + } + + child = dom.getFirstChild(node, "records"); + if (child) + { + fRecordCount = dom.countChildren(child, "record"); + fRecords = new SkString[fRecordCount * fFieldCount]; + + int n = 0; + child = dom.getFirstChild(child, "record"); + while (child) + { + for (int i = 0; i < fFieldCount; i++) + fRecords[n * fFieldCount + i].set(dom.findAttr(child, fFields[i].c_str())); + child = dom.getNextSibling(child, "record"); + n += 1; + } + SkASSERT(n == fRecordCount); + } +} + +///////////////////////////////////////////////////////////////////////////////////////////// + +SkListSource* SkListSource::Factory(const char name[]) +{ + static const char gDoc[] = + "<db name='contacts.db'>" + "<fields>" + "<field name='name'/>" + "<field name='work-num'/>" + "<field name='home-num'/>" + "<field name='type'/>" + "</fields>" + "<records>" + "<record name='Andy McFadden' work-num='919 357-1234' home-num='919 123-4567' type='0'/>" + "<record name='Brian Swetland' work-num='919 123-1234' home-num='929 123-4567' type='1' />" + "<record name='Chris Desalvo' work-num='919 345-1234' home-num='949 123-4567' type='1' />" + "<record name='Chris White' work-num='919 234-1234' home-num='939 123-4567' type='2' />" + "<record name='Dan Bornstein' work-num='919 357-1234' home-num='919 123-4567' type='0' />" + "<record name='Don Cung' work-num='919 123-1234' home-num='929 123-4567' type='2' />" + "<record name='Eric Fischer' work-num='919 345-1234' home-num='949 123-4567' type='2' />" + "<record name='Ficus Kirkpatric' work-num='919 234-1234' home-num='939 123-4567' type='1' />" + "<record name='Jack Veenstra' work-num='919 234-1234' home-num='939 123-4567' type='2' />" + "<record name='Jeff Yaksick' work-num='919 234-1234' home-num='939 123-4567' type='0' />" + "<record name='Joe Onorato' work-num='919 234-1234' home-num='939 123-4567' type='0' />" + "<record name='Mathias Agopian' work-num='919 234-1234' home-num='939 123-4567' type='1' />" + "<record name='Mike Fleming' work-num='919 234-1234' home-num='939 123-4567' type='2' />" + "<record name='Nick Sears' work-num='919 234-1234' home-num='939 123-4567' type='1' />" + "<record name='Rich Miner' work-num='919 234-1234' home-num='939 123-4567' type='1' />" + "<record name='Tracey Cole' work-num='919 234-1234' home-num='939 123-4567' type='0' />" + "<record name='Wei Huang' work-num='919 234-1234' home-num='939 123-4567' type='0' />" + "</records>" + "</db>"; + +//SkDebugf("doc size %d\n", sizeof(gDoc)-1); + return new SkXMLListSource(gDoc, sizeof(gDoc) - 1); +} + + + diff --git a/libsgl/views/SkOSFile.cpp b/libsgl/views/SkOSFile.cpp new file mode 100644 index 0000000..c8eeeea --- /dev/null +++ b/libsgl/views/SkOSFile.cpp @@ -0,0 +1,223 @@ +#include "SkOSFile.h" + +#ifdef SK_BUILD_FOR_WIN + +static U16* concat_to_16(const char src[], const char suffix[]) +{ + size_t i, len = strlen(src); + size_t len2 = 3 + (suffix ? strlen(suffix) : 0); + U16* dst = (U16*)sk_malloc_throw((len + len2) * sizeof(U16)); + + for (i = 0; i < len; i++) + dst[i] = src[i]; + + if (i > 0 && dst[i-1] != '/') + dst[i++] = '/'; + dst[i++] = '*'; + + if (suffix) + { + while (*suffix) + dst[i++] = *suffix++; + } + dst[i] = 0; + SkASSERT(i + 1 <= len + len2); + + return dst; +} + +SkUTF16_Str::SkUTF16_Str(const char src[]) +{ + size_t len = strlen(src); + + fStr = (U16*)sk_malloc_throw((len + 1) * sizeof(U16)); + for (size_t i = 0; i < len; i++) + fStr[i] = src[i]; + fStr[i] = 0; +} + +//////////////////////////////////////////////////////////////////////////// + +SkOSFile::Iter::Iter() : fHandle(0), fPath16(nil) +{ +} + +SkOSFile::Iter::Iter(const char path[], const char suffix[]) : fHandle(0), fPath16(nil) +{ + this->reset(path, suffix); +} + +SkOSFile::Iter::~Iter() +{ + sk_free(fPath16); + if (fHandle) + ::FindClose(fHandle); +} + +void SkOSFile::Iter::reset(const char path[], const char suffix[]) +{ + if (fHandle) + { + ::FindClose(fHandle); + fHandle = 0; + } + if (path == nil) + path = ""; + + sk_free(fPath16); + fPath16 = concat_to_16(path, suffix); +} + +static bool is_magic_dir(const U16 dir[]) +{ + // return true for "." and ".." + return dir[0] == '.' && (dir[1] == 0 || dir[1] == '.' && dir[2] == 0); +} + +static bool get_the_file(HANDLE handle, SkString* name, WIN32_FIND_DATAW* dataPtr, bool getDir) +{ + WIN32_FIND_DATAW data; + + if (dataPtr == nil) + { + if (::FindNextFileW(handle, &data)) + dataPtr = &data; + else + return false; + } + + for (;;) + { + if (getDir) + { + if ((dataPtr->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && !is_magic_dir(dataPtr->cFileName)) + break; + } + else + { + if (!(dataPtr->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) + break; + } + if (!::FindNextFileW(handle, dataPtr)) + return false; + } + // if we get here, we've found a file/dir + if (name) + name->setUTF16(dataPtr->cFileName); + return true; +} + +bool SkOSFile::Iter::next(SkString* name, bool getDir) +{ + WIN32_FIND_DATAW data; + WIN32_FIND_DATAW* dataPtr = nil; + + if (fHandle == 0) // our first time + { + if (fPath16 == nil || *fPath16 == 0) // check for no path + return false; + + fHandle = ::FindFirstFileW(fPath16, &data); + if (fHandle != 0 && fHandle != (HANDLE)~0) + dataPtr = &data; + } + return fHandle != (HANDLE)~0 && get_the_file(fHandle, name, dataPtr, getDir); +} + +#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX) + +#if 0 +OSStatus FSPathMakeRef ( + const UInt8 * path, + FSRef * ref, + Boolean * isDirectory +); +#endif + +SkOSFile::Iter::Iter() : fDIR(0) +{ +} + +SkOSFile::Iter::Iter(const char path[], const char suffix[]) : fDIR(0) +{ + this->reset(path, suffix); +} + +SkOSFile::Iter::~Iter() +{ + if (fDIR) + ::closedir(fDIR); +} + +void SkOSFile::Iter::reset(const char path[], const char suffix[]) +{ + if (fDIR) + { + ::closedir(fDIR); + fDIR = 0; + } + + fPath.set(path); + if (path) + { + fDIR = ::opendir(path); + fSuffix.set(suffix); + } + else + fSuffix.reset(); +} + +// returns true if suffix is empty, or if str ends with suffix +static bool issuffixfor(const SkString& suffix, const char str[]) +{ + size_t suffixLen = suffix.size(); + size_t strLen = strlen(str); + + return strLen >= suffixLen && + suffixLen == 0 || + memcmp(suffix.c_str(), str + strLen - suffixLen, suffixLen) == 0; +} + +#include <sys/stat.h> + +bool SkOSFile::Iter::next(SkString* name, bool getDir) +{ + if (fDIR) + { + dirent* entry; + + while ((entry = ::readdir(fDIR)) != NULL) + { + struct stat s; + SkString str(fPath); + + if (!str.endsWith("/") && !str.endsWith("\\")) + str.append("/"); + str.append(entry->d_name); + + if (0 == stat(str.c_str(), &s)) + { + if (getDir) + { + if (s.st_mode & S_IFDIR) + break; + } + else + { + if (!(s.st_mode & S_IFDIR) && issuffixfor(fSuffix, entry->d_name)) + break; + } + } + } + if (entry) // we broke out with a file + { + if (name) + name->set(entry->d_name); + return true; + } + } + return false; +} + +#endif + diff --git a/libsgl/views/SkOSMenu.cpp b/libsgl/views/SkOSMenu.cpp new file mode 100644 index 0000000..3760ddd --- /dev/null +++ b/libsgl/views/SkOSMenu.cpp @@ -0,0 +1,53 @@ +#include "SkOSMenu.h" + +static int gOSMenuCmd = 7000; + +SkOSMenu::SkOSMenu(const char title[]) +{ + fTitle = title; +} + +SkOSMenu::~SkOSMenu() +{ +} + +int SkOSMenu::countItems() const +{ + return fItems.count(); +} + +void SkOSMenu::appendItem(const char title[], const char eventType[], int32_t eventData) +{ + Item* item = fItems.append(); + + item->fTitle = title; + item->fEventType = eventType; + item->fEventData = eventData; + item->fOSCmd = ++gOSMenuCmd; +} + +SkEvent* SkOSMenu::createEvent(uint32_t os_cmd) +{ + const Item* iter = fItems.begin(); + const Item* stop = fItems.end(); + + while (iter < stop) + { + if (iter->fOSCmd == os_cmd) + { + SkEvent* evt = new SkEvent(iter->fEventType); + evt->setFast32(iter->fEventData); + return evt; + } + iter++; + } + return NULL; +} + +const char* SkOSMenu::getItem(int index, uint32_t* cmdID) const +{ + if (cmdID) + *cmdID = fItems[index].fOSCmd; + return fItems[index].fTitle; +} + diff --git a/libsgl/views/SkOSSound.cpp b/libsgl/views/SkOSSound.cpp new file mode 100644 index 0000000..13cd037 --- /dev/null +++ b/libsgl/views/SkOSSound.cpp @@ -0,0 +1,343 @@ +#include "SkOSSound.h" + +#ifdef SK_BUILD_FOR_WIN + +////////////////////////////////////////////////////////////////////// +// Construction/Destruction +////////////////////////////////////////////////////////////////////// + +#include <Mmreg.h> +#if defined _WIN32 && _MSC_VER >= 1300 // disable nameless struct/union +#pragma warning ( push ) +#pragma warning ( disable : 4201 ) +#endif +#include <Mmsystem.h> +#if defined _WIN32 && _MSC_VER >= 1300 +#pragma warning ( pop ) +#endif +#include <stdio.h> + +class CWaveFile { +public: + BOOL Open(const char path[]); + void Close(); + + long Read(char* pData, long nLength); + + long GetLength() const {return m_nLength;} + WAVEFORMATEX* GetWaveFormat() {return (&m_Format);} + +protected: + FILE* m_pFile; + long m_nLength; + WAVEFORMATEX m_Format; + +private: + enum { + WF_OFFSET_FORMATTAG = 20, + WF_OFFSET_CHANNELS = 22, + WF_OFFSET_SAMPLESPERSEC = 24, + WF_OFFSET_AVGBYTESPERSEC = 28, + WF_OFFSET_BLOCKALIGN = 32, + WF_OFFSET_BITSPERSAMPLE = 34, + WF_OFFSET_DATASIZE = 40, + WF_OFFSET_DATA = 44, + WF_HEADER_SIZE = WF_OFFSET_DATA + }; +}; + +BOOL CWaveFile::Open(const char path[]) +{ + BYTE aHeader[WF_HEADER_SIZE]; + +/* hResInfo = FindResource (hInst, lpName, "WAVE"); + + if (hResInfo == NULL) + return FALSE; + + // Load the wave resource. + hRes = LoadResource (hInst, hResInfo); + + if (hRes == NULL) + return FALSE; + + // Lock the wave resource and play it. + lpRes = LockResource (0); +*/ + + + // open file +// m_pFile = _tfopen(szFileName, TEXT("rb")); + m_pFile = fopen(path, "rb"); + if (!m_pFile) { + return FALSE; + } + + // set file length + fseek(m_pFile, 0, SEEK_END); + m_nLength = ftell(m_pFile) - WF_HEADER_SIZE; + + // set the format attribute members + fseek(m_pFile, 0, SEEK_SET); + fread(aHeader, 1, WF_HEADER_SIZE, m_pFile); + m_Format.wFormatTag = *((WORD*) (aHeader + WF_OFFSET_FORMATTAG)); + m_Format.nChannels = *((WORD*) (aHeader + WF_OFFSET_CHANNELS)); + m_Format.nSamplesPerSec = *((DWORD*) (aHeader + WF_OFFSET_SAMPLESPERSEC)); + m_Format.nAvgBytesPerSec = *((DWORD*) (aHeader + WF_OFFSET_AVGBYTESPERSEC)); + m_Format.nBlockAlign = *((WORD*) (aHeader + WF_OFFSET_BLOCKALIGN)); + m_Format.wBitsPerSample = *((WORD*) (aHeader + WF_OFFSET_BITSPERSAMPLE)); + + return TRUE; +} + +void CWaveFile::Close() +{ + fclose(m_pFile); +} + +long CWaveFile::Read(char* pData, long nLength) +{ + return fread(pData, 1, nLength, m_pFile); +} + +//////////////////////////////////////////////////////////////////////////////////////// + +struct SkOSSoundWave { + HWAVEOUT hwo; + WAVEHDR whdr; + DWORD dwOldVolume; + CWaveFile waveFile; + HANDLE hDoneEvent; +}; + +static SkOSSoundWave gWave; +static bool gWavePaused; +static U8 gVolume; +static bool gInited = false; + +static void init_wave() +{ + if (gInited == false) + { + gWave.hwo = nil; + gWavePaused = false; + gVolume = 0x80; + gInited = true; + } +} + +MMRESULT StartWave(const char path[], SkOSSoundWave* wave, U32 vol); +MMRESULT EndWave(SkOSSoundWave* wave); + +#define MAX_ERRMSG 256 + +//#include "SkOSFile.h" // for utf16 + +void SkOSSound::Play(const char path[]) +{ + init_wave(); + + if (gWave.hwo != nil) + SkOSSound::Stop(); + + U32 v32 = (gVolume << 8) | gVolume; // fill it out to 16bits + v32 |= v32 << 16; // set the left and right channels + + StartWave(path, &gWave, v32); + gWavePaused = false; +} + +bool SkOSSound::TogglePause() +{ + init_wave(); + + if (gWavePaused) + SkOSSound::Resume(); + else + SkOSSound::Pause(); + return !gWavePaused; +} + + +void SkOSSound::Pause() +{ + init_wave(); + + if (gWave.hwo == nil || (gWave.whdr.dwFlags & WHDR_DONE)) + return; + waveOutPause(gWave.hwo); + gWavePaused = true; +} + +void SkOSSound::Resume() +{ + init_wave(); + + if (gWave.hwo == nil || (gWave.whdr.dwFlags & WHDR_DONE)) + return; + waveOutRestart(gWave.hwo); + gWavePaused = false; +} + +void SkOSSound::Stop() +{ + init_wave(); + +// if (gWave.hwo == nil || (gWave.whdr.dwFlags & WHDR_DONE)) + if (gWave.hwo == nil) + return; + waveOutReset(gWave.hwo); + EndWave(&gWave); + gWavePaused = false; + gWave.hwo = nil; +} + +U8 SkOSSound::GetVolume() +{ + init_wave(); + return gVolume; +} + +void SkOSSound::SetVolume(U8CPU vol) +{ + if ((int)vol < 0) + vol = 0; + else if (vol > 255) + vol = 255; + + init_wave(); + gVolume = SkToU8(vol); + + if (gWave.hwo) + { + unsigned long v32 = (vol << 8) | vol; // fill it out to 16bits + v32 |= v32 << 16; // set the left and right channels + waveOutSetVolume(gWave.hwo, v32); + } +} + +#if 0 +unsigned long SoundManager::GetPosition() +{ + if (fWave.hwo == nil) + return 0; + MMTIME time; + time.wType = TIME_MS; + if (waveOutGetPosition(fWave.hwo, &time, sizeof(time)) == MMSYSERR_NOERROR && + time.wType == TIME_MS) + { + return time.u.ms; + } + return 0; +} +#endif + +MMRESULT StartWave(const char path[], SkOSSoundWave* wave, U32 vol) +{ + HWAVEOUT hwo = nil; +// WAVEHDR whdr; + MMRESULT mmres = 0; +// CWaveFile waveFile; +// HANDLE hDoneEvent = wave.hDoneEvent = +// CreateEvent(NULL, FALSE, FALSE, TEXT("DONE_EVENT")); + UINT devId; +// DWORD dwOldVolume; + + // Open wave file + if (!wave->waveFile.Open(path)) { +// TCHAR szErrMsg[MAX_ERRMSG]; +// _stprintf(szErrMsg, TEXT("Unable to open file: %s\n"), szWavFile); +// MessageBox(NULL, szErrMsg, TEXT("File I/O Error"), MB_OK); + return MMSYSERR_NOERROR; + } + + // Open audio device + for (devId = 0; devId < waveOutGetNumDevs(); devId++) + { + mmres = waveOutOpen(&hwo, devId, wave->waveFile.GetWaveFormat(), 0, 0, CALLBACK_NULL); + if (mmres == MMSYSERR_NOERROR) + { + wave->hwo = hwo; + break; + } + } + if (mmres != MMSYSERR_NOERROR) + { + SkDEBUGCODE(SkDebugf("waveOutOpen(%s) -> %d\n", path, mmres);) + return mmres; + } + + // Set volume + mmres = waveOutGetVolume(hwo, &wave->dwOldVolume); + if (mmres != MMSYSERR_NOERROR) { + return mmres; + } + + waveOutSetVolume(hwo, vol); + if (mmres != MMSYSERR_NOERROR) { + return mmres; + } + + // Initialize wave header + ZeroMemory(&wave->whdr, sizeof(WAVEHDR)); + wave->whdr.lpData = new char[wave->waveFile.GetLength()]; + wave->whdr.dwBufferLength = wave->waveFile.GetLength(); + wave->whdr.dwUser = 0; + wave->whdr.dwFlags = 0; + wave->whdr.dwLoops = 0; + wave->whdr.dwBytesRecorded = 0; + wave->whdr.lpNext = 0; + wave->whdr.reserved = 0; + + // Play buffer + wave->waveFile.Read(wave->whdr.lpData, wave->whdr.dwBufferLength); + + mmres = waveOutPrepareHeader(hwo, &wave->whdr, sizeof(WAVEHDR)); + if (mmres != MMSYSERR_NOERROR) { + return mmres; + } + + mmres = waveOutWrite(hwo, &wave->whdr, sizeof(WAVEHDR)); +// if (mmres != MMSYSERR_NOERROR) { + return mmres; +// } +} + +#if 0 +void IdleWave(Wave& wave) +{ + // Wait for audio to finish playing + while (!(wave.whdr.dwFlags & WHDR_DONE)) { + WaitForSingleObject(wave.hDoneEvent, INFINITE); + } +} +#endif + +MMRESULT EndWave(SkOSSoundWave* wave) +{ + HWAVEOUT hwo = wave->hwo; + MMRESULT mmres; + // Clean up + mmres = waveOutUnprepareHeader(hwo, &wave->whdr, sizeof(WAVEHDR)); + if (mmres != MMSYSERR_NOERROR) { + return mmres; + } + + waveOutSetVolume(hwo, wave->dwOldVolume); + if (mmres != MMSYSERR_NOERROR) { + return mmres; + } + + mmres = waveOutClose(hwo); + if (mmres != MMSYSERR_NOERROR) { + return mmres; + } + + delete [] wave->whdr.lpData; + wave->waveFile.Close(); + + return MMSYSERR_NOERROR; +} + +#endif /* SK_BUILD_FOR_WIN */ + diff --git a/libsgl/views/SkParsePaint.cpp b/libsgl/views/SkParsePaint.cpp new file mode 100644 index 0000000..7bf0244 --- /dev/null +++ b/libsgl/views/SkParsePaint.cpp @@ -0,0 +1,103 @@ +#include "SkParsePaint.h" +#include "SkTSearch.h" +#include "SkParse.h" +#include "SkImageDecoder.h" +#include "SkGradientShader.h" + +static SkShader* inflate_shader(const SkDOM& dom, const SkDOM::Node* node) +{ + if ((node = dom.getFirstChild(node, "shader")) == nil) + return nil; + + const char* str; + + if (dom.hasAttr(node, "type", "linear-gradient")) + { + SkColor colors[2]; + SkPoint pts[2]; + + colors[0] = colors[1] = SK_ColorBLACK; // need to initialized the alpha to opaque, since FindColor doesn't set it + if ((str = dom.findAttr(node, "c0")) != nil && + SkParse::FindColor(str, &colors[0]) && + (str = dom.findAttr(node, "c1")) != nil && + SkParse::FindColor(str, &colors[1]) && + dom.findScalars(node, "p0", &pts[0].fX, 2) && + dom.findScalars(node, "p1", &pts[1].fX, 2)) + { + SkShader::TileMode mode = SkShader::kClamp_TileMode; + int index; + + if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0) + mode = (SkShader::TileMode)index; + return SkGradientShader::CreateLinear(pts, colors, nil, 2, mode); + } + } + else if (dom.hasAttr(node, "type", "bitmap")) + { + if ((str = dom.findAttr(node, "src")) == nil) + return nil; + + SkBitmap bm; + + if (SkImageDecoder::DecodeFile(str, &bm)) + { + SkShader::TileMode mode = SkShader::kRepeat_TileMode; + int index; + + if ((index = dom.findList(node, "tile-mode", "clamp,repeat,mirror")) >= 0) + mode = (SkShader::TileMode)index; + + return SkShader::CreateBitmapShader(bm, mode, mode); + } + } + return nil; +} + +void SkPaint_Inflate(SkPaint* paint, const SkDOM& dom, const SkDOM::Node* node) +{ + SkASSERT(paint); + SkASSERT(&dom); + SkASSERT(node); + + SkScalar x; + + if (dom.findScalar(node, "stroke-width", &x)) + paint->setStrokeWidth(x); + if (dom.findScalar(node, "text-size", &x)) + paint->setTextSize(x); + + bool b; + + SkASSERT("legacy: use is-stroke" && !dom.findBool(node, "is-frame", &b)); + + if (dom.findBool(node, "is-stroke", &b)) + paint->setStyle(b ? SkPaint::kStroke_Style : SkPaint::kFill_Style); + if (dom.findBool(node, "is-antialias", &b)) + paint->setAntiAlias(b); + if (dom.findBool(node, "is-lineartext", &b)) + paint->setLinearText(b); + + const char* str = dom.findAttr(node, "color"); + if (str) + { + SkColor c = paint->getColor(); + if (SkParse::FindColor(str, &c)) + paint->setColor(c); + } + + // do this AFTER parsing for the color + if (dom.findScalar(node, "opacity", &x)) + { + x = SkMaxScalar(0, SkMinScalar(x, SK_Scalar1)); + paint->setAlpha(SkScalarRound(x * 255)); + } + + int index = dom.findList(node, "text-anchor", "left,center,right"); + if (index >= 0) + paint->setTextAlign((SkPaint::Align)index); + + SkShader* shader = inflate_shader(dom, node); + if (shader) + paint->setShader(shader)->unref(); +} + diff --git a/libsgl/views/SkProgressBarView.cpp b/libsgl/views/SkProgressBarView.cpp new file mode 100644 index 0000000..21349a5 --- /dev/null +++ b/libsgl/views/SkProgressBarView.cpp @@ -0,0 +1,102 @@ +#include "SkProgressBarView.h" +#include "SkAnimator.h" +#include "SkWidgetViews.h" +#include "SkTime.h" +#include "SkSystemEventTypes.h" + +SkProgressBarView::SkProgressBarView() +{ + init_skin_anim(kProgress_SkinEnum, &fAnim); + fAnim.setHostEventSink(this); + fProgress = 0; + fMax = 100; + +} + +void SkProgressBarView::changeProgress(int diff) +{ + int newProg = fProgress + diff; + if (newProg > 0 && newProg < fMax) + this->setProgress(newProg); + //otherwise i'll just leave it as it is + //this implies that if a new max and progress are set, max must be set first +} + +/*virtual*/ void SkProgressBarView::onDraw(SkCanvas* canvas) +{ + SkPaint paint; + SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs()); + + if (diff == SkAnimator::kDifferent) + this->inval(nil); + else if (diff == SkAnimator::kPartiallyDifferent) + { + SkRect bounds; + fAnim.getInvalBounds(&bounds); + this->inval(&bounds); + } +} + +/*virtual*/ bool SkProgressBarView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Inval)) + { + this->inval(nil); + return true; + } + if (evt.isType("recommendDim")) + { + SkScalar height; + + if (evt.findScalar("y", &height)) + this->setHeight(height); + return true; + } + return this->INHERITED::onEvent(evt); +} + +/*virtual*/ void SkProgressBarView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + int32_t temp; + if (dom.findS32(node, "max", &temp)) + this->setMax(temp); + if (dom.findS32(node, "progress", &temp)) + this->setProgress(temp); +} + +/*virtual*/ void SkProgressBarView::onSizeChange() +{ + this->INHERITED::onSizeChange(); + SkEvent evt("user"); + evt.setString("id", "setDim"); + evt.setScalar("dimX", this->width()); + evt.setScalar("dimY", this->height()); + fAnim.doUserEvent(evt); +} + +void SkProgressBarView::reset() +{ + fProgress = 0; + SkEvent e("user"); + e.setString("id", "reset"); + fAnim.doUserEvent(e); +} + +void SkProgressBarView::setMax(int max) +{ + fMax = max; + SkEvent e("user"); + e.setString("id", "setMax"); + e.setS32("newMax", max); + fAnim.doUserEvent(e); +} + +void SkProgressBarView::setProgress(int progress) +{ + fProgress = progress; + SkEvent e("user"); + e.setString("id", "setProgress"); + e.setS32("newProgress", progress); + fAnim.doUserEvent(e); +} diff --git a/libsgl/views/SkProgressView.cpp b/libsgl/views/SkProgressView.cpp new file mode 100644 index 0000000..a34c284 --- /dev/null +++ b/libsgl/views/SkProgressView.cpp @@ -0,0 +1,125 @@ +#include "SkWidget.h" +#include "SkCanvas.h" +#include "SkShader.h" +#include "SkInterpolator.h" +#include "SkTime.h" + +SkProgressView::SkProgressView(uint32_t flags) : SkView(flags), fOnShader(NULL), fOffShader(NULL) +{ + fValue = 0; + fMax = 0; + fInterp = NULL; + fDoInterp = false; +} + +SkProgressView::~SkProgressView() +{ + delete fInterp; + fOnShader->safeUnref(); + fOffShader->safeUnref(); +} + +void SkProgressView::setMax(U16CPU max) +{ + if (fMax != max) + { + fMax = SkToU16(max); + if (fValue > 0) + this->inval(NULL); + } +} + +void SkProgressView::setValue(U16CPU value) +{ + if (fValue != value) + { + if (fDoInterp) + { + if (fInterp) + delete fInterp; + fInterp = new SkInterpolator(1, 2); + SkScalar x = (SkScalar)(fValue << 8); + fInterp->setKeyFrame(0, SkTime::GetMSecs(), &x, 0); + x = (SkScalar)(value << 8); + fInterp->setKeyFrame(1, SkTime::GetMSecs() + 333, &x); + } + fValue = SkToU16(value); + this->inval(NULL); + } +} + +void SkProgressView::onDraw(SkCanvas* canvas) +{ + if (fMax == 0) + return; + + SkFixed percent; + + if (fInterp) + { + SkScalar x; + if (fInterp->timeToValues(SkTime::GetMSecs(), &x) == SkInterpolator::kFreezeEnd_Result) + { + delete fInterp; + fInterp = NULL; + } + percent = (SkFixed)x; // now its 16.8 + percent = SkMax32(0, SkMin32(percent, fMax << 8)); // now its pinned + percent = SkFixedDiv(percent, fMax << 8); // now its 0.16 + this->inval(NULL); + } + else + { + U16CPU value = SkMax32(0, SkMin32(fValue, fMax)); + percent = SkFixedDiv(value, fMax); + } + + + SkRect r; + SkPaint p; + + r.set(0, 0, this->width(), this->height()); + p.setAntiAlias(true); + + r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent)); + p.setStyle(SkPaint::kFill_Style); + + p.setColor(SK_ColorDKGRAY); + p.setShader(fOnShader); + canvas->drawRect(r, p); + + p.setColor(SK_ColorWHITE); + p.setShader(fOffShader); + r.fLeft = r.fRight; + r.fRight = this->width() - SK_Scalar1; + if (r.width() > 0) + canvas->drawRect(r, p); +} + +#include "SkImageDecoder.h" + +static SkShader* inflate_shader(const char file[]) +{ + SkBitmap bm; + + return SkImageDecoder::DecodeFile(file, &bm) ? + SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode) : + NULL; +} + +void SkProgressView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + const char* s; + + SkASSERT(fOnShader == NULL); + SkASSERT(fOffShader == NULL); + + if ((s = dom.findAttr(node, "src-on")) != NULL) + fOnShader = inflate_shader(s); + if ((s = dom.findAttr(node, "src-off")) != NULL) + fOffShader = inflate_shader(s); + (void)dom.findBool(node, "do-interp", &fDoInterp); +} + diff --git a/libsgl/views/SkScrollBarView.cpp b/libsgl/views/SkScrollBarView.cpp new file mode 100644 index 0000000..2e087bd --- /dev/null +++ b/libsgl/views/SkScrollBarView.cpp @@ -0,0 +1,139 @@ +#include "SkScrollBarView.h" +#include "SkAnimator.h" +#include "SkWidgetViews.h" +#include "SkSystemEventTypes.h" +#include "SkTime.h" + +//see SkProgressBarView.cpp +//#include "SkWidgetViews.cpp" + +SkScrollBarView::SkScrollBarView() +{ + fAnim.setHostEventSink(this); + init_skin_anim(kScroll_SkinEnum, &fAnim); + + fTotalLength = 0; + fStartPoint = 0; + fShownLength = 0; + + this->adjust(); +} + +void SkScrollBarView::setStart(unsigned start) +{ + if ((int)start < 0) + start = 0; + + if (fStartPoint != start) + { + fStartPoint = start; + this->adjust(); + } +} + +void SkScrollBarView::setShown(unsigned shown) +{ + if ((int)shown < 0) + shown = 0; + + if (fShownLength != shown) + { + fShownLength = shown; + this->adjust(); + } +} + +void SkScrollBarView::setTotal(unsigned total) +{ + if ((int)total < 0) + total = 0; + + if (fTotalLength != total) + { + fTotalLength = total; + this->adjust(); + } +} + +/* virtual */ void SkScrollBarView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + int32_t value; + if (dom.findS32(node, "total", &value)) + this->setTotal(value); + if (dom.findS32(node, "shown", &value)) + this->setShown(value); +} + +/*virtual*/ void SkScrollBarView::onSizeChange() +{ + this->INHERITED::onSizeChange(); + SkEvent evt("user"); + evt.setString("id", "setDim"); + evt.setScalar("dimX", this->width()); + evt.setScalar("dimY", this->height()); + fAnim.doUserEvent(evt); +} + +/*virtual*/ void SkScrollBarView::onDraw(SkCanvas* canvas) +{ + SkPaint paint; + SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs()); + + if (diff == SkAnimator::kDifferent) + this->inval(NULL); + else if (diff == SkAnimator::kPartiallyDifferent) + { + SkRect bounds; + fAnim.getInvalBounds(&bounds); + this->inval(&bounds); + } +} + +/*virtual*/ bool SkScrollBarView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Inval)) + { + this->inval(NULL); + return true; + } + if (evt.isType("recommendDim")) + { + SkScalar width; + + if (evt.findScalar("x", &width)) + this->setWidth(width); + return true; + } + + return this->INHERITED::onEvent(evt); +} + +void SkScrollBarView::adjust() +{ + int total = fTotalLength; + int start = fStartPoint; + int shown = fShownLength; + int hideBar = 0; + + if (total <= 0 || shown <= 0 || shown >= total) // no bar to show + { + total = 1; // avoid divide-by-zero. should be done by skin/script + hideBar = 1; // signal we don't want a thumb + } + else + { + if (start + shown > total) + start = total - shown; + } + + SkEvent e("user"); + e.setString("id", "adjustScrollBar"); + e.setScalar("_totalLength", SkIntToScalar(total)); + e.setScalar("_startPoint", SkIntToScalar(start)); + e.setScalar("_shownLength", SkIntToScalar(shown)); +// e.setS32("hideBar", hideBar); + fAnim.doUserEvent(e); +} + diff --git a/libsgl/views/SkStackViewLayout.cpp b/libsgl/views/SkStackViewLayout.cpp new file mode 100644 index 0000000..ae2e9e8 --- /dev/null +++ b/libsgl/views/SkStackViewLayout.cpp @@ -0,0 +1,262 @@ +#include "SkStackViewLayout.h" + +SkStackViewLayout::SkStackViewLayout() +{ + fMargin.set(0, 0, 0, 0); + fSpacer = 0; + fOrient = kHorizontal_Orient; + fPack = kStart_Pack; + fAlign = kStart_Align; + fRound = false; +} + +void SkStackViewLayout::setOrient(Orient ori) +{ + SkASSERT((unsigned)ori < kOrientCount); + fOrient = SkToU8(ori); +} + +void SkStackViewLayout::getMargin(SkRect* margin) const +{ + if (margin) + *margin = fMargin; +} + +void SkStackViewLayout::setMargin(const SkRect& margin) +{ + fMargin = margin; +} + +void SkStackViewLayout::setSpacer(SkScalar spacer) +{ + fSpacer = spacer; +} + +void SkStackViewLayout::setPack(Pack pack) +{ + SkASSERT((unsigned)pack < kPackCount); + fPack = SkToU8(pack); +} + +void SkStackViewLayout::setAlign(Align align) +{ + SkASSERT((unsigned)align < kAlignCount); + fAlign = SkToU8(align); +} + +void SkStackViewLayout::setRound(bool r) +{ + fRound = SkToU8(r); +} + +//////////////////////////////////////////////////////////////////////////////// + +typedef SkScalar (*AlignProc)(SkScalar childLimit, SkScalar parentLimit); +typedef SkScalar (SkView::*GetSizeProc)() const; +typedef void (SkView::*SetLocProc)(SkScalar coord); +typedef void (SkView::*SetSizeProc)(SkScalar coord); + +static SkScalar left_align_proc(SkScalar childLimit, SkScalar parentLimit) { return 0; } +static SkScalar center_align_proc(SkScalar childLimit, SkScalar parentLimit) { return SkScalarHalf(parentLimit - childLimit); } +static SkScalar right_align_proc(SkScalar childLimit, SkScalar parentLimit) { return parentLimit - childLimit; } +static SkScalar fill_align_proc(SkScalar childLimit, SkScalar parentLimit) { return 0; } + +/* Measure the main-dimension for all the children. If a child is marked flex in that direction + ignore its current value but increment the counter for flexChildren +*/ +static SkScalar compute_children_limit(SkView* parent, GetSizeProc sizeProc, int* count, + uint32_t flexMask, int* flexCount) +{ + SkView::B2FIter iter(parent); + SkView* child; + SkScalar limit = 0; + int n = 0, flex = 0; + + while ((child = iter.next()) != NULL) + { + n += 1; + if (child->getFlags() & flexMask) + flex += 1; + else + limit += (child->*sizeProc)(); + } + if (count) + *count = n; + if (flexCount) + *flexCount = flex; + return limit; +} + +void SkStackViewLayout::onLayoutChildren(SkView* parent) +{ + static AlignProc gAlignProcs[] = { + left_align_proc, + center_align_proc, + right_align_proc, + fill_align_proc + }; + + SkScalar startM, endM, crossStartM, crossLimit; + GetSizeProc mainGetSizeP, crossGetSizeP; + SetLocProc mainLocP, crossLocP; + SetSizeProc mainSetSizeP, crossSetSizeP; + SkView::Flag_Mask flexMask; + + if (fOrient == kHorizontal_Orient) + { + startM = fMargin.fLeft; + endM = fMargin.fRight; + crossStartM = fMargin.fTop; + crossLimit = -fMargin.fTop - fMargin.fBottom; + + mainGetSizeP = &SkView::width; + crossGetSizeP = &SkView::height; + mainLocP = &SkView::setLocX; + crossLocP = &SkView::setLocY; + + mainSetSizeP = &SkView::setWidth; + crossSetSizeP = &SkView::setHeight; + + flexMask = SkView::kFlexH_Mask; + } + else + { + startM = fMargin.fTop; + endM = fMargin.fBottom; + crossStartM = fMargin.fLeft; + crossLimit = -fMargin.fLeft - fMargin.fRight; + + mainGetSizeP = &SkView::height; + crossGetSizeP = &SkView::width; + mainLocP = &SkView::setLocY; + crossLocP = &SkView::setLocX; + + mainSetSizeP = &SkView::setHeight; + crossSetSizeP = &SkView::setWidth; + + flexMask = SkView::kFlexV_Mask; + } + crossLimit += (parent->*crossGetSizeP)(); + if (fAlign != kStretch_Align) + crossSetSizeP = NULL; + + int childCount, flexCount; + SkScalar childLimit = compute_children_limit(parent, mainGetSizeP, &childCount, flexMask, &flexCount); + + if (childCount == 0) + return; + + childLimit += (childCount - 1) * fSpacer; + + SkScalar parentLimit = (parent->*mainGetSizeP)() - startM - endM; + SkScalar pos = startM + gAlignProcs[fPack](childLimit, parentLimit); + SkScalar flexAmount = 0; + SkView::B2FIter iter(parent); + SkView* child; + + if (flexCount > 0 && parentLimit > childLimit) + flexAmount = (parentLimit - childLimit) / flexCount; + + while ((child = iter.next()) != NULL) + { + if (fRound) + pos = SkIntToScalar(SkScalarRound(pos)); + (child->*mainLocP)(pos); + SkScalar crossLoc = crossStartM + gAlignProcs[fAlign]((child->*crossGetSizeP)(), crossLimit); + if (fRound) + crossLoc = SkIntToScalar(SkScalarRound(crossLoc)); + (child->*crossLocP)(crossLoc); + + if (crossSetSizeP) + (child->*crossSetSizeP)(crossLimit); + if (child->getFlags() & flexMask) + (child->*mainSetSizeP)(flexAmount); + pos += (child->*mainGetSizeP)() + fSpacer; + } +} + +////////////////////////////////////////////////////////////////////////////////////// + +#ifdef SK_DEBUG + static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[]) + { + const char* value = dom.findAttr(node, attr); + if (value) + SkDebugf("unknown attribute %s=\"%s\"\n", attr, value); + } +#else + #define assert_no_attr(dom, node, attr) +#endif + +void SkStackViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + int index; + SkScalar value[4]; + + if ((index = dom.findList(node, "orient", "horizontal,vertical")) >= 0) + this->setOrient((Orient)index); + else + assert_no_attr(dom, node, "orient"); + + if (dom.findScalars(node, "margin", value, 4)) + { + SkRect margin; + margin.set(value[0], value[1], value[2], value[3]); + this->setMargin(margin); + } + else + assert_no_attr(dom, node, "margin"); + + if (dom.findScalar(node, "spacer", value)) + this->setSpacer(value[0]); + else + assert_no_attr(dom, node, "spacer"); + + if ((index = dom.findList(node, "pack", "start,center,end")) >= 0) + this->setPack((Pack)index); + else + assert_no_attr(dom, node, "pack"); + + if ((index = dom.findList(node, "align", "start,center,end,stretch")) >= 0) + this->setAlign((Align)index); + else + assert_no_attr(dom, node, "align"); +} + +/////////////////////////////////////////////////////////////////////////////////////////// + +SkFillViewLayout::SkFillViewLayout() +{ + fMargin.setEmpty(); +} + +void SkFillViewLayout::getMargin(SkRect* r) const +{ + if (r) + *r = fMargin; +} + +void SkFillViewLayout::setMargin(const SkRect& margin) +{ + fMargin = margin; +} + +void SkFillViewLayout::onLayoutChildren(SkView* parent) +{ + SkView::B2FIter iter(parent); + SkView* child; + + while ((child = iter.next()) != NULL) + { + child->setLoc(fMargin.fLeft, fMargin.fTop); + child->setSize( parent->width() - fMargin.fRight - fMargin.fLeft, + parent->height() - fMargin.fBottom - fMargin.fTop); + } +} + +void SkFillViewLayout::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + (void)dom.findScalars(node, "margin", (SkScalar*)&fMargin, 4); +} + diff --git a/libsgl/views/SkView.cpp b/libsgl/views/SkView.cpp new file mode 100644 index 0000000..a027744 --- /dev/null +++ b/libsgl/views/SkView.cpp @@ -0,0 +1,760 @@ +#include "SkView.h" +#include "SkCanvas.h" + +//////////////////////////////////////////////////////////////////////// + +SkView::SkView(uint32_t flags) : fFlags(SkToU8(flags)) +{ + fWidth = fHeight = 0; + fLoc.set(0, 0); + fParent = fFirstChild = fNextSibling = fPrevSibling = NULL; + + fContainsFocus = 0; +} + +SkView::~SkView() +{ + this->detachAllChildren(); +} + +void SkView::setFlags(uint32_t flags) +{ + SkASSERT((flags & ~kAllFlagMasks) == 0); + + uint32_t diff = fFlags ^ flags; + + if (diff & kVisible_Mask) + this->inval(NULL); + + fFlags = SkToU8(flags); + + if (diff & kVisible_Mask) + { + this->inval(NULL); + } +} + +void SkView::setVisibleP(bool pred) +{ + this->setFlags(SkSetClearShift(fFlags, pred, kVisible_Shift)); +} + +void SkView::setEnabledP(bool pred) +{ + this->setFlags(SkSetClearShift(fFlags, pred, kEnabled_Shift)); +} + +void SkView::setFocusableP(bool pred) +{ + this->setFlags(SkSetClearShift(fFlags, pred, kFocusable_Shift)); +} + +void SkView::setSize(SkScalar width, SkScalar height) +{ + width = SkMaxScalar(0, width); + height = SkMaxScalar(0, height); + + if (fWidth != width || fHeight != height) + { + this->inval(NULL); + fWidth = width; + fHeight = height; + this->inval(NULL); + this->onSizeChange(); + this->invokeLayout(); + } +} + +void SkView::setLoc(SkScalar x, SkScalar y) +{ + if (fLoc.fX != x || fLoc.fY != y) + { + this->inval(NULL); + fLoc.set(x, y); + this->inval(NULL); + } +} + +void SkView::offset(SkScalar dx, SkScalar dy) +{ + if (dx || dy) + this->setLoc(fLoc.fX + dx, fLoc.fY + dy); +} + +void SkView::draw(SkCanvas* canvas) +{ + if (fWidth && fHeight && this->isVisible()) + { + SkRect r; + r.set(fLoc.fX, fLoc.fY, fLoc.fX + fWidth, fLoc.fY + fHeight); + if (canvas->quickReject(r, SkCanvas::kBW_EdgeType)) + return; + + SkAutoCanvasRestore as(canvas, true); + + canvas->clipRect(r); + canvas->translate(fLoc.fX, fLoc.fY); + + this->onDraw(canvas); + + B2FIter iter(this); + SkView* child; + + SkCanvas* childCanvas = this->beforeChildren(canvas); + + while ((child = iter.next()) != NULL) + child->draw(childCanvas); + + this->afterChildren(canvas); + } +} + +void SkView::inval(SkRect* rect) +{ + if (!this->isVisible()) + return; + + SkRect bounds; + + this->getLocalBounds(&bounds); + if (rect && !bounds.intersect(*rect)) + return; + + rect = &bounds; + SkView* view = this; + + for (;;) + { + if (view->handleInval(bounds)) + break; + + SkRect parentR; + SkView* parent = view->fParent; + + if (parent == NULL || !parent->isVisible()) + break; + + bounds.offset(view->fLoc.fX, view->fLoc.fY); + parent->getLocalBounds(&parentR); + if (!bounds.intersect(parentR)) + return; + + view = parent; + } +} + +//////////////////////////////////////////////////////////////////////////// + +bool SkView::setFocusView(SkView* fv) +{ + SkView* view = this; + + do { + if (view->onSetFocusView(fv)) + return true; + } while ((view = view->fParent) != NULL); + return false; +} + +SkView* SkView::getFocusView() const +{ + SkView* focus = NULL; + const SkView* view = this; + do { + if (view->onGetFocusView(&focus)) + break; + } while ((view = view->fParent) != NULL); + return focus; +} + +bool SkView::hasFocus() const +{ + return this == this->getFocusView(); +} + +bool SkView::acceptFocus() +{ + return this->isFocusable() && this->setFocusView(this); +} + +/* + Try to give focus to this view, or its children +*/ +SkView* SkView::acceptFocus(FocusDirection dir) +{ + if (dir == kNext_FocusDirection) + { + if (this->acceptFocus()) + return this; + + B2FIter iter(this); + SkView* child, *focus; + while ((child = iter.next()) != NULL) + if ((focus = child->acceptFocus(dir)) != NULL) + return focus; + } + else // prev + { + F2BIter iter(this); + SkView* child, *focus; + while ((child = iter.next()) != NULL) + if ((focus = child->acceptFocus(dir)) != NULL) + return focus; + + if (this->acceptFocus()) + return this; + } + + return NULL; +} + +SkView* SkView::moveFocus(FocusDirection dir) +{ + SkView* focus = this->getFocusView(); + + if (focus == NULL) + { // start with the root + focus = this; + while (focus->fParent) + focus = focus->fParent; + } + + SkView* child, *parent; + + if (dir == kNext_FocusDirection) + { + parent = focus; + child = focus->fFirstChild; + if (child) + goto FIRST_CHILD; + else + goto NEXT_SIB; + + do { + while (child != parent->fFirstChild) + { + FIRST_CHILD: + if ((focus = child->acceptFocus(dir)) != NULL) + return focus; + child = child->fNextSibling; + } + NEXT_SIB: + child = parent->fNextSibling; + parent = parent->fParent; + } while (parent != NULL); + } + else // prevfocus + { + parent = focus->fParent; + if (parent == NULL) // we're the root + return focus->acceptFocus(dir); + else + { + child = focus; + while (parent) + { + while (child != parent->fFirstChild) + { + child = child->fPrevSibling; + if ((focus = child->acceptFocus(dir)) != NULL) + return focus; + } + if (parent->acceptFocus()) + return parent; + + child = parent; + parent = parent->fParent; + } + } + } + return NULL; +} + +void SkView::onFocusChange(bool gainFocusP) +{ + this->inval(NULL); +} + +//////////////////////////////////////////////////////////////////////////// + +SkView::Click::Click(SkView* target) +{ + SkASSERT(target); + fTargetID = target->getSinkID(); + fType = NULL; + fWeOwnTheType = false; +} + +SkView::Click::~Click() +{ + this->resetType(); +} + +void SkView::Click::resetType() +{ + if (fWeOwnTheType) + { + sk_free(fType); + fWeOwnTheType = false; + } + fType = NULL; +} + +bool SkView::Click::isType(const char type[]) const +{ + const char* t = fType; + + if (type == t) + return true; + + if (type == NULL) + type = ""; + if (t == NULL) + t = ""; + return !strcmp(t, type); +} + +void SkView::Click::setType(const char type[]) +{ + this->resetType(); + fType = (char*)type; +} + +void SkView::Click::copyType(const char type[]) +{ + if (fType != type) + { + this->resetType(); + if (type) + { + size_t len = strlen(type) + 1; + fType = (char*)sk_malloc_throw(len); + memcpy(fType, type, len); + fWeOwnTheType = true; + } + } +} + +SkView::Click* SkView::findClickHandler(SkScalar x, SkScalar y) +{ + if (x < 0 || y < 0 || x >= fWidth || y >= fHeight) + return false; + + F2BIter iter(this); + SkView* child; + + while ((child = iter.next()) != NULL) + { + Click* click = child->findClickHandler(x - child->fLoc.fX, y - child->fLoc.fY); + if (click) + return click; + } + return this->onFindClickHandler(x, y); +} + +void SkView::DoClickDown(Click* click, int x, int y) +{ + SkASSERT(click); + + SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID); + if (target == NULL) + return; + + click->fIOrig.set(x, y); + click->fICurr = click->fIPrev = click->fIOrig; + + click->fOrig.iset(x, y); + target->globalToLocal(&click->fOrig); + click->fPrev = click->fCurr = click->fOrig; + + click->fState = Click::kDown_State; + target->onClick(click); +} + +void SkView::DoClickMoved(Click* click, int x, int y) +{ + SkASSERT(click); + + SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID); + if (target == NULL) + return; + + click->fIPrev = click->fICurr; + click->fICurr.set(x, y); + + click->fPrev = click->fCurr; + click->fCurr.iset(x, y); + target->globalToLocal(&click->fCurr); + + click->fState = Click::kMoved_State; + target->onClick(click); +} + +void SkView::DoClickUp(Click* click, int x, int y) +{ + SkASSERT(click); + + SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID); + if (target == NULL) + return; + + click->fIPrev = click->fICurr; + click->fICurr.set(x, y); + + click->fPrev = click->fCurr; + click->fCurr.iset(x, y); + target->globalToLocal(&click->fCurr); + + click->fState = Click::kUp_State; + target->onClick(click); +} + +////////////////////////////////////////////////////////////////////// + +void SkView::invokeLayout() +{ + SkView::Layout* layout = this->getLayout(); + + if (layout) + layout->layoutChildren(this); +} + +void SkView::onDraw(SkCanvas* canvas) +{ + Artist* artist = this->getArtist(); + + if (artist) + artist->draw(this, canvas); +} + +void SkView::onSizeChange() +{ +} + +SkView::Click* SkView::onFindClickHandler(SkScalar x, SkScalar y) +{ + return NULL; +} + +bool SkView::onClick(Click*) +{ + return false; +} + +bool SkView::handleInval(const SkRect& r) +{ + return false; +} + +////////////////////////////////////////////////////////////////////// + +void SkView::getLocalBounds(SkRect* bounds) const +{ + if (bounds) + bounds->set(0, 0, fWidth, fHeight); +} + +////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////// + +void SkView::detachFromParent_NoLayout() +{ + if (fParent == NULL) + return; + + if (fContainsFocus) + (void)this->setFocusView(NULL); + + this->inval(NULL); + + SkView* next = NULL; + + if (fNextSibling != this) // do we have any siblings + { + fNextSibling->fPrevSibling = fPrevSibling; + fPrevSibling->fNextSibling = fNextSibling; + next = fNextSibling; + } + + if (fParent->fFirstChild == this) + fParent->fFirstChild = next; + + fParent = fNextSibling = fPrevSibling = NULL; + + this->unref(); +} + +void SkView::detachFromParent() +{ + SkView* parent = fParent; + + if (parent) + { + this->detachFromParent_NoLayout(); + parent->invokeLayout(); + } +} + +SkView* SkView::attachChildToBack(SkView* child) +{ + SkASSERT(child != this); + + if (child == NULL || fFirstChild == child) + goto DONE; + + child->ref(); + child->detachFromParent_NoLayout(); + + if (fFirstChild == NULL) + { + child->fNextSibling = child; + child->fPrevSibling = child; + } + else + { + child->fNextSibling = fFirstChild; + child->fPrevSibling = fFirstChild->fPrevSibling; + fFirstChild->fPrevSibling->fNextSibling = child; + fFirstChild->fPrevSibling = child; + } + + fFirstChild = child; + child->fParent = this; + child->inval(NULL); + + this->invokeLayout(); +DONE: + return child; +} + +SkView* SkView::attachChildToFront(SkView* child) +{ + SkASSERT(child != this); + + if (child == NULL || fFirstChild && fFirstChild->fPrevSibling == child) + goto DONE; + + child->ref(); + child->detachFromParent_NoLayout(); + + if (fFirstChild == NULL) + { + fFirstChild = child; + child->fNextSibling = child; + child->fPrevSibling = child; + } + else + { + child->fNextSibling = fFirstChild; + child->fPrevSibling = fFirstChild->fPrevSibling; + fFirstChild->fPrevSibling->fNextSibling = child; + fFirstChild->fPrevSibling = child; + } + + child->fParent = this; + child->inval(NULL); + + this->invokeLayout(); +DONE: + return child; +} + +void SkView::detachAllChildren() +{ + while (fFirstChild) + fFirstChild->detachFromParent_NoLayout(); +} + +void SkView::globalToLocal(SkScalar x, SkScalar y, SkPoint* local) const +{ + SkASSERT(this); + + if (local) + { + const SkView* view = this; + while (view) + { + x -= view->fLoc.fX; + y -= view->fLoc.fY; + view = view->fParent; + } + local->set(x, y); + } +} + +////////////////////////////////////////////////////////////////// + +/* Even if the subclass overrides onInflate, they should always be + sure to call the inherited method, so that we get called. +*/ +void SkView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + SkScalar x, y; + + x = this->locX(); + y = this->locY(); + (void)dom.findScalar(node, "x", &x); + (void)dom.findScalar(node, "y", &y); + this->setLoc(x, y); + + x = this->width(); + y = this->height(); + (void)dom.findScalar(node, "width", &x); + (void)dom.findScalar(node, "height", &y); + this->setSize(x, y); + + // inflate the flags + + static const char* gFlagNames[] = { + "visible", "enabled", "focusable", "flexH", "flexV" + }; + SkASSERT(SK_ARRAY_COUNT(gFlagNames) == kFlagShiftCount); + + bool b; + uint32_t flags = this->getFlags(); + for (unsigned i = 0; i < SK_ARRAY_COUNT(gFlagNames); i++) + if (dom.findBool(node, gFlagNames[i], &b)) + flags = SkSetClearShift(flags, b, i); + this->setFlags(flags); +} + +void SkView::inflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->onInflate(dom, node); +} + +void SkView::onPostInflate(const SkTDict<SkView*>&) +{ + // override in subclass as needed +} + +void SkView::postInflate(const SkTDict<SkView*>& dict) +{ + this->onPostInflate(dict); + + B2FIter iter(this); + SkView* child; + while ((child = iter.next()) != NULL) + child->postInflate(dict); +} + +////////////////////////////////////////////////////////////////// + +SkView* SkView::sendEventToParents(const SkEvent& evt) +{ + SkView* parent = fParent; + + while (parent) + { + if (parent->doEvent(evt)) + return parent; + parent = parent->fParent; + } + return NULL; +} + +////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////// + +SkView::F2BIter::F2BIter(const SkView* parent) +{ + fFirstChild = parent ? parent->fFirstChild : NULL; + fChild = fFirstChild ? fFirstChild->fPrevSibling : NULL; +} + +SkView* SkView::F2BIter::next() +{ + SkView* curr = fChild; + + if (fChild) + { + if (fChild == fFirstChild) + fChild = NULL; + else + fChild = fChild->fPrevSibling; + } + return curr; +} + +SkView::B2FIter::B2FIter(const SkView* parent) +{ + fFirstChild = parent ? parent->fFirstChild : NULL; + fChild = fFirstChild; +} + +SkView* SkView::B2FIter::next() +{ + SkView* curr = fChild; + + if (fChild) + { + SkView* next = fChild->fNextSibling; + if (next == fFirstChild) + next = NULL; + fChild = next; + } + return curr; +} + +////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////// + +#ifdef SK_DEBUG + +static inline void show_if_nonzero(const char name[], SkScalar value) +{ + if (value) + SkDebugf("%s=\"%g\"", name, value/65536.); +} + +static void tab(int level) +{ + for (int i = 0; i < level; i++) + SkDebugf(" "); +} + +static void dumpview(const SkView* view, int level, bool recurse) +{ + tab(level); + + SkDebugf("<view"); + show_if_nonzero(" x", view->locX()); + show_if_nonzero(" y", view->locY()); + show_if_nonzero(" width", view->width()); + show_if_nonzero(" height", view->height()); + + if (recurse) + { + SkView::B2FIter iter(view); + SkView* child; + bool noChildren = true; + + while ((child = iter.next()) != NULL) + { + if (noChildren) + SkDebugf(">\n"); + noChildren = false; + dumpview(child, level + 1, true); + } + + if (!noChildren) + { + tab(level); + SkDebugf("</view>\n"); + } + else + goto ONELINER; + } + else + { + ONELINER: + SkDebugf(" />\n"); + } +} + +void SkView::dump(bool recurse) const +{ + dumpview(this, 0, recurse); +} + +#endif diff --git a/libsgl/views/SkViewInflate.cpp b/libsgl/views/SkViewInflate.cpp new file mode 100644 index 0000000..8f5489d --- /dev/null +++ b/libsgl/views/SkViewInflate.cpp @@ -0,0 +1,139 @@ +#include "SkViewInflate.h" +#include "SkView.h" +#include <stdio.h> + +SkViewInflate::SkViewInflate() : fIDs(kMinIDStrAlloc), fStrings(kMinIDStrAlloc) +{ +} + +SkViewInflate::~SkViewInflate() +{ +} + +void SkViewInflate::rInflate(const SkDOM& dom, const SkDOM::Node* node, SkView* parent) +{ + const char* str = dom.findAttr(node, "id"); + if (str) + fIDs.set(str, parent); + + const SkDOM::Node* child = dom.getFirstChild(node); + while (child) + { + SkView* view = this->createView(dom, child); + if (view) + { + this->rInflate(dom, child, view); + parent->attachChildToFront(view)->unref(); + } + else + { + const char* name = dom.getName(child); + const char* target; + + if (!strcmp(name, "listenTo") && (target = dom.findAttr(child, "target")) != NULL) + this->addIDStr(&fListenTo, parent, target); + + if (!strcmp(name, "broadcastTo") && (target = dom.findAttr(child, "target")) != NULL) + this->addIDStr(&fBroadcastTo, parent, target); + } + child = dom.getNextSibling(child); + } + + parent->setVisibleP(true); + this->inflateView(parent, dom, node); +} + +void SkViewInflate::inflateView(SkView* view, const SkDOM& dom, const SkDOM::Node* node) +{ + // called after all of view's children have been instantiated. + // this may be overridden by a subclass, to load in layout or other helpers + // they should call through to us (INHERITED) before or after their patch + view->inflate(dom, node); +} + +SkView* SkViewInflate::inflate(const SkDOM& dom, const SkDOM::Node* node, SkView* root) +{ + fIDs.reset(); + + if (root == NULL) + { + root = this->createView(dom, node); + if (root == NULL) + { + printf("createView returned NULL on <%s>\n", dom.getName(node)); + return NULL; + } + } + this->rInflate(dom, node, root); + + // resolve listeners and broadcasters + { + SkView* target; + const IDStr* iter = fListenTo.begin(); + const IDStr* stop = fListenTo.end(); + for (; iter < stop; iter++) + { + if (fIDs.find(iter->fStr, &target)) + target->addListenerID(iter->fView->getSinkID()); + } + + iter = fBroadcastTo.begin(); + stop = fBroadcastTo.end(); + for (; iter < stop; iter++) + { + if (fIDs.find(iter->fStr, &target)) + iter->fView->addListenerID(target->getSinkID()); + } + } + + // now that the tree is built, give everyone a shot at the ID dict + root->postInflate(fIDs); + return root; +} + +SkView* SkViewInflate::inflate(const char xml[], size_t len, SkView* root) +{ + SkDOM dom; + const SkDOM::Node* node = dom.build(xml, len); + + return node ? this->inflate(dom, node, root) : NULL; +} + +SkView* SkViewInflate::findViewByID(const char id[]) const +{ + SkASSERT(id); + SkView* view; + return fIDs.find(id, &view) ? view : NULL; +} + +SkView* SkViewInflate::createView(const SkDOM& dom, const SkDOM::Node* node) +{ + if (!strcmp(dom.getName(node), "view")) + return new SkView; + return NULL; +} + +void SkViewInflate::addIDStr(SkTDArray<IDStr>* list, SkView* view, const char* str) +{ + size_t len = strlen(str) + 1; + IDStr* pair = list->append(); + pair->fView = view; + pair->fStr = (char*)fStrings.alloc(len, SkChunkAlloc::kThrow_AllocFailType); + memcpy(pair->fStr, str, len); +} + +#ifdef SK_DEBUG +void SkViewInflate::dump() const +{ + const IDStr* iter = fListenTo.begin(); + const IDStr* stop = fListenTo.end(); + for (; iter < stop; iter++) + SkDebugf("inflate: listenTo(\"%s\")\n", iter->fStr); + + iter = fBroadcastTo.begin(); + stop = fBroadcastTo.end(); + for (; iter < stop; iter++) + SkDebugf("inflate: broadcastFrom(\"%s\")\n", iter->fStr); +} +#endif + diff --git a/libsgl/views/SkViewPriv.cpp b/libsgl/views/SkViewPriv.cpp new file mode 100644 index 0000000..b03ca8c --- /dev/null +++ b/libsgl/views/SkViewPriv.cpp @@ -0,0 +1,97 @@ +#include "SkViewPriv.h" + +////////////////////////////////////////////////////////////////////// + +void SkView::Artist::draw(SkView* view, SkCanvas* canvas) +{ + SkASSERT(view && canvas); + this->onDraw(view, canvas); +} + +void SkView::Artist::inflate(const SkDOM& dom, const SkDOM::Node* node) +{ + SkASSERT(&dom && node); + this->onInflate(dom, node); +} + +void SkView::Artist::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + // subclass should override this as needed +} + +SkView::Artist* SkView::getArtist() const +{ + Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList); + SkASSERT(rec == NULL || rec->fArtist != NULL); + + return rec ? rec->fArtist : NULL; +} + +SkView::Artist* SkView::setArtist(Artist* obj) +{ + if (obj == NULL) + { + this->removeTagList(kViewArtist_SkTagList); + } + else // add/replace + { + Artist_SkTagList* rec = (Artist_SkTagList*)this->findTagList(kViewArtist_SkTagList); + + if (rec) + SkRefCnt_SafeAssign(rec->fArtist, obj); + else + this->addTagList(new Artist_SkTagList(obj)); + } + return obj; +} + +//////////////////////////////////////////////////////////////////////////////// + +void SkView::Layout::layoutChildren(SkView* parent) +{ + SkASSERT(parent); + if (parent->width() > 0 && parent->height() > 0) + this->onLayoutChildren(parent); +} + +void SkView::Layout::inflate(const SkDOM& dom, const SkDOM::Node* node) +{ + SkASSERT(&dom && node); + this->onInflate(dom, node); +} + +void SkView::Layout::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + // subclass should override this as needed +} + +SkView::Layout* SkView::getLayout() const +{ + Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList); + SkASSERT(rec == NULL || rec->fLayout != NULL); + + return rec ? rec->fLayout : NULL; +} + +SkView::Layout* SkView::setLayout(Layout* obj, bool invokeLayoutNow) +{ + if (obj == NULL) + { + this->removeTagList(kViewLayout_SkTagList); + } + else // add/replace + { + Layout_SkTagList* rec = (Layout_SkTagList*)this->findTagList(kViewLayout_SkTagList); + + if (rec) + SkRefCnt_SafeAssign(rec->fLayout, obj); + else + this->addTagList(new Layout_SkTagList(obj)); + } + + if (invokeLayoutNow) + this->invokeLayout(); + + return obj; +} + diff --git a/libsgl/views/SkViewPriv.h b/libsgl/views/SkViewPriv.h new file mode 100644 index 0000000..06ce59b --- /dev/null +++ b/libsgl/views/SkViewPriv.h @@ -0,0 +1,38 @@ +#ifndef SkViewPriv_DEFINED +#define SkViewPriv_DEFINED + +#include "SkView.h" +#include "SkTagList.h" + +struct Layout_SkTagList : SkTagList { + SkView::Layout* fLayout; + + Layout_SkTagList(SkView::Layout* layout) + : SkTagList(kViewLayout_SkTagList), fLayout(layout) + { + SkASSERT(layout); + layout->ref(); + } + virtual ~Layout_SkTagList() + { + fLayout->unref(); + } +}; + +struct Artist_SkTagList : SkTagList { + SkView::Artist* fArtist; + + Artist_SkTagList(SkView::Artist* artist) + : SkTagList(kViewArtist_SkTagList), fArtist(artist) + { + SkASSERT(artist); + artist->ref(); + } + virtual ~Artist_SkTagList() + { + fArtist->unref(); + } +}; + +#endif + diff --git a/libsgl/views/SkWidget.cpp b/libsgl/views/SkWidget.cpp new file mode 100644 index 0000000..8d945f1 --- /dev/null +++ b/libsgl/views/SkWidget.cpp @@ -0,0 +1,323 @@ +#include "SkWidget.h" +#include "SkCanvas.h" +#include "SkInterpolator.h" +#include "SkTime.h" +#include "SkParsePaint.h" + +#if 0 +SkWidgetView::SkWidgetView(U32 flags) : SkView(flags) +{ +} + +SkWidgetView::~SkWidgetView() +{ +} + +const char* SkWidgetView::GetEventType() +{ + return "SkWidgetView"; +} + +///////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + +class SkTextView::Interp { +public: + Interp(const SkString& old, SkMSec now, SkMSec dur, AnimaDir dir) : fOldText(old), fInterp(1, 2) + { + SkScalar x = 0; + fInterp.setKeyFrame(0, now, &x, 0); + x = SK_Scalar1; + if (dir == kBackward_AnimDir) + x = -x; + fInterp.setKeyFrame(1, now + dur, &x); + } + bool draw(SkCanvas* canvas, const SkString& newText, SkScalar x, SkScalar y, SkPaint& paint) + { + SkScalar scale; + + if (fInterp.timeToValues(SkTime::GetMSecs(), &scale) == SkInterpolator::kFreezeEnd_Result) + { + canvas->drawText(newText.c_str(), newText.size(), x, y, paint); + return false; + } + else + { + U8 alpha = paint.getAlpha(); + SkScalar above, below; + (void)paint.measureText(nil, 0, &above, &below); + SkScalar height = below - above; + SkScalar dy = SkScalarMul(height, scale); + if (scale < 0) + height = -height; + + // draw the old + paint.setAlpha((U8)SkScalarMul(alpha, SK_Scalar1 - SkScalarAbs(scale))); + canvas->drawText(fOldText.c_str(), fOldText.size(), x, y - dy, paint); + // draw the new + paint.setAlpha((U8)SkScalarMul(alpha, SkScalarAbs(scale))); + canvas->drawText(newText.c_str(), newText.size(), x, y + height - dy, paint); + // restore the paint + paint.setAlpha(alpha); + return true; + } + } + +private: + SkString fOldText; + SkInterpolator fInterp; +}; + +SkTextView::SkTextView(U32 flags) : SkView(flags), fInterp(nil), fDoInterp(false) +{ + fMargin.set(0, 0); +} + +SkTextView::~SkTextView() +{ + delete fInterp; +} + +void SkTextView::getText(SkString* str) const +{ + if (str) + str->set(fText); +} + +void SkTextView::setText(const char text[], AnimaDir dir) +{ + if (!fText.equals(text)) + { + SkString tmp(text); + this->privSetText(tmp, dir); + } +} + +void SkTextView::setText(const char text[], size_t len, AnimaDir dir) +{ + if (!fText.equals(text)) + { + SkString tmp(text, len); + this->privSetText(tmp, dir); + } +} + +void SkTextView::setText(const SkString& src, AnimaDir dir) +{ + if (fText != src) + this->privSetText(src, dir); +} + +void SkTextView::privSetText(const SkString& src, AnimaDir dir) +{ + SkASSERT(fText != src); + + if (fDoInterp) + { + if (fInterp) + delete fInterp; + fInterp = new Interp(fText, SkTime::GetMSecs(), 500, dir); + } + fText = src; + this->inval(nil); +} + +///////////////////////////////////////////////////////////////// + +void SkTextView::getMargin(SkPoint* margin) const +{ + if (margin) + *margin = fMargin; +} + +void SkTextView::setMargin(const SkPoint& margin) +{ + if (fMargin != margin) + { + fMargin = margin; + this->inval(nil); + } +} + +void SkTextView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + if (fText.size() == 0) + return; + + SkPaint::Align align = fPaint.getTextAlign(); + SkScalar x, y; + + switch (align) { + case SkPaint::kLeft_Align: + x = fMargin.fX; + break; + case SkPaint::kCenter_Align: + x = SkScalarHalf(this->width()); + break; + default: + SkASSERT(align == SkPaint::kRight_Align); + x = this->width() - fMargin.fX; + break; + } + + fPaint.measureText(nil, 0, &y, nil); + y = fMargin.fY - y; + + if (fInterp) + { + if (fInterp->draw(canvas, fText, x, y, fPaint)) + this->inval(nil); + else + { + delete fInterp; + fInterp = nil; + } + } + else + canvas->drawText(fText.c_str(), fText.size(), x, y, fPaint); +} + +////////////////////////////////////////////////////////////////////////////////////// + +void SkTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + const char* text = dom.findAttr(node, "text"); + if (text) + this->setText(text); + + SkPoint margin; + if (dom.findScalars(node, "margin", (SkScalar*)&margin, 2)) + this->setMargin(margin); + (void)dom.findBool(node, "do-interp", &fDoInterp); + + SkPaint_Inflate(&fPaint, dom, node); +} + +////////////////////////////////////////////////////////////////////////////////////// + +SkSliderView::SkSliderView(U32 flags) : SkWidgetView(flags) +{ + fValue = 0; + fMax = 0; +} + +static U16 actual_value(U16CPU value, U16CPU max) +{ + return SkToU16(SkMax32(0, SkMin32(value, max))); +} + +void SkSliderView::setMax(U16CPU max) +{ + if (fMax != max) + { + fMax = SkToU16(max); + if (fValue > 0) + this->inval(nil); + } +} + +void SkSliderView::setValue(U16CPU value) +{ + if (fValue != value) + { + U16 prev = actual_value(fValue, fMax); + U16 next = actual_value(value, fMax); + + fValue = SkToU16(value); + if (prev != next) + { + this->inval(nil); + + if (this->hasListeners()) + { + SkEvent evt; + + evt.setType(SkWidgetView::GetEventType()); + evt.setFast32(this->getSinkID()); + evt.setS32("sliderValue", next); + this->postToListeners(evt); + } + } + } +} + +#include "SkGradientShader.h" + +static void setgrad(SkPaint* paint, const SkRect& r) +{ + SkPoint pts[2]; + SkColor colors[2]; + +#if 0 + pts[0].set(r.fLeft, r.fTop); + pts[1].set(r.fLeft + r.height(), r.fBottom); +#else + pts[0].set(r.fRight, r.fBottom); + pts[1].set(r.fRight - r.height(), r.fTop); +#endif + colors[0] = SK_ColorBLUE; + colors[1] = SK_ColorWHITE; + + paint->setShader(SkGradientShader::CreateLinear(pts, colors, nil, 2, SkShader::kMirror_TileMode))->unref(); +} + +void SkSliderView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + U16CPU value = SkMax32(0, SkMin32(fValue, fMax)); + + SkRect r; + SkPaint p; + + r.set(0, 0, this->width(), this->height()); + + p.setAntiAliasOn(true); + p.setStyle(SkPaint::kStroke_Style); + p.setStrokeWidth(SK_Scalar1); + r.inset(SK_Scalar1/2, SK_Scalar1/2); + canvas->drawRect(r, p); + + if (fMax) + { + SkFixed percent = SkFixedDiv(value, fMax); + + r.inset(SK_Scalar1/2, SK_Scalar1/2); + r.fRight = r.fLeft + SkScalarMul(r.width(), SkFixedToScalar(percent)); + p.setStyle(SkPaint::kFill_Style); + setgrad(&p, r); + canvas->drawRect(r, p); + } + +#if 0 + r.set(0, 0, this->width(), this->height()); + r.inset(SK_Scalar1, SK_Scalar1); + r.inset(r.width()/2, 0); + p.setColor(SK_ColorBLACK); + canvas->drawLine(*(SkPoint*)&r.fLeft, *(SkPoint*)&r.fRight, p); +#endif +} + +SkView::Click* SkSliderView::onFindClickHandler(SkScalar x, SkScalar y) +{ + return new Click(this); +} + +bool SkSliderView::onClick(Click* click) +{ + if (fMax) + { + SkScalar percent = SkScalarDiv(click->fCurr.fX + SK_Scalar1, this->width() - SK_Scalar1*2); + percent = SkMaxScalar(0, SkMinScalar(percent, SK_Scalar1)); + this->setValue(SkScalarRound(percent * fMax)); + return true; + } + return false; +} + +#endif + diff --git a/libsgl/views/SkWidgetViews.cpp b/libsgl/views/SkWidgetViews.cpp new file mode 100644 index 0000000..e7eb772 --- /dev/null +++ b/libsgl/views/SkWidgetViews.cpp @@ -0,0 +1,570 @@ +#include "SkWidgetViews.h" +#include "SkAnimator.h" +#include "SkCanvas.h" +#include "SkPaint.h" +#include "SkStream.h" +#include "SkSystemEventTypes.h" + +#ifdef SK_DEBUG + static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[]) + { + const char* value = dom.findAttr(node, attr); + if (value) + SkDebugf("unknown attribute %s=\"%s\"\n", attr, value); + } +#else + #define assert_no_attr(dom, node, attr) +#endif +/* +I have moved this to SkWidgetViews.h +enum SkinEnum { + kButton_SkinEnum, + kProgress_SkinEnum, + kScroll_SkinEnum, + kStaticText_SkinEnum, + + kSkinEnumCount +}; +*/ + +const char* get_skin_enum_path(SkinEnum se) +{ + SkASSERT((unsigned)se < kSkinEnumCount); + + static const char* gSkinPaths[] = { + "common/default/default/skins/border3.xml", + "common/default/default/skins/button.xml", + "common/default/default/skins/progressBar.xml", + "common/default/default/skins/scrollBar.xml", + "common/default/default/skins/statictextpaint.xml" + }; + + return gSkinPaths[se]; +} + +void init_skin_anim(const char path[], SkAnimator* anim) +{ + SkASSERT(path && anim); + + SkFILEStream stream(path); + + if (!stream.isValid()) + { + SkDEBUGF(("init_skin_anim: loading skin failed <%s>\n", path)); + sk_throw(); + } + + if (!anim->decodeStream(&stream)) + { + SkDEBUGF(("init_skin_anim: decoding skin failed <%s>\n", path)); + sk_throw(); + } +} + +void init_skin_anim(SkinEnum se, SkAnimator* anim) +{ + init_skin_anim(get_skin_enum_path(se), anim); +} + +void init_skin_paint(SkinEnum se, SkPaint* paint) +{ + SkASSERT(paint); + + SkAnimator anim; + SkCanvas canvas; + + init_skin_anim(se, &anim); + anim.draw(&canvas, paint, 0); +} + +void inflate_paint(const SkDOM& dom, const SkDOM::Node* node, SkPaint* paint) +{ + SkASSERT(paint); + + SkAnimator anim; + SkCanvas canvas; + + if (!anim.decodeDOM(dom, node)) + { + SkDEBUGF(("inflate_paint: decoding dom failed\n")); + SkDEBUGCODE(dom.dump(node);) + sk_throw(); + } + anim.draw(&canvas, paint, 0); +} + +//////////////////////////////////////////////////////////////////////////////////////// + +SkWidgetView::SkWidgetView() : SkView(SkView::kFocusable_Mask | SkView::kEnabled_Mask) +{ +} + +const char* SkWidgetView::getLabel() const +{ + return fLabel.c_str(); +} + +void SkWidgetView::getLabel(SkString* label) const +{ + if (label) + *label = fLabel; +} + +void SkWidgetView::setLabel(const char label[]) +{ + this->setLabel(label, label ? strlen(label) : 0); +} + +void SkWidgetView::setLabel(const char label[], size_t len) +{ + if (label == nil && fLabel.size() != 0 || !fLabel.equals(label, len)) + { + SkString tmp(label, len); + + this->onLabelChange(fLabel.c_str(), tmp.c_str()); + fLabel.swap(tmp); + } +} + +void SkWidgetView::setLabel(const SkString& label) +{ + if (fLabel != label) + { + this->onLabelChange(fLabel.c_str(), label.c_str()); + fLabel = label; + } +} + +bool SkWidgetView::postWidgetEvent() +{ + if (!fEvent.isType("")) + { + SkEvent evt(fEvent); // make a copy since onPrepareWidgetEvent may edit the event + + if (this->onPrepareWidgetEvent(&evt)) + { + SkDEBUGCODE(evt.dump("SkWidgetView::postWidgetEvent");) + + this->postToListeners(evt); // wonder if this should return true if there are > 0 listeners... + return true; + } + } + return false; +} + +/*virtual*/ void SkWidgetView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + const char* label = dom.findAttr(node, "label"); + if (label) + this->setLabel(label); + + if ((node = dom.getFirstChild(node, "event")) != nil) + fEvent.inflate(dom, node); +} + +/*virtual*/ void SkWidgetView::onLabelChange(const char oldLabel[], const char newLabel[]) +{ + this->inval(nil); +} + +static const char gWidgetEventSinkIDSlotName[] = "sk-widget-sinkid-slot"; + +/*virtual*/ bool SkWidgetView::onPrepareWidgetEvent(SkEvent* evt) +{ + evt->setS32(gWidgetEventSinkIDSlotName, this->getSinkID()); + return true; +} + +SkEventSinkID SkWidgetView::GetWidgetEventSinkID(const SkEvent& evt) +{ + int32_t sinkID; + + return evt.findS32(gWidgetEventSinkIDSlotName, &sinkID) ? (SkEventSinkID)sinkID : 0; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +/*virtual*/ bool SkButtonView::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey) + { + this->postWidgetEvent(); + return true; + } + return this->INHERITED::onEvent(evt); +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +SkCheckButtonView::SkCheckButtonView() : fCheckState(kOff_CheckState) +{ +} + +void SkCheckButtonView::setCheckState(CheckState state) +{ + SkASSERT((unsigned)state <= kUnknown_CheckState); + + if (fCheckState != state) + { + this->onCheckStateChange(this->getCheckState(), state); + fCheckState = SkToU8(state); + } +} + +/*virtual*/ void SkCheckButtonView::onCheckStateChange(CheckState oldState, CheckState newState) +{ + this->inval(nil); +} + +/*virtual*/ void SkCheckButtonView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + int index = dom.findList(node, "check-state", "off,on,unknown"); + if (index >= 0) + this->setCheckState((CheckState)index); +} + +static const char gCheckStateSlotName[] = "sk-checkbutton-check-slot"; + +/*virtual*/ bool SkCheckButtonView::onPrepareWidgetEvent(SkEvent* evt) +{ + // could check if we're "disabled", and return false... + + evt->setS32(gCheckStateSlotName, this->getCheckState()); + return true; +} + +bool SkCheckButtonView::GetWidgetEventCheckState(const SkEvent& evt, CheckState* state) +{ + int32_t state32; + + if (evt.findS32(gCheckStateSlotName, &state32)) + { + if (state) + *state = (CheckState)state32; + return true; + } + return false; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////////////////////////// + +#include "SkTime.h" +#include <stdio.h> + +class SkAnimButtonView : public SkButtonView { +public: + SkAnimButtonView() + { + fAnim.setHostEventSink(this); + init_skin_anim(kButton_SkinEnum, &fAnim); + } + +protected: + virtual void onLabelChange(const char oldLabel[], const char newLabel[]) + { + this->INHERITED::onLabelChange(oldLabel, newLabel); + + SkEvent evt("user"); + evt.setString("id", "setLabel"); + evt.setString("LABEL", newLabel); + fAnim.doUserEvent(evt); + } + + virtual void onFocusChange(bool gainFocus) + { + this->INHERITED::onFocusChange(gainFocus); + + SkEvent evt("user"); + evt.setString("id", "setFocus"); + evt.setS32("FOCUS", gainFocus); + fAnim.doUserEvent(evt); + } + + virtual void onSizeChange() + { + this->INHERITED::onSizeChange(); + + SkEvent evt("user"); + evt.setString("id", "setDim"); + evt.setScalar("dimX", this->width()); + evt.setScalar("dimY", this->height()); + fAnim.doUserEvent(evt); + } + + virtual void onDraw(SkCanvas* canvas) + { + SkPaint paint; + SkAnimator::DifferenceType diff = fAnim.draw(canvas, &paint, SkTime::GetMSecs()); + + if (diff == SkAnimator::kDifferent) + this->inval(nil); + else if (diff == SkAnimator::kPartiallyDifferent) + { + SkRect bounds; + fAnim.getInvalBounds(&bounds); + this->inval(&bounds); + } + } + + virtual bool onEvent(const SkEvent& evt) + { + if (evt.isType(SK_EventType_Inval)) + { + this->inval(nil); + return true; + } + if (evt.isType("recommendDim")) + { + SkScalar height; + + if (evt.findScalar("y", &height)) + this->setHeight(height); + return true; + } + return this->INHERITED::onEvent(evt); + } + + virtual bool onPrepareWidgetEvent(SkEvent* evt) + { + if (this->INHERITED::onPrepareWidgetEvent(evt)) + { + SkEvent e("user"); + e.setString("id", "handlePress"); + (void)fAnim.doUserEvent(e); + return true; + } + return false; + } + +private: + SkAnimator fAnim; + + typedef SkButtonView INHERITED; +}; + +//////////////////////////////////////////////////////////////////////////////////////////// + +#include "SkTextBox.h" + +SkStaticTextView::SkStaticTextView() +{ + fMargin.set(0, 0); + fMode = kFixedSize_Mode; + fSpacingAlign = SkTextBox::kStart_SpacingAlign; + + init_skin_paint(kStaticText_SkinEnum, &fPaint); +} + +SkStaticTextView::~SkStaticTextView() +{ +} + +void SkStaticTextView::computeSize() +{ + if (fMode == kAutoWidth_Mode) + { + SkScalar width = fPaint.measureText(fText.c_str(), fText.size()); + this->setWidth(width + fMargin.fX * 2); + } + else if (fMode == kAutoHeight_Mode) + { + SkScalar width = this->width() - fMargin.fX * 2; + int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0; + + this->setHeight(lines * fPaint.getFontSpacing() + fMargin.fY * 2); + } +} + +void SkStaticTextView::setMode(Mode mode) +{ + SkASSERT((unsigned)mode < kModeCount); + + if (fMode != mode) + { + fMode = SkToU8(mode); + this->computeSize(); + } +} + +void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align) +{ + fSpacingAlign = SkToU8(align); + this->inval(nil); +} + +void SkStaticTextView::getMargin(SkPoint* margin) const +{ + if (margin) + *margin = fMargin; +} + +void SkStaticTextView::setMargin(SkScalar dx, SkScalar dy) +{ + if (fMargin.fX != dx || fMargin.fY != dy) + { + fMargin.set(dx, dy); + this->computeSize(); + this->inval(nil); + } +} + +size_t SkStaticTextView::getText(SkString* text) const +{ + if (text) + *text = fText; + return fText.size(); +} + +size_t SkStaticTextView::getText(char text[]) const +{ + if (text) + memcpy(text, fText.c_str(), fText.size()); + return fText.size(); +} + +void SkStaticTextView::setText(const SkString& text) +{ + this->setText(text.c_str(), text.size()); +} + +void SkStaticTextView::setText(const char text[]) +{ + if (text == nil) + text = ""; + this->setText(text, strlen(text)); +} + +void SkStaticTextView::setText(const char text[], size_t len) +{ + if (!fText.equals(text, len)) + { + fText.set(text, len); + this->computeSize(); + this->inval(nil); + } +} + +void SkStaticTextView::getPaint(SkPaint* paint) const +{ + if (paint) + *paint = fPaint; +} + +void SkStaticTextView::setPaint(const SkPaint& paint) +{ + if (fPaint != paint) + { + fPaint = paint; + this->computeSize(); + this->inval(nil); + } +} + +void SkStaticTextView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + if (fText.isEmpty()) + return; + + SkTextBox box; + + box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode); + box.setSpacingAlign(this->getSpacingAlign()); + box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY); + box.draw(canvas, fText.c_str(), fText.size(), fPaint); +} + +void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + int index; + if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0) + this->setMode((Mode)index); + else + assert_no_attr(dom, node, "mode"); + + if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0) + this->setSpacingAlign((SkTextBox::SpacingAlign)index); + else + assert_no_attr(dom, node, "spacing-align"); + + SkScalar s[2]; + if (dom.findScalars(node, "margin", s, 2)) + this->setMargin(s[0], s[1]); + else + assert_no_attr(dom, node, "margin"); + + const char* text = dom.findAttr(node, "text"); + if (text) + this->setText(text); + + if ((node = dom.getFirstChild(node, "paint")) != nil && + (node = dom.getFirstChild(node, "screenplay")) != nil) + { + inflate_paint(dom, node, &fPaint); + } +} + +//////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////// + +SkView* SkWidgetFactory(const char name[]) +{ + if (name == nil) + return nil; + + // must be in the same order as the SkSkinWidgetEnum is declared + static const char* gNames[] = { + "sk-border", + "sk-button", + "sk-image", + "sk-list", + "sk-progress", + "sk-scroll", + "sk-text" + + }; + + for (int i = 0; i < SK_ARRAY_COUNT(gNames); i++) + if (!strcmp(gNames[i], name)) + return SkWidgetFactory((SkWidgetEnum)i); + + return nil; +} + +#include "SkImageView.h" +#include "SkProgressBarView.h" +#include "SkScrollBarView.h" +#include "SkBorderView.h" + +SkView* SkWidgetFactory(SkWidgetEnum sw) +{ + switch (sw) { + case kBorder_WidgetEnum: + return new SkBorderView; + case kButton_WidgetEnum: + return new SkAnimButtonView; + case kImage_WidgetEnum: + return new SkImageView; + case kList_WidgetEnum: + return new SkListView; + case kProgress_WidgetEnum: + return new SkProgressBarView; + case kScroll_WidgetEnum: + return new SkScrollBarView; + case kText_WidgetEnum: + return new SkStaticTextView; + default: + SkASSERT(!"unknown enum passed to SkWidgetFactory"); + break; + } + return nil; +} diff --git a/libsgl/views/SkWidgets.cpp b/libsgl/views/SkWidgets.cpp new file mode 100644 index 0000000..fe87cd6 --- /dev/null +++ b/libsgl/views/SkWidgets.cpp @@ -0,0 +1,554 @@ +#include "SkWidget.h" +#include "SkCanvas.h" +#include "SkKey.h" +#include "SkParsePaint.h" +#include "SkSystemEventTypes.h" +#include "SkTextBox.h" + +#if 0 + +#ifdef SK_DEBUG + static void assert_no_attr(const SkDOM& dom, const SkDOM::Node* node, const char attr[]) + { + const char* value = dom.findAttr(node, attr); + if (value) + SkDebugf("unknown attribute %s=\"%s\"\n", attr, value); + } +#else + #define assert_no_attr(dom, node, attr) +#endif + +#include "SkAnimator.h" +#include "SkTime.h" + +/////////////////////////////////////////////////////////////////////////////// + +enum SkinType { + kPushButton_SkinType, + kStaticText_SkinType, + + kSkinTypeCount +}; + +struct SkinSuite { + SkinSuite(); + ~SkinSuite() + { + for (int i = 0; i < kSkinTypeCount; i++) + delete fAnimators[i]; + } + + SkAnimator* get(SkinType); + +private: + SkAnimator* fAnimators[kSkinTypeCount]; +}; + +SkinSuite::SkinSuite() +{ + static const char kSkinPath[] = "skins/"; + + static const char* gSkinNames[] = { + "pushbutton_skin.xml", + "statictext_skin.xml" + }; + + for (unsigned i = 0; i < SK_ARRAY_COUNT(gSkinNames); i++) + { + size_t len = strlen(gSkinNames[i]); + SkString path(sizeof(kSkinPath) - 1 + len); + + memcpy(path.writable_str(), kSkinPath, sizeof(kSkinPath) - 1); + memcpy(path.writable_str() + sizeof(kSkinPath) - 1, gSkinNames[i], len); + + fAnimators[i] = new SkAnimator; + if (!fAnimators[i]->decodeURI(path.c_str())) + { + delete fAnimators[i]; + fAnimators[i] = nil; + } + } +} + +SkAnimator* SkinSuite::get(SkinType st) +{ + SkASSERT((unsigned)st < kSkinTypeCount); + return fAnimators[st]; +} + +static SkinSuite* gSkinSuite; + +static SkAnimator* get_skin_animator(SkinType st) +{ +#if 0 + if (gSkinSuite == nil) + gSkinSuite = new SkinSuite; + return gSkinSuite->get(st); +#else + return nil; +#endif +} + +/////////////////////////////////////////////////////////////////////////////// + +void SkWidget::Init() +{ +} + +void SkWidget::Term() +{ + delete gSkinSuite; +} + +void SkWidget::onEnabledChange() +{ + this->inval(nil); +} + +void SkWidget::postWidgetEvent() +{ + if (!fEvent.isType("") && this->hasListeners()) + { + this->prepareWidgetEvent(&fEvent); + this->postToListeners(fEvent); + } +} + +void SkWidget::prepareWidgetEvent(SkEvent*) +{ + // override in subclass to add any additional fields before posting +} + +void SkWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + if ((node = dom.getFirstChild(node, "event")) != nil) + fEvent.inflate(dom, node); +} + +/////////////////////////////////////////////////////////////////////////////// + +size_t SkHasLabelWidget::getLabel(SkString* str) const +{ + if (str) + *str = fLabel; + return fLabel.size(); +} + +size_t SkHasLabelWidget::getLabel(char buffer[]) const +{ + if (buffer) + memcpy(buffer, fLabel.c_str(), fLabel.size()); + return fLabel.size(); +} + +void SkHasLabelWidget::setLabel(const SkString& str) +{ + this->setLabel(str.c_str(), str.size()); +} + +void SkHasLabelWidget::setLabel(const char label[]) +{ + this->setLabel(label, strlen(label)); +} + +void SkHasLabelWidget::setLabel(const char label[], size_t len) +{ + if (!fLabel.equals(label, len)) + { + fLabel.set(label, len); + this->onLabelChange(); + } +} + +void SkHasLabelWidget::onLabelChange() +{ + // override in subclass +} + +void SkHasLabelWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + const char* text = dom.findAttr(node, "label"); + if (text) + this->setLabel(text); +} + +///////////////////////////////////////////////////////////////////////////////////// + +void SkButtonWidget::setButtonState(State state) +{ + if (fState != state) + { + fState = state; + this->onButtonStateChange(); + } +} + +void SkButtonWidget::onButtonStateChange() +{ + this->inval(nil); +} + +void SkButtonWidget::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + int index; + if ((index = dom.findList(node, "buttonState", "off,on,unknown")) >= 0) + this->setButtonState((State)index); +} + +///////////////////////////////////////////////////////////////////////////////////// + +bool SkPushButtonWidget::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventType_Key) && evt.getFast32() == kOK_SkKey) + { + this->postWidgetEvent(); + return true; + } + return this->INHERITED::onEvent(evt); +} + +static const char* computeAnimatorState(int enabled, int focused, SkButtonWidget::State state) +{ + if (!enabled) + return "disabled"; + if (state == SkButtonWidget::kOn_State) + { + SkASSERT(focused); + return "enabled-pressed"; + } + if (focused) + return "enabled-focused"; + return "enabled"; +} + +#include "SkBlurMaskFilter.h" +#include "SkEmbossMaskFilter.h" + +static void create_emboss(SkPaint* paint, SkScalar radius, bool focus, bool pressed) +{ + SkEmbossMaskFilter::Light light; + + light.fDirection[0] = SK_Scalar1/2; + light.fDirection[1] = SK_Scalar1/2; + light.fDirection[2] = SK_Scalar1/3; + light.fAmbient = 0x48; + light.fSpecular = 0x80; + + if (pressed) + { + light.fDirection[0] = -light.fDirection[0]; + light.fDirection[1] = -light.fDirection[1]; + } + if (focus) + light.fDirection[2] += SK_Scalar1/4; + + paint->setMaskFilter(new SkEmbossMaskFilter(light, radius))->unref(); +} + +void SkPushButtonWidget::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + SkString label; + this->getLabel(&label); + + SkAnimator* anim = get_skin_animator(kPushButton_SkinType); + + if (anim) + { + SkEvent evt("user"); + + evt.setString("id", "prime"); + evt.setScalar("prime-width", this->width()); + evt.setScalar("prime-height", this->height()); + evt.setString("prime-text", label); + evt.setString("prime-state", computeAnimatorState(this->isEnabled(), this->hasFocus(), this->getButtonState())); + + (void)anim->doUserEvent(evt); + SkPaint paint; + anim->draw(canvas, &paint, SkTime::GetMSecs()); + } + else + { + SkRect r; + SkPaint p; + + r.set(0, 0, this->width(), this->height()); + p.setAntiAliasOn(true); + p.setColor(SK_ColorBLUE); + create_emboss(&p, SkIntToScalar(12)/5, this->hasFocus(), this->getButtonState() == kOn_State); + canvas->drawRoundRect(r, SkScalarHalf(this->height()), SkScalarHalf(this->height()), p); + p.setMaskFilter(nil); + + p.setTextAlign(SkPaint::kCenter_Align); + + SkTextBox box; + box.setMode(SkTextBox::kOneLine_Mode); + box.setSpacingAlign(SkTextBox::kCenter_SpacingAlign); + box.setBox(0, 0, this->width(), this->height()); + +// if (this->getButtonState() == kOn_State) +// p.setColor(SK_ColorRED); +// else + p.setColor(SK_ColorWHITE); + + box.draw(canvas, label.c_str(), label.size(), p); + } +} + +SkView::Click* SkPushButtonWidget::onFindClickHandler(SkScalar x, SkScalar y) +{ + this->acceptFocus(); + return new Click(this); +} + +bool SkPushButtonWidget::onClick(Click* click) +{ + SkRect r; + State state = kOff_State; + + this->getLocalBounds(&r); + if (r.contains(click->fCurr)) + { + if (click->fState == Click::kUp_State) + this->postWidgetEvent(); + else + state = kOn_State; + } + this->setButtonState(state); + return true; +} + +////////////////////////////////////////////////////////////////////////////////////////// + +SkStaticTextView::SkStaticTextView(U32 flags) : SkView(flags) +{ + fMargin.set(0, 0); + fMode = kFixedSize_Mode; + fSpacingAlign = SkTextBox::kStart_SpacingAlign; +} + +SkStaticTextView::~SkStaticTextView() +{ +} + +void SkStaticTextView::computeSize() +{ + if (fMode == kAutoWidth_Mode) + { + SkScalar width = fPaint.measureText(fText.c_str(), fText.size(), nil, nil); + this->setWidth(width + fMargin.fX * 2); + } + else if (fMode == kAutoHeight_Mode) + { + SkScalar width = this->width() - fMargin.fX * 2; + int lines = width > 0 ? SkTextLineBreaker::CountLines(fText.c_str(), fText.size(), fPaint, width) : 0; + + SkScalar before, after; + (void)fPaint.measureText(0, nil, &before, &after); + + this->setHeight(lines * (after - before) + fMargin.fY * 2); + } +} + +void SkStaticTextView::setMode(Mode mode) +{ + SkASSERT((unsigned)mode < kModeCount); + + if (fMode != mode) + { + fMode = SkToU8(mode); + this->computeSize(); + } +} + +void SkStaticTextView::setSpacingAlign(SkTextBox::SpacingAlign align) +{ + fSpacingAlign = SkToU8(align); + this->inval(nil); +} + +void SkStaticTextView::getMargin(SkPoint* margin) const +{ + if (margin) + *margin = fMargin; +} + +void SkStaticTextView::setMargin(SkScalar dx, SkScalar dy) +{ + if (fMargin.fX != dx || fMargin.fY != dy) + { + fMargin.set(dx, dy); + this->computeSize(); + this->inval(nil); + } +} + +size_t SkStaticTextView::getText(SkString* text) const +{ + if (text) + *text = fText; + return fText.size(); +} + +size_t SkStaticTextView::getText(char text[]) const +{ + if (text) + memcpy(text, fText.c_str(), fText.size()); + return fText.size(); +} + +void SkStaticTextView::setText(const SkString& text) +{ + this->setText(text.c_str(), text.size()); +} + +void SkStaticTextView::setText(const char text[]) +{ + this->setText(text, strlen(text)); +} + +void SkStaticTextView::setText(const char text[], size_t len) +{ + if (!fText.equals(text, len)) + { + fText.set(text, len); + this->computeSize(); + this->inval(nil); + } +} + +void SkStaticTextView::getPaint(SkPaint* paint) const +{ + if (paint) + *paint = fPaint; +} + +void SkStaticTextView::setPaint(const SkPaint& paint) +{ + if (fPaint != paint) + { + fPaint = paint; + this->computeSize(); + this->inval(nil); + } +} + +void SkStaticTextView::onDraw(SkCanvas* canvas) +{ + this->INHERITED::onDraw(canvas); + + if (fText.isEmpty()) + return; + + SkTextBox box; + + box.setMode(fMode == kAutoWidth_Mode ? SkTextBox::kOneLine_Mode : SkTextBox::kLineBreak_Mode); + box.setSpacingAlign(this->getSpacingAlign()); + box.setBox(fMargin.fX, fMargin.fY, this->width() - fMargin.fX, this->height() - fMargin.fY); + box.draw(canvas, fText.c_str(), fText.size(), fPaint); +} + +void SkStaticTextView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + int index; + if ((index = dom.findList(node, "mode", "fixed,auto-width,auto-height")) >= 0) + this->setMode((Mode)index); + else + assert_no_attr(dom, node, "mode"); + + if ((index = dom.findList(node, "spacing-align", "start,center,end")) >= 0) + this->setSpacingAlign((SkTextBox::SpacingAlign)index); + else + assert_no_attr(dom, node, "mode"); + + SkScalar s[2]; + if (dom.findScalars(node, "margin", s, 2)) + this->setMargin(s[0], s[1]); + else + assert_no_attr(dom, node, "margin"); + + const char* text = dom.findAttr(node, "text"); + if (text) + this->setText(text); + + if ((node = dom.getFirstChild(node, "paint")) != nil) + SkPaint_Inflate(&fPaint, dom, node); +} + +///////////////////////////////////////////////////////////////////////////////////////////////////// + +#include "SkImageDecoder.h" + +SkBitmapView::SkBitmapView(U32 flags) : SkView(flags) +{ +} + +SkBitmapView::~SkBitmapView() +{ +} + +bool SkBitmapView::getBitmap(SkBitmap* bitmap) const +{ + if (bitmap) + *bitmap = fBitmap; + return fBitmap.getConfig() != SkBitmap::kNo_Config; +} + +void SkBitmapView::setBitmap(const SkBitmap* bitmap, bool viewOwnsPixels) +{ + if (bitmap) + { + fBitmap = *bitmap; + fBitmap.setOwnsPixels(viewOwnsPixels); + } +} + +bool SkBitmapView::loadBitmapFromFile(const char path[]) +{ + SkBitmap bitmap; + + if (SkImageDecoder::DecodeFile(path, &bitmap)) + { + this->setBitmap(&bitmap, true); + bitmap.setOwnsPixels(false); + return true; + } + return false; +} + +void SkBitmapView::onDraw(SkCanvas* canvas) +{ + if (fBitmap.getConfig() != SkBitmap::kNo_Config && + fBitmap.width() && fBitmap.height()) + { + SkAutoCanvasRestore restore(canvas, true); + SkPaint p; + + p.setFilterType(SkPaint::kBilinear_FilterType); + canvas->scale( this->width() / fBitmap.width(), + this->height() / fBitmap.height(), + 0, 0); + canvas->drawBitmap(fBitmap, 0, 0, p); + } +} + +void SkBitmapView::onInflate(const SkDOM& dom, const SkDOM::Node* node) +{ + this->INHERITED::onInflate(dom, node); + + const char* src = dom.findAttr(node, "src"); + if (src) + (void)this->loadBitmapFromFile(src); +} + +#endif + diff --git a/libsgl/views/SkWindow.cpp b/libsgl/views/SkWindow.cpp new file mode 100644 index 0000000..5d00d4f --- /dev/null +++ b/libsgl/views/SkWindow.cpp @@ -0,0 +1,367 @@ +#include "SkWindow.h" +#include "SkCanvas.h" +#include "SkOSMenu.h" +#include "SkSystemEventTypes.h" +#include "SkTime.h" + +#define SK_EventDelayInval "\xd" "n" "\xa" "l" + +#define TEST_BOUNDERx + +#include "SkBounder.h" +class test_bounder : public SkBounder { +public: + test_bounder(const SkBitmap& bm) : fCanvas(bm) {} +protected: + virtual bool onIRect(const SkIRect& r) + { + SkRect rr; + + rr.set(SkIntToScalar(r.fLeft), SkIntToScalar(r.fTop), + SkIntToScalar(r.fRight), SkIntToScalar(r.fBottom)); + + SkPaint p; + + p.setStyle(SkPaint::kStroke_Style); + p.setColor(SK_ColorYELLOW); + +#if 0 + rr.inset(SK_ScalarHalf, SK_ScalarHalf); +#else + rr.inset(-SK_ScalarHalf, -SK_ScalarHalf); +#endif + + fCanvas.drawRect(rr, p); + return true; + } +private: + SkCanvas fCanvas; +}; + +SkWindow::SkWindow() : fFocusView(NULL) +{ + fClick = NULL; + fWaitingOnInval = false; + +#ifdef SK_BUILD_FOR_WINCE + fConfig = SkBitmap::kRGB_565_Config; +#else + fConfig = SkBitmap::kARGB_8888_Config; +#endif +} + +SkWindow::~SkWindow() +{ + delete fClick; + + fMenus.deleteAll(); +} + +void SkWindow::setConfig(SkBitmap::Config config) +{ + this->resize(fBitmap.width(), fBitmap.height(), config); +} + +#include "SkImageDecoder.h" + +void SkWindow::resize(int width, int height, SkBitmap::Config config) +{ + if (config == SkBitmap::kNo_Config) + config = fConfig; + + if (width != fBitmap.width() || height != fBitmap.height() || config != fConfig) + { + fConfig = config; + fBitmap.setConfig(config, width, height); + fBitmap.allocPixels(); + + this->setSize(SkIntToScalar(width), SkIntToScalar(height)); + this->inval(NULL); + } + + SkImageDecoder::SetDeviceConfig(fConfig); +} + +void SkWindow::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) +{ + fBitmap.eraseARGB(a, r, g, b); +} + +void SkWindow::eraseRGB(U8CPU r, U8CPU g, U8CPU b) +{ + fBitmap.eraseRGB(r, g, b); +} + +bool SkWindow::handleInval(const SkRect& r) +{ + SkIRect ir; + + r.round(&ir); + fDirtyRgn.op(ir, SkRegion::kUnion_Op); + +#ifdef SK_BUILD_FOR_WIN32 + if (!fWaitingOnInval) + { + fWaitingOnInval = true; + (new SkEvent(SK_EventDelayInval))->post(this->getSinkID(), 10); + } +#else + this->onHandleInval(ir); +#endif + return true; +} + +#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN) + #include <windows.h> + #include <gx.h> + extern GXDisplayProperties gDisplayProps; +#endif + +#ifdef SK_SIMULATE_FAILED_MALLOC +extern bool gEnableControlledThrow; +#endif + +bool SkWindow::update(SkIRect* updateArea) +{ + if (!fDirtyRgn.isEmpty()) + { + SkBitmap bm = this->getBitmap(); + +#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN) + char* buffer = (char*)GXBeginDraw(); + SkASSERT(buffer); + + RECT rect; + GetWindowRect((HWND)((SkOSWindow*)this)->getHWND(), &rect); + buffer += rect.top * gDisplayProps.cbyPitch + rect.left * gDisplayProps.cbxPitch; + + bm.setPixels(buffer); +#endif + + SkCanvas canvas(bm); + + canvas.clipRegion(fDirtyRgn); + if (updateArea) + *updateArea = fDirtyRgn.getBounds(); + + // empty this now, so we can correctly record any inval calls that + // might be made during the draw call. + fDirtyRgn.setEmpty(); + +#ifdef TEST_BOUNDER + test_bounder b(bm); + canvas.setBounder(&b); +#endif +#ifdef SK_SIMULATE_FAILED_MALLOC + gEnableControlledThrow = true; +#endif +#ifdef SK_BUILD_FOR_WIN32 + try { + this->draw(&canvas); + } + catch (...) { + } +#else + this->draw(&canvas); +#endif +#ifdef SK_SIMULATE_FAILED_MALLOC + gEnableControlledThrow = false; +#endif +#ifdef TEST_BOUNDER + canvas.setBounder(NULL); +#endif + +#if defined(SK_BUILD_FOR_WINCE) && defined(USE_GX_SCREEN) + GXEndDraw(); +#endif + + return true; + } + return false; +} + +bool SkWindow::handleChar(SkUnichar uni) +{ + if (this->onHandleChar(uni)) + return true; + + SkView* focus = this->getFocusView(); + if (focus == NULL) + focus = this; + + SkEvent evt(SK_EventType_Unichar); + evt.setFast32(uni); + return focus->doEvent(evt); +} + +bool SkWindow::handleKey(SkKey key) +{ + if (key == kNONE_SkKey) + return false; + + if (this->onHandleKey(key)) + return true; + + // send an event to the focus-view + { + SkView* focus = this->getFocusView(); + if (focus == NULL) + focus = this; + + SkEvent evt(SK_EventType_Key); + evt.setFast32(key); + if (focus->doEvent(evt)) + return true; + } + + if (key == kUp_SkKey || key == kDown_SkKey) + { + if (this->moveFocus(key == kUp_SkKey ? kPrev_FocusDirection : kNext_FocusDirection) == NULL) + this->onSetFocusView(NULL); + return true; + } + return false; +} + +bool SkWindow::handleKeyUp(SkKey key) +{ + if (key == kNONE_SkKey) + return false; + + if (this->onHandleKeyUp(key)) + return true; + + //send an event to the focus-view + { + SkView* focus = this->getFocusView(); + if (focus == NULL) + focus = this; + + //should this one be the same? + SkEvent evt(SK_EventType_KeyUp); + evt.setFast32(key); + if (focus->doEvent(evt)) + return true; + } + return false; +} + +void SkWindow::addMenu(SkOSMenu* menu) +{ + *fMenus.append() = menu; + this->onAddMenu(menu); +} + +void SkWindow::setTitle(const char title[]) +{ + if (NULL == title) + title = ""; + this->onSetTitle(title); +} + +bool SkWindow::handleMenu(uint32_t cmd) +{ + for (int i = 0; i < fMenus.count(); i++) + { + SkEvent* evt = fMenus[i]->createEvent(cmd); + if (evt) + { + evt->post(this->getSinkID()); + return true; + } + } + return false; +} + +////////////////////////////////////////////////////////////////////// + +bool SkWindow::onEvent(const SkEvent& evt) +{ + if (evt.isType(SK_EventDelayInval)) + { + SkRegion::Iterator iter(fDirtyRgn); + + for (; !iter.done(); iter.next()) + this->onHandleInval(iter.rect()); + fWaitingOnInval = false; + return true; + } + return this->INHERITED::onEvent(evt); +} + +bool SkWindow::onGetFocusView(SkView** focus) const +{ + if (focus) + *focus = fFocusView; + return true; +} + +bool SkWindow::onSetFocusView(SkView* focus) +{ + if (fFocusView != focus) + { + if (fFocusView) + fFocusView->onFocusChange(false); + fFocusView = focus; + if (focus) + focus->onFocusChange(true); + } + return true; +} + +////////////////////////////////////////////////////////////////////// + +void SkWindow::onHandleInval(const SkIRect&) +{ +} + +bool SkWindow::onHandleChar(SkUnichar) +{ + return false; +} + +bool SkWindow::onHandleKey(SkKey key) +{ + return false; +} + +bool SkWindow::onHandleKeyUp(SkKey key) +{ + return false; +} + +bool SkWindow::handleClick(int x, int y, Click::State state) +{ + bool handled = false; + + switch (state) { + case Click::kDown_State: + if (fClick) + delete fClick; + fClick = this->findClickHandler(SkIntToScalar(x), SkIntToScalar(y)); + if (fClick) + { + SkView::DoClickDown(fClick, x, y); + handled = true; + } + break; + case Click::kMoved_State: + if (fClick) + { + SkView::DoClickMoved(fClick, x, y); + handled = true; + } + break; + case Click::kUp_State: + if (fClick) + { + SkView::DoClickUp(fClick, x, y); + delete fClick; + fClick = NULL; + handled = true; + } + break; + } + return handled; +} + diff --git a/sgl_doxygen/html/Sk1DPathEffect_8h-source.html b/sgl_doxygen/html/Sk1DPathEffect_8h-source.html deleted file mode 100644 index 2835206..0000000 --- a/sgl_doxygen/html/Sk1DPathEffect_8h-source.html +++ /dev/null @@ -1,42 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Sk1DPathEffect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>Sk1DPathEffect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef Sk1DPathEffect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define Sk1DPathEffect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPathEffect.h"</span> -00005 -00006 <span class="keyword">class </span>SkMatrix; -00007 -00008 <span class="keyword">class </span>Sk1DPathEffect : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00009 <span class="keyword">public</span>: -00010 Sk1DPathEffect() {} -00011 -00012 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkPathEffect.html#a1">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00013 -00014 <span class="keyword">protected</span>: -00018 <span class="keyword">virtual</span> SkScalar begin(SkScalar contourLength); -00024 <span class="keyword">virtual</span> SkScalar next(SkScalar distance, <span class="keyword">const</span> SkMatrix&, <a class="code" href="classSkPath.html">SkPath</a>* dst); -00025 -00026 Sk1DPathEffect(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer) : <a class="code" href="classSkPathEffect.html">SkPathEffect</a>(buffer) {} -00027 -00028 <span class="keyword">private</span>: -00029 <span class="comment">// illegal</span> -00030 Sk1DPathEffect(<span class="keyword">const</span> Sk1DPathEffect&); -00031 Sk1DPathEffect& operator=(<span class="keyword">const</span> Sk1DPathEffect&); -00032 -00033 <span class="keyword">typedef</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> INHERITED; -00034 }; -00035 -00036 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/Sk2DPathEffect_8h-source.html b/sgl_doxygen/html/Sk2DPathEffect_8h-source.html deleted file mode 100644 index aae2e92..0000000 --- a/sgl_doxygen/html/Sk2DPathEffect_8h-source.html +++ /dev/null @@ -1,51 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Sk2DPathEffect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>Sk2DPathEffect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef Sk2DPathEffect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define Sk2DPathEffect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPathEffect.h"</span> -00005 <span class="preprocessor">#include "SkMatrix.h"</span> -00006 -00007 <span class="keyword">class </span>Sk2DPathEffect : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00008 <span class="keyword">public</span>: -00009 Sk2DPathEffect(<span class="keyword">const</span> SkMatrix& mat); -00010 -00011 <span class="comment">// overrides</span> -00012 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkPathEffect.html#a1">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00013 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00014 -00015 <span class="keyword">protected</span>: -00022 <span class="keyword">virtual</span> <span class="keywordtype">void</span> begin(<span class="keyword">const</span> SkRect16& uvBounds, <a class="code" href="classSkPath.html">SkPath</a>* dst); -00023 <span class="keyword">virtual</span> <span class="keywordtype">void</span> next(<span class="keyword">const</span> SkPoint& loc, <span class="keywordtype">int</span> u, <span class="keywordtype">int</span> v, <a class="code" href="classSkPath.html">SkPath</a>* dst); -00024 <span class="keyword">virtual</span> <span class="keywordtype">void</span> end(<a class="code" href="classSkPath.html">SkPath</a>* dst); -00025 -00030 <span class="keyword">virtual</span> <span class="keywordtype">void</span> nextSpan(<span class="keywordtype">int</span> u, <span class="keywordtype">int</span> v, <span class="keywordtype">int</span> ucount, <a class="code" href="classSkPath.html">SkPath</a>* dst); -00031 -00032 <span class="keyword">const</span> SkMatrix& getMatrix()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMatrix; } -00033 -00034 <span class="comment">// protected so that subclasses can call this during unflattening</span> -00035 Sk2DPathEffect(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00036 -00037 <span class="keyword">private</span>: -00038 SkMatrix fMatrix, fInverse; -00039 <span class="comment">// illegal</span> -00040 Sk2DPathEffect(<span class="keyword">const</span> Sk2DPathEffect&); -00041 Sk2DPathEffect& operator=(<span class="keyword">const</span> Sk2DPathEffect&); -00042 -00043 <span class="keyword">friend</span> <span class="keyword">class </span>Sk2DPathEffectBlitter; -00044 <span class="keyword">typedef</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> INHERITED; -00045 }; -00046 -00047 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkAnimatorView_8h-source.html b/sgl_doxygen/html/SkAnimatorView_8h-source.html deleted file mode 100644 index e6ece11..0000000 --- a/sgl_doxygen/html/SkAnimatorView_8h-source.html +++ /dev/null @@ -1,45 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAnimatorView.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkAnimatorView.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkAnimatorView_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkAnimatorView_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkAnimator.h"</span> -00006 -00007 <span class="keyword">class </span>SkAnimatorView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00008 <span class="keyword">public</span>: -00009 SkAnimatorView(); -00010 <span class="keyword">virtual</span> ~SkAnimatorView(); -00011 -00012 <a class="code" href="classSkAnimator.html">SkAnimator</a>* getAnimator()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fAnimator; } -00013 -00014 <span class="keywordtype">bool</span> decodeFile(<span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00015 <span class="keywordtype">bool</span> decodeMemory(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t size); -00016 <span class="keywordtype">bool</span> decodeStream(SkStream* stream); -00017 -00018 <span class="keyword">protected</span>: -00019 <span class="comment">// overrides</span> -00020 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#b0">onEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00021 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00022 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00023 -00024 <span class="keyword">private</span>: -00025 <a class="code" href="classSkAnimator.html">SkAnimator</a>* fAnimator; -00026 -00027 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00028 }; -00029 -00030 <span class="preprocessor">#endif</span> -00031 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkAnimator_8h-source.html b/sgl_doxygen/html/SkAnimator_8h-source.html deleted file mode 100644 index c29fc97..0000000 --- a/sgl_doxygen/html/SkAnimator_8h-source.html +++ /dev/null @@ -1,194 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAnimator.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkAnimator.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkAnimator_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkAnimator_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkScalar.h"</span> -00005 <span class="preprocessor">#include "SkKey.h"</span> -00006 <span class="preprocessor">#include "SkEventSink.h"</span> -00007 -00008 <span class="keyword">class </span>SkAnimateMaker; -00009 <span class="keyword">class </span><a class="code" href="classSkCanvas.html">SkCanvas</a>; -00010 <span class="keyword">class </span>SkDisplayable; -00011 <span class="keyword">class </span><a class="code" href="classSkEvent.html">SkEvent</a>; -00012 <span class="keyword">class </span>SkExtras; -00013 <span class="keyword">struct </span>SkMemberInfo; -00014 <span class="keyword">class </span><a class="code" href="classSkPaint.html">SkPaint</a>; -00015 <span class="keyword">struct </span>SkRect; -00016 <span class="keyword">class </span>SkStream; -00017 <span class="keyword">class </span>SkXMLParserError; -00018 <span class="keyword">class </span>SkDOM; -00019 <span class="keyword">struct </span>SkDOMNode; -00020 -00023 <span class="keyword">enum</span> SkElementType { -00024 kElementDummyType -00025 }; -00028 <span class="keyword">enum</span> SkFieldType { -00029 kFieldDummyType -00030 }; -00031 -<a name="l00072"></a><a class="code" href="classSkAnimator.html">00072</a> <span class="keyword">class </span><a class="code" href="classSkAnimator.html">SkAnimator</a> : <span class="keyword">public</span> <a class="code" href="classSkEventSink.html">SkEventSink</a> { -00073 <span class="keyword">public</span>: -00074 <a class="code" href="classSkAnimator.html">SkAnimator</a>(); -00075 <span class="keyword">virtual</span> ~<a class="code" href="classSkAnimator.html">SkAnimator</a>(); -00076 -00080 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a2">addExtras</a>(SkExtras* extras); -00081 -00088 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a3">appendStream</a>(SkStream* stream); -00089 -00097 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a4">decodeMemory</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t size); -00098 -00105 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a5">decodeStream</a>(SkStream* stream); -00106 -00112 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a6">decodeDOM</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOMNode*); -00113 -00120 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a7">decodeURI</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> uri[]); -00121 -00128 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a8">doCharEvent</a>(SkUnichar ch); -00129 -00140 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a9">doClickEvent</a>(<span class="keywordtype">int</span> state, SkScalar x, SkScalar y); -00141 -00148 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a10">doKeyEvent</a>(SkKey code); -00149 <span class="keywordtype">bool</span> doKeyUpEvent(SkKey code); -00150 -00155 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a12">doUserEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& evt); -00156 -<a name="l00159"></a><a class="code" href="classSkAnimator.html#w4">00159</a> <span class="keyword">enum</span> <a class="code" href="classSkAnimator.html#w4">DifferenceType</a> { -00160 kNotDifferent, -00161 kDifferent, -00162 kPartiallyDifferent -00163 }; -00175 DifferenceType <a class="code" href="classSkAnimator.html#a13">draw</a>(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas, <a class="code" href="classSkPaint.html">SkPaint</a>* paint, SkMSec time); -00176 -00188 DifferenceType <a class="code" href="classSkAnimator.html#a13">draw</a>(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas, SkMSec time); -00189 -00196 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a15">findClickEvent</a>(SkScalar x, SkScalar y); -00197 -00198 -00204 <span class="keyword">const</span> <a class="code" href="classSkAnimator.html">SkAnimator</a>* <a class="code" href="classSkAnimator.html#a16">getAnimator</a>(<span class="keyword">const</span> SkDisplayable* element) <span class="keyword">const</span>; -00205 -00212 int32_t <a class="code" href="classSkAnimator.html#a17">getArrayInt</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field, <span class="keywordtype">int</span> index); -00213 -00220 int32_t <a class="code" href="classSkAnimator.html#a17">getArrayInt</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName, <span class="keywordtype">int</span> index); -00221 -00228 SkScalar <a class="code" href="classSkAnimator.html#a19">getArrayScalar</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field, <span class="keywordtype">int</span> index); -00229 -00236 SkScalar <a class="code" href="classSkAnimator.html#a19">getArrayScalar</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName, <span class="keywordtype">int</span> index); -00237 -00244 <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkAnimator.html#a21">getArrayString</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field, <span class="keywordtype">int</span> index); -00245 -00252 <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkAnimator.html#a21">getArrayString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName, <span class="keywordtype">int</span> index); -00253 -00258 <span class="keyword">const</span> SkDisplayable* <a class="code" href="classSkAnimator.html#a23">getElement</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID); -00259 -00265 SkElementType <a class="code" href="classSkAnimator.html#a24">getElementType</a>(<span class="keyword">const</span> SkDisplayable* element); -00266 -00271 SkElementType <a class="code" href="classSkAnimator.html#a24">getElementType</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID); -00272 -00278 <span class="keyword">const</span> SkMemberInfo* <a class="code" href="classSkAnimator.html#a26">getField</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName); -00279 -00285 <span class="keyword">const</span> SkMemberInfo* <a class="code" href="classSkAnimator.html#a26">getField</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName); -00286 -00292 SkFieldType <a class="code" href="classSkAnimator.html#a28">getFieldType</a>(<span class="keyword">const</span> SkMemberInfo* field); -00293 -00299 SkFieldType <a class="code" href="classSkAnimator.html#a28">getFieldType</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName); -00300 -00304 SkMSec <a class="code" href="classSkAnimator.html#a30">getInterval</a>(); -00305 -00308 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a31">getInvalBounds</a>(SkRect* inval); -00309 -00312 <span class="keyword">const</span> SkXMLParserError* <a class="code" href="classSkAnimator.html#a32">getParserError</a>(); -00313 -00316 <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkAnimator.html#a33">getParserErrorString</a>(); -00317 -00323 int32_t <a class="code" href="classSkAnimator.html#a34">getInt</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field); -00324 -00330 int32_t <a class="code" href="classSkAnimator.html#a34">getInt</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName); -00331 -00337 SkScalar <a class="code" href="classSkAnimator.html#a36">getScalar</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field); -00338 -00344 SkScalar <a class="code" href="classSkAnimator.html#a36">getScalar</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName); -00345 -00351 <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkAnimator.html#a38">getString</a>(<span class="keyword">const</span> SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field); -00352 -00358 <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkAnimator.html#a38">getString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName); -00359 -00361 <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkAnimator.html#a40">getURIBase</a>(); -00362 -00364 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a41">initialize</a>(); -00365 -00368 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a42">reset</a>(); -00369 -00376 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a43">setInt</a>(SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field, int32_t data); -00377 -00384 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a43">setInt</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName, int32_t data); -00385 -00392 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a45">setScalar</a>(SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field, SkScalar data); -00393 -00400 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a45">setScalar</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName, SkScalar data); -00401 -00408 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a47">setString</a>(SkDisplayable* element, <span class="keyword">const</span> SkMemberInfo* field, <span class="keyword">const</span> <span class="keywordtype">char</span>* data); -00409 -00416 <span class="keywordtype">bool</span> <a class="code" href="classSkAnimator.html#a47">setString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* elementID, <span class="keyword">const</span> <span class="keywordtype">char</span>* fieldName, <span class="keyword">const</span> <span class="keywordtype">char</span>* data); -00417 -<a name="l00422"></a><a class="code" href="classSkAnimator_1_1Timeline.html">00422</a> <span class="keyword">class </span><a class="code" href="classSkAnimator_1_1Timeline.html">Timeline</a> { -00423 <span class="keyword">public</span>: -00425 <span class="keyword">virtual</span> SkMSec <a class="code" href="classSkAnimator_1_1Timeline.html#a0">getMSecs</a>() <span class="keyword">const </span>= 0; -00426 }; -00427 -00432 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a49">setTimeline</a>(<span class="keyword">const</span> <a class="code" href="classSkAnimator_1_1Timeline.html">Timeline</a>& ); -00433 -00437 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a50">setURIBase</a>(<span class="keyword">const</span> <span class="keywordtype">char</span>* path); -00438 -00439 <span class="keyword">static</span> <span class="keywordtype">void</span> Init(<span class="keywordtype">bool</span> runUnitTests); -00440 <span class="keyword">static</span> <span class="keywordtype">void</span> Term(); -00441 -00447 <span class="keywordtype">void</span> <a class="code" href="classSkAnimator.html#a51">setHostEventSinkID</a>(SkEventSinkID hostID); -00448 SkEventSinkID getHostEventSinkID() <span class="keyword">const</span>; -00449 -00450 <span class="comment">// helper</span> -00451 <span class="keywordtype">void</span> setHostEventSink(<a class="code" href="classSkEventSink.html">SkEventSink</a>* sink) { -00452 this-><a class="code" href="classSkAnimator.html#a51">setHostEventSinkID</a>(sink ? sink->getSinkID() : 0); -00453 } -00454 -00455 <span class="keyword">typedef</span> <span class="keywordtype">void</span>* Handler; -00456 <span class="keyword">virtual</span> <span class="keywordtype">void</span> setHostHandler(Handler handler); -00457 <span class="keyword">virtual</span> <span class="keywordtype">void</span> setJavaOwner(Handler owner); -00458 -00459 <span class="preprocessor">#ifdef SK_DEBUG</span> -00460 <span class="preprocessor"></span> <span class="keyword">virtual</span> <span class="keywordtype">void</span> eventDone(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& evt); -00461 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> isTrackingEvents(); -00462 <span class="keyword">static</span> <span class="keywordtype">bool</span> NoLeaks(); -00463 <span class="preprocessor">#endif </span> -00464 <span class="preprocessor"></span> -00465 <span class="keyword">protected</span>: -00466 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onEventPost(<a class="code" href="classSkEvent.html">SkEvent</a>*, SkEventSinkID); -00467 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onEventPostTime(<a class="code" href="classSkEvent.html">SkEvent</a>*, SkEventSinkID, SkMSec time); -00468 -00469 <span class="keyword">private</span>: -00470 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#b0">onEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00471 SkAnimateMaker* fMaker; -00472 <span class="keyword">friend</span> <span class="keyword">class </span>SkAnimateMaker; -00473 <span class="keyword">friend</span> <span class="keyword">class </span>SkAnimatorScript; -00474 <span class="keyword">friend</span> <span class="keyword">class </span>SkAnimatorScript2; -00475 <span class="keyword">friend</span> <span class="keyword">class </span>SkApply; -00476 <span class="keyword">friend</span> <span class="keyword">class </span>SkDisplayMovie; -00477 <span class="keyword">friend</span> <span class="keyword">class </span>SkDisplayType; -00478 <span class="keyword">friend</span> <span class="keyword">class </span>SkPost; -00479 <span class="keyword">friend</span> <span class="keyword">class </span>SkXMLAnimatorWriter; -00480 }; -00481 -00482 <span class="preprocessor">#endif</span> -00483 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkApplication_8h-source.html b/sgl_doxygen/html/SkApplication_8h-source.html deleted file mode 100644 index 435b606..0000000 --- a/sgl_doxygen/html/SkApplication_8h-source.html +++ /dev/null @@ -1,24 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkApplication.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkApplication.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkApplication_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkApplication_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="keyword">class </span>SkOSWindow; -00005 -00006 <span class="keyword">extern</span> SkOSWindow* create_sk_window(<span class="keywordtype">void</span>* hwnd); -00007 <span class="keyword">extern</span> <span class="keywordtype">void</span> application_init(); -00008 <span class="keyword">extern</span> <span class="keywordtype">void</span> application_term(); -00009 -00010 <span class="preprocessor">#endif // SkApplication_DEFINED</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBGViewArtist_8h-source.html b/sgl_doxygen/html/SkBGViewArtist_8h-source.html deleted file mode 100644 index 3f783b5..0000000 --- a/sgl_doxygen/html/SkBGViewArtist_8h-source.html +++ /dev/null @@ -1,39 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBGViewArtist.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBGViewArtist.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBGViewArtist_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBGViewArtist_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkPaint.h"</span> -00006 -00007 <span class="keyword">class </span>SkBGViewArtist : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a>::Artist { -00008 <span class="keyword">public</span>: -00009 SkBGViewArtist(SkColor c = SK_ColorWHITE); -00010 <span class="keyword">virtual</span> ~SkBGViewArtist(); -00011 -00012 <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fPaint; } -00013 <a class="code" href="classSkPaint.html">SkPaint</a>& paint() { <span class="keywordflow">return</span> fPaint; } -00014 -00015 <span class="keyword">protected</span>: -00016 <span class="comment">// overrides</span> -00017 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkView.html">SkView</a>*, <a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00018 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00019 -00020 <span class="keyword">private</span>: -00021 <a class="code" href="classSkPaint.html">SkPaint</a> fPaint; -00022 }; -00023 -00024 <span class="preprocessor">#endif</span> -00025 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBML__WXMLParser_8h-source.html b/sgl_doxygen/html/SkBML__WXMLParser_8h-source.html deleted file mode 100644 index 9425e27..0000000 --- a/sgl_doxygen/html/SkBML__WXMLParser_8h-source.html +++ /dev/null @@ -1,50 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBML_WXMLParser.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBML_WXMLParser.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBML_WXMLParser_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBML_WXMLParser_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkString.h"</span> -00005 <span class="preprocessor">#include "SkXMLParser.h"</span> -00006 -00007 <span class="keyword">class </span>SkStream; -00008 <span class="keyword">class </span>SkWStream; -00009 -00010 <span class="keyword">class </span>BML_WXMLParser : <span class="keyword">public</span> SkXMLParser { -00011 <span class="keyword">public</span>: -00012 BML_WXMLParser(SkWStream& writer); -00013 <span class="keyword">virtual</span> ~BML_WXMLParser(); -00014 <span class="keyword">static</span> <span class="keywordtype">void</span> Write(SkStream& s, <span class="keyword">const</span> <span class="keywordtype">char</span> filename[]); -00015 -00017 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00019 <span class="keyword">private</span>: -00020 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onAddAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]); -00021 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEndElement(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00022 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onStartElement(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00023 BML_WXMLParser& operator=(<span class="keyword">const</span> BML_WXMLParser& src); -00024 <span class="preprocessor">#ifdef SK_DEBUG</span> -00025 <span class="preprocessor"></span> <span class="keywordtype">int</span> fElemsCount, fElemsReused; -00026 <span class="keywordtype">int</span> fAttrsCount, fNamesReused, fValuesReused; -00027 <span class="preprocessor">#endif</span> -00028 <span class="preprocessor"></span> SkWStream& fWriter; -00029 <span class="keywordtype">char</span>* fElems[256]; -00030 <span class="keywordtype">char</span>* fAttrNames[256]; -00031 <span class="keywordtype">char</span>* fAttrValues[256]; -00032 -00033 <span class="comment">// important that these are U8, so we get automatic wrap-around</span> -00034 U8 fNextElem, fNextAttrName, fNextAttrValue; -00035 }; -00036 -00037 <span class="preprocessor">#endif // SkBML_WXMLParser_DEFINED</span> -00038 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBML__XMLParser_8h-source.html b/sgl_doxygen/html/SkBML__XMLParser_8h-source.html deleted file mode 100644 index 97bcbda..0000000 --- a/sgl_doxygen/html/SkBML__XMLParser_8h-source.html +++ /dev/null @@ -1,31 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBML_XMLParser.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBML_XMLParser.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBML_XMLParser_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBML_XMLParser_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="keyword">class </span>SkStream; -00005 <span class="keyword">class </span>SkWStream; -00006 <span class="keyword">class </span>SkXMLParser; -00007 <span class="keyword">class </span>SkXMLWriter; -00008 -00009 <span class="keyword">class </span>BML_XMLParser { -00010 <span class="keyword">public</span>: -00013 <span class="keyword">static</span> <span class="keywordtype">void</span> Read(SkStream& s, SkXMLWriter& writer); -00016 <span class="keyword">static</span> <span class="keywordtype">void</span> Read(SkStream& s, SkWStream& output); -00019 <span class="keyword">static</span> <span class="keywordtype">void</span> Read(SkStream& s, SkXMLParser& output); -00020 }; -00021 -00022 <span class="preprocessor">#endif // SkBML_XMLParser_DEFINED</span> -00023 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBitmapRef_8h-source.html b/sgl_doxygen/html/SkBitmapRef_8h-source.html deleted file mode 100644 index 230c3d5..0000000 --- a/sgl_doxygen/html/SkBitmapRef_8h-source.html +++ /dev/null @@ -1,64 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBitmapRef.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBitmapRef.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBitmapRef_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBitmapRef_DEFINED </span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkBitmap.h"</span> -00005 -00006 <span class="keyword">class </span>SkStream; -00007 -<a name="l00010"></a><a class="code" href="classSkBitmapRef.html">00010</a> <span class="keyword">class </span><a class="code" href="classSkBitmapRef.html">SkBitmapRef</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00011 <span class="keyword">public</span>: -00014 <a class="code" href="classSkBitmapRef.html#a0">SkBitmapRef</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& src, <span class="keywordtype">bool</span> transferOwnsPixels); -00015 <span class="keyword">virtual</span> ~<a class="code" href="classSkBitmapRef.html">SkBitmapRef</a>(); -00016 -00017 <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& bitmap(); -00018 -00019 <span class="keyword">static</span> <a class="code" href="classSkBitmapRef.html">SkBitmapRef</a>* create(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& src, <span class="keywordtype">bool</span> transferOwnsPixels); -00020 <span class="keyword">static</span> <a class="code" href="classSkBitmapRef.html">SkBitmapRef</a>* DecodeFile(<span class="keyword">const</span> <span class="keywordtype">char</span> file[], <span class="keywordtype">bool</span> forceDecode); -00021 <span class="keyword">static</span> <a class="code" href="classSkBitmapRef.html">SkBitmapRef</a>* DecodeMemory(<span class="keyword">const</span> <span class="keywordtype">void</span>* bytes, size_t len); -00022 <span class="keyword">static</span> <a class="code" href="classSkBitmapRef.html">SkBitmapRef</a>* DecodeStream(SkStream* stream); -00023 -00026 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkBitmapRef.html#e4">PurgeCacheAll</a>(); -00027 -00030 <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkBitmapRef.html#e5">PurgeCacheOne</a>(); -00031 -00032 <span class="keyword">private</span>: -00033 <span class="keyword">struct </span>Rec; -00034 Rec* fRec; -00035 -00036 <a class="code" href="classSkBitmapRef.html#a0">SkBitmapRef</a>(Rec*); -00037 -00038 <span class="keyword">friend</span> <span class="keyword">class </span>SkBitmapRef_Globals; -00039 }; -00040 -00041 <span class="keyword">class </span>SkAutoBitmapRef { -00042 <span class="keyword">public</span>: -00043 SkAutoBitmapRef(<span class="keyword">const</span> <span class="keywordtype">char</span> file[], <span class="keywordtype">bool</span> forceDecode) -00044 { -00045 fRef = SkBitmapRef::DecodeFile(file, forceDecode); -00046 } -00047 ~SkAutoBitmapRef() { <span class="keyword">delete</span> fRef; } -00048 -00049 <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>* bitmap()<span class="keyword"> const</span> -00050 <span class="keyword"> </span>{ -00051 <span class="keywordflow">return</span> fRef ? &fRef-><a class="code" href="classSkBitmapRef.html#a2">bitmap</a>() : nil; -00052 } -00053 <span class="keyword">private</span>: -00054 <a class="code" href="classSkBitmapRef.html">SkBitmapRef</a>* fRef; -00055 }; -00056 -00057 -00058 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBitmap_8h-source.html b/sgl_doxygen/html/SkBitmap_8h-source.html deleted file mode 100644 index e5008fa..0000000 --- a/sgl_doxygen/html/SkBitmap_8h-source.html +++ /dev/null @@ -1,257 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBitmap.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBitmap.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBitmap_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBitmap_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "<a class="code" href="SkColor_8h.html">SkColor.h</a>"</span> -00005 <span class="preprocessor">#include "SkRefCnt.h"</span> -00006 -00007 <span class="comment">// Android - we need to run as an embedded product, not X11</span> -00008 <span class="comment">//#ifdef SK_BUILD_FOR_UNIX</span> -00009 <span class="comment">//#include <X11/Xlib.h></span> -00010 <span class="comment">//#endif</span> -00011 -00012 -00013 <span class="keyword">class </span><a class="code" href="classSkColorTable.html">SkColorTable</a>; -00014 -<a name="l00022"></a><a class="code" href="classSkBitmap.html">00022</a> <span class="keyword">class </span><a class="code" href="classSkBitmap.html">SkBitmap</a> { -00023 <span class="keyword">public</span>: -<a name="l00024"></a><a class="code" href="classSkBitmap.html#w7">00024</a> <span class="keyword">enum</span> <a class="code" href="classSkBitmap.html#w7">Config</a> { -00025 kNo_Config, -00026 <a class="code" href="classSkBitmap.html#w7w1">kA1_Config</a>, -00027 <a class="code" href="classSkBitmap.html#w7w2">kA8_Config</a>, -00028 <a class="code" href="classSkBitmap.html#w7w3">kIndex8_Config</a>, -00029 <a class="code" href="classSkBitmap.html#w7w4">kRGB_565_Config</a>, -00030 <a class="code" href="classSkBitmap.html#w7w5">kARGB_8888_Config</a>, -00031 -00032 kConfigCount -00033 }; -00034 -00038 <a class="code" href="classSkBitmap.html#a0">SkBitmap</a>(); -00042 <a class="code" href="classSkBitmap.html#a0">SkBitmap</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& src); -00045 <a class="code" href="classSkBitmap.html#a2">~SkBitmap</a>(); -00046 -00050 <a class="code" href="classSkBitmap.html">SkBitmap</a>& <a class="code" href="classSkBitmap.html#a3">operator=</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& src); -00053 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a4">swap</a>(<a class="code" href="classSkBitmap.html">SkBitmap</a>& other); -00054 -<a name="l00057"></a><a class="code" href="classSkBitmap.html#a5">00057</a> <a class="code" href="classSkBitmap.html#w7">Config</a> <a class="code" href="classSkBitmap.html#a5">getConfig</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<a class="code" href="classSkBitmap.html#w7">Config</a>)fConfig; } -<a name="l00060"></a><a class="code" href="classSkBitmap.html#a6">00060</a> <span class="keywordtype">unsigned</span> <a class="code" href="classSkBitmap.html#a6">width</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fWidth; } -<a name="l00063"></a><a class="code" href="classSkBitmap.html#a7">00063</a> <span class="keywordtype">unsigned</span> <a class="code" href="classSkBitmap.html#a7">height</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fHeight; } -<a name="l00066"></a><a class="code" href="classSkBitmap.html#a8">00066</a> <span class="keywordtype">unsigned</span> <a class="code" href="classSkBitmap.html#a8">rowBytes</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fRowBytes; } -<a name="l00072"></a><a class="code" href="classSkBitmap.html#a9">00072</a> <span class="keywordtype">void</span>* <a class="code" href="classSkBitmap.html#a9">getPixels</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fPixels; } -<a name="l00075"></a><a class="code" href="classSkBitmap.html#a10">00075</a> size_t <a class="code" href="classSkBitmap.html#a10">getSize</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fHeight * fRowBytes; } -00076 -00079 <span class="keywordtype">bool</span> <a class="code" href="classSkBitmap.html#a11">isOpaque</a>() <span class="keyword">const</span>; -00083 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a12">setIsOpaque</a>(<span class="keywordtype">bool</span>); -00084 -00088 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a13">reset</a>(); -00093 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a14">setConfig</a>(Config, U16CPU width, U16CPU height, U16CPU rowBytes = 0); -00098 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a15">setPixels</a>(<span class="keywordtype">void</span>* p); -00103 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a16">allocPixels</a>(); -00108 <span class="comment">// not implemented</span> -00109 <span class="comment">// void resizeAlloc(U16CPU width, U16CPU height);</span> -00110 -00114 <span class="keywordtype">bool</span> <a class="code" href="classSkBitmap.html#a17">getOwnsPixels</a>() <span class="keyword">const</span>; -00119 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a18">setOwnsPixels</a>(<span class="keywordtype">bool</span> ownsPixels); -00120 -<a name="l00124"></a><a class="code" href="classSkBitmap.html#a19">00124</a> <a class="code" href="classSkColorTable.html">SkColorTable</a>* <a class="code" href="classSkBitmap.html#a19">getColorTable</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fColorTable; } -00132 <a class="code" href="classSkColorTable.html">SkColorTable</a>* <a class="code" href="classSkBitmap.html#a20">setColorTable</a>(<a class="code" href="classSkColorTable.html">SkColorTable</a>* ctable); -00133 -00138 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a21">eraseARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b); -<a name="l00144"></a><a class="code" href="classSkBitmap.html#a22">00144</a> <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a22">eraseRGB</a>(U8CPU r, U8CPU g, U8CPU b) -00145 { -00146 this-><a class="code" href="classSkBitmap.html#a21">eraseARGB</a>(0xFF, r, g, b); -00147 } -<a name="l00152"></a><a class="code" href="classSkBitmap.html#a23">00152</a> <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a23">eraseColor</a>(SkColor c) -00153 { -00154 this-><a class="code" href="classSkBitmap.html#a21">eraseARGB</a>(<a class="code" href="SkColor_8h.html#a1">SkColorGetA</a>(c), <a class="code" href="SkColor_8h.html#a2">SkColorGetR</a>(c), <a class="code" href="SkColor_8h.html#a3">SkColorGetG</a>(c), <a class="code" href="SkColor_8h.html#a4">SkColorGetB</a>(c)); -00155 } -00156 -00160 <span class="keyword">inline</span> uint32_t* <a class="code" href="classSkBitmap.html#a24">getAddr32</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y) <span class="keyword">const</span>; -00164 <span class="keyword">inline</span> uint16_t* <a class="code" href="classSkBitmap.html#a25">getAddr16</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y) <span class="keyword">const</span>; -00168 <span class="keyword">inline</span> uint8_t* <a class="code" href="classSkBitmap.html#a26">getAddr8</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y) <span class="keyword">const</span>; -00172 <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> <a class="code" href="classSkBitmap.html#a27">getIndex8Color</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y) <span class="keyword">const</span>; -00176 <span class="keyword">inline</span> uint8_t* <a class="code" href="classSkBitmap.html#a28">getAddr1</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y) <span class="keyword">const</span>; -00177 -00178 <span class="preprocessor">#ifdef SK_SUPPORT_16_8_BITMAP</span> -00179 <span class="preprocessor"></span> uint8_t* getA8Plane()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fA8Plane; } -00180 <span class="keywordtype">void</span> setA8Plane(U8* plane) { fA8Plane = plane; } -00181 <span class="keywordtype">unsigned</span> getA8PlaneRowBytes()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fA8PlaneRowBytes; } -00182 <span class="keywordtype">void</span> setA8PlaneRowBytes(U16CPU rb) { fA8PlaneRowBytes = SkToU16(rb); } -00183 <span class="preprocessor">#endif</span> -00184 <span class="preprocessor"></span> -00190 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a29">applyGamma</a>(<span class="keyword">const</span> U8 red[256], <span class="keyword">const</span> U8 green[256], <span class="keyword">const</span> U8 blue[256]); -00191 <span class="keywordtype">void</span> <a class="code" href="classSkBitmap.html#a29">applyGamma</a>(<span class="keyword">const</span> U8 table[256]) -00192 { -00193 this-><a class="code" href="classSkBitmap.html#a29">applyGamma</a>(table, table, table); -00194 } -00195 -00196 <span class="comment">// OS-specific helpers</span> -00197 <span class="preprocessor">#ifndef SK_USE_WXWIDGETS</span> -00198 <span class="preprocessor"></span><span class="preprocessor">#ifdef SK_BUILD_FOR_WIN</span> -00199 <span class="preprocessor"></span> -00202 <span class="keywordtype">void</span> drawToHDC(HDC, <span class="keywordtype">int</span> left, <span class="keywordtype">int</span> top) <span class="keyword">const</span>; -00203 <span class="preprocessor">#elif defined(SK_BUILD_FOR_MAC)</span> -00204 <span class="preprocessor"></span> -00207 <span class="keywordtype">void</span> drawToPort(WindowRef) <span class="keyword">const</span>; -00208 <span class="preprocessor">#elif defined(SK_BUILD_FOR_UNIX)</span> -00209 <span class="preprocessor"></span> -00212 <span class="comment">//void drawToWin(Display*, Window) const;</span> -00213 <span class="comment">// not implemented</span> -00214 <span class="comment">// void drawToWin(void*, void*) const;</span> -00215 <span class="preprocessor">#endif</span> -00216 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00217 <span class="preprocessor"></span> -00218 <span class="preprocessor">#ifdef SK_SUPPORT_MIPMAP</span> -00219 <span class="preprocessor"></span> <span class="keyword">struct </span>MipLevel { -00220 <span class="keywordtype">void</span>* fPixels; -00221 uint16_t fWidth, fHeight, fRowBytes; -00222 uint8_t fConfig, fShift; -00223 }; -00224 <span class="keywordtype">void</span> buildMipMap(); -00225 <span class="keywordtype">unsigned</span> countMipLevels() <span class="keyword">const</span>; -00226 <span class="keyword">const</span> MipLevel* getMipLevel(<span class="keywordtype">unsigned</span> level) <span class="keyword">const</span>; -00227 <span class="preprocessor">#endif</span> -00228 <span class="preprocessor"></span> -00229 <span class="keyword">private</span>: -00230 <a class="code" href="classSkColorTable.html">SkColorTable</a>* fColorTable; <span class="comment">// only meaningful for kIndex8</span> -00231 <span class="preprocessor">#ifdef SK_SUPPORT_16_8_BITMAP</span> -00232 <span class="preprocessor"></span> U8* fA8Plane; -00233 uint16_t fA8PlaneRowBytes; -00234 <span class="preprocessor">#endif</span> -00235 <span class="preprocessor"></span> -00236 <span class="preprocessor">#ifdef SK_SUPPORT_MIPMAP</span> -00237 <span class="preprocessor"></span> <span class="keyword">enum</span> { -00238 kMaxMipLevels = 5 -00239 }; -00240 <span class="keyword">struct </span>MipMap { -00241 MipLevel fLevel[kMaxMipLevels]; -00242 }; -00243 MipMap* fMipMap; -00244 <span class="preprocessor">#endif</span> -00245 <span class="preprocessor"></span> -00246 <span class="keyword">enum</span> Flags { -00247 kWeOwnThePixels_Flag = 0x01, -00248 kWeOwnTheMipMap_Flag = 0x02, -00249 kImageIsOpaque_Flag = 0x04 -00250 }; -00251 -00252 <span class="keywordtype">void</span>* fPixels; -00253 uint16_t fWidth, fHeight, fRowBytes; -00254 uint8_t fConfig; -00255 uint8_t fFlags; -00256 -00257 <span class="keywordtype">void</span> freePixels(); -00258 }; -00259 -<a name="l00265"></a><a class="code" href="classSkColorTable.html">00265</a> <span class="keyword">class </span><a class="code" href="classSkColorTable.html">SkColorTable</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00266 <span class="keyword">public</span>: -00269 <a class="code" href="classSkColorTable.html#a0">SkColorTable</a>(); -00270 <span class="keyword">virtual</span> ~<a class="code" href="classSkColorTable.html">SkColorTable</a>(); -00271 -<a name="l00272"></a><a class="code" href="classSkColorTable.html#w1">00272</a> <span class="keyword">enum</span> <a class="code" href="classSkColorTable.html#w1">Flags</a> { -00273 <a class="code" href="classSkColorTable.html#w1w0">kColorsAreOpaque_Flag</a> = 0x01 -00274 }; -<a name="l00277"></a><a class="code" href="classSkColorTable.html#a2">00277</a> <span class="keywordtype">unsigned</span> <a class="code" href="classSkColorTable.html#a2">getFlags</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFlags; } -00280 <span class="keywordtype">void</span> <a class="code" href="classSkColorTable.html#a3">setFlags</a>(<span class="keywordtype">unsigned</span> flags); -00281 -<a name="l00284"></a><a class="code" href="classSkColorTable.html#a4">00284</a> <span class="keywordtype">int</span> <a class="code" href="classSkColorTable.html#a4">count</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount; } -00285 -<a name="l00289"></a><a class="code" href="classSkColorTable.html#a5">00289</a> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> <a class="code" href="classSkColorTable.html#a5">operator[]</a>(<span class="keywordtype">int</span> index)<span class="keyword"> const</span> -00290 <span class="keyword"> </span>{ -00291 SkASSERT(fColors != nil && (<span class="keywordtype">unsigned</span>)index < fCount); -00292 <span class="keywordflow">return</span> fColors[index]; -00293 } -00294 -<a name="l00300"></a><a class="code" href="classSkColorTable.html#a6">00300</a> <span class="keywordtype">void</span> <a class="code" href="classSkColorTable.html#a6">setColors</a>(<span class="keywordtype">int</span> count) { this-><a class="code" href="classSkColorTable.html#a6">setColors</a>(nil, count); } -00301 <span class="keywordtype">void</span> <a class="code" href="classSkColorTable.html#a6">setColors</a>(<span class="keyword">const</span> SkPMColor[], <span class="keywordtype">int</span> count); -00302 -<a name="l00307"></a><a class="code" href="classSkColorTable.html#a8">00307</a> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a>* <a class="code" href="classSkColorTable.html#a8">lockColors</a>() -00308 { -00309 SkDEBUGCODE(fColorLockCount += 1;) -00310 <span class="keywordflow">return</span> fColors; -00311 } -<a name="l00314"></a><a class="code" href="classSkColorTable.html#a9">00314</a> <span class="keywordtype">void</span> <a class="code" href="classSkColorTable.html#a9">unlockColors</a>(<span class="keywordtype">bool</span> changed) -00315 { -00316 SkASSERT(fColorLockCount != 0); -00317 SkDEBUGCODE(fColorLockCount -= 1;) -00318 } -00319 -00325 <span class="keyword">const</span> uint16_t* <a class="code" href="classSkColorTable.html#a10">lock16BitCache</a>(); -<a name="l00328"></a><a class="code" href="classSkColorTable.html#a11">00328</a> <span class="keywordtype">void</span> <a class="code" href="classSkColorTable.html#a11">unlock16BitCache</a>() -00329 { -00330 SkASSERT(f16BitCacheLockCount > 0); -00331 SkDEBUGCODE(f16BitCacheLockCount -= 1); -00332 } -00333 -00334 <span class="keyword">private</span>: -00335 <a class="code" href="SkColor_8h.html#a18">SkPMColor</a>* fColors; -00336 uint16_t* f16BitCache; -00337 uint16_t fCount; -00338 uint8_t fFlags; -00339 SkDEBUGCODE(<span class="keywordtype">int</span> fColorLockCount;) -00340 SkDEBUGCODE(<span class="keywordtype">int</span> f16BitCacheLockCount;) -00341 -00342 <span class="keywordtype">void</span> inval16BitCache(); -00343 }; -00344 -00346 -<a name="l00347"></a><a class="code" href="classSkBitmap.html#a24">00347</a> <span class="keyword">inline</span> uint32_t* <a class="code" href="classSkBitmap.html#a24">SkBitmap::getAddr32</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00348 <span class="keyword"></span>{ -00349 SkASSERT(fPixels); -00350 SkASSERT(fConfig == <a class="code" href="classSkBitmap.html#w7w5">kARGB_8888_Config</a>); -00351 SkASSERT((<span class="keywordtype">unsigned</span>)x < fWidth && (<span class="keywordtype">unsigned</span>)y < fHeight); -00352 -00353 <span class="keywordflow">return</span> (uint32_t*)((<span class="keywordtype">char</span>*)fPixels + y * fRowBytes + (x << 2)); -00354 } -00355 -<a name="l00356"></a><a class="code" href="classSkBitmap.html#a25">00356</a> <span class="keyword">inline</span> uint16_t* <a class="code" href="classSkBitmap.html#a25">SkBitmap::getAddr16</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00357 <span class="keyword"></span>{ -00358 SkASSERT(fPixels); -00359 SkASSERT(fConfig == <a class="code" href="classSkBitmap.html#w7w4">kRGB_565_Config</a>); -00360 SkASSERT((<span class="keywordtype">unsigned</span>)x < fWidth && (<span class="keywordtype">unsigned</span>)y < fHeight); -00361 -00362 <span class="keywordflow">return</span> (uint16_t*)((<span class="keywordtype">char</span>*)fPixels + y * fRowBytes + (x << 1)); -00363 } -00364 -<a name="l00365"></a><a class="code" href="classSkBitmap.html#a26">00365</a> <span class="keyword">inline</span> uint8_t* <a class="code" href="classSkBitmap.html#a26">SkBitmap::getAddr8</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00366 <span class="keyword"></span>{ -00367 SkASSERT(fPixels); -00368 SkASSERT(fConfig == <a class="code" href="classSkBitmap.html#w7w2">kA8_Config</a> || fConfig == <a class="code" href="classSkBitmap.html#w7w3">kIndex8_Config</a>); -00369 SkASSERT((<span class="keywordtype">unsigned</span>)x < fWidth && (<span class="keywordtype">unsigned</span>)y < fHeight); -00370 <span class="keywordflow">return</span> (uint8_t*)fPixels + y * fRowBytes + x; -00371 } -00372 -<a name="l00373"></a><a class="code" href="classSkBitmap.html#a27">00373</a> <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> <a class="code" href="classSkBitmap.html#a27">SkBitmap::getIndex8Color</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00374 <span class="keyword"></span>{ -00375 SkASSERT(fPixels); -00376 SkASSERT(fConfig == <a class="code" href="classSkBitmap.html#w7w3">kIndex8_Config</a>); -00377 SkASSERT((<span class="keywordtype">unsigned</span>)x < fWidth && (<span class="keywordtype">unsigned</span>)y < fHeight); -00378 SkASSERT(fColorTable); -00379 <span class="keywordflow">return</span> (*fColorTable)[*((<span class="keyword">const</span> uint8_t*)fPixels + y * fRowBytes + x)]; -00380 } -00381 -00382 <span class="comment">// returns the address of the byte that contains the x coordinate</span> -<a name="l00383"></a><a class="code" href="classSkBitmap.html#a28">00383</a> <span class="keyword">inline</span> uint8_t* <a class="code" href="classSkBitmap.html#a28">SkBitmap::getAddr1</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00384 <span class="keyword"></span>{ -00385 SkASSERT(fPixels); -00386 SkASSERT(fConfig == <a class="code" href="classSkBitmap.html#w7w1">kA1_Config</a>); -00387 SkASSERT((<span class="keywordtype">unsigned</span>)x < fWidth && (<span class="keywordtype">unsigned</span>)y < fHeight); -00388 <span class="keywordflow">return</span> (uint8_t*)fPixels + y * fRowBytes + (x >> 3); -00389 } -00390 -00391 -00392 <span class="preprocessor">#endif</span> -00393 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBlurMaskFilter_8h-source.html b/sgl_doxygen/html/SkBlurMaskFilter_8h-source.html deleted file mode 100644 index 24e0075..0000000 --- a/sgl_doxygen/html/SkBlurMaskFilter_8h-source.html +++ /dev/null @@ -1,49 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBlurMaskFilter.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBlurMaskFilter.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBlurMaskFilter_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBlurMaskFilter_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMaskFilter.h"</span> -00005 -00006 <span class="keyword">class </span>SkBlurMaskFilter : <span class="keyword">public</span> <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a> { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">enum</span> BlurStyle { -00009 kNormal_BlurStyle, -00010 kSolid_BlurStyle, -00011 kOuter_BlurStyle, -00012 kInner_BlurStyle, -00013 -00014 kBlurStyleCount -00015 }; -00021 SkBlurMaskFilter(SkScalar radius, BlurStyle style); -00022 <span class="keyword">virtual</span> ~SkBlurMaskFilter(); -00023 -00024 <span class="comment">// overrides from SkMaskFilter</span> -00025 <span class="keyword">virtual</span> <a class="code" href="structSkMask.html#w3">SkMask::Format</a> <a class="code" href="classSkMaskFilter.html#a0">getFormat</a>(); -00026 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkMaskFilter.html#a1">filterMask</a>(<a class="code" href="structSkMask.html">SkMask</a>* dst, <span class="keyword">const</span> <a class="code" href="structSkMask.html">SkMask</a>& src, <span class="keyword">const</span> SkMatrix& matrix, SkIPoint* margin); -00027 -00028 <span class="comment">// overrides from SkFlattenable</span> -00029 <span class="keyword">virtual</span> Factory getFactory(); -00030 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00031 -00032 <span class="keyword">private</span>: -00033 SkScalar fRadius; -00034 BlurStyle fBlurStyle; -00035 -00036 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00037 }; -00038 -00039 <span class="preprocessor">#endif</span> -00040 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBorderView_8h-source.html b/sgl_doxygen/html/SkBorderView_8h-source.html deleted file mode 100644 index bd5ee6b..0000000 --- a/sgl_doxygen/html/SkBorderView_8h-source.html +++ /dev/null @@ -1,45 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBorderView.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBorderView.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBorderView_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBorderView_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkWidgetViews.h"</span> -00006 <span class="preprocessor">#include "SkAnimator.h"</span> -00007 -00008 <span class="keyword">class </span>SkBorderView : <span class="keyword">public</span> SkWidgetView { -00009 <span class="keyword">public</span>: -00010 SkBorderView(); -00011 ~SkBorderView(); -00012 <span class="keywordtype">void</span> setSkin(<span class="keyword">const</span> <span class="keywordtype">char</span> skin[]); -00013 SkScalar getLeft()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fLeft; } -00014 SkScalar getRight()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fRight; } -00015 SkScalar getTop()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTop; } -00016 SkScalar getBottom()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fBottom; } -00017 <span class="keyword">protected</span>: -00018 <span class="comment">//overrides</span> -00019 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00020 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00021 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas); -00022 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& evt); -00023 <span class="keyword">private</span>: -00024 <a class="code" href="classSkAnimator.html">SkAnimator</a> fAnim; -00025 SkScalar fLeft, fRight, fTop, fBottom; <span class="comment">//margin on each side</span> -00026 SkRect fMargin; -00027 -00028 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00029 }; -00030 -00031 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkBounder_8h-source.html b/sgl_doxygen/html/SkBounder_8h-source.html deleted file mode 100644 index 83c2aeb..0000000 --- a/sgl_doxygen/html/SkBounder_8h-source.html +++ /dev/null @@ -1,44 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBounder.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkBounder.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkBounder_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkBounder_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 <span class="preprocessor">#include "SkRefCnt.h"</span> -00006 -00007 <span class="keyword">struct </span>SkRect16; -00008 <span class="keyword">struct </span>SkPoint; -00009 <span class="keyword">struct </span>SkRect; -00010 <span class="keyword">class </span><a class="code" href="classSkPaint.html">SkPaint</a>; -00011 <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a>; -00012 <span class="keyword">class </span>SkRegion; -00013 -<a name="l00019"></a><a class="code" href="classSkBounder.html">00019</a> <span class="keyword">class </span><a class="code" href="classSkBounder.html">SkBounder</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00020 <span class="keyword">public</span>: -00021 <span class="keywordtype">bool</span> doIRect(<span class="keyword">const</span> SkRect16&, <span class="keyword">const</span> SkRegion&); -00022 <span class="keywordtype">bool</span> doHairline(<span class="keyword">const</span> SkPoint&, <span class="keyword">const</span> SkPoint&, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&, <span class="keyword">const</span> SkRegion&); -00023 <span class="keywordtype">bool</span> doRect(<span class="keyword">const</span> SkRect&, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&, <span class="keyword">const</span> SkRegion&); -00024 <span class="keywordtype">bool</span> doPath(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&, <span class="keyword">const</span> SkRegion&, SkScalar width); -00025 -00026 <span class="keyword">protected</span>: -00033 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkBounder.html#b0">onIRect</a>(<span class="keyword">const</span> SkRect16&) = 0; -00034 -00039 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkBounder.html#b1">commit</a>(); -00040 -00041 <span class="keyword">friend</span> <span class="keyword">class </span>SkAutoBounderCommit; -00042 }; -00043 -00044 <span class="preprocessor">#endif</span> -00045 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkCamera_8h-source.html b/sgl_doxygen/html/SkCamera_8h-source.html deleted file mode 100644 index ab2cc8e..0000000 --- a/sgl_doxygen/html/SkCamera_8h-source.html +++ /dev/null @@ -1,94 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkCamera.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkCamera.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkCamera_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkCamera_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMatrix.h"</span> -00005 <span class="preprocessor">#include "Sk64.h"</span> -00006 -00007 <span class="preprocessor">#ifdef SK_SCALAR_IS_FIXED</span> -00008 <span class="preprocessor"></span> <span class="keyword">typedef</span> SkFract SkUnitScalar; -00009 <span class="preprocessor"> #define SK_UnitScalar1 SK_Fract1</span> -00010 <span class="preprocessor"></span><span class="preprocessor"> #define SkUnitScalarMul(a, b) SkFractMul(a, b)</span> -00011 <span class="preprocessor"></span><span class="preprocessor"> #define SkUnitScalarDiv(a, b) SkFractDiv(a, b)</span> -00012 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00013 <span class="preprocessor"></span> <span class="keyword">typedef</span> <span class="keywordtype">float</span> SkUnitScalar; -00014 <span class="preprocessor"> #define SK_UnitScalar1 SK_Scalar1</span> -00015 <span class="preprocessor"></span><span class="preprocessor"> #define SkUnitScalarMul(a, b) SkScalarMul(a, b)</span> -00016 <span class="preprocessor"></span><span class="preprocessor"> #define SkUnitScalarDiv(a, b) SkScalarDiv(a, b)</span> -00017 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00018 <span class="preprocessor"></span> -00019 <span class="comment">// Taken from Rob Johnson's most excellent QuickDraw GX library</span> -00020 -00021 <span class="keyword">struct </span>SkUnit3D { -00022 SkUnitScalar fX, fY, fZ; -00023 -00024 <span class="keywordtype">void</span> set(SkUnitScalar x, SkUnitScalar y, SkUnitScalar z) -00025 { -00026 fX = x; fY = y; fZ = z; -00027 } -00028 <span class="keyword">static</span> SkUnitScalar Dot(<span class="keyword">const</span> SkUnit3D&, <span class="keyword">const</span> SkUnit3D&); -00029 <span class="keyword">static</span> <span class="keywordtype">void</span> Cross(<span class="keyword">const</span> SkUnit3D&, <span class="keyword">const</span> SkUnit3D&, SkUnit3D* cross); -00030 }; -00031 -00032 <span class="keyword">struct </span>SkPoint3D { -00033 SkScalar fX, fY, fZ; -00034 -00035 <span class="keywordtype">void</span> set(SkScalar x, SkScalar y, SkScalar z) -00036 { -00037 fX = x; fY = y; fZ = z; -00038 } -00039 SkScalar normalize(SkUnit3D*) <span class="keyword">const</span>; -00040 }; -00041 -00042 <span class="keyword">class </span>SkPatch3D { -00043 <span class="keyword">public</span>: -00044 SkPatch3D(); -00045 -00046 <span class="keywordtype">void</span> reset(); -00047 <span class="keywordtype">void</span> rotate(SkScalar radX, SkScalar radY, SkScalar radZ); -00048 <span class="keywordtype">void</span> rotateDegrees(SkScalar degX, SkScalar degY, SkScalar degZ) -00049 { -00050 this->rotate(SkDegreesToRadians(degX), -00051 SkDegreesToRadians(degY), -00052 SkDegreesToRadians(degZ)); -00053 } -00054 -00055 <span class="comment">// dot a unit vector with the patch's normal</span> -00056 SkScalar dotWith(SkScalar dx, SkScalar dy, SkScalar dz) <span class="keyword">const</span>; -00057 -00058 SkPoint3D fU, fV, fOrigin; -00059 <span class="keyword">private</span>: -00060 <span class="keyword">friend</span> <span class="keyword">class </span>SkCamera3D; -00061 }; -00062 -00063 <span class="keyword">class </span>SkCamera3D { -00064 <span class="keyword">public</span>: -00065 SkCamera3D(); -00066 -00067 <span class="keywordtype">void</span> update(); -00068 <span class="keywordtype">void</span> computeMatrix(<span class="keyword">const</span> SkPatch3D&, SkMatrix* matrix) <span class="keyword">const</span>; -00069 -00070 SkPoint3D fLocation; -00071 SkPoint3D fAxis; -00072 SkPoint3D fZenith; -00073 SkPoint3D fObserver; -00074 -00075 <span class="keyword">private</span>: -00076 SkMatrix fOrientation; -00077 }; -00078 -00079 <span class="preprocessor">#endif</span> -00080 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkCanvas_8h-source.html b/sgl_doxygen/html/SkCanvas_8h-source.html deleted file mode 100644 index fe3238b..0000000 --- a/sgl_doxygen/html/SkCanvas_8h-source.html +++ /dev/null @@ -1,143 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkCanvas.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkCanvas.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkCanvas_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkCanvas_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkBitmap.h"</span> -00005 <span class="preprocessor">#include "SkDeque.h"</span> -00006 <span class="preprocessor">#include "SkPaint.h"</span> -00007 <span class="preprocessor">#include "SkPath.h"</span> -00008 <span class="preprocessor">#include "SkRegion.h"</span> -00009 -00010 <span class="keyword">class </span><a class="code" href="classSkBounder.html">SkBounder</a>; -00011 -<a name="l00019"></a><a class="code" href="classSkCanvas.html">00019</a> <span class="keyword">class </span><a class="code" href="classSkCanvas.html">SkCanvas</a> { -00020 <span class="keyword">public</span>: -00021 <a class="code" href="classSkCanvas.html">SkCanvas</a>(); -00022 <a class="code" href="classSkCanvas.html">SkCanvas</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&); -00023 ~<a class="code" href="classSkCanvas.html">SkCanvas</a>(); -00024 -00028 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a3">getPixels</a>(<a class="code" href="classSkBitmap.html">SkBitmap</a>*) <span class="keyword">const</span>; -00033 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a4">setPixels</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&); -00034 -00040 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a5">save</a>(); -00045 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a6">restore</a>(); -00049 <span class="keywordtype">int</span> <a class="code" href="classSkCanvas.html#a7">getSaveCount</a>() <span class="keyword">const</span>; -00052 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a8">restoreToCount</a>(<span class="keywordtype">int</span> saveCount); -00053 -00059 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a9">translate</a>(SkScalar dx, SkScalar dy); -00068 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a10">scale</a>(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py); -00076 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a11">rotate</a>(SkScalar degrees, SkScalar px, SkScalar py); -00085 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a12">skew</a>(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py); -00089 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a13">concat</a>(<span class="keyword">const</span> SkMatrix&); -00090 -00094 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a14">clipRect</a>(<span class="keyword">const</span> SkRect&); -<a name="l00098"></a><a class="code" href="classSkCanvas.html#a15">00098</a> <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a14">clipRect</a>(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom) -00099 { -00100 SkRect r; -00101 r.set(left, top, right, bottom); -00102 this-><a class="code" href="classSkCanvas.html#a14">clipRect</a>(r); -00103 } -00107 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a16">clipPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&); -00117 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a17">quickReject</a>(<span class="keyword">const</span> SkRect&, <span class="keywordtype">bool</span> antialiased = <span class="keyword">false</span>) <span class="keyword">const</span>; -00129 <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a17">quickReject</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&, <span class="keywordtype">bool</span> antialiased = <span class="keyword">false</span>) <span class="keyword">const</span>; -<a name="l00132"></a><a class="code" href="classSkCanvas.html#a19">00132</a> <span class="keywordtype">bool</span> <a class="code" href="classSkCanvas.html#a17">quickReject</a>(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, <span class="keywordtype">bool</span> antialiased = <span class="keyword">false</span>)<span class="keyword"> const</span> -00133 <span class="keyword"> </span>{ -00134 SkRect r; -00135 r.set(left, top, right, bottom); -00136 <span class="keywordflow">return</span> this-><a class="code" href="classSkCanvas.html#a17">quickReject</a>(r, antialiased); -00137 } -00138 -00142 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a20">drawRGB</a>(U8CPU r, U8CPU g, U8CPU b); -00146 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a21">drawARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b); -00150 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a22">drawColor</a>(SkColor); -00151 -00156 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a23">drawPaint</a>(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00161 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a24">drawLine</a>(<span class="keyword">const</span> SkPoint& start, <span class="keyword">const</span> SkPoint& stop, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00166 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a24">drawLine</a>(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00170 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a26">drawRect</a>(<span class="keyword">const</span> SkRect&, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00174 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a27">drawOval</a>(<span class="keyword">const</span> SkRect& oval, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00179 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a28">drawCircle</a>(SkScalar cx, SkScalar cy, SkScalar radius, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00185 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a29">drawRoundRect</a>(<span class="keyword">const</span> SkRect&, SkScalar rx, SkScalar ry, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00189 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a30">drawPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00192 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a31">drawBitmap</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&, SkScalar x, SkScalar y, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00195 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a31">drawBitmap</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&, SkScalar x, SkScalar y); -00202 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a33">drawText</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t byteLength, SkScalar x, SkScalar y, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00209 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a34">drawText16</a>(<span class="keyword">const</span> U16 text[], size_t numberOf16BitValues, SkScalar x, SkScalar y, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00218 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a35">drawTextOnPath</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t byteLength, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& path, SkScalar offset, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint); -00227 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a36">drawText16OnPath</a>(<span class="keyword">const</span> U16 text[], size_t numberOf16BitValues, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& path, SkScalar offset, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint); -00228 -00232 U32 <a class="code" href="classSkCanvas.html#a37">getPaintSetBits</a>() <span class="keyword">const</span>; -00236 U32 <a class="code" href="classSkCanvas.html#a38">getPaintClearBits</a>() <span class="keyword">const</span>; -00242 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a39">setPaintSetClearBits</a>(U32 setBits, U32 clrBits); -00246 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a40">orPaintSetClearBits</a>(U32 setBits, U32 clearBits); -00247 -00254 <span class="keywordtype">void</span> <a class="code" href="classSkCanvas.html#a41">clipDeviceRgn</a>(<span class="keyword">const</span> SkRegion& deviceRgn); -00255 -<a name="l00258"></a><a class="code" href="classSkCanvas.html#a42">00258</a> <a class="code" href="classSkBounder.html">SkBounder</a>* <a class="code" href="classSkCanvas.html#a42">getBounder</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fBounder; } -00263 <a class="code" href="classSkBounder.html">SkBounder</a>* <a class="code" href="classSkCanvas.html#a43">setBounder</a>(<a class="code" href="classSkBounder.html">SkBounder</a>*); -00264 -00265 <span class="comment">// needs to be public for our type traits trick in SkCanvas.cpp. If that can be fixed,</span> -00266 <span class="comment">// change back to private.</span> -00267 <span class="keyword">struct </span>MCRec { -00268 MCRec* fNext; -00269 SkMatrix fMatrix; -00270 <span class="keyword">mutable</span> SkMatrix::MapPtProc fMapPtProc; -00271 SkRegion fRegion; -00272 U8 fSetPaintBits; -00273 U8 fClearPaintBits; -00274 -00275 MCRec() {} -00276 MCRec(<span class="keyword">const</span> MCRec& other) -00277 : fMatrix(other.fMatrix), fRegion(other.fRegion) -00278 { -00279 <span class="comment">// don't bother initializing fNext</span> -00280 fMapPtProc = other.fMapPtProc; -00281 fSetPaintBits = other.fSetPaintBits; -00282 fClearPaintBits = other.fClearPaintBits; -00283 } -00284 }; -00285 -00286 <span class="keyword">private</span>: -00287 SkSTDeque<8, MCRec> fMCStack; -00288 MCRec* fMCRec; <span class="comment">// points to top of stack</span> -00289 -00290 <a class="code" href="classSkBitmap.html">SkBitmap</a> fBitmap; -00291 <a class="code" href="classSkBounder.html">SkBounder</a>* fBounder; -00292 -00293 <span class="keyword">friend</span> <span class="keyword">class </span>SkDraw; -00294 }; -00295 -<a name="l00300"></a><a class="code" href="classSkAutoCanvasRestore.html">00300</a> <span class="keyword">class </span><a class="code" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a> { -00301 <span class="keyword">public</span>: -00302 <a class="code" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a>(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas, <span class="keywordtype">bool</span> doSave) : fCanvas(canvas) -00303 { -00304 SkASSERT(canvas); -00305 fSaveCount = canvas->getSaveCount(); -00306 <span class="keywordflow">if</span> (doSave) -00307 canvas->save(); -00308 } -00309 ~<a class="code" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a>() -00310 { -00311 fCanvas-><a class="code" href="classSkCanvas.html#a8">restoreToCount</a>(fSaveCount); -00312 } -00313 -00314 <span class="keyword">private</span>: -00315 <a class="code" href="classSkCanvas.html">SkCanvas</a>* fCanvas; -00316 <span class="keywordtype">int</span> fSaveCount; -00317 }; -00318 -00319 <span class="preprocessor">#endif</span> -00320 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkColorPriv_8h-source.html b/sgl_doxygen/html/SkColorPriv_8h-source.html deleted file mode 100644 index 24efa5e..0000000 --- a/sgl_doxygen/html/SkColorPriv_8h-source.html +++ /dev/null @@ -1,210 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkColorPriv.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkColorPriv.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkColorPriv_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkColorPriv_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "<a class="code" href="SkColor_8h.html">SkColor.h</a>"</span> -00005 -00006 <span class="keyword">inline</span> <span class="keywordtype">unsigned</span> SkAlpha255To256(U8CPU alpha) -00007 { -00008 SkASSERT(SkToU8(alpha) == alpha); -00009 <span class="keywordflow">return</span> alpha + (alpha >> 7); -00010 } -00011 -00012 <span class="preprocessor">#define SkAlphaMul(value, alpha256) ((value) * (alpha256) >> 8)</span> -00013 <span class="preprocessor"></span> -00014 <span class="comment">// The caller may want negative values, so keep all params signed (int)</span> -00015 <span class="comment">// so we don't accidentally slip into unsigned math and lose the sign</span> -00016 <span class="comment">// extension when we shift (in SkAlphaMul)</span> -00017 <span class="keyword">inline</span> <span class="keywordtype">int</span> SkAlphaBlend(<span class="keywordtype">int</span> src, <span class="keywordtype">int</span> dst, <span class="keywordtype">int</span> scale256) -00018 { -00019 SkASSERT((<span class="keywordtype">unsigned</span>)scale256 <= 256); -00020 <span class="keywordflow">return</span> dst + SkAlphaMul(src - dst, scale256); -00021 } -00022 -00023 <span class="preprocessor">#ifdef SK_BITMAP_16BIT_IS_555</span> -00024 <span class="preprocessor"></span><span class="preprocessor"> #define SK_R16_BITS 5</span> -00025 <span class="preprocessor"></span><span class="preprocessor"> #define SK_G16_BITS 5</span> -00026 <span class="preprocessor"></span><span class="preprocessor"> #define SK_B16_BITS 5</span> -00027 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00028 <span class="preprocessor"></span><span class="preprocessor"> #define SK_R16_BITS 5</span> -00029 <span class="preprocessor"></span><span class="preprocessor"> #define SK_G16_BITS 6</span> -00030 <span class="preprocessor"></span><span class="preprocessor"> #define SK_B16_BITS 5</span> -00031 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00032 <span class="preprocessor"></span> -00033 <span class="preprocessor">#define SK_R16_SHIFT (SK_B16_BITS + SK_G16_BITS)</span> -00034 <span class="preprocessor"></span><span class="preprocessor">#define SK_G16_SHIFT (SK_B16_BITS)</span> -00035 <span class="preprocessor"></span><span class="preprocessor">#define SK_B16_SHIFT 0</span> -00036 <span class="preprocessor"></span> -00037 <span class="preprocessor">#define SK_R16_MASK ((1 << SK_R16_BITS) - 1)</span> -00038 <span class="preprocessor"></span><span class="preprocessor">#define SK_G16_MASK ((1 << SK_G16_BITS) - 1)</span> -00039 <span class="preprocessor"></span><span class="preprocessor">#define SK_B16_MASK ((1 << SK_B16_BITS) - 1)</span> -00040 <span class="preprocessor"></span> -00041 <span class="preprocessor">#define SkGetPackedR16(color) (((unsigned)(color) >> SK_R16_SHIFT) & SK_R16_MASK)</span> -00042 <span class="preprocessor"></span><span class="preprocessor">#define SkGetPackedG16(color) (((unsigned)(color) >> SK_G16_SHIFT) & SK_G16_MASK)</span> -00043 <span class="preprocessor"></span><span class="preprocessor">#define SkGetPackedB16(color) (((unsigned)(color) >> SK_B16_SHIFT) & SK_B16_MASK)</span> -00044 <span class="preprocessor"></span> -00045 <span class="keyword">inline</span> U16 SkPackRGB16(<span class="keywordtype">unsigned</span> r, <span class="keywordtype">unsigned</span> g, <span class="keywordtype">unsigned</span> b) -00046 { -00047 SkASSERT(r <= SK_R16_MASK); -00048 SkASSERT(g <= SK_G16_MASK); -00049 SkASSERT(b <= SK_B16_MASK); -00050 -00051 <span class="keywordflow">return</span> SkToU16((r << SK_R16_SHIFT) | (g << SK_G16_SHIFT) | (b << SK_B16_SHIFT)); -00052 } -00053 -00054 <span class="preprocessor">#define SK_R16_MASK_IN_PLACE (SK_R16_MASK << SK_R16_SHIFT)</span> -00055 <span class="preprocessor"></span><span class="preprocessor">#define SK_G16_MASK_IN_PLACE (SK_G16_MASK << SK_G16_SHIFT)</span> -00056 <span class="preprocessor"></span><span class="preprocessor">#define SK_B16_MASK_IN_PLACE (SK_B16_MASK << SK_B16_SHIFT)</span> -00057 <span class="preprocessor"></span> -00058 <span class="preprocessor">#define SK_R16B16_MASK_IN_PLACE (SK_R16_MASK_IN_PLACE | SK_B16_MASK_IN_PLACE)</span> -00059 <span class="preprocessor"></span> -00060 <span class="keyword">inline</span> U16CPU SkAlphaMulRGB16(U16CPU c, <span class="keywordtype">unsigned</span> scale) -00061 { -00062 <span class="preprocessor">#if SK_G16_MASK_IN_PLACE != 0x07E0</span> -00063 <span class="preprocessor"></span> <span class="keywordflow">return</span> SkPackRGB16( SkAlphaMul(SkGetPackedR16(c), scale), -00064 SkAlphaMul(SkGetPackedG16(c), scale), -00065 SkAlphaMul(SkGetPackedB16(c), scale)); -00066 <span class="preprocessor">#else</span> -00067 <span class="preprocessor"></span> scale >>= (8 - SK_G16_BITS); -00068 uint32_t rb = (c & SK_R16B16_MASK_IN_PLACE) * scale >> SK_G16_BITS; -00069 uint32_t g = (c & SK_G16_MASK_IN_PLACE) * scale >> SK_G16_BITS; -00070 <span class="keywordflow">return</span> (g & SK_G16_MASK_IN_PLACE) | (rb & SK_R16B16_MASK_IN_PLACE); -00071 <span class="preprocessor">#endif</span> -00072 <span class="preprocessor"></span>} -00073 -00074 <span class="keyword">inline</span> U16CPU SkBlendRGB16(U16CPU src, U16CPU dst, <span class="keywordtype">unsigned</span> scale) -00075 { -00076 SkASSERT(scale <= 256); -00077 -00078 <span class="keywordflow">return</span> SkPackRGB16( SkAlphaBlend(SkGetPackedR16(src), SkGetPackedR16(dst), scale), -00079 SkAlphaBlend(SkGetPackedG16(src), SkGetPackedG16(dst), scale), -00080 SkAlphaBlend(SkGetPackedB16(src), SkGetPackedB16(dst), scale)); -00081 } -00082 -00084 -00085 <span class="preprocessor">#define SK_A32_BITS 8</span> -00086 <span class="preprocessor"></span><span class="preprocessor">#define SK_R32_BITS 8</span> -00087 <span class="preprocessor"></span><span class="preprocessor">#define SK_G32_BITS 8</span> -00088 <span class="preprocessor"></span><span class="preprocessor">#define SK_B32_BITS 8</span> -00089 <span class="preprocessor"></span> -00090 <span class="preprocessor">#define SK_A32_SHIFT 24</span> -00091 <span class="preprocessor"></span><span class="preprocessor">#define SK_R32_SHIFT 16</span> -00092 <span class="preprocessor"></span><span class="preprocessor">#define SK_G32_SHIFT 8</span> -00093 <span class="preprocessor"></span><span class="preprocessor">#define SK_B32_SHIFT 0</span> -00094 <span class="preprocessor"></span> -00095 <span class="preprocessor">#define SK_A32_MASK ((1 << SK_A32_BITS) - 1)</span> -00096 <span class="preprocessor"></span><span class="preprocessor">#define SK_R32_MASK ((1 << SK_R32_BITS) - 1)</span> -00097 <span class="preprocessor"></span><span class="preprocessor">#define SK_G32_MASK ((1 << SK_G32_BITS) - 1)</span> -00098 <span class="preprocessor"></span><span class="preprocessor">#define SK_B32_MASK ((1 << SK_B32_BITS) - 1)</span> -00099 <span class="preprocessor"></span> -00100 <span class="preprocessor">#define SkGetPackedA32(packed) ((uint32_t)((packed) << (24 - SK_A32_SHIFT)) >> 24)</span> -00101 <span class="preprocessor"></span><span class="preprocessor">#define SkGetPackedR32(packed) ((uint32_t)((packed) << (24 - SK_R32_SHIFT)) >> 24)</span> -00102 <span class="preprocessor"></span><span class="preprocessor">#define SkGetPackedG32(packed) ((uint32_t)((packed) << (24 - SK_G32_SHIFT)) >> 24)</span> -00103 <span class="preprocessor"></span><span class="preprocessor">#define SkGetPackedB32(packed) ((uint32_t)((packed) << (24 - SK_B32_SHIFT)) >> 24)</span> -00104 <span class="preprocessor"></span> -00105 <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> SkPackARGB32(U8CPU a, U8CPU r, U8CPU g, U8CPU b) -00106 { -00107 SkASSERT(a <= SK_A32_MASK); -00108 SkASSERT(r <= a); -00109 SkASSERT(g <= a); -00110 SkASSERT(b <= a); -00111 -00112 <span class="keywordflow">return</span> (a << SK_A32_SHIFT) | (r << SK_R32_SHIFT) | (g << SK_G32_SHIFT) | (b << SK_B32_SHIFT); -00113 } -00114 -00115 <span class="keyword">inline</span> uint32_t SkAlphaMulQ(uint32_t c, <span class="keywordtype">unsigned</span> scale) -00116 { -00117 uint32_t rb = ((c & 0xFF00FF) * scale) >> 8; -00118 uint32_t ag = ((c >> 8) & 0xFF00FF) * scale; -00119 <span class="keywordflow">return</span> (rb & 0xFF00FF) | (ag & ~0xFF00FF); -00120 } -00121 -00122 <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> SkPMSrcOver(SkPMColor src, SkPMColor dst) -00123 { -00124 <span class="keywordflow">return</span> src + SkAlphaMulQ(dst, SkAlpha255To256(255 - SkGetPackedA32(src))); -00125 } -00126 -00127 <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> SkBlendARGB32(SkPMColor src, SkPMColor dst, U8CPU aa) -00128 { -00129 SkASSERT((<span class="keywordtype">unsigned</span>)aa <= 255); -00130 -00131 <span class="keywordtype">unsigned</span> src_scale = SkAlpha255To256(aa); -00132 <span class="keywordtype">unsigned</span> dst_scale = SkAlpha255To256(255 - SkAlphaMul(SkGetPackedA32(src), src_scale)); -00133 -00134 <span class="keywordflow">return</span> SkAlphaMulQ(src, src_scale) + SkAlphaMulQ(dst, dst_scale); -00135 } -00136 -00138 <span class="comment">// Convert a 32bit pixel to a 16bit pixel (no dither)</span> -00139 -00140 <span class="preprocessor">#define SkR32ToR16(r) ((unsigned)(r) >> (SK_R32_BITS - SK_R16_BITS))</span> -00141 <span class="preprocessor"></span><span class="preprocessor">#define SkG32ToG16(g) ((unsigned)(g) >> (SK_G32_BITS - SK_G16_BITS))</span> -00142 <span class="preprocessor"></span><span class="preprocessor">#define SkB32ToB16(b) ((unsigned)(b) >> (SK_B32_BITS - SK_B16_BITS))</span> -00143 <span class="preprocessor"></span> -00144 <span class="preprocessor">#define SkPacked32ToR16(c) (((unsigned)(c) >> (SK_R32_SHIFT + SK_R32_BITS - SK_R16_BITS)) & SK_R16_MASK)</span> -00145 <span class="preprocessor"></span><span class="preprocessor">#define SkPacked32ToG16(c) (((unsigned)(c) >> (SK_G32_SHIFT + SK_G32_BITS - SK_G16_BITS)) & SK_G16_MASK)</span> -00146 <span class="preprocessor"></span><span class="preprocessor">#define SkPacked32ToB16(c) (((unsigned)(c) >> (SK_B32_SHIFT + SK_B32_BITS - SK_B16_BITS)) & SK_B16_MASK)</span> -00147 <span class="preprocessor"></span> -00148 <span class="keyword">inline</span> U16CPU SkPixel32ToPixel16(SkPMColor src) -00149 { -00150 <span class="preprocessor">#if 0</span> -00151 <span class="preprocessor"></span> <span class="keywordflow">return</span> (SkPacked32ToR16(src) << SK_R16_SHIFT) | -00152 (SkPacked32ToG16(src) << SK_G16_SHIFT) | -00153 (SkPacked32ToB16(src) << SK_B16_SHIFT); -00154 <span class="preprocessor">#else // only works if the components are in the same order in both formats (i.e. foo32_shift >= foo16_shift)</span> -00155 <span class="preprocessor"></span> <span class="keywordflow">return</span> ((src >> (SK_R32_SHIFT + SK_R32_BITS - SK_R16_BITS - SK_R16_SHIFT)) & (SK_R16_MASK << SK_R16_SHIFT)) | -00156 ((src >> (SK_G32_SHIFT + SK_G32_BITS - SK_G16_BITS - SK_G16_SHIFT)) & (SK_G16_MASK << SK_G16_SHIFT)) | -00157 ((src >> (SK_B32_SHIFT + SK_B32_BITS - SK_B16_BITS - SK_B16_SHIFT)) & (SK_B16_MASK << SK_B16_SHIFT)); -00158 <span class="preprocessor">#endif</span> -00159 <span class="preprocessor"></span>} -00160 -00161 <span class="preprocessor">#define SkPixel32ToPixel16_ToU16(src) SkToU16(SkPixel32ToPixel16(src))</span> -00162 <span class="preprocessor"></span> -00164 <span class="comment">// Convert a 16bit pixel to a 32bit pixel</span> -00165 -00166 <span class="keyword">inline</span> <span class="keywordtype">unsigned</span> SkR16ToR32(<span class="keywordtype">unsigned</span> r) -00167 { -00168 <span class="keywordflow">return</span> (r << (8 - SK_R16_BITS)) | (r >> (2 * SK_R16_BITS - 8)); -00169 } -00170 <span class="keyword">inline</span> <span class="keywordtype">unsigned</span> SkG16ToG32(<span class="keywordtype">unsigned</span> g) -00171 { -00172 <span class="keywordflow">return</span> (g << (8 - SK_G16_BITS)) | (g >> (2 * SK_G16_BITS - 8)); -00173 } -00174 <span class="keyword">inline</span> <span class="keywordtype">unsigned</span> SkB16ToB32(<span class="keywordtype">unsigned</span> b) -00175 { -00176 <span class="keywordflow">return</span> (b << (8 - SK_B16_BITS)) | (b >> (2 * SK_B16_BITS - 8)); -00177 } -00178 -00179 <span class="preprocessor">#define SkPacked16ToR32(c) SkR16ToR32(SkGetPackedR16(c))</span> -00180 <span class="preprocessor"></span><span class="preprocessor">#define SkPacked16ToG32(c) SkG16ToG32(SkGetPackedG16(c))</span> -00181 <span class="preprocessor"></span><span class="preprocessor">#define SkPacked16ToB32(c) SkB16ToB32(SkGetPackedB16(c))</span> -00182 <span class="preprocessor"></span> -00183 <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> SkPixel16ToPixel32(U16CPU src) -00184 { -00185 SkASSERT(src == SkToU16(src)); -00186 -00187 <span class="keywordtype">unsigned</span> r = SkPacked16ToR32(src); -00188 <span class="keywordtype">unsigned</span> g = SkPacked16ToG32(src); -00189 <span class="keywordtype">unsigned</span> b = SkPacked16ToB32(src); -00190 -00191 SkASSERT((r >> (8 - SK_R16_BITS)) == SkGetPackedR16(src)); -00192 SkASSERT((g >> (8 - SK_G16_BITS)) == SkGetPackedG16(src)); -00193 SkASSERT((b >> (8 - SK_B16_BITS)) == SkGetPackedB16(src)); -00194 -00195 <span class="keywordflow">return</span> SkPackARGB32(0xFF, r, g, b); -00196 } -00197 -00198 <span class="preprocessor">#endif</span> -00199 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkColor_8h-source.html b/sgl_doxygen/html/SkColor_8h-source.html deleted file mode 100644 index dce0704..0000000 --- a/sgl_doxygen/html/SkColor_8h-source.html +++ /dev/null @@ -1,60 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkColor.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkColor.h</h1><a href="SkColor_8h.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkColor_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkColor_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -<a name="l00013"></a><a class="code" href="SkColor_8h.html#a16">00013</a> <span class="keyword">typedef</span> uint8_t <a class="code" href="SkColor_8h.html#a16">SkAlpha</a>; -<a name="l00019"></a><a class="code" href="SkColor_8h.html#a17">00019</a> <span class="keyword">typedef</span> uint32_t <a class="code" href="SkColor_8h.html#a17">SkColor</a>; -00020 -<a name="l00023"></a><a class="code" href="SkColor_8h.html#a19">00023</a> <span class="keyword">inline</span> <a class="code" href="SkColor_8h.html#a17">SkColor</a> <a class="code" href="SkColor_8h.html#a19">SkColorSetARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b) -00024 { -00025 SkASSERT(a <= 255 && r <= 255 && g <= 255 && b <= 255); -00026 -00027 <span class="keywordflow">return</span> (a << 24) | (r << 16) | (g << 8) | (b << 0); -00028 } -00029 -<a name="l00033"></a><a class="code" href="SkColor_8h.html#a0">00033</a> <span class="preprocessor">#define SkColorSetRGB(r, g, b) SkColorSetARGB(0xFF, r, g, b)</span> -00034 <span class="preprocessor"></span> -<a name="l00035"></a><a class="code" href="SkColor_8h.html#a1">00035</a> <span class="preprocessor">#define SkColorGetA(color) ((color) >> 24) </span> -<a name="l00036"></a><a class="code" href="SkColor_8h.html#a2">00036</a> <span class="preprocessor">#define SkColorGetR(color) ((color) << 8 >> 24) </span> -<a name="l00037"></a><a class="code" href="SkColor_8h.html#a3">00037</a> <span class="preprocessor">#define SkColorGetG(color) ((color) << 16 >> 24) </span> -<a name="l00038"></a><a class="code" href="SkColor_8h.html#a4">00038</a> <span class="preprocessor">#define SkColorGetB(color) ((color) << 24 >> 24) </span> -00039 <span class="preprocessor"></span> -00040 <span class="preprocessor"></span><span class="comment">// common colors</span> -00041 -<a name="l00042"></a><a class="code" href="SkColor_8h.html#a5">00042</a> <span class="preprocessor">#define SK_ColorBLACK 0xFF000000 </span> -<a name="l00043"></a><a class="code" href="SkColor_8h.html#a6">00043</a> <span class="preprocessor">#define SK_ColorDKGRAY 0xFF444444 </span> -<a name="l00044"></a><a class="code" href="SkColor_8h.html#a7">00044</a> <span class="preprocessor">#define SK_ColorGRAY 0xFF888888 </span> -<a name="l00045"></a><a class="code" href="SkColor_8h.html#a8">00045</a> <span class="preprocessor">#define SK_ColorLTGRAY 0xFFCCCCCC </span> -<a name="l00046"></a><a class="code" href="SkColor_8h.html#a9">00046</a> <span class="preprocessor">#define SK_ColorWHITE 0xFFFFFFFF </span> -00047 <span class="preprocessor"></span> -<a name="l00048"></a><a class="code" href="SkColor_8h.html#a10">00048</a> <span class="preprocessor"></span><span class="preprocessor">#define SK_ColorRED 0xFFFF0000 </span> -<a name="l00049"></a><a class="code" href="SkColor_8h.html#a11">00049</a> <span class="preprocessor">#define SK_ColorGREEN 0xFF00FF00 </span> -<a name="l00050"></a><a class="code" href="SkColor_8h.html#a12">00050</a> <span class="preprocessor">#define SK_ColorBLUE 0xFF0000FF </span> -<a name="l00051"></a><a class="code" href="SkColor_8h.html#a13">00051</a> <span class="preprocessor">#define SK_ColorYELLOW 0xFFFFFF00 </span> -<a name="l00052"></a><a class="code" href="SkColor_8h.html#a14">00052</a> <span class="preprocessor">#define SK_ColorCYAN 0xFF00FFFF </span> -<a name="l00053"></a><a class="code" href="SkColor_8h.html#a15">00053</a> <span class="preprocessor">#define SK_ColorMAGENTA 0xFFFF00FF </span> -00054 <span class="preprocessor"></span> -00055 <span class="preprocessor"></span> -00056 -<a name="l00061"></a><a class="code" href="SkColor_8h.html#a18">00061</a> <span class="keyword">typedef</span> uint32_t <a class="code" href="SkColor_8h.html#a18">SkPMColor</a>; -00062 -00065 <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> <a class="code" href="SkColor_8h.html#a20">SkPreMultiplyARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b); -00070 <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> <a class="code" href="SkColor_8h.html#a21">SkPreMultiplyColor</a>(SkColor c); -00071 -00072 <span class="preprocessor">#endif</span> -00073 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkColor_8h.html b/sgl_doxygen/html/SkColor_8h.html deleted file mode 100644 index ceaee19..0000000 --- a/sgl_doxygen/html/SkColor_8h.html +++ /dev/null @@ -1,330 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkColor.h File Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkColor.h File Reference</h1><code>#include "SkTypes.h"</code><br> - -<p> -<a href="SkColor_8h-source.html">Go to the source code of this file.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Defines</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a0">SkColorSetRGB</a>(r, g, b) SkColorSetARGB(0xFF, r, g, b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkColor.h::SkColorGetA"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a1">SkColorGetA</a>(color) ((color) >> 24)</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">return the alpha byte from a SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkColor.h::SkColorGetR"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a2">SkColorGetR</a>(color) ((color) << 8 >> 24)</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">return the red byte from a SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkColor.h::SkColorGetG"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a3">SkColorGetG</a>(color) ((color) << 16 >> 24)</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">return the green byte from a SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkColor.h::SkColorGetB"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a4">SkColorGetB</a>(color) ((color) << 24 >> 24)</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">return the blue byte from a SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkColor.h::SK_ColorBLACK"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a5">SK_ColorBLACK</a> 0xFF000000</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">black SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a6" doxytag="SkColor.h::SK_ColorDKGRAY"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a6">SK_ColorDKGRAY</a> 0xFF444444</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">dark gray SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a7" doxytag="SkColor.h::SK_ColorGRAY"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a7">SK_ColorGRAY</a> 0xFF888888</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">gray SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a8" doxytag="SkColor.h::SK_ColorLTGRAY"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a8">SK_ColorLTGRAY</a> 0xFFCCCCCC</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">light gray SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a9" doxytag="SkColor.h::SK_ColorWHITE"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a9">SK_ColorWHITE</a> 0xFFFFFFFF</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">white SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a10" doxytag="SkColor.h::SK_ColorRED"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a10">SK_ColorRED</a> 0xFFFF0000</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">red SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a11" doxytag="SkColor.h::SK_ColorGREEN"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a11">SK_ColorGREEN</a> 0xFF00FF00</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">green SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a12" doxytag="SkColor.h::SK_ColorBLUE"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a12">SK_ColorBLUE</a> 0xFF0000FF</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">blue SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a13" doxytag="SkColor.h::SK_ColorYELLOW"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a13">SK_ColorYELLOW</a> 0xFFFFFF00</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">yellow SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a14" doxytag="SkColor.h::SK_ColorCYAN"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a14">SK_ColorCYAN</a> 0xFF00FFFF</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">cyan SkColor value <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a15" doxytag="SkColor.h::SK_ColorMAGENTA"></a> -#define </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a15">SK_ColorMAGENTA</a> 0xFFFF00FF</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">magenta SkColor value <br></td></tr> -<tr><td colspan="2"><br><h2>Typedefs</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">typedef uint8_t </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a16">SkAlpha</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a17">SkColor</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">typedef uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a></td></tr> - -<tr><td colspan="2"><br><h2>Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a19">SkColorSetARGB</a> (U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a20">SkPreMultiplyARGB</a> (U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html#a21">SkPreMultiplyColor</a> (<a class="el" href="SkColor_8h.html#a17">SkColor</a> c)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Types and macros for colors<hr><h2>Define Documentation</h2> -<a class="anchor" name="a0" doxytag="SkColor.h::SkColorSetRGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">#define SkColorSetRGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">r, <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>g, <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>b </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> SkColorSetARGB(0xFF, r, g, b)</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a SkColor value from 8 bit component values, with an implied value of 0xFF for alpha (fully opaque) </td> - </tr> -</table> -<hr><h2>Typedef Documentation</h2> -<a class="anchor" name="a16" doxytag="SkColor.h::SkAlpha"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">typedef uint8_t <a class="el" href="SkColor_8h.html#a16">SkAlpha</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -8-bit type for an alpha value. 0xFF is 100% opaque, 0x00 is 100% transparent. </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkColor.h::SkColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">typedef uint32_t <a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -32 bit ARGB color value, not premultiplied. The color components are always in a known order. This is different from SkPMColor, which has its bytes in a configuration dependent order, to match the format of kARGB32 bitmaps. SkColor is the type used to specify colors in <a class="el" href="classSkPaint.html">SkPaint</a> and in gradients. </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkColor.h::SkPMColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">typedef uint32_t <a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -32 bit ARGB color value, premultiplied. The byte order for this value is configuration dependent, matching the format of kARGB32 bitmaps. This is different from SkColor, which is nonpremultiplied, and is always in the same byte order. </td> - </tr> -</table> -<hr><h2>Function Documentation</h2> -<a class="anchor" name="a19" doxytag="SkColor.h::SkColorSetARGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> SkColorSetARGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>a</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a SkColor value from 8 bit component values </td> - </tr> -</table> -<a class="anchor" name="a20" doxytag="SkColor.h::SkPreMultiplyARGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> SkPreMultiplyARGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>a</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a SkPMColor value from unpremultiplied 8 bit component values </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkColor.h::SkPreMultiplyColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> SkPreMultiplyColor </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - <td class="mdname1" valign="top" nowrap> <em>c</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a SkPMColor value from a SkColor value. This is done by multiplying the color components by the color's alpha, and by arranging the bytes in a configuration dependent order, to match the format of kARGB32 bitmaps. </td> - </tr> -</table> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkCornerPathEffect_8h-source.html b/sgl_doxygen/html/SkCornerPathEffect_8h-source.html deleted file mode 100644 index cf6e91b..0000000 --- a/sgl_doxygen/html/SkCornerPathEffect_8h-source.html +++ /dev/null @@ -1,46 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkCornerPathEffect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkCornerPathEffect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkCornerPathEffect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkCornerPathEffect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPathEffect.h"</span> -00005 -<a name="l00011"></a><a class="code" href="classSkCornerPathEffect.html">00011</a> <span class="keyword">class </span><a class="code" href="classSkCornerPathEffect.html">SkCornerPathEffect</a> : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00012 <span class="keyword">public</span>: -00016 <a class="code" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a>(SkScalar radius); -00017 <span class="keyword">virtual</span> ~<a class="code" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>(); -00018 -00019 <span class="comment">// overrides for SkPathEffect</span> -00020 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkCornerPathEffect.html#a2">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00021 -00022 <span class="comment">// overrides for SkFlattenable</span> -00023 <span class="keyword">virtual</span> Factory <a class="code" href="classSkCornerPathEffect.html#a3">getFactory</a>(); -00024 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00025 -00026 <span class="keyword">protected</span>: -00027 <a class="code" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00028 -00029 <span class="keyword">private</span>: -00030 SkScalar fRadius; -00031 -00032 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00033 -00034 <span class="comment">// illegal</span> -00035 <a class="code" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a>(<span class="keyword">const</span> <a class="code" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>&); -00036 <a class="code" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>&); -00037 }; -00038 -00039 <span class="preprocessor">#endif</span> -00040 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkDOM_8h-source.html b/sgl_doxygen/html/SkDOM_8h-source.html deleted file mode 100644 index 2efd623..0000000 --- a/sgl_doxygen/html/SkDOM_8h-source.html +++ /dev/null @@ -1,95 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDOM.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkDOM.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkDOM_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkDOM_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkChunkAlloc.h"</span> -00005 <span class="preprocessor">#include "SkMath.h"</span> -00006 <span class="preprocessor">#include "SkTemplates.h"</span> -00007 -00008 <span class="keyword">struct </span>SkDOMNode; -00009 <span class="keyword">struct </span>SkDOMAttr; -00010 -00011 <span class="keyword">class </span>SkDOM { -00012 <span class="keyword">public</span>: -00013 SkDOM(); -00014 ~SkDOM(); -00015 -00016 <span class="keyword">typedef</span> SkDOMNode Node; -00017 <span class="keyword">typedef</span> SkDOMAttr Attr; -00018 -00021 <span class="keyword">const</span> Node* build(<span class="keyword">const</span> <span class="keywordtype">char</span> doc[], size_t len); -00022 <span class="keyword">const</span> Node* copy(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> Node* node); -00023 -00024 <span class="keyword">const</span> Node* getRootNode() <span class="keyword">const</span>; -00025 -00026 <span class="keyword">enum</span> Type { -00027 kElement_Type, -00028 kText_Type -00029 }; -00030 Type getType(<span class="keyword">const</span> Node*) <span class="keyword">const</span>; -00031 -00032 <span class="keyword">const</span> <span class="keywordtype">char</span>* getName(<span class="keyword">const</span> Node*) <span class="keyword">const</span>; -00033 <span class="keyword">const</span> Node* getFirstChild(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> elem[] = nil) <span class="keyword">const</span>; -00034 <span class="keyword">const</span> Node* getNextSibling(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> elem[] = nil) <span class="keyword">const</span>; -00035 -00036 <span class="keyword">const</span> <span class="keywordtype">char</span>* findAttr(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> attrName[]) <span class="keyword">const</span>; -00037 <span class="keyword">const</span> Attr* getFirstAttr(<span class="keyword">const</span> Node*) <span class="keyword">const</span>; -00038 <span class="keyword">const</span> Attr* getNextAttr(<span class="keyword">const</span> Node*, <span class="keyword">const</span> Attr*) <span class="keyword">const</span>; -00039 <span class="keyword">const</span> <span class="keywordtype">char</span>* getAttrName(<span class="keyword">const</span> Node*, <span class="keyword">const</span> Attr*) <span class="keyword">const</span>; -00040 <span class="keyword">const</span> <span class="keywordtype">char</span>* getAttrValue(<span class="keyword">const</span> Node*, <span class="keyword">const</span> Attr*) <span class="keyword">const</span>; -00041 -00042 <span class="comment">// helpers for walking children</span> -00043 <span class="keywordtype">int</span> countChildren(<span class="keyword">const</span> Node* node, <span class="keyword">const</span> <span class="keywordtype">char</span> elem[] = nil) <span class="keyword">const</span>; -00044 -00045 <span class="comment">// helpers for calling SkParse</span> -00046 <span class="keywordtype">bool</span> findS32(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32* value) <span class="keyword">const</span>; -00047 <span class="keywordtype">bool</span> findScalars(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value[], <span class="keywordtype">int</span> count) <span class="keyword">const</span>; -00048 <span class="keywordtype">bool</span> findHex(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], U32* value) <span class="keyword">const</span>; -00049 <span class="keywordtype">bool</span> findBool(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span>*) <span class="keyword">const</span>; -00050 <span class="keywordtype">int</span> findList(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> list[]) <span class="keyword">const</span>; -00051 -00052 <span class="keywordtype">bool</span> findScalar(<span class="keyword">const</span> Node* node, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value[])<span class="keyword"> const</span> -00053 <span class="keyword"> </span>{ -00054 <span class="keywordflow">return</span> this->findScalars(node, name, value, 1); -00055 } -00056 -00057 <span class="keywordtype">bool</span> hasAttr(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]) <span class="keyword">const</span>; -00058 <span class="keywordtype">bool</span> hasS32(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32 value) <span class="keyword">const</span>; -00059 <span class="keywordtype">bool</span> hasScalar(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value) <span class="keyword">const</span>; -00060 <span class="keywordtype">bool</span> hasHex(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], U32 value) <span class="keyword">const</span>; -00061 <span class="keywordtype">bool</span> hasBool(<span class="keyword">const</span> Node*, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span> value) <span class="keyword">const</span>; -00062 -00063 <span class="keyword">class </span>AttrIter { -00064 <span class="keyword">public</span>: -00065 AttrIter(<span class="keyword">const</span> <span class="keyword">class</span> SkDOM&, <span class="keyword">const</span> Node*); -00066 <span class="keyword">const</span> <span class="keywordtype">char</span>* next(<span class="keyword">const</span> <span class="keywordtype">char</span>** value); -00067 <span class="keyword">private</span>: -00068 <span class="keyword">const</span> Attr* fAttr; -00069 <span class="keyword">const</span> Attr* fStop; -00070 }; -00071 -00072 SkDEBUGCODE(<span class="keywordtype">void</span> dump(<span class="keyword">const</span> Node* node = nil, <span class="keywordtype">int</span> tabLevel = 0) <span class="keyword">const</span>;) -00073 SkDEBUGCODE(static <span class="keywordtype">void</span> UnitTest();) -00074 -00075 private: -00076 SkChunkAlloc fAlloc; -00077 Node* fRoot; -00078 friend class AttrIter; -00079 friend class SkDOMParser; -00080 }; -00081 -00082 #endif -00083 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkDashPathEffect_8h-source.html b/sgl_doxygen/html/SkDashPathEffect_8h-source.html deleted file mode 100644 index eb1d665..0000000 --- a/sgl_doxygen/html/SkDashPathEffect_8h-source.html +++ /dev/null @@ -1,47 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDashPathEffect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkDashPathEffect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkDashPathEffect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkDashPathEffect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPathEffect.h"</span> -00005 -<a name="l00010"></a><a class="code" href="classSkDashPathEffect.html">00010</a> <span class="keyword">class </span><a class="code" href="classSkDashPathEffect.html">SkDashPathEffect</a> : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00011 <span class="keyword">public</span>: -00018 <a class="code" href="classSkDashPathEffect.html#a0">SkDashPathEffect</a>(<span class="keyword">const</span> SkScalar intervals[], <span class="keywordtype">int</span> count, SkScalar phase, <span class="keywordtype">bool</span> scaleToFit = <span class="keyword">false</span>); -00019 <span class="keyword">virtual</span> ~<a class="code" href="classSkDashPathEffect.html">SkDashPathEffect</a>(); -00020 -00021 <span class="comment">// overrides for SkPathEffect</span> -00022 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkDashPathEffect.html#a2">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00023 -00024 <span class="comment">// overrides for SkFlattenable</span> -00025 <span class="keyword">virtual</span> Factory <a class="code" href="classSkDashPathEffect.html#a3">getFactory</a>(); -00026 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00027 -00028 <span class="keyword">private</span>: -00029 SkScalar* fIntervals; -00030 int32_t fCount; -00031 <span class="comment">// computed from phase</span> -00032 SkScalar fInitialDashLength; -00033 int32_t fInitialDashIndex; -00034 SkScalar fIntervalLength; -00035 <span class="keywordtype">bool</span> fScaleToFit; -00036 -00037 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00038 -00039 <a class="code" href="classSkDashPathEffect.html#a0">SkDashPathEffect</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00040 }; -00041 -00042 <span class="preprocessor">#endif</span> -00043 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkDeque_8h-source.html b/sgl_doxygen/html/SkDeque_8h-source.html deleted file mode 100644 index ea43e7b..0000000 --- a/sgl_doxygen/html/SkDeque_8h-source.html +++ /dev/null @@ -1,202 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDeque.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkDeque.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTDeque_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTDeque_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">struct </span>sk_trait_trivial_constructor { <span class="keyword">enum</span> { value = <span class="keyword">false</span> }; }; -00007 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">struct </span>sk_trait_trivial_destructor { <span class="keyword">enum</span> { value = <span class="keyword">false</span> }; }; -00008 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">struct </span>sk_trait_trivial_copy { <span class="keyword">enum</span> { value = <span class="keyword">false</span> }; }; -00009 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">struct </span>sk_trait_trivial_assign { <span class="keyword">enum</span> { value = <span class="keyword">false</span> }; }; -00010 -00011 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">struct </span>sk_traits { -00012 <span class="keyword">enum</span> { -00013 has_trivial_constructor = sk_trait_trivial_constructor<T>::value, -00014 has_trivial_destructor = sk_trait_trivial_destructor<T>::value, -00015 has_trivial_copy = sk_trait_trivial_copy<T>::value, -00016 has_trivial_assign = sk_trait_trivial_assign<T>::value -00017 }; -00018 }; -00019 -00020 <span class="preprocessor">#define SK_SET_BASIC_TRAITS(T) \</span> -00021 <span class="preprocessor"> template <> struct sk_trait_trivial_constructor<T> { enum { value = true }; }; \</span> -00022 <span class="preprocessor"> template <> struct sk_trait_trivial_destructor<T> { enum { value = true }; }; \</span> -00023 <span class="preprocessor"> template <> struct sk_trait_trivial_copy<T> { enum { value = true }; }; \</span> -00024 <span class="preprocessor"> template <> struct sk_trait_trivial_assign<T> { enum { value = true }; }</span> -00025 <span class="preprocessor"></span> -00026 <span class="preprocessor">#define SK_SET_TYPE_TRAITS(T, ctor, dtor, copy, asgn) \</span> -00027 <span class="preprocessor"> template <> struct sk_trait_trivial_constructor<T> { enum { value = ctor }; }; \</span> -00028 <span class="preprocessor"> template <> struct sk_trait_trivial_destructor<T> { enum { value = dtor }; }; \</span> -00029 <span class="preprocessor"> template <> struct sk_trait_trivial_copy<T> { enum { value = copy }; }; \</span> -00030 <span class="preprocessor"> template <> struct sk_trait_trivial_assign<T> { enum { value = asgn }; }</span> -00031 <span class="preprocessor"></span> -00032 <span class="preprocessor">#include <new></span> -00033 -00034 <span class="keyword">class </span>SkDeque { -00035 <span class="keyword">public</span>: -00036 SkDeque(size_t elemSize); -00037 SkDeque(size_t elemSize, <span class="keywordtype">void</span>* storage, size_t storageSize); -00038 ~SkDeque(); -00039 -00040 <span class="keywordtype">bool</span> empty()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount == 0; } -00041 <span class="keywordtype">int</span> count()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount; } -00042 -00043 <span class="keyword">const</span> <span class="keywordtype">void</span>* front() <span class="keyword">const</span>; -00044 <span class="keyword">const</span> <span class="keywordtype">void</span>* back() <span class="keyword">const</span>; -00045 -00046 <span class="keywordtype">void</span>* front() -00047 { -00048 <span class="keywordflow">return</span> (<span class="keywordtype">void</span>*)((<span class="keyword">const</span> SkDeque*)<span class="keyword">this</span>)->front(); -00049 } -00050 <span class="keywordtype">void</span>* back() -00051 { -00052 <span class="keywordflow">return</span> (<span class="keywordtype">void</span>*)((<span class="keyword">const</span> SkDeque*)<span class="keyword">this</span>)->back(); -00053 } -00054 -00055 <span class="keywordtype">void</span>* push_front(); -00056 <span class="keywordtype">void</span>* push_back(); -00057 -00058 <span class="keywordtype">void</span> pop_front(); -00059 <span class="keywordtype">void</span> pop_back(); -00060 -00061 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00062 -00063 <span class="keyword">private</span>: -00064 <span class="keyword">struct </span>Head; -00065 -00066 <span class="keyword">public</span>: -00067 <span class="keyword">class </span>Iter { -00068 <span class="keyword">public</span>: -00069 Iter(<span class="keyword">const</span> SkDeque& d); -00070 <span class="keywordtype">void</span>* next(); -00071 -00072 <span class="keyword">private</span>: -00073 SkDeque::Head* fHead; -00074 <span class="keywordtype">char</span>* fPos; -00075 size_t fElemSize; -00076 }; -00077 -00078 <span class="keyword">private</span>: -00079 Head* fFront; -00080 Head* fBack; -00081 size_t fElemSize; -00082 <span class="keywordtype">void</span>* fInitialStorage; -00083 <span class="keywordtype">int</span> fCount; -00084 -00085 <span class="keyword">friend</span> <span class="keyword">class </span>Iter; -00086 }; -00087 -00088 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">class </span>SkTDeque { -00089 <span class="keyword">public</span>: -00090 SkTDeque() : fD(sizeof(T)) {} -00091 SkTDeque(T storage[], <span class="keywordtype">int</span> count) : fD(sizeof(T), storage, count * sizeof(T)) {} -00092 <span class="keyword">inline</span> ~SkTDeque(); -00093 -00094 <span class="keywordtype">bool</span> empty()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fD.empty(); } -00095 <span class="keywordtype">int</span> count()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fD.count(); } -00096 -00097 T* front() { <span class="keywordflow">return</span> (T*)fD.front(); } -00098 const T* front()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keyword">const</span> T*)fD.front(); } -00099 T* back() { <span class="keywordflow">return</span> (T*)fD.back(); } -00100 const T* back()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keyword">const</span> T*)fD.back(); } -00101 -00102 T* push_front() -00103 { -00104 T* front = (T*)fD.push_front(); -00105 <span class="keywordflow">if</span> (!sk_traits<T>::has_trivial_constructor) { -00106 <span class="keyword">new</span>(front) T(); -00107 } -00108 <span class="keywordflow">return</span> front; -00109 } -00110 T* push_back() -00111 { -00112 T* back = (T*)fD.push_back(); -00113 <span class="keywordflow">if</span> (!sk_traits<T>::has_trivial_constructor) { -00114 <span class="keyword">new</span>(back) T(); -00115 } -00116 <span class="keywordflow">return</span> back; -00117 } -00118 -00119 T* push_front(<span class="keyword">const</span> T& value) -00120 { -00121 T* front = (T*)fD.push_front(); -00122 <span class="keywordflow">if</span> (sk_traits<T>::has_trivial_copy) { -00123 *front = value; -00124 } -00125 <span class="keywordflow">else</span> { -00126 <span class="keyword">new</span>(front) T(value); -00127 } -00128 <span class="keywordflow">return</span> front; -00129 } -00130 T* push_back(<span class="keyword">const</span> T& value) -00131 { -00132 T* back = (T*)fD.push_back(); -00133 <span class="keywordflow">if</span> (sk_traits<T>::has_trivial_copy) { -00134 *back = value; -00135 } -00136 <span class="keywordflow">else</span> { -00137 <span class="keyword">new</span>(back) T(value); -00138 } -00139 <span class="keywordflow">return</span> back; -00140 } -00141 -00142 <span class="keywordtype">void</span> pop_front() -00143 { -00144 <span class="keywordflow">if</span> (!sk_traits<T>::has_trivial_destructor) { -00145 this->front()->~T(); -00146 } -00147 fD.pop_front(); -00148 } -00149 <span class="keywordtype">void</span> pop_back() -00150 { -00151 <span class="keywordflow">if</span> (!sk_traits<T>::has_trivial_destructor) { -00152 this->back()->~T(); -00153 } -00154 fD.pop_back(); -00155 } -00156 -00157 <span class="keyword">class </span>Iter : <span class="keyword">private</span> SkDeque::Iter { -00158 <span class="keyword">public</span>: -00159 Iter(<span class="keyword">const</span> SkTDeque<T>& d) : SkDeque::Iter(d.fD) {} -00160 T* next() { <span class="keywordflow">return</span> (T*)SkDeque::Iter::next(); } -00161 }; -00162 -00163 private: -00164 SkDeque fD; -00165 }; -00166 -00167 template <size_t COUNT, typename T> class SkSTDeque : public SkTDeque<T> { -00168 <span class="keyword">public</span>: -00169 SkSTDeque() : SkTDeque<T>((T*)fStorage, COUNT) {} -00170 -00171 <span class="keyword">private</span>: -00172 uint32_t fStorage[SkAlign4(COUNT * <span class="keyword">sizeof</span>(T))]; -00173 }; -00174 -00176 -00177 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">inline</span> SkTDeque<T>::~SkTDeque() -00178 { -00179 <span class="keywordflow">if</span> (!sk_traits<T>::has_trivial_destructor) -00180 { -00181 Iter iter(*<span class="keyword">this</span>); -00182 T* t; -00183 <span class="keywordflow">while</span> ((t = iter.next()) != nil) { -00184 t->~T(); -00185 } -00186 } -00187 } -00188 -00189 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkDescriptor_8h-source.html b/sgl_doxygen/html/SkDescriptor_8h-source.html deleted file mode 100644 index e9fca5e..0000000 --- a/sgl_doxygen/html/SkDescriptor_8h-source.html +++ /dev/null @@ -1,143 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDescriptor.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkDescriptor.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkDescriptor_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkDescriptor_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">class </span>SkDescriptor { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> size_t ComputeOverhead(<span class="keywordtype">int</span> entryCount) -00009 { -00010 SkASSERT(entryCount >= 0); -00011 <span class="keywordflow">return</span> <span class="keyword">sizeof</span>(SkDescriptor) + entryCount * <span class="keyword">sizeof</span>(Entry); -00012 } -00013 -00014 <span class="keyword">static</span> SkDescriptor* Alloc(size_t length) -00015 { -00016 SkASSERT(SkAlign4(length) == length); -00017 SkDescriptor* desc = (SkDescriptor*)sk_malloc_throw(length); -00018 <span class="keywordflow">return</span> desc; -00019 } -00020 -00021 <span class="keyword">static</span> <span class="keywordtype">void</span> Free(SkDescriptor* desc) -00022 { -00023 sk_free(desc); -00024 } -00025 -00026 <span class="keywordtype">void</span> init() -00027 { -00028 fLength = <span class="keyword">sizeof</span>(SkDescriptor); -00029 fCount = 0; -00030 } -00031 -00032 U32 getLength()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fLength; } -00033 -00034 <span class="keywordtype">void</span>* addEntry(U32 tag, U32 length, <span class="keyword">const</span> <span class="keywordtype">void</span>* data = nil) -00035 { -00036 SkASSERT(tag); -00037 SkASSERT(SkAlign4(length) == length); -00038 SkASSERT(this->findEntry(tag, nil) == nil); -00039 -00040 Entry* entry = (Entry*)((<span class="keywordtype">char</span>*)<span class="keyword">this</span> + fLength); -00041 entry->fTag = tag; -00042 entry->fLen = length; -00043 <span class="keywordflow">if</span> (data) -00044 memcpy(entry + 1, data, length); -00045 -00046 fCount += 1; -00047 fLength += sizeof(Entry) + length; -00048 return (entry + 1); <span class="comment">// return its data</span> -00049 } -00050 -00051 <span class="keywordtype">void</span> computeChecksum() -00052 { -00053 fChecksum = SkDescriptor::ComputeChecksum(<span class="keyword">this</span>); -00054 } -00055 -00056 <span class="preprocessor">#ifdef SK_DEBUG</span> -00057 <span class="preprocessor"></span> <span class="keywordtype">void</span> assertChecksum()<span class="keyword"> const</span> -00058 <span class="keyword"> </span>{ -00059 SkASSERT(fChecksum == SkDescriptor::ComputeChecksum(<span class="keyword">this</span>)); -00060 } -00061 <span class="preprocessor">#endif</span> -00062 <span class="preprocessor"></span> -00063 <span class="keyword">const</span> <span class="keywordtype">void</span>* findEntry(U32 tag, U32* length)<span class="keyword"> const</span> -00064 <span class="keyword"> </span>{ -00065 <span class="keyword">const</span> Entry* entry = (<span class="keyword">const</span> Entry*)(<span class="keyword">this</span> + 1); -00066 <span class="keywordtype">int</span> count = fCount; -00067 -00068 <span class="keywordflow">while</span> (--count >= 0) -00069 { -00070 <span class="keywordflow">if</span> (entry->fTag == tag) -00071 { -00072 <span class="keywordflow">if</span> (length) -00073 *length = entry->fLen; -00074 <span class="keywordflow">return</span> entry + 1; -00075 } -00076 entry = (<span class="keyword">const</span> Entry*)((<span class="keyword">const</span> <span class="keywordtype">char</span>*)(entry + 1) + entry->fLen); -00077 } -00078 <span class="keywordflow">return</span> nil; -00079 } -00080 -00081 SkDescriptor* copy()<span class="keyword"> const</span> -00082 <span class="keyword"> </span>{ -00083 SkDescriptor* desc = SkDescriptor::Alloc(fLength); -00084 memcpy(desc, <span class="keyword">this</span>, fLength); -00085 <span class="keywordflow">return</span> desc; -00086 } -00087 -00088 <span class="keyword">friend</span> <span class="keywordtype">bool</span> operator==(<span class="keyword">const</span> SkDescriptor& a, <span class="keyword">const</span> SkDescriptor& b) -00089 { -00090 <span class="keywordflow">return</span> a.fChecksum == b.fChecksum && -00091 a.fLength == b.fLength && -00092 <span class="comment">// this assumes that fCount is the beginning of the rest of the descriptor</span> -00093 <span class="comment">// (after fCheckSum and fLength)</span> -00094 memcmp(&a.fCount, &b.fCount, a.fLength - 2*<span class="keyword">sizeof</span>(U32)) == 0; -00095 } -00096 -00097 <span class="keyword">struct </span>Entry { -00098 U32 fTag; -00099 U32 fLen; -00100 }; -00101 -00102 <span class="preprocessor">#ifdef SK_DEBUG</span> -00103 <span class="preprocessor"></span> U32 getChecksum()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fChecksum; } -00104 U32 getCount()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount; } -00105 <span class="preprocessor">#endif</span> -00106 <span class="preprocessor"></span> -00107 <span class="keyword">private</span>: -00108 U32 fChecksum; <span class="comment">// must be first</span> -00109 U32 fLength; <span class="comment">// must be second</span> -00110 U32 fCount; -00111 -00112 <span class="keyword">static</span> U32 ComputeChecksum(<span class="keyword">const</span> SkDescriptor* desc) -00113 { -00114 <span class="keyword">const</span> U32* ptr = (<span class="keyword">const</span> U32*)desc + 1; <span class="comment">// skip the checksum field</span> -00115 <span class="keyword">const</span> U32* stop = (<span class="keyword">const</span> U32*)((<span class="keyword">const</span> <span class="keywordtype">char</span>*)desc + desc->fLength); -00116 U32 sum = 0; -00117 -00118 SkASSERT(ptr < stop); -00119 <span class="keywordflow">do</span> { -00120 sum = (sum << 1) | (sum >> 31); -00121 sum += *ptr++; -00122 } <span class="keywordflow">while</span> (ptr < stop); -00123 -00124 <span class="keywordflow">return</span> sum; -00125 } -00126 }; -00127 -00128 <span class="preprocessor">#endif</span> -00129 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkDiscretePathEffect_8h-source.html b/sgl_doxygen/html/SkDiscretePathEffect_8h-source.html deleted file mode 100644 index 6ce02fb..0000000 --- a/sgl_doxygen/html/SkDiscretePathEffect_8h-source.html +++ /dev/null @@ -1,38 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDiscretePathEffect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkDiscretePathEffect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkDiscretePathEffect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkDiscretePathEffect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPathEffect.h"</span> -00005 -00006 <span class="keyword">class </span>SkDiscretePathEffect : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00007 <span class="keyword">public</span>: -00012 SkDiscretePathEffect(SkScalar segLength, SkScalar deviation); -00013 -00014 <span class="comment">// overrides for SkPathEffect</span> -00015 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkPathEffect.html#a1">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00016 -00017 <span class="comment">// overrides for SkFlattenable</span> -00018 <span class="keyword">virtual</span> Factory <a class="code" href="classSkPathEffect.html#a2">getFactory</a>(); -00019 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00020 -00021 <span class="keyword">private</span>: -00022 SkScalar fSegLength, fPerterb; -00023 -00024 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00025 }; -00026 -00027 <span class="preprocessor">#endif</span> -00028 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkEmbossMaskFilter_8h-source.html b/sgl_doxygen/html/SkEmbossMaskFilter_8h-source.html deleted file mode 100644 index 00c3d7a..0000000 --- a/sgl_doxygen/html/SkEmbossMaskFilter_8h-source.html +++ /dev/null @@ -1,47 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkEmbossMaskFilter.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkEmbossMaskFilter.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkEmbossMaskFilter_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkEmbossMaskFilter_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMaskFilter.h"</span> -00005 -00006 <span class="keyword">class </span>SkEmbossMaskFilter : <span class="keyword">public</span> <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a> { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">struct </span>Light { -00009 SkScalar fDirection[3]; <span class="comment">// x,y,z</span> -00010 U16 fPad; -00011 U8 fAmbient; -00012 U8 fSpecular; <span class="comment">// exponent, 4.4 right now</span> -00013 }; -00014 -00015 SkEmbossMaskFilter(<span class="keyword">const</span> Light& light, SkScalar blurRadius); -00016 -00017 <span class="comment">// overrides from SkMaskFilter</span> -00018 <span class="keyword">virtual</span> <a class="code" href="structSkMask.html#w3">SkMask::Format</a> <a class="code" href="classSkMaskFilter.html#a0">getFormat</a>(); -00019 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkMaskFilter.html#a1">filterMask</a>(<a class="code" href="structSkMask.html">SkMask</a>* dst, <span class="keyword">const</span> <a class="code" href="structSkMask.html">SkMask</a>& src, <span class="keyword">const</span> SkMatrix& matrix, SkIPoint* margin); -00020 -00021 <span class="comment">// overrides from SkFlattenable</span> -00022 <span class="keyword">virtual</span> Factory getFactory(); -00023 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00024 -00025 <span class="keyword">private</span>: -00026 Light fLight; -00027 SkScalar fBlurRadius; -00028 -00029 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00030 }; -00031 -00032 <span class="preprocessor">#endif</span> -00033 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkEventSink_8h-source.html b/sgl_doxygen/html/SkEventSink_8h-source.html deleted file mode 100644 index aa36882..0000000 --- a/sgl_doxygen/html/SkEventSink_8h-source.html +++ /dev/null @@ -1,65 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkEventSink.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkEventSink.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkEventSink_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkEventSink_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkRefCnt.h"</span> -00005 <span class="preprocessor">#include "SkEvent.h"</span> -00006 -00007 <span class="keyword">struct </span>SkTagList; -00008 -<a name="l00013"></a><a class="code" href="classSkEventSink.html">00013</a> <span class="keyword">class </span><a class="code" href="classSkEventSink.html">SkEventSink</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00014 <span class="keyword">public</span>: -00015 <a class="code" href="classSkEventSink.html">SkEventSink</a>(); -00016 <span class="keyword">virtual</span> ~<a class="code" href="classSkEventSink.html">SkEventSink</a>(); -00017 -<a name="l00021"></a><a class="code" href="classSkEventSink.html#a2">00021</a> SkEventSinkID <a class="code" href="classSkEventSink.html#a2">getSinkID</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fID; } -00022 -00026 <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#a3">doEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00030 <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#a4">doQuery</a>(<a class="code" href="classSkEvent.html">SkEvent</a>* query); -00031 -00035 <span class="keywordtype">void</span> <a class="code" href="classSkEventSink.html#a5">addListenerID</a>(SkEventSinkID sinkID); -00039 <span class="keywordtype">void</span> <a class="code" href="classSkEventSink.html#a6">copyListeners</a>(<span class="keyword">const</span> <a class="code" href="classSkEventSink.html">SkEventSink</a>& from); -00043 <span class="keywordtype">void</span> <a class="code" href="classSkEventSink.html#a7">removeListenerID</a>(SkEventSinkID); -00046 <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#a8">hasListeners</a>() <span class="keyword">const</span>; -00049 <span class="keywordtype">void</span> <a class="code" href="classSkEventSink.html#a9">postToListeners</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& evt, SkMSec delay = 0); -00050 -<a name="l00051"></a><a class="code" href="classSkEventSink.html#w3">00051</a> <span class="keyword">enum</span> <a class="code" href="classSkEventSink.html#w3">EventResult</a> { -00052 <a class="code" href="classSkEventSink.html#w3w0">kHandled_EventResult</a>, -00053 <a class="code" href="classSkEventSink.html#w3w1">kNotHandled_EventResult</a>, -00054 <a class="code" href="classSkEventSink.html#w3w2">kSinkNotFound_EventResult</a> -00055 }; -00061 <span class="keyword">static</span> EventResult <a class="code" href="classSkEventSink.html#e0">DoEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&, SkEventSinkID targetID); -00062 -00065 <span class="keyword">static</span> <a class="code" href="classSkEventSink.html">SkEventSink</a>* <a class="code" href="classSkEventSink.html#e1">FindSink</a>(SkEventSinkID); -00066 -00067 <span class="keyword">protected</span>: -00071 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#b0">onEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00072 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onQuery(<a class="code" href="classSkEvent.html">SkEvent</a>*); -00073 -00074 SkTagList* findTagList(U8CPU tag) <span class="keyword">const</span>; -00075 <span class="keywordtype">void</span> addTagList(SkTagList*); -00076 <span class="keywordtype">void</span> removeTagList(U8CPU tag); -00077 -00078 <span class="keyword">private</span>: -00079 SkEventSinkID fID; -00080 SkTagList* fTagHead; -00081 -00082 <span class="comment">// for our private link-list</span> -00083 <a class="code" href="classSkEventSink.html">SkEventSink</a>* fNextSink; -00084 }; -00085 -00086 <span class="preprocessor">#endif</span> -00087 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkEvent_8h-source.html b/sgl_doxygen/html/SkEvent_8h-source.html deleted file mode 100644 index f809a24..0000000 --- a/sgl_doxygen/html/SkEvent_8h-source.html +++ /dev/null @@ -1,144 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkEvent.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkEvent.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkEvent_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkEvent_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkDOM.h"</span> -00005 <span class="preprocessor">#include "SkMetaData.h"</span> -00006 <span class="preprocessor">#include "SkString.h"</span> -00007 -00008 <span class="comment">//class SkOSWindow;</span> -00009 -00015 <span class="keyword">typedef</span> U32 SkEventSinkID; -00016 -<a name="l00023"></a><a class="code" href="classSkEvent.html">00023</a> <span class="keyword">class </span><a class="code" href="classSkEvent.html">SkEvent</a> { -00024 <span class="keyword">public</span>: -00027 <a class="code" href="classSkEvent.html#a0">SkEvent</a>(); -00030 <span class="keyword">explicit</span> <a class="code" href="classSkEvent.html#a0">SkEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& type); -00033 <span class="keyword">explicit</span> <a class="code" href="classSkEvent.html#a0">SkEvent</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> type[]); -00036 <a class="code" href="classSkEvent.html#a0">SkEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& src); -00037 ~<a class="code" href="classSkEvent.html">SkEvent</a>(); -00038 -00039 <span class="comment">// /** Return the event's type (will never be nil) */</span> -00040 <span class="comment">// const char* getType() const;</span> -00042 <span class="comment"></span> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a5">getType</a>(<a class="code" href="classSkString.html">SkString</a>* str) <span class="keyword">const</span>; -00044 <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a6">isType</a>(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& str) <span class="keyword">const</span>; -00046 <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a6">isType</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> type[], size_t len = 0) <span class="keyword">const</span>; -00050 <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a8">setType</a>(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00054 <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a8">setType</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> type[], size_t len = 0); -00055 -<a name="l00057"></a><a class="code" href="classSkEvent.html#a10">00057</a> U32 <a class="code" href="classSkEvent.html#a10">getFast32</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> f32; } -<a name="l00061"></a><a class="code" href="classSkEvent.html#a11">00061</a> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a11">setFast32</a>(U32 x) { f32 = x; } -00062 -<a name="l00067"></a><a class="code" href="classSkEvent.html#a12">00067</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a12">findS32</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32* value = nil)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.findS32(name, value); } -<a name="l00072"></a><a class="code" href="classSkEvent.html#a13">00072</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a13">findScalar</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar* value = nil)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.findScalar(name, value); } -<a name="l00077"></a><a class="code" href="classSkEvent.html#a14">00077</a> <span class="keyword">const</span> SkScalar* <a class="code" href="classSkEvent.html#a14">findScalars</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">int</span>* count, SkScalar values[] = nil)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.findScalars(name, count, values); } -<a name="l00080"></a><a class="code" href="classSkEvent.html#a15">00080</a> <span class="keyword">const</span> <span class="keywordtype">char</span>* <a class="code" href="classSkEvent.html#a15">findString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[])<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.findString(name); } -<a name="l00085"></a><a class="code" href="classSkEvent.html#a16">00085</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a16">findPtr</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">void</span>** value)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.findPtr(name, value); } -00086 <span class="keywordtype">bool</span> findBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span>* value)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.findBool(name, value); } -00087 -<a name="l00089"></a><a class="code" href="classSkEvent.html#a18">00089</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a18">hasS32</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32 value)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.hasS32(name, value); } -<a name="l00091"></a><a class="code" href="classSkEvent.html#a19">00091</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a19">hasScalar</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.hasScalar(name, value); } -<a name="l00093"></a><a class="code" href="classSkEvent.html#a20">00093</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a20">hasString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[])<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.hasString(name, value); } -<a name="l00095"></a><a class="code" href="classSkEvent.html#a21">00095</a> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#a21">hasPtr</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">void</span>* value)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.hasPtr(name, value); } -00096 <span class="keywordtype">bool</span> hasBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span> value)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta.hasBool(name, value); } -00097 -<a name="l00099"></a><a class="code" href="classSkEvent.html#a23">00099</a> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a23">setS32</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32 value) { fMeta.setS32(name, value); } -<a name="l00101"></a><a class="code" href="classSkEvent.html#a24">00101</a> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a24">setScalar</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value) { fMeta.setScalar(name, value); } -<a name="l00103"></a><a class="code" href="classSkEvent.html#a25">00103</a> SkScalar* <a class="code" href="classSkEvent.html#a25">setScalars</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> SkScalar values[] = nil) { <span class="keywordflow">return</span> fMeta.setScalars(name, count, values); } -<a name="l00105"></a><a class="code" href="classSkEvent.html#a26">00105</a> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a26">setString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& value) { fMeta.setString(name, value.c_str()); } -<a name="l00107"></a><a class="code" href="classSkEvent.html#a27">00107</a> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a26">setString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]) { fMeta.setString(name, value); } -<a name="l00109"></a><a class="code" href="classSkEvent.html#a28">00109</a> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a28">setPtr</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">void</span>* value) { fMeta.setPtr(name, value); } -00110 <span class="keywordtype">void</span> setBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span> value) { fMeta.setBool(name, value); } -00111 -<a name="l00113"></a><a class="code" href="classSkEvent.html#a30">00113</a> SkMetaData& <a class="code" href="classSkEvent.html#a30">getMetaData</a>() { <span class="keywordflow">return</span> fMeta; } -<a name="l00115"></a><a class="code" href="classSkEvent.html#a31">00115</a> <span class="keyword">const</span> SkMetaData& <a class="code" href="classSkEvent.html#a30">getMetaData</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMeta; } -00116 -00117 <span class="keywordtype">void</span> tron() { <a class="code" href="classSkEvent.html#a36">SkDEBUGCODE</a>(fDebugTrace = <span class="keyword">true</span>;) } -00118 <span class="keywordtype">void</span> troff() { <a class="code" href="classSkEvent.html#a36">SkDEBUGCODE</a>(fDebugTrace = <span class="keyword">false</span>;) } -00119 <span class="keywordtype">bool</span> isDebugTrace()<span class="keyword"> const</span> -00120 <span class="keyword"> </span>{ -00121 <span class="preprocessor">#ifdef SK_DEBUG</span> -00122 <span class="preprocessor"></span> <span class="keywordflow">return</span> fDebugTrace; -00123 <span class="preprocessor">#else</span> -00124 <span class="preprocessor"></span> <span class="keywordflow">return</span> <span class="keyword">false</span>; -00125 <span class="preprocessor">#endif</span> -00126 <span class="preprocessor"></span> } -00127 -00129 <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#a35">inflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00130 -00131 <a class="code" href="classSkEvent.html#a36">SkDEBUGCODE</a>(<span class="keywordtype">void</span> dump(<span class="keyword">const</span> <span class="keywordtype">char</span> title[] = nil);) -00132 -00133 -00138 static <span class="keywordtype">bool</span> Post(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkEventSinkID targetID, SkMSec delay = 0); -00144 static <span class="keywordtype">bool</span> PostTime(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkEventSinkID targetID, SkMSec time); -00145 -<a name="l00150"></a><a class="code" href="classSkEvent.html#a37">00150</a> <span class="keywordtype">bool</span> post(SkEventSinkID sinkID, SkMSec delay = 0) -00151 { -00152 <span class="keywordflow">return</span> SkEvent::Post(<span class="keyword">this</span>, sinkID, delay); -00153 } -00154 -00155 <span class="keywordtype">void</span> postTime(SkEventSinkID sinkID, SkMSec time) -00156 { -00157 <a class="code" href="classSkEvent.html#e0">SkEvent::PostTime</a>(<span class="keyword">this</span>, sinkID, time); -00158 } -00159 -00161 -00162 -00163 -00168 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#e1">Init</a>(); -00172 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#e2">Term</a>(); -00173 -00177 <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkEvent.html#e3">ProcessEvent</a>(); -00182 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#e4">ServiceQueueTimer</a>(); -00183 -00185 -00186 -00187 -00191 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#e5">SignalNonEmptyQueue</a>(); -00195 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkEvent.html#e6">SignalQueueTimer</a>(SkMSec delay); -00196 -00197 <span class="preprocessor">#ifndef SK_USE_WXWIDGETS</span> -00198 <span class="preprocessor"></span><span class="preprocessor">#ifdef SK_BUILD_FOR_WIN</span> -00199 <span class="preprocessor"></span> <span class="keyword">static</span> <span class="keywordtype">bool</span> WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam); -00200 <span class="preprocessor">#elif defined(SK_BUILD_FOR_UNIXx)</span> -00201 <span class="preprocessor"></span> <span class="keyword">static</span> U32 HandleTimer(U32, <span class="keywordtype">void</span>*); -00202 <span class="keyword">static</span> <span class="keywordtype">bool</span> WndProc(Display*, Window, XEvent&); -00203 <span class="preprocessor">#endif</span> -00204 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00205 <span class="preprocessor"></span> <span class="comment">// Don't know yet what this will be</span> -00206 <span class="comment">//static bool CustomEvent();</span> -00207 <span class="preprocessor">#endif</span> -00208 <span class="preprocessor"></span> -00209 <span class="keyword">private</span>: -00210 SkMetaData fMeta; -00211 <span class="keyword">mutable</span> <span class="keywordtype">char</span>* fType; <span class="comment">// may be characters with low bit set to know that it is not a pointer</span> -00212 U32 f32; -00213 <a class="code" href="classSkEvent.html#a36">SkDEBUGCODE</a>(<span class="keywordtype">bool</span> fDebugTrace;) -00214 -00215 <span class="comment">// these are for our implementation of the event queue</span> -00216 SkEventSinkID fTargetID; -00217 SkMSec fTime; -00218 <a class="code" href="classSkEvent.html">SkEvent</a>* fNextEvent; <span class="comment">// either in the delay or normal event queue</span> -00219 <span class="keywordtype">void</span> initialize(<span class="keyword">const</span> <span class="keywordtype">char</span>* type, size_t typeLen); -00220 -00221 <span class="keyword">static</span> <span class="keywordtype">bool</span> Enqueue(<a class="code" href="classSkEvent.html">SkEvent</a>* evt); -00222 <span class="keyword">static</span> SkMSec EnqueueTime(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkMSec time); -00223 <span class="keyword">static</span> <a class="code" href="classSkEvent.html">SkEvent</a>* Dequeue(SkEventSinkID* targetID); -00224 <span class="keyword">static</span> <span class="keywordtype">bool</span> QHasEvents(); -00225 }; -00226 -00227 <span class="preprocessor">#endif</span> -00228 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkFlattenable_8h-source.html b/sgl_doxygen/html/SkFlattenable_8h-source.html deleted file mode 100644 index 59ea1ce..0000000 --- a/sgl_doxygen/html/SkFlattenable_8h-source.html +++ /dev/null @@ -1,30 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkFlattenable.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkFlattenable.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkFlattenable_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkFlattenable_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkRefCnt.h"</span> -00005 <span class="preprocessor">#include "SkScalar.h"</span> -00006 -<a name="l00013"></a><a class="code" href="classSkFlattenable.html">00013</a> <span class="keyword">class </span><a class="code" href="classSkFlattenable.html">SkFlattenable</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00014 <span class="keyword">public</span>: -00015 <span class="keyword">typedef</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* (*Factory)(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00016 -00017 <span class="keyword">virtual</span> Factory getFactory(); -00018 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer = nil); -00019 }; -00020 -00021 <span class="preprocessor">#endif</span> -00022 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkFontCodec_8h-source.html b/sgl_doxygen/html/SkFontCodec_8h-source.html deleted file mode 100644 index 71fe2af..0000000 --- a/sgl_doxygen/html/SkFontCodec_8h-source.html +++ /dev/null @@ -1,34 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkFontCodec.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkFontCodec.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkFontCodec_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkFontCodec_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkSFNT.h"</span> -00005 -00006 <span class="keyword">class </span>SkFontCodec { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> <span class="keywordtype">void</span> Compress(SkSFNT& font, <span class="keyword">const</span> <span class="keywordtype">char</span> fileName[]); -00009 -00010 <span class="comment">/* Format is [count] + [instruction, bitcount] * count</span> -00011 <span class="comment"> Allocated with sk_malloc()</span> -00012 <span class="comment"> */</span> -00013 <span class="keyword">static</span> U8* BuildInstrHuffmanTable(SkSFNT&); -00014 <span class="keyword">static</span> U8* BuildOutlineHuffmanTable(SkSFNT& font); -00015 -00016 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00017 }; -00018 -00019 <span class="preprocessor">#endif</span> -00020 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkFontHost_8h-source.html b/sgl_doxygen/html/SkFontHost_8h-source.html deleted file mode 100644 index 3e87a25..0000000 --- a/sgl_doxygen/html/SkFontHost_8h-source.html +++ /dev/null @@ -1,32 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkFontHost.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkFontHost.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkFontHost_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkFontHost_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkString.h"</span> -00005 <span class="preprocessor">#include "SkPaint.h"</span> -00006 -00007 <span class="keyword">class </span>SkDescriptor; -00008 <span class="keyword">class </span>SkScalerContext; -00009 -<a name="l00015"></a><a class="code" href="classSkFontHost.html">00015</a> <span class="keyword">class </span><a class="code" href="classSkFontHost.html">SkFontHost</a> { -00016 <span class="keyword">public</span>: -00023 <span class="keyword">static</span> SkTypeface* <a class="code" href="classSkFontHost.html#e0">CreateTypeface</a>(<span class="keyword">const</span> SkTypeface* family, <span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkTypeface::Style); -00029 <span class="keyword">static</span> uint32_t <a class="code" href="classSkFontHost.html#e1">FlattenTypeface</a>(<span class="keyword">const</span> SkTypeface* face, <span class="keywordtype">void</span>* buffer); -00032 <span class="keyword">static</span> SkScalerContext* <a class="code" href="classSkFontHost.html#e2">CreateScalarContext</a>(<span class="keyword">const</span> SkDescriptor* desc); -00033 }; -00034 -00035 <span class="preprocessor">#endif</span> -00036 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkGIFImageDecoder_8h-source.html b/sgl_doxygen/html/SkGIFImageDecoder_8h-source.html deleted file mode 100644 index 16f41ca..0000000 --- a/sgl_doxygen/html/SkGIFImageDecoder_8h-source.html +++ /dev/null @@ -1,28 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkGIFImageDecoder.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkGIFImageDecoder.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkGIFImageDecoder_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkGIFImageDecoder_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkImageDecoder.h"</span> -00005 -00006 <span class="keyword">class </span>SkGIFImageDecoder : <span class="keyword">public</span> <a class="code" href="classSkImageDecoder.html">SkImageDecoder</a> { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> <span class="keywordtype">bool</span> IsImage(SkStream* stream); -00009 <span class="keyword">protected</span>: -00010 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#b1">onDecode</a>(SkStream* stream, <a class="code" href="classSkBitmap.html">SkBitmap</a>* bm); -00011 }; -00012 -00013 <span class="preprocessor">#endif</span> -00014 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkGlobals_8h-source.html b/sgl_doxygen/html/SkGlobals_8h-source.html deleted file mode 100644 index 6ef85eb..0000000 --- a/sgl_doxygen/html/SkGlobals_8h-source.html +++ /dev/null @@ -1,56 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkGlobals.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkGlobals.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkGlobals_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkGlobals_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkThread.h"</span> -00005 -00006 <span class="keyword">class </span>SkGlobals { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">class </span>Rec { -00009 <span class="keyword">public</span>: -00010 <span class="keyword">virtual</span> ~Rec(); -00011 <span class="keyword">private</span>: -00012 Rec* fNext; -00013 U32 fTag; -00014 -00015 <span class="keyword">friend</span> <span class="keyword">class </span>SkGlobals; -00016 }; -00017 -00025 <span class="keyword">static</span> Rec* Find(U32 tag, Rec* (*create_proc)()); -00028 <span class="keyword">static</span> Rec* Get(U32 tag) -00029 { -00030 Rec* rec = SkGlobals::Find(tag, nil); -00031 SkASSERT(rec); -00032 <span class="keywordflow">return</span> rec; -00033 } -00034 -00035 <span class="comment">// used by porting layer</span> -00036 <span class="keyword">struct </span>BootStrap { -00037 SkMutex fMutex; -00038 Rec* fHead; -00039 }; -00040 -00041 <span class="keyword">private</span>: -00042 <span class="keyword">static</span> <span class="keywordtype">void</span> Init(); -00043 <span class="keyword">static</span> <span class="keywordtype">void</span> Term(); -00044 <span class="keyword">friend</span> <span class="keyword">class </span>SkGraphics; -00045 -00046 <span class="comment">// This last function is implemented in the porting layer</span> -00047 <span class="keyword">static</span> BootStrap& GetBootStrap(); -00048 }; -00049 -00050 <span class="preprocessor">#endif</span> -00051 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkGradientShader_8h-source.html b/sgl_doxygen/html/SkGradientShader_8h-source.html deleted file mode 100644 index 126ada8..0000000 --- a/sgl_doxygen/html/SkGradientShader_8h-source.html +++ /dev/null @@ -1,36 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkGradientShader.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkGradientShader.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkGradientShader_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkGradientShader_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkShader.h"</span> -00005 -00006 <span class="keyword">class </span>SkUnitMapper; -00007 -<a name="l00013"></a><a class="code" href="classSkGradientShader.html">00013</a> <span class="keyword">class </span><a class="code" href="classSkGradientShader.html">SkGradientShader</a> : <span class="keyword">public</span> <a class="code" href="classSkShader.html">SkShader</a> { -00014 <span class="keyword">public</span>: -00029 <span class="keyword">static</span> <a class="code" href="classSkShader.html">SkShader</a>* <a class="code" href="classSkGradientShader.html#e0">CreateLinear</a>( <span class="keyword">const</span> SkPoint pts[2], -00030 <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a17">SkColor</a> colors[], <span class="keyword">const</span> SkScalar pos[], <span class="keywordtype">int</span> count, -00031 TileMode mode, -00032 SkUnitMapper* mapper = nil); -00033 -00048 <span class="keyword">static</span> <a class="code" href="classSkShader.html">SkShader</a>* <a class="code" href="classSkGradientShader.html#e1">CreateRadial</a>( <span class="keyword">const</span> SkPoint& center, SkScalar radius, -00049 <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a17">SkColor</a> colors[], <span class="keyword">const</span> SkScalar pos[], <span class="keywordtype">int</span> count, -00050 TileMode mode, -00051 SkUnitMapper* mapper = nil); -00052 }; -00053 -00054 <span class="preprocessor">#endif</span> -00055 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkGraphics_8h-source.html b/sgl_doxygen/html/SkGraphics_8h-source.html deleted file mode 100644 index d725784..0000000 --- a/sgl_doxygen/html/SkGraphics_8h-source.html +++ /dev/null @@ -1,32 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkGraphics.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkGraphics.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkGraphics_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkGraphics_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">class </span>SkGraphics { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> <span class="keywordtype">void</span> Init(<span class="keywordtype">bool</span> runUnitTests); -00009 <span class="keyword">static</span> <span class="keywordtype">void</span> Term(); -00010 -00019 <span class="keyword">static</span> <span class="keywordtype">bool</span> FreeCaches(size_t bytesNeeded); -00020 -00021 <span class="keyword">private</span>: -00026 <span class="keyword">static</span> <span class="keywordtype">void</span> InstallNewHandler(); -00027 }; -00028 -00029 <span class="preprocessor">#endif</span> -00030 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkImageDecoder_8h-source.html b/sgl_doxygen/html/SkImageDecoder_8h-source.html deleted file mode 100644 index 17dbd1d..0000000 --- a/sgl_doxygen/html/SkImageDecoder_8h-source.html +++ /dev/null @@ -1,73 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkImageDecoder.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkImageDecoder.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkImageDecoder_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkImageDecoder_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkBitmap.h"</span> -00005 <span class="preprocessor">#include "SkBitmapRef.h"</span> -00006 -00007 <span class="keyword">class </span>SkStream; -00008 -<a name="l00013"></a><a class="code" href="classSkImageDecoder.html">00013</a> <span class="keyword">class </span><a class="code" href="classSkImageDecoder.html">SkImageDecoder</a> { -00014 <span class="keyword">public</span>: -00015 <span class="keyword">virtual</span> ~<a class="code" href="classSkImageDecoder.html">SkImageDecoder</a>(); -00016 -00028 <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#e0">DecodeFile</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> file[], <a class="code" href="classSkBitmap.html">SkBitmap</a>* bitmap); -00040 <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#e1">DecodeMemory</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t size, <a class="code" href="classSkBitmap.html">SkBitmap</a>* bitmap); -00052 <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#e2">DecodeStream</a>(SkStream*, <a class="code" href="classSkBitmap.html">SkBitmap</a>* bitmap); -00053 -00067 <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#e3">DecodeURL</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> url[], <a class="code" href="classSkBitmap.html">SkBitmap</a>* bitmap); -00068 -00074 <span class="keyword">static</span> SkBitmap::Config <a class="code" href="classSkImageDecoder.html#e4">GetDeviceConfig</a>(); -00081 <span class="keyword">static</span> <span class="keywordtype">void</span> <a class="code" href="classSkImageDecoder.html#e5">SetDeviceConfig</a>(SkBitmap::Config); -00082 -00084 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00087 <span class="keyword">protected</span>: -00088 <a class="code" href="classSkImageDecoder.html">SkImageDecoder</a>(); -00089 -00097 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#b1">onDecode</a>(SkStream*, <a class="code" href="classSkBitmap.html">SkBitmap</a>* bitmap) = 0; -00098 -00099 <span class="keyword">private</span>: -00100 <span class="keyword">static</span> <a class="code" href="classSkImageDecoder.html">SkImageDecoder</a>* Factory(SkStream*); -00101 }; -00102 -00103 <span class="preprocessor">#ifdef SK_SUPPORT_IMAGE_ENCODE</span> -00104 <span class="preprocessor"></span> -00105 <span class="keyword">class </span>SkWStream; -00106 -00107 <span class="keyword">class </span>SkImageEncoder { -00108 <span class="keyword">public</span>: -00109 <span class="keyword">enum</span> Type { -00110 kJPEG_Type, -00111 kPNG_Type -00112 }; -00113 <span class="keyword">static</span> SkImageEncoder* Create(Type); -00114 -00115 <span class="keyword">virtual</span> ~SkImageEncoder(); -00116 -00117 <span class="comment">/* Quality ranges from 0..100 */</span> -00118 -00119 <span class="keywordtype">bool</span> encodeFile(<span class="keyword">const</span> <span class="keywordtype">char</span> file[], <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&, <span class="keywordtype">int</span> quality = 80); -00120 <span class="keywordtype">bool</span> encodeStream(SkWStream*, <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&, <span class="keywordtype">int</span> quality = 80); -00121 -00122 <span class="keyword">protected</span>: -00123 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEncode(SkWStream*, <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>&, <span class="keywordtype">int</span> quality) = 0; -00124 }; -00125 -00126 <span class="preprocessor">#endif </span><span class="comment">/* SK_SUPPORT_IMAGE_ENCODE */</span> -00127 -00129 -00130 <span class="preprocessor">#endif</span> -00131 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkImageView_8h-source.html b/sgl_doxygen/html/SkImageView_8h-source.html deleted file mode 100644 index 3164438..0000000 --- a/sgl_doxygen/html/SkImageView_8h-source.html +++ /dev/null @@ -1,73 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkImageView.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkImageView.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkImageView_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkImageView_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkString.h"</span> -00006 -00007 <span class="keyword">class </span><a class="code" href="classSkAnimator.html">SkAnimator</a>; -00008 <span class="keyword">class </span><a class="code" href="classSkBitmap.html">SkBitmap</a>; -00009 <span class="keyword">struct </span>SkMatrix; -00010 -00011 <span class="keyword">class </span>SkImageView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00012 <span class="keyword">public</span>: -00013 SkImageView(); -00014 <span class="keyword">virtual</span> ~SkImageView(); -00015 -00016 <span class="keywordtype">void</span> getUri(<a class="code" href="classSkString.html">SkString</a>*) <span class="keyword">const</span>; -00017 <span class="keywordtype">void</span> setUri(<span class="keyword">const</span> <span class="keywordtype">char</span> []); -00018 <span class="keywordtype">void</span> setUri(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00019 -00020 -00021 <span class="keyword">enum</span> ScaleType { -00022 kMatrix_ScaleType, -00023 kFitXY_ScaleType, -00024 kFitStart_ScaleType, -00025 kFitCenter_ScaleType, -00026 kFitEnd_ScaleType -00027 }; -00028 ScaleType getScaleType()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (ScaleType)fScaleType; } -00029 <span class="keywordtype">void</span> setScaleType(ScaleType); -00030 -00031 <span class="keywordtype">bool</span> getImageMatrix(SkMatrix*) const; -00032 <span class="keywordtype">void</span> setImageMatrix(const SkMatrix*); -00033 -00034 protected: -00035 <span class="comment">// overrides</span> -00036 virtual <span class="keywordtype">bool</span> onEvent(const <a class="code" href="classSkEvent.html">SkEvent</a>&); -00037 virtual <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00038 virtual <span class="keywordtype">void</span> onInflate(const SkDOM&, const SkDOMNode*); -00039 -00040 private: -00041 <a class="code" href="classSkString.html">SkString</a> fUri; -00042 SkMatrix* fMatrix; <span class="comment">// nil or copy of caller's matrix ,,,,,</span> -00043 union { -00044 <a class="code" href="classSkAnimator.html">SkAnimator</a>* fAnim; -00045 <a class="code" href="classSkBitmap.html">SkBitmap</a>* fBitmap; -00046 } fData; -00047 U8 fScaleType; -00048 SkBool8 fDataIsAnim; <span class="comment">// as opposed to bitmap</span> -00049 SkBool8 fUriIsValid; -00050 -00051 <span class="keywordtype">void</span> onUriChange(); -00052 <span class="keywordtype">bool</span> getDataBounds(SkRect* bounds); -00053 <span class="keywordtype">bool</span> freeData(); -00054 <span class="keywordtype">bool</span> ensureUriIsLoaded(); -00055 -00056 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00057 }; -00058 -00059 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkInterpolator_8h-source.html b/sgl_doxygen/html/SkInterpolator_8h-source.html deleted file mode 100644 index 25d3080..0000000 --- a/sgl_doxygen/html/SkInterpolator_8h-source.html +++ /dev/null @@ -1,84 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkInterpolator.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkInterpolator.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkInterpolator_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkInterpolator_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMath.h"</span> -00005 -00006 <span class="keyword">class </span>SkInterpolatorBase { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">enum</span> Result { -00009 kNormal_Result, -00010 kFreezeStart_Result, -00011 kFreezeEnd_Result -00012 }; -00013 <span class="keyword">static</span> SkScalar Blend(SkScalar t, SkScalar blend); -00014 <span class="keyword">protected</span>: -00015 SkInterpolatorBase(); -00016 ~SkInterpolatorBase(); -00017 <span class="keyword">public</span>: -00018 <span class="keywordtype">void</span> reset(<span class="keywordtype">int</span> elemCount, <span class="keywordtype">int</span> frameCount); -00019 -00030 <span class="keywordtype">bool</span> getDuration(SkMSec* startTime, SkMSec* endTime) <span class="keyword">const</span>; -00031 -00032 -00036 <span class="keywordtype">void</span> setMirror(<span class="keywordtype">bool</span> mirror) { fFlags = SkToU8(fFlags & ~kMirror | (<span class="keywordtype">int</span>) mirror); } -00037 -00041 <span class="keywordtype">void</span> setRepeatCount(SkScalar repeatCount) { fRepeat = repeatCount; } -00042 -00046 <span class="keywordtype">void</span> setReset(<span class="keywordtype">bool</span> reset) { fFlags = SkToU8(fFlags & ~kReset | (<span class="keywordtype">int</span>) reset); } -00047 -00048 Result timeToT(SkMSec time, SkScalar* T, <span class="keywordtype">int</span>* index, SkBool* exact) <span class="keyword">const</span>; -00049 <span class="keyword">protected</span>: -00050 <span class="keyword">enum</span> Flags { -00051 kMirror = 1, -00052 kReset = 2 -00053 }; -00054 <span class="keyword">static</span> SkScalar ComputeRelativeT(SkMSec time, SkMSec prevTime, SkMSec nextTime, SkScalar blend); -00055 S16 fFrameCount; -00056 U8 fElemCount; -00057 U8 fFlags; -00058 SkScalar fRepeat; -00059 <span class="keyword">struct </span>SkTimeCode { -00060 SkMSec fTime; -00061 SkScalar fBlend; -00062 }; -00063 SkTimeCode* fTimes; <span class="comment">// pointer into fStorage</span> -00064 <span class="keywordtype">void</span>* fStorage; -00065 <span class="preprocessor">#ifdef SK_DEBUG</span> -00066 <span class="preprocessor"></span> SkTimeCode(* fTimesArray)[10]; -00067 <span class="preprocessor">#endif</span> -00068 <span class="preprocessor"></span>}; -00069 -00070 <span class="keyword">class </span>SkInterpolator : <span class="keyword">public</span> SkInterpolatorBase { -00071 <span class="keyword">public</span>: -00072 SkInterpolator(); -00073 SkInterpolator(<span class="keywordtype">int</span> elemCount, <span class="keywordtype">int</span> frameCount); -00074 <span class="keywordtype">void</span> reset(<span class="keywordtype">int</span> elemCount, <span class="keywordtype">int</span> frameCount); -00075 -00085 <span class="keywordtype">bool</span> setKeyFrame(<span class="keywordtype">int</span> index, SkMSec time, <span class="keyword">const</span> SkScalar values[], SkScalar blend = SK_Scalar1); -00086 Result timeToValues(SkMSec time, SkScalar values[]) <span class="keyword">const</span>; -00087 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00088 <span class="keyword">private</span>: -00089 SkScalar* fValues; <span class="comment">// pointer into fStorage</span> -00090 <span class="preprocessor">#ifdef SK_DEBUG</span> -00091 <span class="preprocessor"></span> SkScalar(* fScalarsArray)[10]; -00092 <span class="preprocessor">#endif</span> -00093 <span class="preprocessor"></span> <span class="keyword">typedef</span> SkInterpolatorBase INHERITED; -00094 }; -00095 -00096 -00097 <span class="preprocessor">#endif</span> -00098 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkJPEGImageDecoder_8h-source.html b/sgl_doxygen/html/SkJPEGImageDecoder_8h-source.html deleted file mode 100644 index 100b09a..0000000 --- a/sgl_doxygen/html/SkJPEGImageDecoder_8h-source.html +++ /dev/null @@ -1,28 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkJPEGImageDecoder.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkJPEGImageDecoder.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkJPEGImageDecoder_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkJPEGImageDecoder_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkImageDecoder.h"</span> -00005 -00006 <span class="keyword">class </span>SkJPEGImageDecoder : <span class="keyword">public</span> <a class="code" href="classSkImageDecoder.html">SkImageDecoder</a> { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> <span class="keywordtype">bool</span> IsImage(SkStream* stream); -00009 <span class="keyword">protected</span>: -00010 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#b1">onDecode</a>(SkStream* stream, <a class="code" href="classSkBitmap.html">SkBitmap</a>* bm); -00011 }; -00012 -00013 <span class="preprocessor">#endif</span> -00014 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkJS_8h-source.html b/sgl_doxygen/html/SkJS_8h-source.html deleted file mode 100644 index d3431fe..0000000 --- a/sgl_doxygen/html/SkJS_8h-source.html +++ /dev/null @@ -1,45 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkJS.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkJS.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#include "SkTypes.h"</span> -00002 <span class="preprocessor">#include "SkWindow.h"</span> -00003 -00004 <span class="keyword">extern</span> <span class="stringliteral">"C"</span> { -00005 <span class="keyword">typedef</span> <span class="keywordtype">long</span> JSWord; -00006 <span class="keyword">typedef</span> JSWord jsword; -00007 <span class="keyword">typedef</span> jsword jsval; -00008 <span class="keyword">typedef</span> <span class="keyword">struct </span>JSRuntime JSRuntime; -00009 <span class="keyword">typedef</span> <span class="keyword">struct </span>JSContext JSContext; -00010 <span class="keyword">typedef</span> <span class="keyword">struct </span>JSObject JSObject; -00011 } -00012 -00013 <span class="keyword">class </span><a class="code" href="classSkString.html">SkString</a>; -00014 -00015 <span class="keyword">class </span>SkJS : <span class="keyword">public</span> SkOSWindow { -00016 <span class="keyword">public</span>: -00017 SkJS(<span class="keywordtype">void</span>* hwnd); -00018 ~SkJS(); -00019 SkBool EvaluateScript(<span class="keyword">const</span> <span class="keywordtype">char</span>* script, jsval* rVal); -00020 SkBool ValueToString(jsval value, <a class="code" href="classSkString.html">SkString</a>* string); -00021 <span class="preprocessor">#ifdef SK_DEBUG</span> -00022 <span class="preprocessor"></span> <span class="keyword">static</span> <span class="keywordtype">void</span> Test(<span class="keywordtype">void</span>* hwnd); -00023 <span class="preprocessor">#endif</span> -00024 <span class="preprocessor"></span><span class="keyword">protected</span>: -00025 <span class="keywordtype">void</span> InitializeDisplayables(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& , JSContext *, JSObject *, JSObject *); -00026 <span class="keywordtype">void</span> DisposeDisplayables(); -00027 JSRuntime *fRuntime; -00028 JSContext *fContext; -00029 JSObject *fGlobal; -00030 }; -00031 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkKey_8h-source.html b/sgl_doxygen/html/SkKey_8h-source.html deleted file mode 100644 index 5c7d96e..0000000 --- a/sgl_doxygen/html/SkKey_8h-source.html +++ /dev/null @@ -1,61 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkKey.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkKey.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkKey_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkKey_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">enum</span> SkKey { -00007 <span class="comment">//reordering these to match android.app.KeyEvent </span> -00008 kNONE_SkKey, <span class="comment">//corresponds to android's UNKNOWN</span> -00009 -00010 kLeftSoftKey_SkKey, -00011 kRightSoftKey_SkKey, -00012 -00013 kHome_SkKey, -00014 kBack_SkKey, -00015 kSend_SkKey, -00016 kEnd_SkKey, -00017 -00018 k0_SkKey, -00019 k1_SkKey, -00020 k2_SkKey, -00021 k3_SkKey, -00022 k4_SkKey, -00023 k5_SkKey, -00024 k6_SkKey, -00025 k7_SkKey, -00026 k8_SkKey, -00027 k9_SkKey, -00028 kStar_SkKey, -00029 kHash_SkKey, -00030 -00031 kUp_SkKey, -00032 kDown_SkKey, -00033 kLeft_SkKey, -00034 kRight_SkKey, -00035 -00036 kOK_SkKey, -00037 -00038 kVolUp_SkKey, -00039 kVolDown_SkKey, -00040 kPower_SkKey, -00041 kCamera_SkKey, -00042 -00043 kSkKeyCount -00044 }; -00045 -00046 <span class="preprocessor">#endif</span> -00047 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkLayersMaskFilter_8h-source.html b/sgl_doxygen/html/SkLayersMaskFilter_8h-source.html deleted file mode 100644 index c13dc8c..0000000 --- a/sgl_doxygen/html/SkLayersMaskFilter_8h-source.html +++ /dev/null @@ -1,47 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkLayersMaskFilter.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkLayersMaskFilter.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkLayersMaskFilter_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkLayersMaskFilter_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMaskFilter.h"</span> -00005 <span class="preprocessor">#include "SkPaint.h"</span> -00006 -00007 <span class="keyword">class </span>SkLayersMaskFilter : <span class="keyword">public</span> <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a> { -00008 <span class="keyword">public</span>: -00009 SkLayersMaskFilter(); -00010 <span class="keyword">virtual</span> ~SkLayersMaskFilter(); -00011 -00012 <span class="comment">// overrides from SkMaskFilter</span> -00013 <span class="keyword">virtual</span> <a class="code" href="structSkMask.html#w3">SkMask::Format</a> <a class="code" href="classSkMaskFilter.html#a0">getFormat</a>(); -00014 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkMaskFilter.html#a1">filterMask</a>(<a class="code" href="structSkMask.html">SkMask</a>* dst, <span class="keyword">const</span> <a class="code" href="structSkMask.html">SkMask</a>& src, <span class="keyword">const</span> SkMatrix& matrix, SkIPoint* margin); -00015 -00016 <span class="comment">// overrides from SkFlattenable</span> -00017 <span class="keyword">virtual</span> Factory getFactory(); -00018 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00019 -00020 <span class="keyword">private</span>: -00021 <span class="keyword">struct </span>Rec { -00022 Rec* fNext; -00023 <a class="code" href="classSkPaint.html">SkPaint</a> fPaint; -00024 SkVector fOffset; -00025 }; -00026 Rec* fHead, *fTail; -00027 -00028 Rec* append(); -00029 -00030 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00031 }; -00032 -00033 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkLightShader_8h-source.html b/sgl_doxygen/html/SkLightShader_8h-source.html deleted file mode 100644 index 92ba254..0000000 --- a/sgl_doxygen/html/SkLightShader_8h-source.html +++ /dev/null @@ -1,40 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkLightShader.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkLightShader.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkLightShader_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkLightShader_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkShader.h"</span> -00005 -<a name="l00012"></a><a class="code" href="classSkLightShader.html">00012</a> <span class="keyword">class </span><a class="code" href="classSkLightShader.html">SkLightShader</a> : <span class="keyword">public</span> <a class="code" href="classSkShader.html">SkShader</a> { -00013 <span class="keyword">public</span>: -00014 <a class="code" href="classSkLightShader.html#a1">SkLightShader</a>(<a class="code" href="classSkShader.html">SkShader</a>* proxy, U8CPU mul, U8CPU add); -00018 <a class="code" href="classSkLightShader.html#a1">SkLightShader</a>(<a class="code" href="classSkShader.html">SkShader</a>* proxy, <span class="keyword">const</span> U8 mul[3], <span class="keyword">const</span> U8 add[3]); -00019 <span class="keyword">virtual</span> ~<a class="code" href="classSkLightShader.html">SkLightShader</a>(); -00020 -00021 <span class="comment">// overrides</span> -00022 <span class="keyword">virtual</span> U32 <a class="code" href="classSkLightShader.html#a3">getFlags</a>(); -00023 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkLightShader.html#a4">setContext</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& device, -00024 <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint, -00025 <span class="keyword">const</span> SkMatrix& matrix); -00026 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkLightShader.html#a5">shadeSpan</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> span[], <span class="keywordtype">int</span> count); -00027 -00028 <span class="keyword">private</span>: -00029 <a class="code" href="classSkShader.html">SkShader</a>* fProxy; -00030 <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> fPMColor; <span class="comment">// in case fProxy is nil</span> -00031 U8 fMul[3], fAdd[3]; -00032 }; -00033 -00034 <span class="preprocessor">#endif</span> -00035 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkMaskFilter_8h-source.html b/sgl_doxygen/html/SkMaskFilter_8h-source.html deleted file mode 100644 index 4fea477..0000000 --- a/sgl_doxygen/html/SkMaskFilter_8h-source.html +++ /dev/null @@ -1,54 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkMaskFilter.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkMaskFilter.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkMaskFilter_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkMaskFilter_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkFlattenable.h"</span> -00005 <span class="preprocessor">#include "SkMask.h"</span> -00006 -00007 <span class="keyword">class </span>SkBlitter; -00008 <span class="keyword">class </span><a class="code" href="classSkBounder.html">SkBounder</a>; -00009 <span class="keyword">class </span>SkMatrix; -00010 <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a>; -00011 <span class="keyword">class </span>SkRegion; -00012 -<a name="l00024"></a><a class="code" href="classSkMaskFilter.html">00024</a> <span class="keyword">class </span><a class="code" href="classSkMaskFilter.html">SkMaskFilter</a> : <span class="keyword">public</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a> { -00025 <span class="keyword">public</span>: -00029 <span class="keyword">virtual</span> SkMask::Format <a class="code" href="classSkMaskFilter.html#a0">getFormat</a>() = 0; -00030 -00044 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkMaskFilter.html#a1">filterMask</a>(<a class="code" href="structSkMask.html">SkMask</a>* dst, <span class="keyword">const</span> <a class="code" href="structSkMask.html">SkMask</a>& src, <span class="keyword">const</span> SkMatrix&, SkIPoint* margin); -00045 -00050 <span class="keywordtype">bool</span> <a class="code" href="classSkMaskFilter.html#a2">filterPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& devPath, <span class="keyword">const</span> SkMatrix& devMatrix, -00051 <span class="keyword">const</span> SkRegion& devClip, <a class="code" href="classSkBounder.html">SkBounder</a>*, SkBlitter* blitter); -00052 }; -00053 -<a name="l00059"></a><a class="code" href="classSkAutoMaskImage.html">00059</a> <span class="keyword">class </span><a class="code" href="classSkAutoMaskImage.html">SkAutoMaskImage</a> { -00060 <span class="keyword">public</span>: -00061 <a class="code" href="classSkAutoMaskImage.html">SkAutoMaskImage</a>(<a class="code" href="structSkMask.html">SkMask</a>* mask, <span class="keywordtype">bool</span> alloc) -00062 { -00063 <span class="keywordflow">if</span> (alloc) -00064 mask->fImage = SkMask::AllocImage(mask->computeImageSize()); -00065 fImage = mask->fImage; -00066 } -00067 ~<a class="code" href="classSkAutoMaskImage.html">SkAutoMaskImage</a>() -00068 { -00069 SkMask::FreeImage(fImage); -00070 } -00071 <span class="keyword">private</span>: -00072 U8* fImage; -00073 }; -00074 -00075 <span class="preprocessor">#endif</span> -00076 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkMask_8h-source.html b/sgl_doxygen/html/SkMask_8h-source.html deleted file mode 100644 index bfd4c8a..0000000 --- a/sgl_doxygen/html/SkMask_8h-source.html +++ /dev/null @@ -1,55 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkMask.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkMask.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkMask_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkMask_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkRect.h"</span> -00005 -<a name="l00010"></a><a class="code" href="structSkMask.html">00010</a> <span class="keyword">struct </span><a class="code" href="structSkMask.html">SkMask</a> { -<a name="l00011"></a><a class="code" href="structSkMask.html#w3">00011</a> <span class="keyword">enum</span> <a class="code" href="structSkMask.html#w3">Format</a> { -00012 <a class="code" href="structSkMask.html#w3w0">kBW_Format</a>, -00013 <a class="code" href="structSkMask.html#w3w1">kA8_Format</a>, -00014 <a class="code" href="structSkMask.html#w3w2">k3D_Format</a> -00015 }; -00016 -00017 U8* fImage; -00018 SkRect16 fBounds; -00019 U16 fRowBytes; -00020 U8 fFormat; <span class="comment">// Format</span> -00021 -00025 size_t <a class="code" href="structSkMask.html#a0">computeImageSize</a>() <span class="keyword">const</span>; -00029 size_t <a class="code" href="structSkMask.html#a1">computeTotalImageSize</a>() <span class="keyword">const</span>; -00030 -<a name="l00035"></a><a class="code" href="structSkMask.html#a2">00035</a> U8* <a class="code" href="structSkMask.html#a2">getAddr1</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00036 <span class="keyword"> </span>{ -00037 SkASSERT(fFormat == <a class="code" href="structSkMask.html#w3w0">kBW_Format</a>); -00038 SkASSERT(fBounds.contains(x, y)); -00039 SkASSERT(fImage != nil); -00040 <span class="keywordflow">return</span> fImage + ((x - fBounds.fLeft) >> 3) + (y - fBounds.fTop) * fRowBytes; -00041 } -<a name="l00046"></a><a class="code" href="structSkMask.html#a3">00046</a> U8* <a class="code" href="structSkMask.html#a3">getAddr</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y)<span class="keyword"> const</span> -00047 <span class="keyword"> </span>{ -00048 SkASSERT(fFormat != <a class="code" href="structSkMask.html#w3w0">kBW_Format</a>); -00049 SkASSERT(fBounds.contains(x, y)); -00050 SkASSERT(fImage != nil); -00051 <span class="keywordflow">return</span> fImage + x - fBounds.fLeft + (y - fBounds.fTop) * fRowBytes; -00052 } -00053 -00054 <span class="keyword">static</span> U8* AllocImage(size_t bytes); -00055 <span class="keyword">static</span> <span class="keywordtype">void</span> FreeImage(U8* image); -00056 }; -00057 -00058 <span class="preprocessor">#endif</span> -00059 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkMetaData_8h-source.html b/sgl_doxygen/html/SkMetaData_8h-source.html deleted file mode 100644 index 3fd84b2..0000000 --- a/sgl_doxygen/html/SkMetaData_8h-source.html +++ /dev/null @@ -1,144 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkMetaData.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkMetaData.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkMetaData_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkMetaData_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMath.h"</span> -00005 -00006 <span class="keyword">class </span>SkMetaData { -00007 <span class="keyword">public</span>: -00008 SkMetaData(); -00009 SkMetaData(<span class="keyword">const</span> SkMetaData& src); -00010 ~SkMetaData(); -00011 -00012 SkMetaData& operator=(<span class="keyword">const</span> SkMetaData& src); -00013 -00014 <span class="keywordtype">void</span> reset(); -00015 -00016 <span class="keywordtype">bool</span> findS32(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32* value = nil) <span class="keyword">const</span>; -00017 <span class="keywordtype">bool</span> findScalar(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar* value = nil) <span class="keyword">const</span>; -00018 <span class="keyword">const</span> SkScalar* findScalars(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">int</span>* count, SkScalar values[] = nil) <span class="keyword">const</span>; -00019 <span class="keyword">const</span> <span class="keywordtype">char</span>* findString(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]) <span class="keyword">const</span>; -00020 <span class="keywordtype">bool</span> findPtr(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">void</span>** value = nil) <span class="keyword">const</span>; -00021 <span class="keywordtype">bool</span> findBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span>* value = nil) <span class="keyword">const</span>; -00022 -00023 <span class="keywordtype">bool</span> hasS32(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32 value)<span class="keyword"> const</span> -00024 <span class="keyword"> </span>{ -00025 S32 v; -00026 <span class="keywordflow">return</span> this->findS32(name, &v) && v == value; -00027 } -00028 <span class="keywordtype">bool</span> hasScalar(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value)<span class="keyword"> const</span> -00029 <span class="keyword"> </span>{ -00030 SkScalar v; -00031 <span class="keywordflow">return</span> this->findScalar(name, &v) && v == value; -00032 } -00033 <span class="keywordtype">bool</span> hasString(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[])<span class="keyword"> const</span> -00034 <span class="keyword"> </span>{ -00035 <span class="keyword">const</span> <span class="keywordtype">char</span>* v = this->findString(name); -00036 <span class="keywordflow">return</span> v == nil && value == nil || -00037 v != nil && value != nil && !strcmp(v, value); -00038 } -00039 <span class="keywordtype">bool</span> hasPtr(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">void</span>* value)<span class="keyword"> const</span> -00040 <span class="keyword"> </span>{ -00041 <span class="keywordtype">void</span>* v; -00042 <span class="keywordflow">return</span> this->findPtr(name, &v) && v == value; -00043 } -00044 <span class="keywordtype">bool</span> hasBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span> value)<span class="keyword"> const</span> -00045 <span class="keyword"> </span>{ -00046 <span class="keywordtype">bool</span> v; -00047 <span class="keywordflow">return</span> this->findBool(name, &v) && v == value; -00048 } -00049 -00050 <span class="keywordtype">void</span> setS32(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32 value); -00051 <span class="keywordtype">void</span> setScalar(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value); -00052 SkScalar* setScalars(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> SkScalar values[] = nil); -00053 <span class="keywordtype">void</span> setString(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]); -00054 <span class="keywordtype">void</span> setPtr(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">void</span>* value); -00055 <span class="keywordtype">void</span> setBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keywordtype">bool</span> value); -00056 -00057 <span class="keywordtype">bool</span> removeS32(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00058 <span class="keywordtype">bool</span> removeScalar(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00059 <span class="keywordtype">bool</span> removeString(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00060 <span class="keywordtype">bool</span> removePtr(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00061 <span class="keywordtype">bool</span> removeBool(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00062 -00063 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00064 -00065 <span class="keyword">enum</span> Type { -00066 kS32_Type, -00067 kScalar_Type, -00068 kString_Type, -00069 kPtr_Type, -00070 kBool_Type, -00071 -00072 kTypeCount -00073 }; -00074 -00075 <span class="keyword">struct </span>Rec; -00076 <span class="keyword">class </span>Iter; -00077 <span class="keyword">friend</span> <span class="keyword">class </span>Iter; -00078 -00079 <span class="keyword">class </span>Iter { -00080 <span class="keyword">public</span>: -00081 Iter() : fRec(nil) {} -00082 Iter(<span class="keyword">const</span> SkMetaData&); -00083 -00087 <span class="keywordtype">void</span> reset(<span class="keyword">const</span> SkMetaData&); -00088 -00094 <span class="keyword">const</span> <span class="keywordtype">char</span>* next(Type*, <span class="keywordtype">int</span>* count); -00095 -00096 <span class="keyword">private</span>: -00097 Rec* fRec; -00098 }; -00099 -00100 <span class="keyword">public</span>: -00101 <span class="keyword">struct </span>Rec { -00102 Rec* fNext; -00103 U16 fDataCount; <span class="comment">// number of elements</span> -00104 U8 fDataLen; <span class="comment">// sizeof a single element</span> -00105 <span class="preprocessor">#ifdef SK_DEBUG</span> -00106 <span class="preprocessor"></span> Type fType; -00107 <span class="preprocessor">#else</span> -00108 <span class="preprocessor"></span> U8 fType; -00109 <span class="preprocessor">#endif</span> -00110 <span class="preprocessor"></span> -00111 <span class="preprocessor">#ifdef SK_DEBUG</span> -00112 <span class="preprocessor"></span> <span class="keyword">const</span> <span class="keywordtype">char</span>* fName; -00113 <span class="keyword">union </span>{ -00114 S32 fS32; -00115 SkScalar fScalar; -00116 <span class="keyword">const</span> <span class="keywordtype">char</span>* fString; -00117 <span class="keywordtype">void</span>* fPtr; -00118 <span class="keywordtype">bool</span> fBool; -00119 } fData; -00120 <span class="preprocessor">#endif</span> -00121 <span class="preprocessor"></span> -00122 <span class="keyword">const</span> <span class="keywordtype">void</span>* data()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keyword">this</span> + 1); } -00123 <span class="keywordtype">void</span>* data() { <span class="keywordflow">return</span> (<span class="keyword">this</span> + 1); } -00124 <span class="keyword">const</span> <span class="keywordtype">char</span>* name()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keyword">const</span> <span class="keywordtype">char</span>*)this->data() + fDataLen * fDataCount; } -00125 <span class="keywordtype">char</span>* name() { <span class="keywordflow">return</span> (<span class="keywordtype">char</span>*)this->data() + fDataLen * fDataCount; } -00126 -00127 static Rec* Alloc(size_t); -00128 static <span class="keywordtype">void</span> Free(Rec*); -00129 }; -00130 Rec* fRec; -00131 -00132 const Rec* find(const <span class="keywordtype">char</span> name[], Type) const; -00133 <span class="keywordtype">void</span>* set(const <span class="keywordtype">char</span> name[], const <span class="keywordtype">void</span>* data, size_t len, Type, <span class="keywordtype">int</span> count); -00134 <span class="keywordtype">bool</span> remove(const <span class="keywordtype">char</span> name[], Type); -00135 }; -00136 -00137 #endif -00138 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSFile_8h-source.html b/sgl_doxygen/html/SkOSFile_8h-source.html deleted file mode 100644 index 9ef7053..0000000 --- a/sgl_doxygen/html/SkOSFile_8h-source.html +++ /dev/null @@ -1,82 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSFile.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSFile.h</h1><div class="fragment"><pre class="fragment">00001 <span class="comment">// Copyright Skia Inc. 2004 - 2005</span> -00002 <span class="comment">// </span> -00003 <span class="preprocessor">#ifndef SkOSFile_DEFINED</span> -00004 <span class="preprocessor"></span><span class="preprocessor">#define SkOSFile_DEFINED</span> -00005 <span class="preprocessor"></span> -00006 <span class="preprocessor">#include "SkString.h"</span> -00007 -00008 <span class="preprocessor">#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX)</span> -00009 <span class="preprocessor"></span><span class="preprocessor"> #include <dirent.h></span> -00010 <span class="preprocessor">#endif</span> -00011 <span class="preprocessor"></span> -00012 <span class="keyword">struct </span>SkFILE; -00013 -00014 <span class="keyword">enum</span> SkFILE_Flags { -00015 kRead_SkFILE_Flag = 0x01, -00016 kWrite_SkFILE_Flag = 0x02 -00017 }; -00018 -00019 SkFILE* sk_fopen(<span class="keyword">const</span> <span class="keywordtype">char</span> path[], SkFILE_Flags); -00020 <span class="keywordtype">void</span> sk_fclose(SkFILE*); -00021 -00022 size_t sk_fgetsize(SkFILE*); -00025 <span class="keywordtype">bool</span> sk_frewind(SkFILE*); -00026 -00027 size_t sk_fread(<span class="keywordtype">void</span>* buffer, size_t byteCount, SkFILE*); -00028 size_t sk_fwrite(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t byteCount, SkFILE*); -00029 <span class="keywordtype">void</span> sk_fflush(SkFILE*); -00030 -00031 <span class="keywordtype">int</span> sk_fseek( SkFILE*, size_t, <span class="keywordtype">int</span> ); -00032 size_t sk_ftell( SkFILE* ); -00033 -00034 <span class="keyword">class </span>SkOSFile { -00035 <span class="keyword">public</span>: -00036 <span class="keyword">class </span>Iter { -00037 <span class="keyword">public</span>: -00038 Iter(); -00039 Iter(<span class="keyword">const</span> <span class="keywordtype">char</span> path[], <span class="keyword">const</span> <span class="keywordtype">char</span> suffix[] = nil); -00040 ~Iter(); -00041 -00042 <span class="keywordtype">void</span> reset(<span class="keyword">const</span> <span class="keywordtype">char</span> path[], <span class="keyword">const</span> <span class="keywordtype">char</span> suffix[] = nil); -00043 <span class="keywordtype">bool</span> next(<a class="code" href="classSkString.html">SkString</a>* name, <span class="keywordtype">bool</span> getDir = <span class="keyword">false</span>); -00044 -00045 <span class="keyword">private</span>: -00046 <span class="preprocessor">#ifdef SK_BUILD_FOR_WIN</span> -00047 <span class="preprocessor"></span> HANDLE fHandle; -00048 U16* fPath16; -00049 <span class="preprocessor">#elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_UNIX)</span> -00050 <span class="preprocessor"></span> DIR* fDIR; -00051 <a class="code" href="classSkString.html">SkString</a> fPath, fSuffix; -00052 <span class="preprocessor">#endif</span> -00053 <span class="preprocessor"></span> }; -00054 }; -00055 -00056 <span class="keyword">class </span>SkUTF16_Str { -00057 <span class="keyword">public</span>: -00058 SkUTF16_Str(<span class="keyword">const</span> <span class="keywordtype">char</span> src[]); -00059 ~SkUTF16_Str() -00060 { -00061 sk_free(fStr); -00062 } -00063 <span class="keyword">const</span> U16* get()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fStr; } -00064 -00065 <span class="keyword">private</span>: -00066 U16* fStr; -00067 }; -00068 -00069 <span class="preprocessor">#endif</span> -00070 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSMenu_8h-source.html b/sgl_doxygen/html/SkOSMenu_8h-source.html deleted file mode 100644 index f76b42c..0000000 --- a/sgl_doxygen/html/SkOSMenu_8h-source.html +++ /dev/null @@ -1,53 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSMenu.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSMenu.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkOSMenu_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkOSMenu_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkEvent.h"</span> -00005 <span class="preprocessor">#include "SkTDArray.h"</span> -00006 -00007 <span class="keyword">class </span>SkOSMenu { -00008 <span class="keyword">public</span>: -00009 <span class="keyword">explicit</span> SkOSMenu(<span class="keyword">const</span> <span class="keywordtype">char</span> title[]); -00010 ~SkOSMenu(); -00011 -00012 <span class="keyword">const</span> <span class="keywordtype">char</span>* getTitle()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTitle; } -00013 -00014 <span class="keywordtype">void</span> appendItem(<span class="keyword">const</span> <span class="keywordtype">char</span> title[], <span class="keyword">const</span> <span class="keywordtype">char</span> eventType[], S32 eventData); -00015 -00016 <span class="comment">// called by SkOSWindow when it receives an OS menu event</span> -00017 <span class="keywordtype">int</span> countItems() <span class="keyword">const</span>; -00018 <span class="keyword">const</span> <span class="keywordtype">char</span>* getItem(<span class="keywordtype">int</span> index, U32* cmdID) <span class="keyword">const</span>; -00019 -00020 <a class="code" href="classSkEvent.html">SkEvent</a>* createEvent(U32 os_cmd); -00021 -00022 <span class="keyword">private</span>: -00023 <span class="keyword">const</span> <span class="keywordtype">char</span>* fTitle; -00024 -00025 <span class="keyword">struct </span>Item { -00026 <span class="keyword">const</span> <span class="keywordtype">char</span>* fTitle; -00027 <span class="keyword">const</span> <span class="keywordtype">char</span>* fEventType; -00028 U32 fEventData; -00029 U32 fOSCmd; <span class="comment">// internal</span> -00030 }; -00031 SkTDArray<Item> fItems; -00032 -00033 <span class="comment">// illegal</span> -00034 SkOSMenu(<span class="keyword">const</span> SkOSMenu&); -00035 SkOSMenu& operator=(<span class="keyword">const</span> SkOSMenu&); -00036 }; -00037 -00038 <span class="preprocessor">#endif</span> -00039 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSSound_8h-source.html b/sgl_doxygen/html/SkOSSound_8h-source.html deleted file mode 100644 index 0d614f3..0000000 --- a/sgl_doxygen/html/SkOSSound_8h-source.html +++ /dev/null @@ -1,34 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSSound.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSSound.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkOSSound_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkOSSound_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">class </span>SkOSSound { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> <span class="keywordtype">void</span> Play(<span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00009 <span class="keyword">static</span> <span class="keywordtype">void</span> Pause(); -00010 <span class="keyword">static</span> <span class="keywordtype">void</span> Resume(); -00011 <span class="keyword">static</span> <span class="keywordtype">bool</span> TogglePause(); <span class="comment">// returns true if we are now playing, or false if we're now paused</span> -00012 <span class="keyword">static</span> <span class="keywordtype">void</span> Stop(); -00013 -00014 <span class="comment">// volume runs from 0 (silent) to 0xFF (max-volume)</span> -00015 <span class="keyword">static</span> U8 GetVolume(); -00016 <span class="keyword">static</span> <span class="keywordtype">void</span> SetVolume(U8CPU volume); -00017 }; -00018 -00019 <span class="preprocessor">#endif</span> -00020 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSWindow__Mac_8h-source.html b/sgl_doxygen/html/SkOSWindow__Mac_8h-source.html deleted file mode 100644 index 2762ae5..0000000 --- a/sgl_doxygen/html/SkOSWindow__Mac_8h-source.html +++ /dev/null @@ -1,46 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSWindow_Mac.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSWindow_Mac.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkOSWindow_Mac_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkOSWindow_Mac_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkWindow.h"</span> -00005 -00006 <span class="keyword">class </span>SkOSWindow : <span class="keyword">public</span> SkWindow { -00007 <span class="keyword">public</span>: -00008 SkOSWindow(<span class="keywordtype">void</span>* hwnd); -00009 -00010 <span class="keywordtype">void</span>* getHWND()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fHWND; } -00011 <span class="keywordtype">void</span> updateSize(); -00012 -00013 <span class="keyword">static</span> <span class="keywordtype">bool</span> PostEvent(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkEventSinkID, SkMSec delay); -00014 -00015 <span class="keyword">static</span> pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, <span class="keywordtype">void</span>* userData ); -00016 -00017 <span class="keyword">protected</span>: -00018 <span class="comment">// overrides from SkWindow</span> -00019 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onHandleInval(<span class="keyword">const</span> SkRect16&); -00020 <span class="comment">// overrides from SkView</span> -00021 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddMenu(<span class="keyword">const</span> SkOSMenu*); -00022 -00023 <span class="keyword">private</span>: -00024 <span class="keywordtype">void</span>* fHWND; -00025 -00026 <span class="keywordtype">void</span> doPaint(<span class="keywordtype">void</span>* ctx); -00027 -00028 <span class="keyword">typedef</span> SkWindow INHERITED; -00029 }; -00030 -00031 <span class="preprocessor">#endif</span> -00032 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSWindow__Unix_8h-source.html b/sgl_doxygen/html/SkOSWindow__Unix_8h-source.html deleted file mode 100644 index 2500503..0000000 --- a/sgl_doxygen/html/SkOSWindow__Unix_8h-source.html +++ /dev/null @@ -1,58 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSWindow_Unix.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSWindow_Unix.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkOSWindow_Unix_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkOSWindow_Unix_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkWindow.h"</span> -00005 <span class="preprocessor">#include <X11/Xlib.h></span> -00006 -00007 <span class="keyword">struct </span>SkUnixWindow { -00008 Display* fDisplay; -00009 Window fWin; -00010 size_t fOSWin; -00011 }; -00012 -00013 <span class="keyword">class </span>SkOSWindow : <span class="keyword">public</span> SkWindow { -00014 <span class="keyword">public</span>: -00015 SkOSWindow(Display* display, Window win); -00016 -00017 <span class="keywordtype">void</span>* getHWND()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keywordtype">void</span>*)fUnixWindow.fWin; } -00018 <span class="keywordtype">void</span>* getDisplay()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keywordtype">void</span>*)fUnixWindow.fDisplay; } -00019 <span class="keywordtype">void</span>* getUnixWindow()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keywordtype">void</span>*)&fUnixWindow; } -00020 <span class="keywordtype">void</span> setSize(<span class="keywordtype">int</span> width, <span class="keywordtype">int</span> height); -00021 <span class="keywordtype">void</span> updateSize(); -00022 -00023 <span class="keyword">static</span> <span class="keywordtype">bool</span> PostEvent(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkEventSinkID, SkMSec delay); -00024 -00025 <span class="keyword">static</span> <span class="keywordtype">bool</span> WndProc(SkUnixWindow* w, XEvent &e); -00026 -00027 <span class="keyword">protected</span>: -00028 <span class="comment">// overrides from SkWindow</span> -00029 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onHandleInval(<span class="keyword">const</span> SkRect16&); -00030 <span class="comment">// overrides from SkView</span> -00031 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddMenu(<span class="keyword">const</span> SkOSMenu*); -00032 -00033 <span class="keyword">private</span>: -00034 SkUnixWindow fUnixWindow; -00035 -00036 <span class="keywordtype">void</span> doPaint(); -00037 -00038 <span class="keywordtype">void</span>* fMBar; -00039 -00040 <span class="keyword">typedef</span> SkWindow INHERITED; -00041 }; -00042 -00043 <span class="preprocessor">#endif</span> -00044 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSWindow__Win_8h-source.html b/sgl_doxygen/html/SkOSWindow__Win_8h-source.html deleted file mode 100644 index 2f4daab..0000000 --- a/sgl_doxygen/html/SkOSWindow__Win_8h-source.html +++ /dev/null @@ -1,57 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSWindow_Win.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSWindow_Win.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkOSWindow_Win_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkOSWindow_Win_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkWindow.h"</span> -00005 -00006 <span class="keyword">class </span>SkOSWindow : <span class="keyword">public</span> SkWindow { -00007 <span class="keyword">public</span>: -00008 SkOSWindow(<span class="keywordtype">void</span>* hwnd); -00009 -00010 <span class="keywordtype">void</span>* getHWND()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fHWND; } -00011 <span class="keywordtype">void</span> setSize(<span class="keywordtype">int</span> width, <span class="keywordtype">int</span> height); -00012 <span class="keywordtype">void</span> updateSize(); -00013 -00014 <span class="keyword">static</span> <span class="keywordtype">bool</span> PostEvent(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkEventSinkID, SkMSec delay); -00015 -00016 <span class="keyword">static</span> <span class="keywordtype">bool</span> WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam); -00017 <span class="keyword">static</span> <span class="keywordtype">bool</span> SkOSWindow::QuitOnDeactivate(HWND hWnd); -00018 -00019 <span class="keyword">enum</span> { -00020 SK_WM_SkEvent = WM_APP + 1000, -00021 SK_WM_SkTimerID = 0xFFFF <span class="comment">// just need a non-zero value</span> -00022 }; -00023 -00024 <span class="keyword">protected</span>: -00025 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> quitOnDeactivate() { <span class="keywordflow">return</span> <span class="keyword">true</span>; } -00026 -00027 <span class="comment">// overrides from SkWindow</span> -00028 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onHandleInval(<span class="keyword">const</span> SkRect16&); -00029 <span class="comment">// overrides from SkView</span> -00030 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddMenu(<span class="keyword">const</span> SkOSMenu*); -00031 -00032 <span class="keyword">private</span>: -00033 <span class="keywordtype">void</span>* fHWND; -00034 -00035 <span class="keywordtype">void</span> doPaint(<span class="keywordtype">void</span>* ctx); -00036 -00037 HMENU fMBar; -00038 -00039 <span class="keyword">typedef</span> SkWindow INHERITED; -00040 }; -00041 -00042 <span class="preprocessor">#endif</span> -00043 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkOSWindow__wxwidgets_8h-source.html b/sgl_doxygen/html/SkOSWindow__wxwidgets_8h-source.html deleted file mode 100644 index 824da0c..0000000 --- a/sgl_doxygen/html/SkOSWindow__wxwidgets_8h-source.html +++ /dev/null @@ -1,51 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkOSWindow_wxwidgets.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkOSWindow_wxwidgets.h</h1><div class="fragment"><pre class="fragment">00001 <span class="comment">/*</span> -00002 <span class="comment"> * SkOSWindow_wxwidgets.h</span> -00003 <span class="comment"> * wxwidgets</span> -00004 <span class="comment"> *</span> -00005 <span class="comment"> * Created by phanna on 12/14/05.</span> -00006 <span class="comment"> * Copyright 2005 __MyCompanyName__. All rights reserved.</span> -00007 <span class="comment"> *</span> -00008 <span class="comment"> */</span> -00009 -00010 <span class="preprocessor">#ifndef SkOSWindow_wxwidgets_DEFINED</span> -00011 <span class="preprocessor"></span><span class="preprocessor">#define SkOSWindow_wxwidgets_DEFINED</span> -00012 <span class="preprocessor"></span> -00013 <span class="preprocessor">#include "SkWindow.h"</span> -00014 <span class="preprocessor">#include "wx/frame.h"</span> -00015 -00016 <span class="keyword">class </span>SkOSWindow: <span class="keyword">public</span> SkWindow -00017 { -00018 <span class="keyword">public</span>: -00019 SkOSWindow(); -00020 SkOSWindow(<span class="keyword">const</span> wxString& title, <span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, <span class="keywordtype">int</span> width, <span class="keywordtype">int</span> height); -00021 ~SkOSWindow(); -00022 -00023 wxFrame* getWXFrame()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFrame; } -00024 -00025 <span class="keywordtype">void</span> updateSize(); -00026 -00027 <span class="keyword">protected</span>: -00028 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onHandleInval(<span class="keyword">const</span> SkRect16&); -00029 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddMenu(<span class="keyword">const</span> SkOSMenu*); -00030 -00031 <span class="keyword">private</span>: -00032 wxFrame* fFrame; -00033 <span class="keyword">typedef</span> SkWindow INHERITED; -00034 -00035 }; -00036 -00037 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPNGImageDecoder_8h-source.html b/sgl_doxygen/html/SkPNGImageDecoder_8h-source.html deleted file mode 100644 index 26be96f..0000000 --- a/sgl_doxygen/html/SkPNGImageDecoder_8h-source.html +++ /dev/null @@ -1,28 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPNGImageDecoder.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPNGImageDecoder.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPNGImageDecoder_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPNGImageDecoder_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkImageDecoder.h"</span> -00005 -00006 <span class="keyword">class </span>SkPNGImageDecoder : <span class="keyword">public</span> <a class="code" href="classSkImageDecoder.html">SkImageDecoder</a> { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">static</span> <span class="keywordtype">bool</span> IsImage(SkStream* stream); -00009 <span class="keyword">protected</span>: -00010 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkImageDecoder.html#b1">onDecode</a>(SkStream* stream, <a class="code" href="classSkBitmap.html">SkBitmap</a>* bm); -00011 }; -00012 -00013 <span class="preprocessor">#endif</span> -00014 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPaint_8h-source.html b/sgl_doxygen/html/SkPaint_8h-source.html deleted file mode 100644 index a44ffc0..0000000 --- a/sgl_doxygen/html/SkPaint_8h-source.html +++ /dev/null @@ -1,315 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPaint.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPaint.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPaint_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPaint_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "<a class="code" href="SkColor_8h.html">SkColor.h</a>"</span> -00005 <span class="preprocessor">#include "SkMath.h"</span> -00006 <span class="preprocessor">#include "SkRefCnt.h"</span> -00007 -00008 <span class="keyword">class </span><a class="code" href="classSkShader.html">SkShader</a>; -00009 <span class="keyword">class </span><a class="code" href="classSkXfermode.html">SkXfermode</a>; -00010 <span class="keyword">class </span><a class="code" href="classSkPathEffect.html">SkPathEffect</a>; -00011 <span class="keyword">class </span><a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>; -00012 <span class="keyword">class </span>SkGlyphCache; -00013 <span class="keyword">class </span>SkMatrix; -00014 <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a>; -00015 <span class="keyword">class </span>SkTypeface; -00016 -00017 <span class="preprocessor">#include "SkPorterDuff.h"</span> -00018 -00019 <span class="keyword">typedef</span> SkUnichar (*SkUnicodeWalkerProc)(<span class="keyword">const</span> <span class="keywordtype">char</span>** text); -00020 -<a name="l00025"></a><a class="code" href="classSkPaint.html">00025</a> <span class="keyword">class </span><a class="code" href="classSkPaint.html">SkPaint</a> { -00026 <span class="keyword">public</span>: -00027 <a class="code" href="classSkPaint.html">SkPaint</a>(); -00028 <a class="code" href="classSkPaint.html">SkPaint</a>(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00029 ~<a class="code" href="classSkPaint.html">SkPaint</a>(); -00030 -00031 <a class="code" href="classSkPaint.html">SkPaint</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00032 -00033 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator==(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& a, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& b); -00034 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator!=(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& a, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& b) { <span class="keywordflow">return</span> !(a == b); } -00035 -00038 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a4">reset</a>(); -00039 -<a name="l00040"></a><a class="code" href="classSkPaint.html#w33">00040</a> <span class="keyword">enum</span> <a class="code" href="classSkPaint.html#w33">FlagShift</a> { -00041 <a class="code" href="classSkPaint.html#w33w0">kAntiAlias_Shift</a>, -00042 <a class="code" href="classSkPaint.html#w33w1">kLinearText_Shift</a> , -00043 <a class="code" href="classSkPaint.html#w33w2">kUnderlineText_Shift</a>, -00044 <a class="code" href="classSkPaint.html#w33w3">kStrikeThruText_Shift</a>, -00045 <a class="code" href="classSkPaint.html#w33w4">kFakeBoldText_Shift</a>, -00046 -00047 kFlagShiftCount -00048 }; -<a name="l00049"></a><a class="code" href="classSkPaint.html#w34">00049</a> <span class="keyword">enum</span> <a class="code" href="classSkPaint.html#w34">FlagMask</a> { -00050 <a class="code" href="classSkPaint.html#w34w6">kAntiAlias_Mask</a> = 1 << <a class="code" href="classSkPaint.html#w33w0">kAntiAlias_Shift</a>, -00051 <a class="code" href="classSkPaint.html#w34w7">kLinearText_Mask</a> = 1 << <a class="code" href="classSkPaint.html#w33w1">kLinearText_Shift</a>, -00052 <a class="code" href="classSkPaint.html#w34w8">kUnderlineText_Mask</a> = 1 << <a class="code" href="classSkPaint.html#w33w2">kUnderlineText_Shift</a>, -00053 <a class="code" href="classSkPaint.html#w34w9">kStrikeThruText_Mask</a>= 1 << <a class="code" href="classSkPaint.html#w33w3">kStrikeThruText_Shift</a>, -00054 <a class="code" href="classSkPaint.html#w34w10">kFakeBoldText_Mask</a> = 1 << <a class="code" href="classSkPaint.html#w33w4">kFakeBoldText_Shift</a>, -00055 -00056 kAllFlagMasks = (1 << kFlagShiftCount) - 1 -00057 }; -00058 -00059 U32 getFlags()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFlags; } -00060 <span class="keywordtype">void</span> setFlags(U32); -00061 -<a name="l00064"></a><a class="code" href="classSkPaint.html#a7">00064</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPaint.html#a7">isAntiAliasOn</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(this->getFlags() & <a class="code" href="classSkPaint.html#w34w6">kAntiAlias_Mask</a>); } -00067 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a8">setAntiAliasOn</a>(<span class="keywordtype">bool</span>); -<a name="l00070"></a><a class="code" href="classSkPaint.html#a9">00070</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPaint.html#a9">isLinearTextOn</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(this->getFlags() & <a class="code" href="classSkPaint.html#w34w7">kLinearText_Mask</a>); } -00073 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a10">setLinearTextOn</a>(<span class="keywordtype">bool</span>); -<a name="l00076"></a><a class="code" href="classSkPaint.html#a11">00076</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPaint.html#a11">isUnderlineTextOn</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(this->getFlags() & <a class="code" href="classSkPaint.html#w34w8">kUnderlineText_Mask</a>); } -00079 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a12">setUnderlineTextOn</a>(<span class="keywordtype">bool</span>); -<a name="l00082"></a><a class="code" href="classSkPaint.html#a13">00082</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPaint.html#a13">isStrikeThruTextOn</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(this->getFlags() & <a class="code" href="classSkPaint.html#w34w9">kStrikeThruText_Mask</a>); } -00085 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a14">setStrikeThruTextOn</a>(<span class="keywordtype">bool</span>); -<a name="l00088"></a><a class="code" href="classSkPaint.html#a15">00088</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPaint.html#a15">isFakeBoldTextOn</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(this->getFlags() & <a class="code" href="classSkPaint.html#w34w10">kFakeBoldText_Mask</a>); } -00091 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a16">setFakeBoldTextOn</a>(<span class="keywordtype">bool</span>); -00092 -<a name="l00096"></a><a class="code" href="classSkPaint.html#w35">00096</a> <span class="keyword">enum</span> <a class="code" href="classSkPaint.html#w35">Style</a> { -00097 <a class="code" href="classSkPaint.html#w35w12">kFill_Style</a>, -00098 <a class="code" href="classSkPaint.html#w35w13">kStroke_Style</a>, -00099 <a class="code" href="classSkPaint.html#w35w14">kStrokeAndFill_Style</a>, -00100 -00101 kStyleCount -00102 }; -<a name="l00107"></a><a class="code" href="classSkPaint.html#a17">00107</a> <a class="code" href="classSkPaint.html#w35">Style</a> <a class="code" href="classSkPaint.html#a17">getStyle</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<a class="code" href="classSkPaint.html#w35">Style</a>)fStyle; } -00112 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a18">setStyle</a>(Style); -00113 -00114 <span class="comment">// deprecated: for compatibility with older clients</span> -00115 <span class="keywordtype">bool</span> isStrokeOn()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> this-><a class="code" href="classSkPaint.html#a17">getStyle</a>() == kStroke_Style; } -00116 <span class="keywordtype">void</span> setStrokeOn(<span class="keywordtype">bool</span> on) { this-><a class="code" href="classSkPaint.html#a18">setStyle</a>(on ? kStroke_Style : kFill_Style); } -00117 -<a name="l00122"></a><a class="code" href="classSkPaint.html#a21">00122</a> <a class="code" href="SkColor_8h.html#a17">SkColor</a> <a class="code" href="classSkPaint.html#a21">getColor</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fColor; } -<a name="l00125"></a><a class="code" href="classSkPaint.html#a22">00125</a> U8 <a class="code" href="classSkPaint.html#a22">getAlpha</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToU8(<a class="code" href="SkColor_8h.html#a1">SkColorGetA</a>(fColor)); } -00130 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a23">setColor</a>(SkColor); -00134 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a24">setAlpha</a>(U8CPU a); -00137 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a25">setARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b); -00138 -<a name="l00142"></a><a class="code" href="classSkPaint.html#a26">00142</a> SkScalar <a class="code" href="classSkPaint.html#a26">getStrokeWidth</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fWidth; } -00147 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a27">setStrokeWidth</a>(SkScalar); -00148 -<a name="l00152"></a><a class="code" href="classSkPaint.html#a28">00152</a> SkScalar <a class="code" href="classSkPaint.html#a28">getStrokeMiter</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMiterLimit; } -00156 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a29">setStrokeMiter</a>(SkScalar); -00157 -<a name="l00158"></a><a class="code" href="classSkPaint.html#w36">00158</a> <span class="keyword">enum</span> <a class="code" href="classSkPaint.html#w36">Cap</a> { -00159 <a class="code" href="classSkPaint.html#w36w16">kButt_Cap</a>, -00160 <a class="code" href="classSkPaint.html#w36w17">kRound_Cap</a>, -00161 <a class="code" href="classSkPaint.html#w36w18">kSquare_Cap</a>, -00162 -00163 kCapCount, -00164 kDefault_Cap = <a class="code" href="classSkPaint.html#w36w16">kButt_Cap</a> -00165 }; -00166 -<a name="l00167"></a><a class="code" href="classSkPaint.html#w37">00167</a> <span class="keyword">enum</span> <a class="code" href="classSkPaint.html#w37">Join</a> { -00168 <a class="code" href="classSkPaint.html#w37w21">kMiter_Join</a>, -00169 <a class="code" href="classSkPaint.html#w37w22">kRound_Join</a>, -00170 <a class="code" href="classSkPaint.html#w37w23">kBevel_Join</a>, -00171 -00172 kJoinCount, -00173 kDefault_Join = <a class="code" href="classSkPaint.html#w37w21">kMiter_Join</a> -00174 }; -00175 -<a name="l00178"></a><a class="code" href="classSkPaint.html#a30">00178</a> <a class="code" href="classSkPaint.html#w36">Cap</a> <a class="code" href="classSkPaint.html#a30">getStrokeCap</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<a class="code" href="classSkPaint.html#w36">Cap</a>)fCapType; } -00181 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a31">setStrokeCap</a>(Cap); -00182 -<a name="l00185"></a><a class="code" href="classSkPaint.html#a32">00185</a> <a class="code" href="classSkPaint.html#w37">Join</a> <a class="code" href="classSkPaint.html#a32">getStrokeJoin</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<a class="code" href="classSkPaint.html#w37">Join</a>)fJoinType; } -00188 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a33">setStrokeJoin</a>(Join); -00189 -<a name="l00190"></a><a class="code" href="classSkPaint.html#w38">00190</a> <span class="keyword">enum</span> <a class="code" href="classSkPaint.html#w38">FilterType</a> { -00191 <a class="code" href="classSkPaint.html#w38w26">kNo_FilterType</a>, -00192 <a class="code" href="classSkPaint.html#w38w27">kBilinear_FilterType</a>, -00193 -00194 kFilterTypeCount -00195 }; -<a name="l00199"></a><a class="code" href="classSkPaint.html#a34">00199</a> <a class="code" href="classSkPaint.html#w38">FilterType</a> <a class="code" href="classSkPaint.html#a34">getFilterType</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<a class="code" href="classSkPaint.html#w38">FilterType</a>)fFilterType; } -00203 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a35">setFilterType</a>(FilterType); -00204 -<a name="l00207"></a><a class="code" href="classSkPaint.html#a36">00207</a> <a class="code" href="classSkShader.html">SkShader</a>* <a class="code" href="classSkPaint.html#a36">getShader</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fShader; } -00214 <a class="code" href="classSkShader.html">SkShader</a>* <a class="code" href="classSkPaint.html#a37">setShader</a>(<a class="code" href="classSkShader.html">SkShader</a>* shader); -00215 -<a name="l00218"></a><a class="code" href="classSkPaint.html#a38">00218</a> <a class="code" href="classSkXfermode.html">SkXfermode</a>* <a class="code" href="classSkPaint.html#a38">getXfermode</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fXfermode; } -00225 <a class="code" href="classSkXfermode.html">SkXfermode</a>* <a class="code" href="classSkPaint.html#a39">setXfermode</a>(<a class="code" href="classSkXfermode.html">SkXfermode</a>* xfermode); -00226 -00227 <a class="code" href="classSkXfermode.html">SkXfermode</a>* setPorterDuffXfermode(SkPorterDuff::Mode); -00228 -<a name="l00231"></a><a class="code" href="classSkPaint.html#a41">00231</a> <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* <a class="code" href="classSkPaint.html#a41">getPathEffect</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fPathEffect; } -00238 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* <a class="code" href="classSkPaint.html#a42">setPathEffect</a>(<a class="code" href="classSkPathEffect.html">SkPathEffect</a>* effect); -00239 -<a name="l00242"></a><a class="code" href="classSkPaint.html#a43">00242</a> <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>* <a class="code" href="classSkPaint.html#a43">getMaskFilter</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMaskFilter; } -00249 <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>* <a class="code" href="classSkPaint.html#a44">setMaskFilter</a>(<a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>* maskfilter); -00250 -00251 <span class="comment">// These attributes are for text/fonts</span> -00252 -<a name="l00258"></a><a class="code" href="classSkPaint.html#a45">00258</a> SkTypeface* <a class="code" href="classSkPaint.html#a45">getTypeface</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTypeface; } -00264 SkTypeface* <a class="code" href="classSkPaint.html#a46">setTypeface</a>(SkTypeface* typeface); -00265 -00266 <span class="keyword">enum</span> Align { -00267 kLeft_Align, -00268 kCenter_Align, -00269 kRight_Align, -00270 -00271 kAlignCount -00272 }; -<a name="l00275"></a><a class="code" href="classSkPaint.html#a47">00275</a> Align <a class="code" href="classSkPaint.html#a47">getTextAlign</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Align)fTextAlign; } -00278 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a48">setTextAlign</a>(Align); -00279 -<a name="l00282"></a><a class="code" href="classSkPaint.html#a49">00282</a> SkScalar <a class="code" href="classSkPaint.html#a49">getTextSize</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTextSize; } -00285 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a50">setTextSize</a>(SkScalar); -00286 -<a name="l00290"></a><a class="code" href="classSkPaint.html#a51">00290</a> SkScalar <a class="code" href="classSkPaint.html#a51">getTextScaleX</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTextScaleX; } -00295 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a52">setTextScaleX</a>(SkScalar scaleX); -00296 -<a name="l00300"></a><a class="code" href="classSkPaint.html#a53">00300</a> SkScalar <a class="code" href="classSkPaint.html#a53">getTextSkewX</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTextSkewX; } -00304 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a54">setTextSkewX</a>(SkScalar skewX); -00305 -<a name="l00310"></a><a class="code" href="classSkPaint.html#a55">00310</a> SkScalar <a class="code" href="classSkPaint.html#a55">getTextTracking</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTextTracking; } -00315 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a56">setTextTracking</a>(SkScalar tracking); -00316 -00324 SkScalar <a class="code" href="classSkPaint.html#a57">measureText</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> utf8[], size_t length, -00325 SkScalar* above, SkScalar* below) <span class="keyword">const</span>; -00333 SkScalar <a class="code" href="classSkPaint.html#a58">measureText16</a>(<span class="keyword">const</span> U16 utf16[], size_t numberOf16BitValues, -00334 SkScalar* above, SkScalar* below) <span class="keyword">const</span>; -00339 SkScalar <a class="code" href="classSkPaint.html#a59">ascent</a>() <span class="keyword">const</span>; -00340 SkScalar descent() <span class="keyword">const</span>; -00341 -<a name="l00344"></a><a class="code" href="classSkPaint.html#a61">00344</a> SkScalar <a class="code" href="classSkPaint.html#a57">measureText</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t length)<span class="keyword"> const</span> -00345 <span class="keyword"> </span>{ -00346 <span class="keywordflow">return</span> this-><a class="code" href="classSkPaint.html#a57">measureText</a>(text, length, nil, nil); -00347 } -00348 SkScalar <a class="code" href="classSkPaint.html#a58">measureText16</a>(<span class="keyword">const</span> U16 utf16[], size_t numberOf16BitValues)<span class="keyword"> const</span> -00349 <span class="keyword"> </span>{ -00350 <span class="keywordflow">return</span> this-><a class="code" href="classSkPaint.html#a58">measureText16</a>(utf16, numberOf16BitValues, nil, nil); -00351 } -00352 -00356 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a63">getTextPath</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t length, SkScalar x, SkScalar y, <a class="code" href="classSkPath.html">SkPath</a>* path) <span class="keyword">const</span>; -00357 -00361 <span class="keywordtype">void</span> <a class="code" href="classSkPaint.html#a64">getText16Path</a>(<span class="keyword">const</span> U16 text[], size_t numberOf16BitValues, SkScalar x, SkScalar y, <a class="code" href="classSkPath.html">SkPath</a>* path) <span class="keyword">const</span>; -00362 -00363 <span class="keyword">private</span>: -00364 SkTypeface* fTypeface; -00365 SkScalar fTextSize; -00366 SkScalar fTextScaleX; -00367 SkScalar fTextSkewX; -00368 SkScalar fTextTracking; -00369 -00370 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* fPathEffect; -00371 <a class="code" href="classSkShader.html">SkShader</a>* fShader; -00372 <a class="code" href="classSkXfermode.html">SkXfermode</a>* fXfermode; -00373 <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>* fMaskFilter; -00374 -00375 <a class="code" href="SkColor_8h.html#a17">SkColor</a> fColor; -00376 SkScalar fWidth; -00377 SkScalar fMiterLimit; -00378 <span class="keywordtype">unsigned</span> fFlags : 5; -00379 <span class="keywordtype">unsigned</span> fFilterType : 2; -00380 <span class="keywordtype">unsigned</span> fTextAlign : 2; -00381 <span class="keywordtype">unsigned</span> fCapType : 2; -00382 <span class="keywordtype">unsigned</span> fJoinType : 2; -00383 <span class="keywordtype">unsigned</span> fStyle : 2; -00384 -00385 SkScalar privateMeasureText(SkUnicodeWalkerProc, <span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t byteLength, -00386 SkScalar* above, SkScalar* below) <span class="keyword">const</span>; -00387 <span class="keywordtype">void</span> privateGetTextPath(SkUnicodeWalkerProc, <span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t length, -00388 SkScalar x, SkScalar y, <a class="code" href="classSkPath.html">SkPath</a>* path) <span class="keyword">const</span>; -00389 -00390 SkGlyphCache* detachCache(<span class="keyword">const</span> SkMatrix*) <span class="keyword">const</span>; -00391 -00392 <span class="keyword">friend</span> <span class="keyword">class </span>SkGlyphCache; -00393 <span class="keyword">enum</span> { -00394 kCanonicalTextSizeForPaths = 64 -00395 }; -00396 <span class="keyword">friend</span> <span class="keyword">class </span>SkDraw; -00397 <span class="keyword">friend</span> <span class="keyword">class </span>SkTextToPathIter; -00398 }; -00399 -00400 <span class="keyword">class </span>SkAutoRestorePaintFlags { -00401 <span class="keyword">public</span>: -00402 SkAutoRestorePaintFlags(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint, U32 newFlags) -00403 { -00404 SkASSERT(&paint); -00405 fPaint = (<a class="code" href="classSkPaint.html">SkPaint</a>*)&paint; <span class="comment">// remove constness</span> -00406 fOldFlags = paint.getFlags(); -00407 fPaint->setFlags(newFlags); -00408 } -00409 ~SkAutoRestorePaintFlags() -00410 { -00411 fPaint->setFlags(fOldFlags); -00412 } -00413 <span class="keyword">private</span>: -00414 <a class="code" href="classSkPaint.html">SkPaint</a>* fPaint; -00415 U32 fOldFlags; -00416 }; -00417 -00418 <span class="keyword">class </span>SkTypeface : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00419 <span class="keyword">public</span>: -00420 <span class="keyword">enum</span> Style { -00421 kNormal = 0, -00422 kBold = 0x01, -00423 kItalic = 0x02, -00424 -00425 <span class="comment">// helpers</span> -00426 kBoldItalic = 0x03 -00427 }; -00428 -00429 Style getStyle()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Style)fStyle; } -00430 <span class="keywordtype">bool</span> isBold()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (fStyle & kBold) != 0; } -00431 <span class="keywordtype">bool</span> isItalic()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (fStyle & kItalic) != 0; } -00432 -00438 <span class="keyword">static</span> SkTypeface* Create(<span class="keyword">const</span> <span class="keywordtype">char</span> familyName[], Style s = kNormal); -00444 <span class="keyword">static</span> SkTypeface* CreateFromTypeface(<span class="keyword">const</span> SkTypeface* family, Style s); -00445 -00446 <span class="keyword">protected</span>: -00447 <span class="keywordtype">void</span> setStyle(Style s) { -00448 fStyle = SkToU8(s); -00449 } -00450 -00451 SkTypeface() {} -00452 -00453 <span class="keyword">private</span>: -00454 uint8_t fStyle; -00455 }; -00456 -00458 -00459 <span class="preprocessor">#include "SkPathEffect.h"</span> -00460 -00461 <span class="keyword">class </span>SkStrokePathEffect : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00462 <span class="keyword">public</span>: -00463 SkStrokePathEffect(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00464 SkStrokePathEffect(SkScalar width, SkPaint::Style, SkPaint::Join, SkPaint::Cap, SkScalar miterLimit = -1); -00465 -00466 <span class="comment">// overrides</span> -00467 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> filterPath(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00468 -00469 <span class="comment">// overrides for SkFlattenable</span> -00470 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>*); -00471 <span class="keyword">virtual</span> Factory getFactory(); -00472 -00473 <span class="keyword">private</span>: -00474 SkScalar fWidth, fMiter; -00475 U8 fStyle, fJoin, fCap; -00476 -00477 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00478 SkStrokePathEffect(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00479 -00480 <span class="keyword">typedef</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> INHERITED; -00481 -00482 <span class="comment">// illegal</span> -00483 SkStrokePathEffect(<span class="keyword">const</span> SkStrokePathEffect&); -00484 SkStrokePathEffect& operator=(<span class="keyword">const</span> SkStrokePathEffect&); -00485 }; -00486 -00487 <span class="preprocessor">#endif</span> -00488 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkParsePaint_8h-source.html b/sgl_doxygen/html/SkParsePaint_8h-source.html deleted file mode 100644 index 296a336..0000000 --- a/sgl_doxygen/html/SkParsePaint_8h-source.html +++ /dev/null @@ -1,24 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkParsePaint.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkParsePaint.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkParsePaint_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkParsePaint_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPaint.h"</span> -00005 <span class="preprocessor">#include "SkDOM.h"</span> -00006 -00015 <span class="keywordtype">void</span> SkPaint_Inflate(<a class="code" href="classSkPaint.html">SkPaint</a>*, <span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00016 -00017 <span class="preprocessor">#endif</span> -00018 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkParse_8h-source.html b/sgl_doxygen/html/SkParse_8h-source.html deleted file mode 100644 index bfe3c6f..0000000 --- a/sgl_doxygen/html/SkParse_8h-source.html +++ /dev/null @@ -1,43 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkParse.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkParse.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkParse_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkParse_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "<a class="code" href="SkColor_8h.html">SkColor.h</a>"</span> -00005 <span class="preprocessor">#include "SkMath.h"</span> -00006 -00007 <span class="keyword">class </span>SkParse { -00008 <span class="keyword">public</span>: -00009 <span class="keyword">static</span> <span class="keywordtype">int</span> Count(<span class="keyword">const</span> <span class="keywordtype">char</span> str[]); <span class="comment">// number of scalars or S32 values</span> -00010 <span class="keyword">static</span> <span class="keywordtype">int</span> Count(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], <span class="keywordtype">char</span> separator); -00011 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindColor(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], SkColor* value); -00012 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindHex(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], U32* value); -00013 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindMSec(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], SkMSec* value); -00014 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindNamedColor(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], size_t len, SkColor* color); -00015 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindS32(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], S32* value); -00016 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindScalar(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], SkScalar* value); -00017 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* FindScalars(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], SkScalar value[], <span class="keywordtype">int</span> count); -00018 -00019 <span class="keyword">static</span> <span class="keywordtype">bool</span> FindBool(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], <span class="keywordtype">bool</span>* value); -00020 <span class="comment">// return the index of str in list[], or -1 if not found</span> -00021 <span class="keyword">static</span> <span class="keywordtype">int</span> FindList(<span class="keyword">const</span> <span class="keywordtype">char</span> str[], <span class="keyword">const</span> <span class="keywordtype">char</span> list[]); -00022 <span class="preprocessor">#ifdef SK_SUPPORT_UNITTEST</span> -00023 <span class="preprocessor"></span> <span class="keyword">static</span> <span class="keywordtype">void</span> TestColor(); -00024 <span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest(); -00025 <span class="preprocessor">#endif</span> -00026 <span class="preprocessor"></span>}; -00027 -00028 <span class="preprocessor">#endif</span> -00029 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPathEffect_8h-source.html b/sgl_doxygen/html/SkPathEffect_8h-source.html deleted file mode 100644 index 4e82982..0000000 --- a/sgl_doxygen/html/SkPathEffect_8h-source.html +++ /dev/null @@ -1,100 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPathEffect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPathEffect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPathEffect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPathEffect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkFlattenable.h"</span> -00005 -00006 <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a>; -00007 -<a name="l00016"></a><a class="code" href="classSkPathEffect.html">00016</a> <span class="keyword">class </span><a class="code" href="classSkPathEffect.html">SkPathEffect</a> : <span class="keyword">public</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a> { -00017 <span class="keyword">public</span>: -00018 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>() {} -00019 -00026 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkPathEffect.html#a1">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00030 <span class="keyword">virtual</span> Factory <a class="code" href="classSkPathEffect.html#a2">getFactory</a>(); -00031 -00032 <span class="keyword">protected</span>: -00033 <span class="comment">// visible to our subclasses</span> -00034 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer) {} -00035 -00036 <span class="keyword">private</span>: -00037 <span class="comment">// illegal</span> -00038 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>(<span class="keyword">const</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a>&); -00039 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a>&); -00040 }; -00041 -<a name="l00048"></a><a class="code" href="classSkPairPathEffect.html">00048</a> <span class="keyword">class </span><a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a> : <span class="keyword">public</span> <a class="code" href="classSkPathEffect.html">SkPathEffect</a> { -00049 <span class="keyword">public</span>: -00050 <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(<a class="code" href="classSkPathEffect.html">SkPathEffect</a>* pe0, <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* pe1); -00051 <span class="keyword">virtual</span> ~<a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(); -00052 -00053 <span class="comment">// overrides</span> -00054 <span class="keyword">virtual</span> U32 flatten(<span class="keywordtype">void</span>* buffer); -00055 -00056 <span class="keyword">protected</span>: -00057 <span class="comment">// these are visible to our subclasses</span> -00058 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* fPE0, *fPE1; -00059 <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00060 }; -00061 -<a name="l00067"></a><a class="code" href="classSkComposePathEffect.html">00067</a> <span class="keyword">class </span><a class="code" href="classSkComposePathEffect.html">SkComposePathEffect</a> : <span class="keyword">public</span> <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a> { -00068 <span class="keyword">public</span>: -<a name="l00074"></a><a class="code" href="classSkComposePathEffect.html#a0">00074</a> <a class="code" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a>(<a class="code" href="classSkPathEffect.html">SkPathEffect</a>* outer, <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* inner) -00075 : <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(outer, inner) {} -00076 -00077 <span class="comment">// overrides</span> -00078 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkComposePathEffect.html#a1">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00079 -00080 <span class="comment">// overrides for SkFlattenable</span> -00081 <span class="keyword">virtual</span> Factory <a class="code" href="classSkComposePathEffect.html#a2">getFactory</a>(); -00082 -00083 <span class="keyword">private</span>: -00084 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* fOuter, *fInner; -00085 -00086 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00087 <a class="code" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer) -00088 : <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(buffer) {} -00089 -00090 <span class="comment">// illegal</span> -00091 <a class="code" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a>(<span class="keyword">const</span> <a class="code" href="classSkComposePathEffect.html">SkComposePathEffect</a>&); -00092 <a class="code" href="classSkComposePathEffect.html">SkComposePathEffect</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkComposePathEffect.html">SkComposePathEffect</a>&); -00093 }; -00094 -<a name="l00100"></a><a class="code" href="classSkSumPathEffect.html">00100</a> <span class="keyword">class </span><a class="code" href="classSkSumPathEffect.html">SkSumPathEffect</a> : <span class="keyword">public</span> <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a> { -00101 <span class="keyword">public</span>: -<a name="l00107"></a><a class="code" href="classSkSumPathEffect.html#a0">00107</a> <a class="code" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a>(<a class="code" href="classSkPathEffect.html">SkPathEffect</a>* first, <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* second) -00108 : <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(first, second) {} -00109 -00110 <span class="comment">// overrides</span> -00111 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkSumPathEffect.html#a1">filterPath</a>(<a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar* width); -00112 -00113 <span class="comment">// overrides for SkFlattenable</span> -00114 <span class="keyword">virtual</span> Factory <a class="code" href="classSkSumPathEffect.html#a2">getFactory</a>(); -00115 -00116 <span class="keyword">private</span>: -00117 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* fFirst, *fSecond; -00118 -00119 <span class="keyword">static</span> <a class="code" href="classSkFlattenable.html">SkFlattenable</a>* CreateProc(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00120 <a class="code" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a>(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer) -00121 : <a class="code" href="classSkPairPathEffect.html">SkPairPathEffect</a>(buffer) {} -00122 -00123 <span class="comment">// illegal</span> -00124 <a class="code" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a>(<span class="keyword">const</span> <a class="code" href="classSkSumPathEffect.html">SkSumPathEffect</a>&); -00125 <a class="code" href="classSkSumPathEffect.html">SkSumPathEffect</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkSumPathEffect.html">SkSumPathEffect</a>&); -00126 }; -00127 -00128 <span class="preprocessor">#endif</span> -00129 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPathMeasure_8h-source.html b/sgl_doxygen/html/SkPathMeasure_8h-source.html deleted file mode 100644 index 9aaf204..0000000 --- a/sgl_doxygen/html/SkPathMeasure_8h-source.html +++ /dev/null @@ -1,83 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPathMeasure.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPathMeasure.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPathMeasure_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPathMeasure_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPath.h"</span> -00005 <span class="preprocessor">#include "SkTDArray.h"</span> -00006 -00007 <span class="keyword">class </span>SkPathMeasure { -00008 <span class="keyword">public</span>: -00009 SkPathMeasure(); -00010 SkPathMeasure(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& path, <span class="keywordtype">bool</span> forceClosed); -00011 ~SkPathMeasure(); -00012 -00015 <span class="keywordtype">void</span> setPath(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>*, <span class="keywordtype">bool</span> forceClosed); -00016 -00020 SkScalar getLength(); -00021 -00027 <span class="keywordtype">bool</span> getPosTan(SkScalar distance, SkPoint* position, SkVector* tangent); -00028 -00029 <span class="keyword">enum</span> MatrixFlags { -00030 kGetPosition_MatrixFlag = 0x01, -00031 kGetTangent_MatrixFlag = 0x02, -00032 kGetPosAndTan_MatrixFlag = kGetPosition_MatrixFlag | kGetTangent_MatrixFlag -00033 }; -00039 <span class="keywordtype">bool</span> getMatrix(SkScalar distance, SkMatrix* matrix, MatrixFlags flags = kGetPosAndTan_MatrixFlag); -00046 <span class="keywordtype">bool</span> getSegment(SkScalar startD, SkScalar stopD, <a class="code" href="classSkPath.html">SkPath</a>* dst, <span class="keywordtype">bool</span> startWithMoveTo); -00047 -00050 <span class="keywordtype">bool</span> isClosed(); -00051 -00055 <span class="keywordtype">bool</span> nextContour(); -00056 -00057 <span class="preprocessor">#ifdef SK_DEBUG</span> -00058 <span class="preprocessor"></span> <span class="keywordtype">void</span> dump(); -00059 <span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest(); -00060 <span class="preprocessor">#endif</span> -00061 <span class="preprocessor"></span> -00062 <span class="keyword">private</span>: -00063 <a class="code" href="classSkPath_1_1Iter.html">SkPath::Iter</a> fIter; -00064 <span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>* fPath; -00065 SkScalar fLength; <span class="comment">// relative to the current contour</span> -00066 <span class="keywordtype">int</span> fFirstPtIndex; <span class="comment">// relative to the current contour</span> -00067 <span class="keywordtype">bool</span> fIsClosed; <span class="comment">// relative to the current contour</span> -00068 <span class="keywordtype">bool</span> fForceClosed; -00069 -00070 <span class="keyword">struct </span>Segment { -00071 SkScalar fDistance; <span class="comment">// total distance up to this point</span> -00072 <span class="keywordtype">unsigned</span> fPtIndex : 15; -00073 <span class="keywordtype">unsigned</span> fTValue : 15; -00074 <span class="keywordtype">unsigned</span> fType : 2; -00075 -00076 SkScalar getScalarT() <span class="keyword">const</span>; -00077 }; -00078 SkTDArray<Segment> fSegments; -00079 -00080 <span class="keyword">static</span> <span class="keyword">const</span> Segment* NextSegment(<span class="keyword">const</span> Segment*); -00081 -00082 <span class="keywordtype">void</span> buildSegments(); -00083 SkScalar compute_quad_segs(<span class="keyword">const</span> SkPoint pts[3], SkScalar distance, -00084 <span class="keywordtype">int</span> mint, <span class="keywordtype">int</span> maxt, <span class="keywordtype">int</span> ptIndex); -00085 SkScalar compute_cubic_segs(<span class="keyword">const</span> SkPoint pts[3], SkScalar distance, -00086 <span class="keywordtype">int</span> mint, <span class="keywordtype">int</span> maxt, <span class="keywordtype">int</span> ptIndex); -00087 <span class="keyword">const</span> Segment* distanceToSegment(SkScalar distance, SkScalar* t); -00088 -00089 <span class="comment">// illegal (for now)</span> -00090 SkPathMeasure(<span class="keyword">const</span> SkPathMeasure&); -00091 SkPathMeasure& operator=(<span class="keyword">const</span> SkPathMeasure&); -00092 }; -00093 -00094 <span class="preprocessor">#endif</span> -00095 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPath_8h-source.html b/sgl_doxygen/html/SkPath_8h-source.html deleted file mode 100644 index 807f7e4..0000000 --- a/sgl_doxygen/html/SkPath_8h-source.html +++ /dev/null @@ -1,171 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPath.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPath.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPath_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPath_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMatrix.h"</span> -00005 <span class="preprocessor">#include "SkTDArray.h"</span> -00006 -<a name="l00012"></a><a class="code" href="classSkPath.html">00012</a> <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a> { -00013 <span class="keyword">public</span>: -00014 <a class="code" href="classSkPath.html">SkPath</a>(); -00015 <a class="code" href="classSkPath.html">SkPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&); -00016 ~<a class="code" href="classSkPath.html">SkPath</a>(); -00017 -00018 <a class="code" href="classSkPath.html">SkPath</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&); -00019 -<a name="l00020"></a><a class="code" href="classSkPath.html#w12">00020</a> <span class="keyword">enum</span> <a class="code" href="classSkPath.html#w12">FillType</a> { -00021 <a class="code" href="classSkPath.html#w12w0">kWinding_FillType</a>, -00022 <a class="code" href="classSkPath.html#w12w1">kEvenOdd_FillType</a> -00023 }; -<a name="l00027"></a><a class="code" href="classSkPath.html#a4">00027</a> <a class="code" href="classSkPath.html#w12">FillType</a> <a class="code" href="classSkPath.html#a4">getFillType</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<a class="code" href="classSkPath.html#w12">FillType</a>)fFillType; } -<a name="l00031"></a><a class="code" href="classSkPath.html#a5">00031</a> <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a5">setFillType</a>(FillType ft) { fFillType = SkToU8(ft); } -00032 -00036 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a6">reset</a>(); -00039 <span class="keywordtype">bool</span> <a class="code" href="classSkPath.html#a7">isEmpty</a>() <span class="keyword">const</span>; -00046 <span class="keywordtype">bool</span> <a class="code" href="classSkPath.html#a8">isRect</a>(SkRect* rect) <span class="keyword">const</span>; -00052 <span class="keywordtype">int</span> <a class="code" href="classSkPath.html#a9">getPoints</a>(SkPoint points[], <span class="keywordtype">int</span> max) <span class="keyword">const</span>; -00054 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a10">swap</a>(<a class="code" href="classSkPath.html">SkPath</a>& other); -00055 -<a name="l00056"></a><a class="code" href="classSkPath.html#w13">00056</a> <span class="keyword">enum</span> <a class="code" href="classSkPath.html#w13">BoundsType</a> { -00057 <a class="code" href="classSkPath.html#w13w2">kFast_BoundsType</a>, -00058 <a class="code" href="classSkPath.html#w13w3">kExact_BoundsType</a> -00059 }; -00063 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a11">computeBounds</a>(SkRect* bounds, BoundsType btype) <span class="keyword">const</span>; -00064 -00065 <span class="comment">// Construction methods</span> -00066 -00067 <span class="keywordtype">void</span> incReserve(U16CPU extraPtCount); -00068 -00071 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a13">moveTo</a>(SkScalar x, SkScalar y); -00075 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a14">rMoveTo</a>(SkScalar x, SkScalar y); -00079 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a15">lineTo</a>(SkScalar x, SkScalar y); -00083 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a16">rLineTo</a>(SkScalar x, SkScalar y); -00088 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a17">quadTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2); -00092 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a18">rQuadTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2); -00097 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a19">cubicTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3); -00101 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a20">rCubicTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3); -00105 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a21">close</a>(); -00106 -00107 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a13">moveTo</a>(<span class="keyword">const</span> SkPoint& p) -00108 { -00109 this-><a class="code" href="classSkPath.html#a13">moveTo</a>(p.fX, p.fY); -00110 } -00111 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a15">lineTo</a>(<span class="keyword">const</span> SkPoint& p1) -00112 { -00113 this-><a class="code" href="classSkPath.html#a15">lineTo</a>(p1.fX, p1.fY); -00114 } -00115 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a17">quadTo</a>(<span class="keyword">const</span> SkPoint& p1, <span class="keyword">const</span> SkPoint& p2) -00116 { -00117 this-><a class="code" href="classSkPath.html#a17">quadTo</a>(p1.fX, p1.fY, p2.fX, p2.fY); -00118 } -00119 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a19">cubicTo</a>(<span class="keyword">const</span> SkPoint& p1, <span class="keyword">const</span> SkPoint& p2, <span class="keyword">const</span> SkPoint& p3) -00120 { -00121 this-><a class="code" href="classSkPath.html#a19">cubicTo</a>(p1.fX, p1.fY, p2.fX, p2.fY, p3.fX, p3.fY); -00122 } -00123 -<a name="l00124"></a><a class="code" href="classSkPath.html#w14">00124</a> <span class="keyword">enum</span> <a class="code" href="classSkPath.html#w14">Direction</a> { -00125 <a class="code" href="classSkPath.html#w14w4">kCW_Direction</a>, -00126 <a class="code" href="classSkPath.html#w14w5">kCCW_Direction</a> -00127 }; -00130 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a26">addRect</a>(<span class="keyword">const</span> SkRect&, Direction dir = kCW_Direction); -00133 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a27">addOval</a>(<span class="keyword">const</span> SkRect&, Direction dir = kCW_Direction); -00136 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a28">addCircle</a>(SkScalar x, SkScalar y, SkScalar radius, Direction dir = kCW_Direction); -00139 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a29">addRoundRect</a>(<span class="keyword">const</span> SkRect&, SkScalar rx, SkScalar ry, Direction dir = kCW_Direction); -00142 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a30">addPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, SkScalar dx, SkScalar dy); -<a name="l00145"></a><a class="code" href="classSkPath.html#a31">00145</a> <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a30">addPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src) { SkMatrix m; m.reset(); this-><a class="code" href="classSkPath.html#a30">addPath</a>(src, m); } -00148 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a30">addPath</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& src, <span class="keyword">const</span> SkMatrix& matrix); -00149 -00152 <span class="keywordtype">bool</span> <a class="code" href="classSkPath.html#a33">offset</a>(SkScalar dx, SkScalar dy); -00156 <span class="keywordtype">bool</span> <a class="code" href="classSkPath.html#a34">transform</a>(<span class="keyword">const</span> SkMatrix&, <a class="code" href="classSkPath.html">SkPath</a>* dst) <span class="keyword">const</span>; -<a name="l00160"></a><a class="code" href="classSkPath.html#a35">00160</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPath.html#a34">transform</a>(<span class="keyword">const</span> SkMatrix& map) -00161 { -00162 <span class="keywordflow">return</span> this-><a class="code" href="classSkPath.html#a34">transform</a>(map, <span class="keyword">this</span>); -00163 } -00164 -00167 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a36">getLastPt</a>(SkPoint* lastPt) <span class="keyword">const</span>; -00170 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a37">setLastPt</a>(SkScalar x, SkScalar y); -00171 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a37">setLastPt</a>(<span class="keyword">const</span> SkPoint& pt) { this-><a class="code" href="classSkPath.html#a37">setLastPt</a>(pt.fX, pt.fY); } -00172 -<a name="l00173"></a><a class="code" href="classSkPath.html#w15">00173</a> <span class="keyword">enum</span> <a class="code" href="classSkPath.html#w15">Verb</a> { -00174 <a class="code" href="classSkPath.html#w15w6">kMove_Verb</a>, -00175 <a class="code" href="classSkPath.html#w15w7">kLine_Verb</a>, -00176 <a class="code" href="classSkPath.html#w15w8">kQuad_Verb</a>, -00177 <a class="code" href="classSkPath.html#w15w9">kCubic_Verb</a>, -00178 <a class="code" href="classSkPath.html#w15w10">kClose_Verb</a>, -00179 <a class="code" href="classSkPath.html#w15w11">kDone_Verb</a> -00180 }; -<a name="l00184"></a><a class="code" href="classSkPath_1_1Iter.html">00184</a> <span class="keyword">class </span><a class="code" href="classSkPath_1_1Iter.html">Iter</a> { -00185 <span class="keyword">public</span>: -00186 <a class="code" href="classSkPath_1_1Iter.html">Iter</a>(); -00187 <a class="code" href="classSkPath_1_1Iter.html">Iter</a>(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&, <span class="keywordtype">bool</span> forceClose); -00188 <span class="keywordtype">void</span> setPath(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&, <span class="keywordtype">bool</span> forceClose); -00189 -00190 Verb next(SkPoint pts[4]); -00191 -<a name="l00198"></a><a class="code" href="classSkPath_1_1Iter.html#a4">00198</a> <span class="keywordtype">bool</span> <a class="code" href="classSkPath_1_1Iter.html#a4">isCloseLine</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(fCloseLine); } -00199 -00200 <span class="comment">//* returns true if the current contour is closed (has a kClose_Verb)</span> -00201 <span class="keywordtype">bool</span> isClosedContour() <span class="keyword">const</span>; -00202 -00203 <span class="keyword">private</span>: -00204 <span class="keyword">const</span> SkPoint* fPts; -00205 <span class="keyword">const</span> U8* fVerbs; -00206 <span class="keyword">const</span> U8* fVerbStop; -00207 SkPoint fMoveTo; -00208 SkPoint fLastPt; -00209 U8 fForceClose; -00210 U8 fNeedClose; -00211 U8 fNeedMoveTo; -00212 U8 fCloseLine; -00213 -00214 <span class="keywordtype">bool</span> cons_moveTo(SkPoint pts[1]); -00215 Verb autoClose(SkPoint pts[2]); -00216 }; -00217 -00218 <span class="preprocessor">#ifdef SK_DEBUG</span> -00219 <span class="preprocessor"></span> -00220 <span class="keywordtype">void</span> dump(<span class="keywordtype">bool</span> forceClose, <span class="keyword">const</span> <span class="keywordtype">char</span> title[] = nil) <span class="keyword">const</span>; -00221 <span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest(); -00223 <span class="preprocessor">#endif</span> -00224 <span class="preprocessor"></span> -00230 U32 <a class="code" href="classSkPath.html#a39">flatten</a>(<span class="keywordtype">void</span>* bufferOrNil) <span class="keyword">const</span>; -00231 <span class="keywordtype">void</span> unflatten(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer); -00232 -00237 <span class="keywordtype">void</span> <a class="code" href="classSkPath.html#a41">subdivide</a>(SkScalar dist, <span class="keywordtype">bool</span> bendLines, <a class="code" href="classSkPath.html">SkPath</a>* dst = nil) <span class="keyword">const</span>; -00238 -00239 <span class="keyword">private</span>: -00240 SkTDArray<SkPoint> fPts; -00241 SkTDArray<U8> fVerbs; -00242 U8 fFillType; -00243 -00244 <span class="keyword">friend</span> <span class="keyword">class </span>Iter; -00245 <span class="keywordtype">void</span> cons_moveto(); -00246 -00247 <span class="keyword">friend</span> <span class="keyword">class </span>SkPathStroker; -00248 <span class="comment">/* Append the first contour of path, ignoring path's initial point.</span> -00249 <span class="comment"> If no moveTo() call has been made for this contour, the first point is automatically set to (0,0).</span> -00250 <span class="comment"> */</span> -00251 <span class="keywordtype">void</span> pathTo(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& path); -00252 <span class="comment">/* Append, in reverse order, the first contour of path, ignoring path's last point.</span> -00253 <span class="comment"> If no moveTo() call has been made for this contour, the first point is automatically set to (0,0).</span> -00254 <span class="comment"> */</span> -00255 <span class="keywordtype">void</span> reversePathTo(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&); -00256 -00257 <span class="keyword">friend</span> <span class="keyword">const</span> SkPoint* sk_get_path_points(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>&, <span class="keywordtype">int</span> index); -00258 }; -00259 -00260 <span class="preprocessor">#endif</span> -00261 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPorterDuff_8h-source.html b/sgl_doxygen/html/SkPorterDuff_8h-source.html deleted file mode 100644 index 2f0dd1b..0000000 --- a/sgl_doxygen/html/SkPorterDuff_8h-source.html +++ /dev/null @@ -1,44 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPorterDuff.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPorterDuff.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPorterDuff_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPorterDuff_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="keyword">class </span><a class="code" href="classSkXfermode.html">SkXfermode</a>; -00005 -00006 <span class="keyword">class </span>SkPorterDuff { -00007 <span class="keyword">public</span>: -00016 <span class="keyword">enum</span> Mode { -00017 kClear_Mode, -00018 kSrc_Mode, -00019 kDst_Mode, -00020 kSrcOver_Mode, -00021 kDstOver_Mode, -00022 kSrcIn_Mode, -00023 kDstIn_Mode, -00024 kSrcOut_Mode, -00025 kDstOut_Mode, -00026 kSrcATop_Mode, -00027 kDstATop_Mode, -00028 kXor_Mode, -00029 kDarken_Mode, -00030 kLighten_Mode, -00031 -00032 kModeCount -00033 }; -00036 <span class="keyword">static</span> <a class="code" href="classSkXfermode.html">SkXfermode</a>* Create(Mode); -00037 }; -00038 -00039 <span class="preprocessor">#endif</span> -00040 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPrefix__Debug__Fixed_8h-source.html b/sgl_doxygen/html/SkPrefix__Debug__Fixed_8h-source.html deleted file mode 100644 index 286e259..0000000 --- a/sgl_doxygen/html/SkPrefix__Debug__Fixed_8h-source.html +++ /dev/null @@ -1,28 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPrefix_Debug_Fixed.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPrefix_Debug_Fixed.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPrefix_Debug_Fixed_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkPrefix_Debug_Fixed_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#define SK_DEBUG</span> -00005 <span class="preprocessor"></span> -00006 <span class="comment">/* define this to test fixed-point */</span> -00007 <span class="preprocessor">#define SK_SCALAR_IS_FIXED</span> -00008 <span class="preprocessor"></span> -00009 <span class="comment">/* these are for expat */</span> -00010 <span class="preprocessor">#define MACOS_CLASSIC</span> -00011 <span class="preprocessor"></span> -00012 <span class="preprocessor">#endif</span> -00013 <span class="preprocessor"></span> -00014 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkPrefix__Release__Fixed_8h-source.html b/sgl_doxygen/html/SkPrefix__Release__Fixed_8h-source.html deleted file mode 100644 index eca6816..0000000 --- a/sgl_doxygen/html/SkPrefix__Release__Fixed_8h-source.html +++ /dev/null @@ -1,40 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPrefix_Release_Fixed.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkPrefix_Release_Fixed.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkPrefix_Release_Fixed_DEFINED</span> -00002 <span class="preprocessor"></span> -00003 <span class="preprocessor">#define SkPrefix_Release_Fixed_DEFINED</span> -00004 <span class="preprocessor"></span> -00005 <span class="comment">/* this means we're a release build */</span> -00006 -00007 <span class="preprocessor">#define NDEBUG</span> -00008 <span class="preprocessor"></span> -00009 -00010 -00011 <span class="comment">/* define this to test fixed-point */</span> -00012 -00013 <span class="preprocessor">#define SK_SCALAR_IS_FIXED</span> -00014 <span class="preprocessor"></span> -00015 -00016 -00017 <span class="comment">/* these are for expat */</span> -00018 -00019 <span class="preprocessor">#define MACOS_CLASSIC</span> -00020 <span class="preprocessor"></span> -00021 -00022 -00023 <span class="preprocessor">#endif</span> -00024 <span class="preprocessor"></span> -00025 -00026 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkProgressBarView_8h-source.html b/sgl_doxygen/html/SkProgressBarView_8h-source.html deleted file mode 100644 index 4bb84d0..0000000 --- a/sgl_doxygen/html/SkProgressBarView_8h-source.html +++ /dev/null @@ -1,55 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkProgressBarView.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkProgressBarView.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkProgressBarView_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkProgressBarView_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkWidgetViews.h"</span> -00006 <span class="preprocessor">#include "SkAnimator.h"</span> -00007 -00008 <span class="keyword">class </span>SkProgressBarView : <span class="keyword">public</span> SkWidgetView { -00009 <span class="keyword">public</span>: -00010 SkProgressBarView(); -00011 <span class="comment">//SkProgressBarView(int max);</span> -00012 -00013 <span class="comment">//inflate: "sk-progress"</span> -00014 -00015 <span class="keywordtype">void</span> reset(); <span class="comment">//reset progress to zero</span> -00016 <span class="keywordtype">void</span> setProgress(<span class="keywordtype">int</span> progress); -00017 <span class="keywordtype">void</span> changeProgress(<span class="keywordtype">int</span> diff); -00018 <span class="keywordtype">void</span> setMax(<span class="keywordtype">int</span> max); -00019 -00020 <span class="keywordtype">int</span> getProgress()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fProgress; } -00021 <span class="keywordtype">int</span> getMax()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMax; } -00022 -00023 <span class="keyword">protected</span>: -00024 <span class="comment">//overrides</span> -00025 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00026 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00027 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas); -00028 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& evt); -00029 -00030 <span class="keyword">private</span>: -00031 <a class="code" href="classSkAnimator.html">SkAnimator</a> fAnim; -00032 <span class="keywordtype">int</span> fProgress; -00033 <span class="keywordtype">int</span> fMax; -00034 -00035 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00036 }; -00037 -00038 -00039 -00040 -00041 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkRefCnt_8h-source.html b/sgl_doxygen/html/SkRefCnt_8h-source.html deleted file mode 100644 index fdc9f5a..0000000 --- a/sgl_doxygen/html/SkRefCnt_8h-source.html +++ /dev/null @@ -1,65 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkRefCnt.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkRefCnt.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkRefCnt_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkRefCnt_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -<a name="l00015"></a><a class="code" href="classSkRefCnt.html">00015</a> <span class="keyword">class </span><a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00016 <span class="keyword">public</span>: -<a name="l00019"></a><a class="code" href="classSkRefCnt.html#a0">00019</a> <a class="code" href="classSkRefCnt.html#a0">SkRefCnt</a>() : fRefCnt(1) {} -<a name="l00022"></a><a class="code" href="classSkRefCnt.html#a1">00022</a> <span class="keyword">virtual</span> <a class="code" href="classSkRefCnt.html#a1">~SkRefCnt</a>() { SkASSERT(fRefCnt == 1); } -00023 -<a name="l00026"></a><a class="code" href="classSkRefCnt.html#a2">00026</a> <span class="keywordtype">int</span> <a class="code" href="classSkRefCnt.html#a2">getRefCnt</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fRefCnt; } -<a name="l00029"></a><a class="code" href="classSkRefCnt.html#a3">00029</a> <span class="keywordtype">void</span> <a class="code" href="classSkRefCnt.html#a3">ref</a>()<span class="keyword"> const </span>{ SkASSERT(fRefCnt > 0); ++fRefCnt; } -<a name="l00034"></a><a class="code" href="classSkRefCnt.html#a4">00034</a> <span class="keywordtype">void</span> <a class="code" href="classSkRefCnt.html#a4">unref</a>()<span class="keyword"> const</span> -00035 <span class="keyword"> </span>{ -00036 SkASSERT(fRefCnt > 0); -00037 <span class="keywordflow">if</span> (fRefCnt == 1) -00038 <span class="keyword">delete</span> <span class="keyword">this</span>; -00039 <span class="keywordflow">else</span> -00040 --fRefCnt; -00041 } -00042 -<a name="l00046"></a><a class="code" href="classSkRefCnt.html#a5">00046</a> <span class="keywordtype">void</span> <a class="code" href="classSkRefCnt.html#a5">safeRef</a>()<span class="keyword"> const </span>{ <span class="keywordflow">if</span> (<span class="keyword">this</span>) this-><a class="code" href="classSkRefCnt.html#a3">ref</a>(); } -<a name="l00050"></a><a class="code" href="classSkRefCnt.html#a6">00050</a> <span class="keywordtype">void</span> <a class="code" href="classSkRefCnt.html#a6">safeUnref</a>()<span class="keyword"> const </span>{ <span class="keywordflow">if</span> (<span class="keyword">this</span>) this-><a class="code" href="classSkRefCnt.html#a4">unref</a>(); } -00051 -00052 <span class="keyword">private</span>: -00053 <span class="keyword">mutable</span> <span class="keywordtype">int</span> fRefCnt; -00054 }; -00055 -<a name="l00061"></a><a class="code" href="classSkAutoUnref.html">00061</a> <span class="keyword">class </span><a class="code" href="classSkAutoUnref.html">SkAutoUnref</a> { -00062 <span class="keyword">public</span>: -00063 <a class="code" href="classSkAutoUnref.html">SkAutoUnref</a>(<a class="code" href="classSkRefCnt.html">SkRefCnt</a>* obj) : fObj(obj) {} -00064 ~<a class="code" href="classSkAutoUnref.html">SkAutoUnref</a>(); -00065 -00066 <a class="code" href="classSkRefCnt.html">SkRefCnt</a>* get()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fObj; } -00067 <span class="keywordtype">bool</span> ref(); -00068 <span class="keywordtype">bool</span> unref(); -00069 <a class="code" href="classSkRefCnt.html">SkRefCnt</a>* detach(); -00070 -00071 <span class="keyword">private</span>: -00072 <a class="code" href="classSkRefCnt.html">SkRefCnt</a>* fObj; -00073 }; -00074 -00079 <span class="preprocessor">#define SkRefCnt_SafeAssign(dst, src) \</span> -00080 <span class="preprocessor"> do { \</span> -00081 <span class="preprocessor"> if (src) src->ref(); \</span> -00082 <span class="preprocessor"> if (dst) dst->unref(); \</span> -00083 <span class="preprocessor"> dst = src; \</span> -00084 <span class="preprocessor"> } while (0)</span> -00085 <span class="preprocessor"></span> -00086 <span class="preprocessor">#endif</span> -00087 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkSVGAttribute_8h-source.html b/sgl_doxygen/html/SkSVGAttribute_8h-source.html deleted file mode 100644 index c36f1a3..0000000 --- a/sgl_doxygen/html/SkSVGAttribute_8h-source.html +++ /dev/null @@ -1,47 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSVGAttribute.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkSVGAttribute.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkSVGAttribute_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkSVGAttribute_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">struct </span>SkSVGAttribute { -00007 <span class="keyword">const</span> <span class="keywordtype">char</span>* fName; -00008 <span class="preprocessor">#ifdef SK_DEBUG</span> -00009 <span class="preprocessor"></span> size_t fOffset; -00010 <span class="preprocessor">#endif</span> -00011 <span class="preprocessor"></span>}; -00012 -00013 <span class="preprocessor">#ifndef SK_OFFSETOF</span> -00014 <span class="preprocessor"></span><span class="preprocessor">#define SK_OFFSETOF(a, b) (((size_t) (&(((a*) 1)->b)))-1)</span> -00015 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00016 <span class="preprocessor"></span> -00017 <span class="preprocessor">#ifdef SK_DEBUG</span> -00018 <span class="preprocessor"></span><span class="preprocessor">#define SVG_ATTRIBUTE(attr) { #attr, SK_OFFSETOF(BASE_CLASS, f_##attr) }</span> -00019 <span class="preprocessor"></span><span class="preprocessor">#define SVG_LITERAL_ATTRIBUTE(svgAttr, cAttr) { #svgAttr, SK_OFFSETOF(BASE_CLASS, cAttr) }</span> -00020 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00021 <span class="preprocessor"></span><span class="preprocessor">#define SVG_ATTRIBUTE(attr) { #attr }</span> -00022 <span class="preprocessor"></span><span class="preprocessor">#define SVG_LITERAL_ATTRIBUTE(svgAttr, cAttr) { #svgAttr }</span> -00023 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00024 <span class="preprocessor"></span> -00025 <span class="preprocessor">#define SVG_ADD_ATTRIBUTE(attr) \</span> -00026 <span class="preprocessor"> if (f_##attr.size() > 0) \</span> -00027 <span class="preprocessor"> parser._addAttributeLen(#attr, f_##attr.c_str(), f_##attr.size())</span> -00028 <span class="preprocessor"></span> -00029 <span class="preprocessor">#define SVG_ADD_ATTRIBUTE_ALIAS(attr, alias) \</span> -00030 <span class="preprocessor"> if (f_##alias.size() > 0) \</span> -00031 <span class="preprocessor"> parser._addAttributeLen(#attr, f_##alias.c_str(), f_##alias.size())</span> -00032 <span class="preprocessor"></span> -00033 <span class="preprocessor">#endif // SkSVGAttribute_DEFINED</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkSVGBase_8h-source.html b/sgl_doxygen/html/SkSVGBase_8h-source.html deleted file mode 100644 index 1607425..0000000 --- a/sgl_doxygen/html/SkSVGBase_8h-source.html +++ /dev/null @@ -1,30 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSVGBase.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkSVGBase.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkSVGBase_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkSVGBase_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkSVGAttribute.h"</span> -00005 -00006 <span class="keyword">class </span>SkSVGParser; -00007 -00008 <span class="keyword">class </span>SkSVGBase { -00009 <span class="keyword">public</span>: -00010 <span class="keyword">virtual</span> ~SkSVGBase(); -00011 <span class="keyword">virtual</span> <span class="keywordtype">void</span> addAttribute(SkSVGParser& parser, <span class="keywordtype">int</span> attrIndex, -00012 <span class="keyword">const</span> <span class="keywordtype">char</span>* attrValue, size_t attrLength); -00013 <span class="keyword">virtual</span> <span class="keywordtype">int</span> getAttributes(<span class="keyword">const</span> SkSVGAttribute** attrPtr) = 0; -00014 }; -00015 -00016 <span class="preprocessor">#endif // SkSVGBase_DEFINED</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkSVGPaintState_8h-source.html b/sgl_doxygen/html/SkSVGPaintState_8h-source.html deleted file mode 100644 index 0a8761b..0000000 --- a/sgl_doxygen/html/SkSVGPaintState_8h-source.html +++ /dev/null @@ -1,94 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSVGPaintState.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkSVGPaintState.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkSVGPaintState_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkSVGPaintState_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkSVGBase.h"</span> -00005 <span class="preprocessor">#include "SkString.h"</span> -00006 -00007 <span class="keyword">class </span>SkSVGPaint : <span class="keyword">public</span> SkSVGBase { -00008 <span class="keyword">public</span>: -00009 <span class="keyword">enum</span> Field { -00010 kInitial = -1, -00011 kClipPath, -00012 kClipRule, -00013 kEnableBackground, -00014 kFill, -00015 kFillRule, -00016 kFilter, -00017 kFontFamily, -00018 kFontSize, -00019 kLetterSpacing, -00020 kMask, -00021 kOpacity, -00022 kStopColor, -00023 kStopOpacity, -00024 kStroke, -00025 kStroke_Dasharray, -00026 kStroke_Linecap, -00027 kStroke_Linejoin, -00028 kStroke_Miterlimit, -00029 kStroke_Width, -00030 kStyle, -00031 kTransform, -00032 kTerminal -00033 }; -00034 -00035 SkSVGPaint(); -00036 <span class="keyword">virtual</span> <span class="keywordtype">void</span> addAttribute(SkSVGParser& parser, <span class="keywordtype">int</span> attrIndex, -00037 <span class="keyword">const</span> <span class="keywordtype">char</span>* attrValue, size_t attrLength); -00038 <span class="keywordtype">bool</span> flush(SkSVGParser& , <span class="keywordtype">bool</span> isFlushable, <span class="keywordtype">bool</span> isDef); -00039 <span class="keyword">virtual</span> <span class="keywordtype">int</span> getAttributes(<span class="keyword">const</span> SkSVGAttribute** attrPtr); -00040 <span class="keyword">static</span> <span class="keywordtype">void</span> Push(SkSVGPaint** head, SkSVGPaint* add); -00041 <span class="keyword">static</span> <span class="keywordtype">void</span> Pop(SkSVGPaint** head); -00042 <a class="code" href="classSkString.html">SkString</a>* operator[](<span class="keywordtype">int</span> index); -00043 <a class="code" href="classSkString.html">SkString</a> fInitial; -00044 <a class="code" href="classSkString.html">SkString</a> f_clipPath; -00045 <a class="code" href="classSkString.html">SkString</a> f_clipRule; -00046 <a class="code" href="classSkString.html">SkString</a> f_enableBackground; -00047 <a class="code" href="classSkString.html">SkString</a> f_fill; -00048 <a class="code" href="classSkString.html">SkString</a> f_fillRule; -00049 <a class="code" href="classSkString.html">SkString</a> f_filter; -00050 <a class="code" href="classSkString.html">SkString</a> f_fontFamily; -00051 <a class="code" href="classSkString.html">SkString</a> f_fontSize; -00052 <a class="code" href="classSkString.html">SkString</a> f_letterSpacing; -00053 <a class="code" href="classSkString.html">SkString</a> f_mask; -00054 <a class="code" href="classSkString.html">SkString</a> f_opacity; -00055 <a class="code" href="classSkString.html">SkString</a> f_stopColor; -00056 <a class="code" href="classSkString.html">SkString</a> f_stopOpacity; -00057 <a class="code" href="classSkString.html">SkString</a> f_stroke; -00058 <a class="code" href="classSkString.html">SkString</a> f_strokeDasharray; -00059 <a class="code" href="classSkString.html">SkString</a> f_strokeLinecap; -00060 <a class="code" href="classSkString.html">SkString</a> f_strokeLinejoin; -00061 <a class="code" href="classSkString.html">SkString</a> f_strokeMiterlimit; -00062 <a class="code" href="classSkString.html">SkString</a> f_strokeWidth; -00063 <a class="code" href="classSkString.html">SkString</a> f_style; <span class="comment">// unused, but allows array access to the rest</span> -00064 <a class="code" href="classSkString.html">SkString</a> f_transform; -00065 <span class="preprocessor">#ifdef SK_DEBUG</span> -00066 <span class="preprocessor"></span> <a class="code" href="classSkString.html">SkString</a> fTerminal; -00067 <span class="preprocessor">#endif</span> -00068 <span class="preprocessor"></span> <a class="code" href="classSkString.html">SkString</a> fTransformID; -00069 <span class="keyword">static</span> SkSVGAttribute gAttributes[]; -00070 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">int</span> kAttributesSize; -00071 <span class="keyword">private</span>: -00072 <span class="keywordtype">void</span> setSave(SkSVGParser& ); -00073 <span class="keywordtype">bool</span> writeChangedAttributes(SkSVGParser& , SkSVGPaint& , <span class="keywordtype">bool</span>* changed); -00074 <span class="keywordtype">bool</span> writeChangedElements(SkSVGParser& , SkSVGPaint& , <span class="keywordtype">bool</span>* changed); -00075 SkSVGPaint* fNext; -00076 <span class="keyword">friend</span> <span class="keyword">class </span>SkSVGParser; -00077 <span class="keyword">typedef</span> SkSVGPaint BASE_CLASS; -00078 }; -00079 -00080 <span class="preprocessor">#endif // SkSVGPaintState_DEFINED</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkSVGParser_8h-source.html b/sgl_doxygen/html/SkSVGParser_8h-source.html deleted file mode 100644 index ade8a0a..0000000 --- a/sgl_doxygen/html/SkSVGParser_8h-source.html +++ /dev/null @@ -1,79 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSVGParser.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkSVGParser.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkSVGParser_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkSVGParser_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMatrix.h"</span> -00005 <span class="preprocessor">#include "SkTDict.h"</span> -00006 <span class="preprocessor">#include "SkTDStack.h"</span> -00007 <span class="preprocessor">#include "SkSVGPaintState.h"</span> -00008 <span class="preprocessor">#include "SkSVGTypes.h"</span> -00009 <span class="preprocessor">#include "SkStream.h"</span> -00010 <span class="preprocessor">#include "SkString.h"</span> -00011 <span class="preprocessor">#include "SkXMLParser.h"</span> -00012 <span class="preprocessor">#include "SkXMLWriter.h"</span> -00013 -00014 <span class="keyword">class </span>SkSVGBase; -00015 <span class="keyword">class </span>SkSVGElement; -00016 -00017 <span class="keyword">class </span>SkSVGParser : <span class="keyword">public</span> SkXMLParser { -00018 <span class="keyword">public</span>: -00019 SkSVGParser(); -00020 <span class="keyword">virtual</span> ~SkSVGParser(); -00021 <span class="keywordtype">void</span> _addAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span>* attrName, <span class="keyword">const</span> <span class="keywordtype">char</span>* attrValue) { -00022 fXMLWriter.addAttribute(attrName, attrValue); } -00023 <span class="keywordtype">void</span> _addAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span>* attrName, <a class="code" href="classSkString.html">SkString</a>& attrValue) { -00024 fXMLWriter.addAttribute(attrName, attrValue.c_str()); } -00025 <span class="keywordtype">void</span> _addAttributeLen(<span class="keyword">const</span> <span class="keywordtype">char</span>* attrName, <span class="keyword">const</span> <span class="keywordtype">char</span>* attrValue, size_t len) { -00026 fXMLWriter.addAttributeLen(attrName, attrValue, len); } -00027 <span class="keywordtype">void</span> _endElement() { fXMLWriter.endElement(); } -00028 <span class="keywordtype">int</span> findAttribute(SkSVGBase* , <span class="keyword">const</span> <span class="keywordtype">char</span>* attrValue, size_t len, <span class="keywordtype">bool</span> isPaint); -00029 <span class="keyword">const</span> <span class="keywordtype">char</span>* getFinal(); -00030 SkTDict<SkSVGElement*>& getIDs() { <span class="keywordflow">return</span> fIDs; } -00031 <a class="code" href="classSkString.html">SkString</a>& getPaintLast(SkSVGPaint::Field field); -00032 <span class="keywordtype">void</span> _startElement(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]) { fXMLWriter.startElement(name); } -00033 <span class="keywordtype">void</span> translate(SkSVGElement*, <span class="keywordtype">bool</span> isDef); -00034 <span class="keywordtype">void</span> translateMatrix(<a class="code" href="classSkString.html">SkString</a>& , <a class="code" href="classSkString.html">SkString</a>* <span class="keywordtype">id</span>); -00035 <span class="keyword">static</span> <span class="keywordtype">void</span> ConvertToArray(<a class="code" href="classSkString.html">SkString</a>& vals); -00036 <span class="keyword">protected</span>: -00037 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onAddAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]); -00038 <span class="keywordtype">bool</span> onAddAttributeLen(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[], size_t len); -00039 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEndElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00040 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onStartElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00041 <span class="keywordtype">bool</span> onStartElementLen(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[], size_t len); -00042 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onText(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], <span class="keywordtype">int</span> len); -00043 <span class="keyword">private</span>: -00044 <span class="keywordtype">bool</span> isStrokeAndFill(SkSVGPaint** stroke, SkSVGPaint** fill); -00045 <span class="keyword">static</span> SkSVGElement* CreateElement(SkSVGTypes type, SkSVGElement* parent); -00046 <span class="keyword">static</span> <span class="keywordtype">void</span> Delete(SkTDArray<SkSVGElement*>& fChildren); -00047 <span class="keyword">static</span> SkSVGTypes GetType(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], size_t len); -00048 SkSVGPaint* fHead; -00049 SkSVGPaint fEmptyPaint; -00050 SkSVGPaint fLastFlush; -00051 <a class="code" href="classSkString.html">SkString</a> fLastColor; -00052 SkMatrix fLastTransform; -00053 SkTDArray<SkSVGElement*> fChildren; -00054 SkTDict<SkSVGElement*> fIDs; -00055 SkTDArray<SkSVGElement*> fParents; -00056 SkMemoryWStream fStream; -00057 SkXMLStreamWriter fXMLWriter; -00058 SkSVGElement* fCurrElement; -00059 SkBool8 fInSVG; -00060 SkBool8 fSuppressPaint; -00061 <span class="keyword">friend</span> <span class="keyword">class </span>SkSVGPaint; -00062 <span class="keyword">friend</span> <span class="keyword">class </span>SkSVGGradient; -00063 }; -00064 -00065 <span class="preprocessor">#endif // SkSVGParser_DEFINED</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkSVGTypes_8h-source.html b/sgl_doxygen/html/SkSVGTypes_8h-source.html deleted file mode 100644 index dabd05d..0000000 --- a/sgl_doxygen/html/SkSVGTypes_8h-source.html +++ /dev/null @@ -1,44 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSVGTypes.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkSVGTypes.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkSVGTypes_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkSVGTypes_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="keyword">enum</span> SkSVGTypes { -00005 SkSVGType_Circle, -00006 SkSVGType_ClipPath, -00007 SkSVGType_Defs, -00008 SkSVGType_Ellipse, -00009 SkSVGType_FeColorMatrix, -00010 SkSVGType_Filter, -00011 SkSVGType_G, -00012 SkSVGType_Image, -00013 SkSVGType_Line, -00014 SkSVGType_LinearGradient, -00015 SkSVGType_Mask, -00016 SkSVGType_Metadata, -00017 SkSVGType_Path, -00018 SkSVGType_Polygon, -00019 SkSVGType_Polyline, -00020 SkSVGType_RadialGradient, -00021 SkSVGType_Rect, -00022 SkSVGType_SVG, -00023 SkSVGType_Stop, -00024 SkSVGType_Symbol, -00025 SkSVGType_Text, -00026 SkSVGType_Tspan, -00027 SkSVGType_Use -00028 }; -00029 -00030 <span class="preprocessor">#endif // SkSVGTypes_DEFINED</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkScalerContext_8h-source.html b/sgl_doxygen/html/SkScalerContext_8h-source.html deleted file mode 100644 index ccaef12..0000000 --- a/sgl_doxygen/html/SkScalerContext_8h-source.html +++ /dev/null @@ -1,90 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkScalerContext.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkScalerContext.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkScalerContext_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkScalerContext_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkDescriptor.h"</span> -00005 <span class="preprocessor">#include "SkMatrix.h"</span> -00006 <span class="preprocessor">#include "SkPath.h"</span> -00007 <span class="preprocessor">#include "SkPoint.h"</span> -00008 -00009 <span class="keyword">class </span><a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>; -00010 <span class="keyword">class </span><a class="code" href="classSkPaint.html">SkPaint</a>; -00011 <span class="keyword">class </span><a class="code" href="classSkPathEffect.html">SkPathEffect</a>; -00012 -00013 <span class="keyword">struct </span>SkGlyph { -00014 <span class="keywordtype">void</span>* fImage; -00015 <a class="code" href="classSkPath.html">SkPath</a>* fPath; -00016 SkFixed fAdvanceX, fAdvanceY; -00017 -00018 U16 fGlyphID; -00019 U16 fWidth, fHeight, fRowBytes; -00020 S16 fTop, fLeft; -00021 -00022 U16 fCharCode; <span class="comment">// might go away with line layout. really wants 20bits</span> -00023 U8 fMaskFormat; -00024 U8 fPad; -00025 -00026 size_t computeImageSize() <span class="keyword">const</span>; -00027 }; -00028 -00029 <span class="keyword">class </span>SkScalerContext { -00030 <span class="keyword">public</span>: -00031 <span class="keyword">struct </span>Rec { -00032 SkScalar fTextSize, fPreScaleX, fPreSkewX; -00033 SkScalar fPost2x2[2][2]; -00034 SkScalar fFrameWidth, fMiterLimit; -00035 SkBool8 fUseHints; -00036 SkBool8 fFrameAndFill; -00037 SkBool8 fDoAA; -00038 U8 fStrokeJoin; -00039 -00040 <span class="keywordtype">void</span> getMatrixFrom2x2(SkMatrix*) <span class="keyword">const</span>; -00041 <span class="keywordtype">void</span> getLocalMatrix(SkMatrix*) <span class="keyword">const</span>; -00042 <span class="keywordtype">void</span> getSingleMatrix(SkMatrix*) <span class="keyword">const</span>; -00043 }; -00044 -00045 SkScalerContext(<span class="keyword">const</span> SkDescriptor* desc); -00046 <span class="keyword">virtual</span> ~SkScalerContext(); -00047 -00048 <span class="keywordtype">void</span> getMetrics(SkGlyph*); -00049 <span class="keywordtype">void</span> getImage(<span class="keyword">const</span> SkGlyph&); -00050 <span class="keywordtype">void</span> getPath(<span class="keyword">const</span> SkGlyph&, <a class="code" href="classSkPath.html">SkPath</a>*); -00051 <span class="keywordtype">void</span> getLineHeight(SkPoint* above, SkPoint* below); -00052 -00053 <span class="keyword">static</span> <span class="keyword">inline</span> <span class="keywordtype">void</span> MakeRec(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&, <span class="keyword">const</span> SkMatrix*, Rec* rec); -00054 <span class="keyword">static</span> SkScalerContext* Create(<span class="keyword">const</span> SkDescriptor*); -00055 -00056 <span class="keyword">protected</span>: -00057 Rec fRec; -00058 -00059 <span class="keyword">virtual</span> <span class="keywordtype">void</span> generateMetrics(SkGlyph*) = 0; -00060 <span class="keyword">virtual</span> <span class="keywordtype">void</span> generateImage(<span class="keyword">const</span> SkGlyph&) = 0; -00061 <span class="keyword">virtual</span> <span class="keywordtype">void</span> generatePath(<span class="keyword">const</span> SkGlyph&, <a class="code" href="classSkPath.html">SkPath</a>*) = 0; -00062 <span class="keyword">virtual</span> <span class="keywordtype">void</span> generateLineHeight(SkPoint* above, SkPoint* below) = 0; -00063 -00064 <span class="keyword">private</span>: -00065 <a class="code" href="classSkPathEffect.html">SkPathEffect</a>* fPathEffect; -00066 <a class="code" href="classSkMaskFilter.html">SkMaskFilter</a>* fMaskFilter; -00067 SkScalar fDevFrameWidth; -00068 }; -00069 -00070 <span class="preprocessor">#define kRec_SkDescriptorTag SkSetFourByteTag('s', 'r', 'e', 'c')</span> -00071 <span class="preprocessor"></span><span class="preprocessor">#define kTypeface_SkDescriptorTag SkSetFourByteTag('t', 'p', 'f', 'c')</span> -00072 <span class="preprocessor"></span><span class="preprocessor">#define kPathEffect_SkDescriptorTag SkSetFourByteTag('p', 't', 'h', 'e')</span> -00073 <span class="preprocessor"></span><span class="preprocessor">#define kMaskFilter_SkDescriptorTag SkSetFourByteTag('m', 's', 'k', 'f')</span> -00074 <span class="preprocessor"></span> -00075 <span class="preprocessor">#endif</span> -00076 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkScrollBarView_8h-source.html b/sgl_doxygen/html/SkScrollBarView_8h-source.html deleted file mode 100644 index 17b9ba9..0000000 --- a/sgl_doxygen/html/SkScrollBarView_8h-source.html +++ /dev/null @@ -1,49 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkScrollBarView.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkScrollBarView.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkScrollBarView_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkScrollBarView_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkWidgetViews.h"</span> -00006 <span class="preprocessor">#include "SkAnimator.h"</span> -00007 -00008 <span class="keyword">class </span>SkScrollBarView : <span class="keyword">public</span> SkWidgetView { -00009 <span class="keyword">public</span>: -00010 SkScrollBarView(); -00011 -00012 <span class="keywordtype">unsigned</span> getStart()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fStartPoint; } -00013 <span class="keywordtype">unsigned</span> getShown()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fShownLength; } -00014 <span class="keywordtype">unsigned</span> getTotal()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTotalLength; } -00015 -00016 <span class="keywordtype">void</span> setStart(<span class="keywordtype">unsigned</span> start); -00017 <span class="keywordtype">void</span> setShown(<span class="keywordtype">unsigned</span> shown); -00018 <span class="keywordtype">void</span> setTotal(<span class="keywordtype">unsigned</span> total); -00019 -00020 <span class="keyword">protected</span>: -00021 <span class="comment">//overrides</span> -00022 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00023 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00024 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas); -00025 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& evt); -00026 -00027 <span class="keyword">private</span>: -00028 <a class="code" href="classSkAnimator.html">SkAnimator</a> fAnim; -00029 <span class="keywordtype">unsigned</span> fTotalLength, fStartPoint, fShownLength; -00030 -00031 <span class="keywordtype">void</span> adjust(); -00032 -00033 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00034 }; -00035 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkShader_8h-source.html b/sgl_doxygen/html/SkShader_8h-source.html deleted file mode 100644 index fbb8a9d..0000000 --- a/sgl_doxygen/html/SkShader_8h-source.html +++ /dev/null @@ -1,168 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkShader.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkShader.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkShader_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkShader_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkRefCnt.h"</span> -00005 <span class="preprocessor">#include "SkBitmap.h"</span> -00006 <span class="preprocessor">#include "SkMask.h"</span> -00007 <span class="preprocessor">#include "SkMatrix.h"</span> -00008 <span class="preprocessor">#include "SkPaint.h"</span> -00009 -00010 <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a>; -00011 -<a name="l00019"></a><a class="code" href="classSkShader.html">00019</a> <span class="keyword">class </span><a class="code" href="classSkShader.html">SkShader</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00020 <span class="keyword">public</span>: -00021 <a class="code" href="classSkShader.html">SkShader</a>(); -00022 <span class="keyword">virtual</span> ~<a class="code" href="classSkShader.html">SkShader</a>(); -00023 -<a name="l00026"></a><a class="code" href="classSkShader.html#a2">00026</a> <span class="keyword">const</span> SkMatrix* <a class="code" href="classSkShader.html#a2">getLocalMatrix</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fLocalMatrix; } -00030 <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a3">setLocalMatrix</a>(<span class="keyword">const</span> SkMatrix&); -00031 -<a name="l00032"></a><a class="code" href="classSkShader.html#w8">00032</a> <span class="keyword">enum</span> <a class="code" href="classSkShader.html#w8">TileMode</a> { -00033 <a class="code" href="classSkShader.html#w8w0">kClamp_TileMode</a>, -00034 <a class="code" href="classSkShader.html#w8w1">kRepeat_TileMode</a>, -00035 <a class="code" href="classSkShader.html#w8w2">kMirror_TileMode</a>, -00036 -00037 kTileModeCount -00038 }; -00039 -00040 <span class="comment">// override these in your subclass</span> -00041 -<a name="l00042"></a><a class="code" href="classSkShader.html#w9">00042</a> <span class="keyword">enum</span> <a class="code" href="classSkShader.html#w9">Flags</a> { -00043 <a class="code" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> = 0x01, -00044 <a class="code" href="classSkShader.html#w9w5">kConstAlpha_Flag</a> = 0x02, -00045 <a class="code" href="classSkShader.html#w9w6">kHasSpan16_Flag</a> = 0x04, -00046 -00047 kFlagsMask = <a class="code" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> | <a class="code" href="classSkShader.html#w9w5">kConstAlpha_Flag</a> | <a class="code" href="classSkShader.html#w9w6">kHasSpan16_Flag</a> -00048 }; -00049 -00056 <span class="keyword">virtual</span> U32 <a class="code" href="classSkShader.html#a4">getFlags</a>(); -00057 -00063 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkShader.html#a5">setContext</a>( <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& device, -00064 <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint, -00065 <span class="keyword">const</span> SkMatrix& matrix); -00066 -00071 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a6">shadeSpan</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, SkPMColor[], <span class="keywordtype">int</span> count) = 0; -00074 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a7">shadeSpanOpaque16</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U16[], <span class="keywordtype">int</span> count); -00079 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a8">shadeSpanAlpha</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U8 alpha[], <span class="keywordtype">int</span> count); -00080 -<a name="l00084"></a><a class="code" href="classSkShader.html#a9">00084</a> <span class="keywordtype">bool</span> <a class="code" href="classSkShader.html#a9">canCallShadeSpanOpaque16</a>() -00085 { -00086 <span class="keywordflow">return</span> <a class="code" href="classSkShader.html#e0">SkShader::CanCallShadeSpanOpaque16</a>(this->getFlags()); -00087 } -00088 -<a name="l00091"></a><a class="code" href="classSkShader.html#e0">00091</a> <span class="keyword">static</span> <span class="keywordtype">bool</span> <a class="code" href="classSkShader.html#e0">CanCallShadeSpanOpaque16</a>(U32 flags) -00092 { -00093 <span class="keywordflow">return</span> (flags & (<a class="code" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> | <a class="code" href="classSkShader.html#w9w6">kHasSpan16_Flag</a>)) == (<a class="code" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> | <a class="code" href="classSkShader.html#w9w6">kHasSpan16_Flag</a>); -00094 } -00095 -00097 <span class="comment">// Factory methods for stock shaders</span> -00098 -00108 <span class="keyword">static</span> <a class="code" href="classSkShader.html">SkShader</a>* <a class="code" href="classSkShader.html#e1">CreateBitmapShader</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& src, -00109 <span class="keywordtype">bool</span> transferOwnershipOfPixels, -00110 SkPaint::FilterType ft, -00111 TileMode tm); -00112 -00113 <span class="keyword">protected</span>: -00114 <span class="keyword">enum</span> MatrixClass { -00115 kLinear_MatrixClass, <span class="comment">// no perspective</span> -00116 kFixedStepInX_MatrixClass, <span class="comment">// fast perspective, need to call fixedStepInX() each scanline</span> -00117 kPerspective_MatrixClass <span class="comment">// slow perspective, need to mappoints each pixel</span> -00118 }; -00119 <span class="keyword">static</span> MatrixClass ComputeMatrixClass(<span class="keyword">const</span> SkMatrix&); -00120 -00121 <span class="comment">// These can be called by your subclass after setContext() has been called</span> -00122 U8 getPaintAlpha()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fPaintAlpha; } -00123 <a class="code" href="classSkBitmap.html#w7">SkBitmap::Config</a> getDeviceConfig()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (SkBitmap::Config)fDeviceConfig; } -00124 const SkMatrix& getTotalInverse()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTotalInverse; } -00125 MatrixClass getInverseClass()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (MatrixClass)fTotalInverseClass; } -00126 SkMatrix::MapPtProc getInverseMapPtProc()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fInverseMapPtProc; } -00127 -00128 <span class="keyword">private</span>: -00129 SkMatrix* fLocalMatrix; -00130 SkMatrix fTotalInverse; -00131 SkMatrix::MapPtProc fInverseMapPtProc; -00132 U8 fPaintAlpha; -00133 U8 fDeviceConfig; -00134 U8 fTotalInverseClass; -00135 -00136 <span class="keyword">static</span> <a class="code" href="classSkShader.html">SkShader</a>* <a class="code" href="classSkShader.html#e1">CreateBitmapShader</a>(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& src, -00137 <span class="keywordtype">bool</span> transferOwnershipOfPixels, -00138 SkPaint::FilterType, -00139 TileMode, -00140 <span class="keywordtype">void</span>* storage, size_t storageSize); -00141 <span class="keyword">friend</span> <span class="keyword">class </span>SkAutoBitmapShaderInstall; -00142 }; -00143 -00145 -00146 <span class="keyword">class </span>SkPairShader : <span class="keyword">public</span> <a class="code" href="classSkShader.html">SkShader</a> { -00147 <span class="keyword">public</span>: -00148 SkPairShader(<a class="code" href="classSkShader.html">SkShader</a>* s0, <a class="code" href="classSkShader.html">SkShader</a>* s1); -00149 <span class="keyword">virtual</span> ~SkPairShader(); -00150 -00151 <span class="comment">// overrides</span> -00152 <span class="keyword">virtual</span> U32 <a class="code" href="classSkShader.html#a4">getFlags</a>(); -00153 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkShader.html#a5">setContext</a>( <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& device, -00154 <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint, -00155 <span class="keyword">const</span> SkMatrix& matrix); -00156 -00157 <span class="keyword">protected</span>: -00158 <a class="code" href="classSkShader.html">SkShader</a>* getShader0()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fShader0; } -00159 <a class="code" href="classSkShader.html">SkShader</a>* getShader1()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fShader1; } -00160 -00161 <span class="keyword">private</span>: -00162 <a class="code" href="classSkShader.html">SkShader</a>* fShader0, *fShader1; -00163 -00164 <span class="keyword">typedef</span> <a class="code" href="classSkShader.html">SkShader</a> INHERITED; -00165 }; -00166 -00167 <span class="keyword">class </span>SkComposeShader : <span class="keyword">public</span> SkPairShader { -00168 <span class="keyword">public</span>: -00169 SkComposeShader(<a class="code" href="classSkShader.html">SkShader</a>* outer, <a class="code" href="classSkShader.html">SkShader</a>* inner) : SkPairShader(outer, inner) {} -00170 -00171 <span class="comment">// overrides</span> -00172 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a6">shadeSpan</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, SkPMColor[], <span class="keywordtype">int</span> count); -00173 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a7">shadeSpanOpaque16</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U16[], <span class="keywordtype">int</span> count); -00174 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a8">shadeSpanAlpha</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U8 alpha[], <span class="keywordtype">int</span> count); -00175 -00176 <span class="keyword">private</span>: -00177 <span class="keyword">typedef</span> SkPairShader INHERITED; -00178 }; -00179 -00180 <span class="keyword">class </span>SkSumShader : <span class="keyword">public</span> SkPairShader { -00181 <span class="keyword">public</span>: -00182 SkSumShader(<a class="code" href="classSkShader.html">SkShader</a>* s0, <a class="code" href="classSkShader.html">SkShader</a>* s1, U8CPU weight); -00183 SkSumShader(<a class="code" href="classSkShader.html">SkShader</a>* s0, <a class="code" href="classSkShader.html">SkShader</a>* s1, <a class="code" href="classSkXfermode.html">SkXfermode</a>*); -00184 <span class="keyword">virtual</span> ~SkSumShader(); -00185 -00186 <span class="comment">// overrides</span> -00187 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkShader.html#a5">setContext</a>( <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& device, -00188 <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint, -00189 <span class="keyword">const</span> SkMatrix& matrix); -00190 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a6">shadeSpan</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, SkPMColor[], <span class="keywordtype">int</span> count); -00191 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a7">shadeSpanOpaque16</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U16[], <span class="keywordtype">int</span> count); -00192 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a8">shadeSpanAlpha</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U8 alpha[], <span class="keywordtype">int</span> count); -00193 -00194 <span class="keyword">private</span>: -00195 <a class="code" href="SkColor_8h.html#a18">SkPMColor</a>* fBuffer; -00196 <a class="code" href="classSkXfermode.html">SkXfermode</a>* fMode; -00197 U8 fWeight; -00198 -00199 <span class="keyword">typedef</span> SkPairShader INHERITED; -00200 }; -00201 -00202 <span class="preprocessor">#endif</span> -00203 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkStackViewLayout_8h-source.html b/sgl_doxygen/html/SkStackViewLayout_8h-source.html deleted file mode 100644 index b265b75..0000000 --- a/sgl_doxygen/html/SkStackViewLayout_8h-source.html +++ /dev/null @@ -1,90 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkStackViewLayout.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkStackViewLayout.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkStackViewLayout_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkStackViewLayout_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 -00006 <span class="keyword">class </span>SkStackViewLayout : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a>::Layout { -00007 <span class="keyword">public</span>: -00008 SkStackViewLayout(); -00009 -00010 <span class="keyword">enum</span> Orient { -00011 kHorizontal_Orient, -00012 kVertical_Orient, -00013 -00014 kOrientCount -00015 }; -00016 Orient getOrient()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Orient)fOrient; } -00017 <span class="keywordtype">void</span> setOrient(Orient); -00018 -00019 <span class="keywordtype">void</span> getMargin(SkRect*) const; -00020 <span class="keywordtype">void</span> setMargin(const SkRect&); -00021 -00022 SkScalar getSpacer()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fSpacer; } -00023 <span class="keywordtype">void</span> setSpacer(SkScalar); -00024 -00027 <span class="keyword">enum</span> Pack { -00028 kStart_Pack, -00029 kCenter_Pack, -00030 kEnd_Pack, -00031 -00032 kPackCount -00033 }; -00034 Pack getPack()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Pack)fPack; } -00035 <span class="keywordtype">void</span> setPack(Pack); -00036 -00039 enum Align { -00040 kStart_Align, -00041 kCenter_Align, -00042 kEnd_Align, -00043 kStretch_Align, -00044 -00045 kAlignCount -00046 }; -00047 Align getAlign()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Align)fAlign; } -00048 <span class="keywordtype">void</span> setAlign(Align); -00049 -00050 <span class="keywordtype">bool</span> getRound()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(fRound); } -00051 <span class="keywordtype">void</span> setRound(<span class="keywordtype">bool</span>); -00052 -00053 <span class="keyword">protected</span>: -00054 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onLayoutChildren(<a class="code" href="classSkView.html">SkView</a>* parent); -00055 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00056 -00057 <span class="keyword">private</span>: -00058 SkRect fMargin; -00059 SkScalar fSpacer; -00060 U8 fOrient, fPack, fAlign, fRound; -00061 }; -00062 -00063 <span class="keyword">class </span>SkFillViewLayout : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a>::Layout { -00064 <span class="keyword">public</span>: -00065 SkFillViewLayout(); -00066 <span class="keywordtype">void</span> getMargin(SkRect*) <span class="keyword">const</span>; -00067 <span class="keywordtype">void</span> setMargin(<span class="keyword">const</span> SkRect&); -00068 -00069 <span class="keyword">protected</span>: -00070 <span class="comment">// overrides;</span> -00071 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onLayoutChildren(<a class="code" href="classSkView.html">SkView</a>* parent); -00072 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00073 -00074 <span class="keyword">private</span>: -00075 SkRect fMargin; -00076 <span class="keyword">typedef</span> <a class="code" href="classSkView_1_1Layout.html">SkView::Layout</a> INHERITED; -00077 }; -00078 -00079 <span class="preprocessor">#endif</span> -00080 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkStdLib__Redirect_8h-source.html b/sgl_doxygen/html/SkStdLib__Redirect_8h-source.html deleted file mode 100644 index d1a0ef3..0000000 --- a/sgl_doxygen/html/SkStdLib__Redirect_8h-source.html +++ /dev/null @@ -1,31 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkStdLib_Redirect.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkStdLib_Redirect.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkStdLib_Redirect_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkStdLib_Redirect_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#error</span> -00005 <span class="preprocessor"></span> -00006 <span class="preprocessor">#include "SkTypes.h"</span> -00007 -00008 <span class="preprocessor">#define fread(buffer, count, size, file) sk_stdlib_fread(buffer, count, size, file)</span> -00009 <span class="preprocessor"></span><span class="preprocessor">#define qsort</span> -00010 <span class="preprocessor"></span><span class="preprocessor">#define tolower</span> -00011 <span class="preprocessor"></span><span class="preprocessor">#define setjmp</span> -00012 <span class="preprocessor"></span><span class="preprocessor">#define longjmp</span> -00013 <span class="preprocessor"></span><span class="preprocessor">#define memmove</span> -00014 <span class="preprocessor"></span><span class="preprocessor">#define malloc</span> -00015 <span class="preprocessor"></span><span class="preprocessor">#define realloc</span> -00016 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00017 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkStream_8h-source.html b/sgl_doxygen/html/SkStream_8h-source.html deleted file mode 100644 index 7b4c7ea..0000000 --- a/sgl_doxygen/html/SkStream_8h-source.html +++ /dev/null @@ -1,150 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkStream.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkStream.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkStream_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkStream_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkScalar.h"</span> -00005 -00006 <span class="keyword">class </span>SkStream { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">virtual</span> ~SkStream() {} -00012 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> rewind() = 0; -00016 <span class="keyword">virtual</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* getFileName(); -00024 <span class="keyword">virtual</span> size_t read(<span class="keywordtype">void</span>* buffer, size_t size) = 0; -00025 <span class="keyword">static</span> SkStream* GetURIStream(<span class="keyword">const</span> <span class="keywordtype">char</span> prefix[], <span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00026 <span class="keyword">static</span> <span class="keywordtype">bool</span> IsAbsoluteURI(<span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00027 }; -00028 -00029 <span class="keyword">class </span>SkWStream { -00030 <span class="keyword">public</span>: -00031 <span class="keyword">virtual</span> ~SkWStream(); -00032 -00038 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> write(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t size) = 0; -00039 <span class="keyword">virtual</span> <span class="keywordtype">void</span> newline(); -00040 <span class="keyword">virtual</span> <span class="keywordtype">void</span> flush(); -00041 <span class="keyword">virtual</span> size_t getOffset() = 0; <span class="comment">// compiled script experiment</span> -00042 -00043 <span class="comment">// helpers</span> -00044 -00045 <span class="keywordtype">bool</span> writeText(<span class="keyword">const</span> <span class="keywordtype">char</span> text[]); -00046 <span class="keywordtype">bool</span> writeDecAsText(S32); -00047 <span class="keywordtype">bool</span> writeHexAsText(U32, <span class="keywordtype">int</span> minDigits = 0); -00048 <span class="keywordtype">bool</span> writeScalarAsText(SkScalar); -00049 -00050 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00051 }; -00052 -00054 -00055 <span class="preprocessor">#include "SkString.h"</span> -00056 -00057 <span class="keyword">struct </span>SkFILE; -00058 -00059 <span class="keyword">class </span>SkFILEStream : <span class="keyword">public</span> SkStream { -00060 <span class="keyword">public</span>: -00061 SkFILEStream(<span class="keyword">const</span> <span class="keywordtype">char</span> path[] = nil); -00062 <span class="keyword">virtual</span> ~SkFILEStream(); -00063 -00066 <span class="keywordtype">bool</span> isValid()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFILE != nil; } -00070 <span class="keywordtype">void</span> setPath(<span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00071 -00072 SkFILE* getSkFILE()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFILE; } -00073 -00074 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> rewind(); -00075 <span class="keyword">virtual</span> size_t read(<span class="keywordtype">void</span>* buffer, size_t size); -00076 <span class="keyword">virtual</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* getFileName(); -00077 -00078 <span class="keyword">private</span>: -00079 SkFILE* fFILE; -00080 <a class="code" href="classSkString.html">SkString</a> fName; -00081 }; -00082 -00083 <span class="keyword">class </span>SkMemoryStream : <span class="keyword">public</span> SkStream { -00084 <span class="keyword">public</span>: -00085 SkMemoryStream(<span class="keyword">const</span> <span class="keywordtype">void</span>* src, size_t length); -00086 -00087 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> rewind(); -00088 <span class="keyword">virtual</span> size_t read(<span class="keywordtype">void</span>* buffer, size_t size); -00089 -00090 <span class="keyword">private</span>: -00091 <span class="keyword">const</span> <span class="keywordtype">void</span>* fSrc; -00092 size_t fSize, fOffset; -00093 }; -00094 -<a name="l00100"></a><a class="code" href="classSkBufferStream.html">00100</a> <span class="keyword">class </span><a class="code" href="classSkBufferStream.html">SkBufferStream</a> : <span class="keyword">public</span> SkStream { -00101 <span class="keyword">public</span>: -00106 <a class="code" href="classSkBufferStream.html#a0">SkBufferStream</a>(SkStream& proxy, size_t bufferSize = 0); -00112 <a class="code" href="classSkBufferStream.html#a0">SkBufferStream</a>(SkStream& proxy, <span class="keywordtype">void</span>* buffer, size_t bufferSize); -00113 <span class="keyword">virtual</span> ~<a class="code" href="classSkBufferStream.html">SkBufferStream</a>(); -00114 -00115 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> rewind(); -00116 <span class="keyword">virtual</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* getFileName(); -00117 <span class="keyword">virtual</span> size_t read(<span class="keywordtype">void</span>* buffer, size_t size); -00118 <span class="keyword">private</span>: -00119 <span class="keyword">enum</span> { -00120 kDefaultBufferSize = 128 -00121 }; -00122 <span class="comment">// illegal</span> -00123 <a class="code" href="classSkBufferStream.html#a0">SkBufferStream</a>(<span class="keyword">const</span> <a class="code" href="classSkBufferStream.html">SkBufferStream</a>&); -00124 <a class="code" href="classSkBufferStream.html">SkBufferStream</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkBufferStream.html">SkBufferStream</a>&); -00125 -00126 SkStream& fProxy; -00127 <span class="keywordtype">char</span>* fBuffer; -00128 size_t fOrigBufferSize, fBufferSize, fBufferOffset; -00129 <span class="keywordtype">bool</span> fWeOwnTheBuffer; -00130 -00131 <span class="keywordtype">void</span> init(<span class="keywordtype">void</span>*, size_t); -00132 }; -00133 -00135 -00136 <span class="keyword">class </span>SkFILEWStream : <span class="keyword">public</span> SkWStream { -00137 <span class="keyword">public</span>: -00138 SkFILEWStream(<span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00139 <span class="keyword">virtual</span> ~SkFILEWStream(); -00140 -00143 <span class="keywordtype">bool</span> isValid()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFILE != nil; } -00144 -00145 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> write(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t size); -00146 <span class="keyword">virtual</span> <span class="keywordtype">void</span> flush(); -00147 <span class="keyword">virtual</span> size_t getOffset() { SkASSERT(0); <span class="keywordflow">return</span> 0; } <span class="comment">// compiled script experiment</span> -00148 <span class="keyword">private</span>: -00149 SkFILE* fFILE; -00150 }; -00151 -00152 <span class="keyword">class </span>SkMemoryWStream : <span class="keyword">public</span> SkWStream { -00153 <span class="keyword">public</span>: -00154 SkMemoryWStream(); -00155 <span class="keyword">virtual</span> ~SkMemoryWStream(); -00156 <span class="keyword">const</span> <span class="keywordtype">char</span>* getStream() { <span class="keywordflow">return</span> (<span class="keyword">const</span> <span class="keywordtype">char</span>*) fDst; } -00157 virtual <span class="keywordtype">bool</span> write(const <span class="keywordtype">void</span>* buffer, size_t size); -00158 virtual size_t getOffset() { <span class="keywordflow">return</span> fOffset; } <span class="comment">// compiled script experiment</span> -00159 <span class="keyword">private</span>: -00160 <span class="keywordtype">void</span>* fDst; -00161 size_t fSize, fOffset; -00162 }; -00163 -00164 -00165 <span class="keyword">class </span>SkDebugWStream : <span class="keyword">public</span> SkWStream { -00166 <span class="keyword">public</span>: -00167 <span class="comment">// overrides</span> -00168 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> write(<span class="keyword">const</span> <span class="keywordtype">void</span>* buffer, size_t size); -00169 <span class="keyword">virtual</span> <span class="keywordtype">void</span> newline(); -00170 <span class="keyword">virtual</span> size_t getOffset() { SkASSERT(0); <span class="keywordflow">return</span> 0; } <span class="comment">// compiled script experiment</span> -00171 }; -00172 -00173 <span class="comment">// for now</span> -00174 <span class="keyword">typedef</span> SkFILEStream SkURLStream; -00175 -00176 <span class="preprocessor">#endif</span> -00177 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkStream__Win_8h-source.html b/sgl_doxygen/html/SkStream__Win_8h-source.html deleted file mode 100644 index de34969..0000000 --- a/sgl_doxygen/html/SkStream__Win_8h-source.html +++ /dev/null @@ -1,46 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkStream_Win.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkStream_Win.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkStream_Win_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkStream_Win_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#ifndef SK_BUILD_FOR_WIN</span> -00005 <span class="preprocessor"></span><span class="preprocessor">#error "only valid for windows and wince builds"</span> -00006 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00007 <span class="preprocessor"></span> -00008 <span class="preprocessor">#ifndef SkStream_DEFINED</span> -00009 <span class="preprocessor"></span><span class="preprocessor">#include "SkStream.h"</span> -00010 <span class="preprocessor">#endif</span> -00011 <span class="preprocessor"></span><span class="preprocessor">#include "SkString.h"</span> -00012 <span class="preprocessor">#include "Wininet.h"</span> -00013 -00015 <span class="keyword">class </span>SkURLStream : <span class="keyword">public</span> SkStream { -00016 <span class="keyword">public</span>: -00017 SkURLStream(<span class="keyword">const</span> <span class="keywordtype">char</span> url[] = nil); -00018 <span class="keyword">virtual</span> ~SkURLStream(); -00019 -00023 <span class="keywordtype">void</span> setURL(<span class="keyword">const</span> <span class="keywordtype">char</span> url[]); -00024 -00025 <span class="comment">// overrides</span> -00026 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> rewind(); -00027 <span class="keyword">virtual</span> size_t read(<span class="keywordtype">void</span>* buffer, size_t size); -00028 -00029 <span class="keyword">private</span>: -00030 <a class="code" href="classSkString.html">SkString</a> fURL; -00031 HINTERNET fConnection; -00032 HINTERNET fURLStream; -00033 }; -00034 -00036 <span class="preprocessor">#endif // SkStream_Win_DEFINED</span> -00037 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkString_8h-source.html b/sgl_doxygen/html/SkString_8h-source.html deleted file mode 100644 index d44f5bd..0000000 --- a/sgl_doxygen/html/SkString_8h-source.html +++ /dev/null @@ -1,143 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkString.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkString.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkString_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkString_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkScalar.h"</span> -00005 -00006 <span class="comment">/* Some helper functions for C strings</span> -00007 <span class="comment">*/</span> -00008 -00009 <span class="keywordtype">bool</span> SkStrStartsWith(<span class="keyword">const</span> <span class="keywordtype">char</span> string[], <span class="keyword">const</span> <span class="keywordtype">char</span> prefix[]); -00010 <span class="keywordtype">bool</span> SkStrEndsWith(<span class="keyword">const</span> <span class="keywordtype">char</span> string[], <span class="keyword">const</span> <span class="keywordtype">char</span> suffix[]); -00011 <span class="keywordtype">int</span> SkStrStartsWithOneOf(<span class="keyword">const</span> <span class="keywordtype">char</span> string[], <span class="keyword">const</span> <span class="keywordtype">char</span> prefixes[]); -00012 -<a name="l00019"></a><a class="code" href="classSkString.html">00019</a> <span class="keyword">class </span><a class="code" href="classSkString.html">SkString</a> { -00020 <span class="keyword">public</span>: -00021 <a class="code" href="classSkString.html">SkString</a>(); -00022 <span class="keyword">explicit</span> <a class="code" href="classSkString.html">SkString</a>(size_t len); -00023 <span class="keyword">explicit</span> <a class="code" href="classSkString.html">SkString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> text[]); -00024 <a class="code" href="classSkString.html">SkString</a>(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len); -00025 <span class="keyword">explicit</span> <a class="code" href="classSkString.html">SkString</a>(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00026 ~<a class="code" href="classSkString.html">SkString</a>(); -00027 -00028 <span class="keywordtype">bool</span> isEmpty()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fRec->fLength == 0; } -00029 size_t size()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (size_t) fRec->fLength; } -00030 <span class="keyword">const</span> <span class="keywordtype">char</span>* c_str()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fRec->data(); } -00031 -00032 <span class="keywordtype">bool</span> equals(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&) <span class="keyword">const</span>; -00033 <span class="keywordtype">bool</span> equals(<span class="keyword">const</span> <span class="keywordtype">char</span> text[]) <span class="keyword">const</span>; -00034 <span class="keywordtype">bool</span> equals(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len) <span class="keyword">const</span>; -00035 -00036 <span class="keywordtype">bool</span> startsWith(<span class="keyword">const</span> <span class="keywordtype">char</span> prefix[])<span class="keyword"> const</span> -00037 <span class="keyword"> </span>{ -00038 <span class="keywordflow">return</span> SkStrStartsWith(fRec->data(), prefix); -00039 } -00040 <span class="keywordtype">bool</span> endsWith(<span class="keyword">const</span> <span class="keywordtype">char</span> suffix[])<span class="keyword"> const</span> -00041 <span class="keyword"> </span>{ -00042 <span class="keywordflow">return</span> SkStrEndsWith(fRec->data(), suffix); -00043 } -00044 -00045 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator==(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& a, <span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& b) -00046 { -00047 <span class="keywordflow">return</span> a.equals(b); -00048 } -00049 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator!=(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& a, <span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& b) -00050 { -00051 <span class="keywordflow">return</span> !a.equals(b); -00052 } -00053 -00054 <span class="comment">// these methods edit the string</span> -00055 -00056 <a class="code" href="classSkString.html">SkString</a>& operator=(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00057 -00058 <span class="keywordtype">char</span>* writable_str(); -00059 -00060 <span class="keywordtype">void</span> reset(); -00061 <span class="keywordtype">void</span> resize(size_t len) { this->set(nil, len); } -00062 <span class="keywordtype">void</span> set(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& src) { *<span class="keyword">this</span> = src; } -00063 <span class="keywordtype">void</span> set(<span class="keyword">const</span> <span class="keywordtype">char</span> text[]); -00064 <span class="keywordtype">void</span> set(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len); -00065 <span class="keywordtype">void</span> setUTF16(<span class="keyword">const</span> U16[]); -00066 -00067 <span class="keywordtype">void</span> insert(size_t offset, <span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& src) { this->insert(offset, src.c_str(), src.size()); } -00068 <span class="keywordtype">void</span> insert(size_t offset, <span class="keyword">const</span> <span class="keywordtype">char</span> text[]); -00069 <span class="keywordtype">void</span> insert(size_t offset, <span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len); -00070 <span class="keywordtype">void</span> insertUnichar(size_t offset, SkUnichar); -00071 <span class="keywordtype">void</span> insertS32(size_t offset, S32 value); -00072 <span class="keywordtype">void</span> insertHex(size_t offset, U32 value, <span class="keywordtype">int</span> minDigits = 0); -00073 <span class="keywordtype">void</span> insertScalar(size_t offset, SkScalar); -00074 -00075 <span class="keywordtype">void</span> append(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& str) { this->insert((size_t)-1, str); } -00076 <span class="keywordtype">void</span> append(<span class="keyword">const</span> <span class="keywordtype">char</span> text[]) { this->insert((size_t)-1, text); } -00077 <span class="keywordtype">void</span> append(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len) { this->insert((size_t)-1, text, len); } -00078 <span class="keywordtype">void</span> appendUnichar(SkUnichar uni) { this->insertUnichar((size_t)-1, uni); } -00079 <span class="keywordtype">void</span> appendS32(S32 value) { this->insertS32((size_t)-1, value); } -00080 <span class="keywordtype">void</span> appendHex(U32 value, <span class="keywordtype">int</span> minDigits = 0) { this->insertHex((size_t)-1, value, minDigits); } -00081 <span class="keywordtype">void</span> appendScalar(SkScalar value) { this->insertScalar((size_t)-1, value); } -00082 -00083 <span class="keywordtype">void</span> prepend(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& str) { this->insert(0, str); } -00084 <span class="keywordtype">void</span> prepend(<span class="keyword">const</span> <span class="keywordtype">char</span> text[]) { this->insert(0, text); } -00085 <span class="keywordtype">void</span> prepend(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len) { this->insert(0, text, len); } -00086 <span class="keywordtype">void</span> prependUnichar(SkUnichar uni) { this->insertUnichar(0, uni); } -00087 <span class="keywordtype">void</span> prependS32(S32 value) { this->insertS32(0, value); } -00088 <span class="keywordtype">void</span> prependHex(U32 value, <span class="keywordtype">int</span> minDigits = 0) { this->insertHex(0, value, minDigits); } -00089 <span class="keywordtype">void</span> prependScalar(SkScalar value) { this->insertScalar((size_t)-1, value); } -00090 -00091 <span class="keywordtype">void</span> printf(<span class="keyword">const</span> <span class="keywordtype">char</span> format[], ...); -00092 -00093 <span class="keywordtype">void</span> remove(size_t offset, size_t length); -00094 -00098 <span class="keywordtype">void</span> <a class="code" href="classSkString.html#a45">swap</a>(<a class="code" href="classSkString.html">SkString</a>& other); -00099 -00101 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00104 <span class="keyword">private</span>: -00105 <span class="preprocessor">#ifdef SK_DEBUG</span> -00106 <span class="preprocessor"></span> <span class="keyword">const</span> <span class="keywordtype">char</span>* fStr; -00107 <span class="preprocessor">#endif</span> -00108 <span class="preprocessor"></span> <span class="keyword">struct </span>Rec { -00109 U16 fLength; -00110 U16 fRefCnt; -00111 <span class="comment">// data[]</span> -00112 <span class="keywordtype">char</span>* data() { <span class="keywordflow">return</span> (<span class="keywordtype">char</span>*)(<span class="keyword">this</span>) + <span class="keyword">sizeof</span>(Rec); } -00113 <span class="keyword">const</span> <span class="keywordtype">char</span>* data()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (<span class="keyword">const</span> <span class="keywordtype">char</span>*)(<span class="keyword">this</span>) + <span class="keyword">sizeof</span>(Rec); } -00114 }; -00115 Rec* fRec; -00116 -00117 <span class="preprocessor">#ifdef SK_DEBUG</span> -00118 <span class="preprocessor"></span> <span class="keywordtype">void</span> validate() <span class="keyword">const</span>; -00119 <span class="preprocessor">#else</span> -00120 <span class="preprocessor"></span> <span class="keywordtype">void</span> validate()<span class="keyword"> const </span>{} -00121 <span class="preprocessor">#endif</span> -00122 <span class="preprocessor"></span> -00123 <span class="keyword">static</span> Rec* AllocRec(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], U16CPU len); -00124 <span class="keyword">static</span> Rec* RefRec(Rec*); -00125 }; -00126 -00127 <span class="keyword">class </span>SkAutoUCS2 { -00128 <span class="keyword">public</span>: -00129 SkAutoUCS2(<span class="keyword">const</span> <span class="keywordtype">char</span> utf8[]); -00130 ~SkAutoUCS2(); -00131 -00134 <span class="keywordtype">int</span> count()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount; } -00137 <span class="keyword">const</span> U16* getUCS2()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fUCS2; } -00138 -00139 <span class="keyword">private</span>: -00140 <span class="keywordtype">int</span> fCount; -00141 U16* fUCS2; -00142 }; -00143 -00144 <span class="preprocessor">#endif</span> -00145 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkStroke_8h-source.html b/sgl_doxygen/html/SkStroke_8h-source.html deleted file mode 100644 index 12fc710..0000000 --- a/sgl_doxygen/html/SkStroke_8h-source.html +++ /dev/null @@ -1,65 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkStroke.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkStroke.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkStroke_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkStroke_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkPoint.h"</span> -00005 <span class="preprocessor">#include "SkPaint.h"</span> -00006 -00007 <span class="keyword">struct </span>SkRect; -00008 <span class="keyword">class </span><a class="code" href="classSkPath.html">SkPath</a>; -00009 -00010 <span class="preprocessor">#define SK_DefaultStrokeWidth SK_Scalar1</span> -00011 <span class="preprocessor"></span><span class="preprocessor">#define SK_DefaultMiterLimit SkIntToScalar(4)</span> -00012 <span class="preprocessor"></span> -00013 -<a name="l00020"></a><a class="code" href="classSkStroke.html">00020</a> <span class="keyword">class </span><a class="code" href="classSkStroke.html">SkStroke</a> { -00021 <span class="keyword">public</span>: -00022 <a class="code" href="classSkStroke.html">SkStroke</a>(); -00023 <a class="code" href="classSkStroke.html">SkStroke</a>(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00024 <a class="code" href="classSkStroke.html">SkStroke</a>(<span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&, SkScalar width); <span class="comment">// width overrides paint.getStrokeWidth()</span> -00025 -00026 SkPaint::Cap getCap()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (SkPaint::Cap)fCap; } -00027 <span class="keywordtype">void</span> setCap(SkPaint::Cap); -00028 -00029 SkPaint::Join getJoin()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (SkPaint::Join)fJoin; } -00030 <span class="keywordtype">void</span> setJoin(SkPaint::Join); -00031 -00032 <span class="comment">// SkScalar getMiterLimit() const { return fMiterLimit; }</span> -00033 <span class="keywordtype">void</span> setMiterLimit(SkScalar); -00034 -00035 <span class="comment">// SkScalar getWidth() const { return fWidth; }</span> -00036 <span class="keywordtype">void</span> setWidth(SkScalar); -00037 -00038 <span class="keywordtype">bool</span> getDoFill()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> SkToBool(fDoFill); } -00039 <span class="keywordtype">void</span> setDoFill(<span class="keywordtype">bool</span> doFill) { fDoFill = SkToU8(doFill); } -00040 -00041 <span class="keywordtype">void</span> strokeLine(<span class="keyword">const</span> SkPoint& start, <span class="keyword">const</span> SkPoint& end, <a class="code" href="classSkPath.html">SkPath</a>*) <span class="keyword">const</span>; -00042 <span class="keywordtype">void</span> strokeRect(<span class="keyword">const</span> SkRect& rect, <a class="code" href="classSkPath.html">SkPath</a>*) <span class="keyword">const</span>; -00043 <span class="keywordtype">void</span> strokeOval(<span class="keyword">const</span> SkRect& oval, <a class="code" href="classSkPath.html">SkPath</a>*) <span class="keyword">const</span>; -00044 <span class="keywordtype">void</span> strokeRRect(<span class="keyword">const</span> SkRect& rect, SkScalar rx, SkScalar ry, <a class="code" href="classSkPath.html">SkPath</a>*) <span class="keyword">const</span>; -00045 <span class="keywordtype">void</span> strokePath(<span class="keyword">const</span> <a class="code" href="classSkPath.html">SkPath</a>& path, <a class="code" href="classSkPath.html">SkPath</a>*) <span class="keyword">const</span>; -00046 -00048 -00049 <span class="keyword">private</span>: -00050 SkScalar fWidth, fMiterLimit; -00051 U8 fCap, fJoin; -00052 SkBool8 fDoFill; -00053 -00054 <span class="keyword">friend</span> <span class="keyword">class </span><a class="code" href="classSkPaint.html">SkPaint</a>; -00055 }; -00056 -00057 <span class="preprocessor">#endif</span> -00058 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkSystemEventTypes_8h-source.html b/sgl_doxygen/html/SkSystemEventTypes_8h-source.html deleted file mode 100644 index 92c3655..0000000 --- a/sgl_doxygen/html/SkSystemEventTypes_8h-source.html +++ /dev/null @@ -1,30 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSystemEventTypes.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkSystemEventTypes.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkSystemEventTypes_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkSystemEventTypes_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="comment">/*</span> -00005 <span class="comment"> The goal of these strings is two-fold:</span> -00006 <span class="comment"> 1) make funny strings (containing at least one char < 32) to avoid colliding with "user" strings</span> -00007 <span class="comment"> 2) keep them <= 4 bytes, so we can avoid an allocation in SkEvent::setType()</span> -00008 <span class="comment">*/</span> -00009 <span class="preprocessor">#define SK_EventType_Delay "\xd" "lay"</span> -00010 <span class="preprocessor"></span><span class="preprocessor">#define SK_EventType_Inval "nv" "\xa" "l"</span> -00011 <span class="preprocessor"></span><span class="preprocessor">#define SK_EventType_Key "key" "\x1" </span> -00012 <span class="preprocessor"></span><span class="preprocessor">#define SK_EventType_OnEnd "on" "\xe" "n"</span> -00013 <span class="preprocessor"></span><span class="preprocessor">#define SK_EventType_Unichar "\xc" "har"</span> -00014 <span class="preprocessor"></span><span class="preprocessor">#define SK_EventType_KeyUp "key" "\xf"</span> -00015 <span class="preprocessor"></span> -00016 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTDArray_8h-source.html b/sgl_doxygen/html/SkTDArray_8h-source.html deleted file mode 100644 index c2ef922..0000000 --- a/sgl_doxygen/html/SkTDArray_8h-source.html +++ /dev/null @@ -1,301 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTDArray.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTDArray.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTDArray_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTDArray_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="preprocessor">#ifdef SK_DEBUG</span> -00007 <span class="preprocessor"></span><span class="preprocessor">#define kDebugArraySize 16</span> -00008 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00009 <span class="preprocessor"></span> -00010 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">class </span>SkTDArray { -00011 <span class="keyword">public</span>: -00012 SkTDArray() -00013 { -00014 fReserve = fCount = 0; -00015 fArray = nil; -00016 <span class="preprocessor">#ifdef SK_DEBUG</span> -00017 <span class="preprocessor"></span> fData = nil; -00018 <span class="preprocessor">#endif</span> -00019 <span class="preprocessor"></span> } -00020 SkTDArray(<span class="keyword">const</span> T src[], U16CPU count) -00021 { -00022 SkASSERT(src || count == 0); -00023 -00024 fReserve = fCount = 0; -00025 fArray = nil; -00026 <span class="preprocessor">#ifdef SK_DEBUG</span> -00027 <span class="preprocessor"></span> fData = nil; -00028 <span class="preprocessor">#endif</span> -00029 <span class="preprocessor"></span> <span class="keywordflow">if</span> (count) -00030 { -00031 fArray = (T*)sk_malloc_throw(count * <span class="keyword">sizeof</span>(T)); -00032 <span class="preprocessor">#ifdef SK_DEBUG</span> -00033 <span class="preprocessor"></span> fData = (T (*)[kDebugArraySize]) fArray; -00034 <span class="preprocessor">#endif</span> -00035 <span class="preprocessor"></span> memcpy(fArray, src, <span class="keyword">sizeof</span>(T) * count); -00036 fReserve = fCount = SkToU16(count); -00037 } -00038 } -00039 SkTDArray(<span class="keyword">const</span> SkTDArray<T>& src) -00040 { -00041 fReserve = fCount = 0; -00042 fArray = nil; -00043 <span class="preprocessor">#ifdef SK_DEBUG</span> -00044 <span class="preprocessor"></span> fData = nil; -00045 <span class="preprocessor">#endif</span> -00046 <span class="preprocessor"></span> SkTDArray<T> tmp(src.fArray, src.fCount); -00047 this->swap(tmp); -00048 } -00049 ~SkTDArray() -00050 { -00051 sk_free(fArray); -00052 } -00053 -00054 SkTDArray<T>& operator=(<span class="keyword">const</span> SkTDArray<T>& src) -00055 { -00056 <span class="keywordflow">if</span> (<span class="keyword">this</span> != &src) -00057 { -00058 <span class="keywordflow">if</span> (src.fCount > fReserve) -00059 { -00060 SkTDArray<T> tmp(src.fArray, src.fCount); -00061 this->swap(tmp); -00062 } -00063 <span class="keywordflow">else</span> -00064 { -00065 memcpy(fArray, src.fArray, <span class="keyword">sizeof</span>(T) * src.fCount); -00066 fCount = src.fCount; -00067 } -00068 } -00069 <span class="keywordflow">return</span> *<span class="keyword">this</span>; -00070 } -00071 -00072 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator==(<span class="keyword">const</span> SkTDArray<T>& a, <span class="keyword">const</span> SkTDArray<T>& b) -00073 { -00074 <span class="keywordflow">return</span> a.fCount == b.fCount && -00075 (a.fCount == 0 || !memcmp(a.fArray, b.fArray, a.fCount * <span class="keyword">sizeof</span>(T))); -00076 } -00077 -00078 <span class="keywordtype">void</span> swap(SkTDArray<T>& other) -00079 { -00080 SkTSwap(fArray, other.fArray); -00081 <span class="preprocessor">#ifdef SK_DEBUG</span> -00082 <span class="preprocessor"></span> SkTSwap(fData, other.fData); -00083 <span class="preprocessor">#endif</span> -00084 <span class="preprocessor"></span> SkTSwap(fReserve, other.fReserve); -00085 SkTSwap(fCount, other.fCount); -00086 } -00087 -00088 <span class="keywordtype">bool</span> isEmpty()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount == 0; } -00089 <span class="keywordtype">int</span> count()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCount; } -00090 T* begin()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fArray; } -00091 T* end()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fArray ? fArray + fCount : nil; } -00092 T& operator[](<span class="keywordtype">int</span> index)<span class="keyword"> const </span>{ SkASSERT((<span class="keywordtype">unsigned</span>)index < fCount); <span class="keywordflow">return</span> fArray[index]; } -00093 -00094 <span class="keywordtype">void</span> reset() -00095 { -00096 <span class="keywordflow">if</span> (fArray) -00097 { -00098 sk_free(fArray); -00099 fArray = nil; -00100 <span class="preprocessor">#ifdef SK_DEBUG</span> -00101 <span class="preprocessor"></span> fData = nil; -00102 <span class="preprocessor">#endif</span> -00103 <span class="preprocessor"></span> fReserve = fCount = 0; -00104 } -00105 <span class="keywordflow">else</span> -00106 { -00107 SkASSERT(fReserve == 0 && fCount == 0); -00108 } -00109 } -00110 -00111 <span class="keywordtype">void</span> setCount(U16CPU count) -00112 { -00113 <span class="keywordflow">if</span> (count > fReserve) -00114 this->growBy(count - fCount); -00115 else -00116 fCount = SkToU16(count); -00117 } -00118 -00119 <span class="keywordtype">void</span> setReserve(U16CPU reserve) -00120 { -00121 <span class="keywordflow">if</span> (reserve > fReserve) -00122 { -00123 SkASSERT(reserve > fCount); -00124 U16 count = fCount; -00125 this->growBy(reserve - fCount); -00126 fCount = count; -00127 } -00128 } -00129 -00130 T* prepend() -00131 { -00132 this->growBy(1); -00133 memmove(fArray + 1, fArray, (fCount - 1) * <span class="keyword">sizeof</span>(T)); -00134 <span class="keywordflow">return</span> fArray; -00135 } -00136 -00137 T* append() { <span class="keywordflow">return</span> this->append(1, nil); } -00138 T* append(U16CPU count, <span class="keyword">const</span> T* src = nil) -00139 { -00140 <span class="keywordtype">unsigned</span> oldCount = fCount; -00141 <span class="keywordflow">if</span> (count) -00142 { -00143 SkASSERT(src == nil || fArray == nil || -00144 src + count <= fArray || fArray + oldCount <= src); -00145 -00146 this->growBy(count); -00147 <span class="keywordflow">if</span> (src) -00148 memcpy(fArray + oldCount, src, sizeof(T) * count); -00149 } -00150 return fArray + oldCount; -00151 } -00152 -00153 T* appendClear() -00154 { -00155 T* result = this->append(); -00156 *result = 0; -00157 <span class="keywordflow">return</span> result; -00158 } -00159 -00160 T* insert(U16CPU index) { <span class="keywordflow">return</span> this->insert(index, 1, nil); } -00161 T* insert(U16CPU index, U16CPU count, <span class="keyword">const</span> T* src = nil) -00162 { -00163 SkASSERT(count); -00164 <span class="keywordtype">int</span> oldCount = fCount; -00165 this->growBy(count); -00166 T* dst = fArray + index; -00167 memmove(dst + count, dst, <span class="keyword">sizeof</span>(T) * (oldCount - index)); -00168 <span class="keywordflow">if</span> (src) -00169 memcpy(dst, src, sizeof(T) * count); -00170 return dst; -00171 } -00172 -00173 <span class="keywordtype">void</span> remove(U16CPU index, U16CPU count = 1) -00174 { -00175 SkASSERT(index + count <= fCount); -00176 fCount = SkToU16(fCount - count); -00177 memmove(fArray + index, fArray + index + count, <span class="keyword">sizeof</span>(T) * (fCount - index)); -00178 } -00179 -00180 <span class="keywordtype">void</span> removeShuffle(U16CPU index) -00181 { -00182 SkASSERT(index < fCount); -00183 <span class="keywordtype">unsigned</span> newCount = fCount - 1; -00184 fCount = SkToU16(newCount); -00185 <span class="keywordflow">if</span> (index != newCount) -00186 memcpy(fArray + index, fArray + newCount, sizeof(T)); -00187 } -00188 -00189 <span class="keywordtype">int</span> find(const T& elem)<span class="keyword"> const</span> -00190 <span class="keyword"> </span>{ -00191 <span class="keyword">const</span> T* iter = fArray; -00192 <span class="keyword">const</span> T* stop = fArray + fCount; -00193 -00194 <span class="keywordflow">for</span> (; iter < stop; iter++) -00195 { -00196 <span class="keywordflow">if</span> (*iter == elem) -00197 return (<span class="keywordtype">int</span>) (iter - fArray); -00198 } -00199 return -1; -00200 } -00201 -00202 <span class="keywordtype">int</span> rfind(const T& elem)<span class="keyword"> const</span> -00203 <span class="keyword"> </span>{ -00204 <span class="keyword">const</span> T* iter = fArray + fCount; -00205 <span class="keyword">const</span> T* stop = fArray; -00206 -00207 <span class="keywordflow">while</span> (iter > stop) -00208 { -00209 <span class="keywordflow">if</span> (*--iter == elem) -00210 return iter - stop; -00211 } -00212 return -1; -00213 } -00214 -00215 <span class="comment">// routines to treat the array like a stack</span> -00216 T* push() { <span class="keywordflow">return</span> this->append(); } -00217 <span class="keywordtype">void</span> push(T& elem) { *this->append() = elem; } -00218 <span class="keyword">const</span> T& top()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (*<span class="keyword">this</span>)[fCount - 1]; } -00219 T& top() { <span class="keywordflow">return</span> (*<span class="keyword">this</span>)[fCount - 1]; } -00220 <span class="keywordtype">void</span> pop(T* elem) { <span class="keywordflow">if</span> (elem) *elem = (*this)[fCount - 1]; --fCount; } -00221 <span class="keywordtype">void</span> pop() { --fCount; } -00222 -00223 <span class="keywordtype">void</span> deleteAll() -00224 { -00225 T* iter = fArray; -00226 T* stop = fArray + fCount; -00227 <span class="keywordflow">while</span> (iter < stop) -00228 { -00229 <span class="keyword">delete</span> (*iter); -00230 iter += 1; -00231 } -00232 this->reset(); -00233 } -00234 -00235 <span class="keywordtype">void</span> freeAll() -00236 { -00237 T* iter = fArray; -00238 T* stop = fArray + fCount; -00239 <span class="keywordflow">while</span> (iter < stop) -00240 { -00241 sk_free(*iter); -00242 iter += 1; -00243 } -00244 this->reset(); -00245 } -00246 -00247 <span class="keywordtype">void</span> unrefAll() -00248 { -00249 T* iter = fArray; -00250 T* stop = fArray + fCount; -00251 <span class="keywordflow">while</span> (iter < stop) -00252 { -00253 (*iter)->unref(); -00254 iter += 1; -00255 } -00256 this->reset(); -00257 } -00258 -00259 <span class="keyword">private</span>: -00260 <span class="preprocessor">#ifdef SK_DEBUG</span> -00261 <span class="preprocessor"></span> T(* fData)[kDebugArraySize]; -00262 <span class="preprocessor">#endif</span> -00263 <span class="preprocessor"></span> T* fArray; -00264 U16 fReserve, fCount; -00265 -00266 <span class="keywordtype">void</span> growBy(U16CPU extra) -00267 { -00268 SkASSERT(extra); -00269 SkASSERT(fCount + extra <= 0xFFFF); -00270 -00271 <span class="keywordflow">if</span> (fCount + extra > fReserve) -00272 { -00273 size_t size = fCount + extra + 4; -00274 size += size >> 2; -00275 -00276 fArray = (T*)sk_realloc_throw(fArray, size * <span class="keyword">sizeof</span>(T)); -00277 <span class="preprocessor">#ifdef SK_DEBUG</span> -00278 <span class="preprocessor"></span> fData = (T (*)[kDebugArraySize]) fArray; -00279 <span class="preprocessor">#endif</span> -00280 <span class="preprocessor"></span> fReserve = SkToU16((U16CPU)size); -00281 } -00282 fCount = SkToU16(fCount + extra); -00283 } -00284 }; -00285 -00286 <span class="preprocessor">#endif</span> -00287 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTDStack_8h-source.html b/sgl_doxygen/html/SkTDStack_8h-source.html deleted file mode 100644 index 7948ead..0000000 --- a/sgl_doxygen/html/SkTDStack_8h-source.html +++ /dev/null @@ -1,118 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTDStack.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTDStack.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTDStack_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTDStack_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">class </span>SkTDStack { -00007 <span class="keyword">public</span>: -00008 SkTDStack() : fCount(0), fTotalCount(0) -00009 { -00010 fInitialRec.fNext = nil; -00011 fRec = &fInitialRec; -00012 -00013 <span class="comment">// fCount = kSlotCount;</span> -00014 } -00015 ~SkTDStack() -00016 { -00017 Rec* rec = fRec; -00018 <span class="keywordflow">while</span> (rec != &fInitialRec) -00019 { -00020 Rec* next = rec->fNext; -00021 sk_free(rec); -00022 rec = next; -00023 } -00024 } -00025 -00026 <span class="keywordtype">int</span> count()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fTotalCount; } -00027 -00028 T* push() -00029 { -00030 SkASSERT(fCount <= kSlotCount); -00031 <span class="keywordflow">if</span> (fCount == kSlotCount) -00032 { -00033 Rec* rec = (Rec*)sk_malloc_throw(<span class="keyword">sizeof</span>(Rec)); -00034 rec->fNext = fRec; -00035 fRec = rec; -00036 fCount = 0; -00037 } -00038 ++fTotalCount; -00039 <span class="keywordflow">return</span> &fRec->fSlots[fCount++]; -00040 } -00041 <span class="keywordtype">void</span> push(<span class="keyword">const</span> T& elem) { *this->push() = elem; } -00042 <span class="keyword">const</span> T& index(<span class="keywordtype">int</span> idx)<span class="keyword"> const</span> -00043 <span class="keyword"> </span>{ -00044 SkASSERT(fRec && fCount > idx); -00045 <span class="keywordflow">return</span> fRec->fSlots[fCount - idx - 1]; -00046 } -00047 T& index(<span class="keywordtype">int</span> idx) -00048 { -00049 SkASSERT(fRec && fCount > idx); -00050 <span class="keywordflow">return</span> fRec->fSlots[fCount - idx - 1]; -00051 } -00052 <span class="keyword">const</span> T& top()<span class="keyword"> const</span> -00053 <span class="keyword"> </span>{ -00054 SkASSERT(fRec && fCount > 0); -00055 <span class="keywordflow">return</span> fRec->fSlots[fCount - 1]; -00056 } -00057 T& top() -00058 { -00059 SkASSERT(fRec && fCount > 0); -00060 <span class="keywordflow">return</span> fRec->fSlots[fCount - 1]; -00061 } -00062 <span class="keywordtype">void</span> pop(T* elem) -00063 { -00064 <span class="keywordflow">if</span> (elem) -00065 *elem = fRec->fSlots[fCount - 1]; -00066 this->pop(); -00067 } -00068 <span class="keywordtype">void</span> pop() -00069 { -00070 SkASSERT(fCount > 0 && fRec); -00071 --fTotalCount; -00072 <span class="keywordflow">if</span> (--fCount == 0) -00073 { -00074 <span class="keywordflow">if</span> (fRec != &fInitialRec) -00075 { -00076 Rec* rec = fRec->fNext; -00077 sk_free(fRec); -00078 fCount = kSlotCount; -00079 fRec = rec; -00080 } -00081 <span class="keywordflow">else</span> -00082 SkASSERT(fTotalCount == 0); -00083 } -00084 } -00085 -00086 <span class="keyword">private</span>: -00087 <span class="keyword">enum</span> { -00088 kSlotCount = 8 -00089 }; -00090 -00091 <span class="keyword">struct </span>Rec; -00092 <span class="keyword">friend</span> <span class="keyword">struct </span>Rec; -00093 -00094 <span class="keyword">struct </span>Rec { -00095 Rec* fNext; -00096 T fSlots[kSlotCount]; -00097 }; -00098 Rec fInitialRec; -00099 Rec* fRec; -00100 <span class="keywordtype">int</span> fCount, fTotalCount; -00101 }; -00102 -00103 <span class="preprocessor">#endif</span> -00104 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTDict_8h-source.html b/sgl_doxygen/html/SkTDict_8h-source.html deleted file mode 100644 index 94f70c9..0000000 --- a/sgl_doxygen/html/SkTDict_8h-source.html +++ /dev/null @@ -1,163 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTDict.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTDict.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTDict_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTDict_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkChunkAlloc.h"</span> -00005 <span class="comment">//#include "SkTemplates.h"</span> -00006 <span class="preprocessor">#include "SkTSearch.h"</span> -00007 <span class="preprocessor">#include "SkTDArray.h"</span> -00008 -00009 <span class="keyword">template</span> <<span class="keyword">typename</span> T> <span class="keyword">class </span>SkTDict { -00010 <span class="keyword">public</span>: -00011 SkTDict(size_t minStringAlloc) : fStrings(minStringAlloc) {} -00012 -00013 <span class="keywordtype">void</span> reset() -00014 { -00015 fArray.reset(); -00016 fStrings.reset(); -00017 } -00018 -00019 <span class="keywordtype">int</span> count()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fArray.count(); } -00020 -00021 <span class="keywordtype">bool</span> set(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> T& value) -00022 { -00023 <span class="keywordflow">return</span> set(name, strlen(name), value); -00024 } -00025 -00026 <span class="keywordtype">bool</span> set(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], size_t len, <span class="keyword">const</span> T& value) -00027 { -00028 SkASSERT(name); -00029 -00030 <span class="keywordtype">int</span> index = this->find_index(name, len); -00031 -00032 <span class="keywordflow">if</span> (index >= 0) -00033 { -00034 fArray[index].fValue = value; -00035 <span class="keywordflow">return</span> <span class="keyword">false</span>; -00036 } -00037 <span class="keywordflow">else</span> -00038 { -00039 len += 1; <span class="comment">// make space for trailing zero</span> -00040 Pair* pair = fArray.insert(~index); -00041 <span class="keywordtype">char</span>* copy = (<span class="keywordtype">char</span>*)fStrings.alloc(len, SkChunkAlloc::kThrow_AllocFailType); -00042 memcpy(copy, name, len); -00043 pair->fName = copy; -00044 pair->fValue = value; -00045 <span class="keywordflow">return</span> <span class="keyword">true</span>; -00046 } -00047 } -00048 -00049 <span class="keywordtype">bool</span> find(<span class="keyword">const</span> <span class="keywordtype">char</span> name[])<span class="keyword"> const</span> -00050 <span class="keyword"> </span>{ -00051 <span class="keywordflow">return</span> this->find_index(name) >= 0; -00052 } -00053 -00054 <span class="keywordtype">bool</span> find(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], T* value)<span class="keyword"> const</span> -00055 <span class="keyword"> </span>{ -00056 <span class="keywordflow">return</span> find(name, strlen(name), value); -00057 } -00058 -00059 <span class="keywordtype">bool</span> find(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], size_t len, T* value)<span class="keyword"> const</span> -00060 <span class="keyword"> </span>{ -00061 <span class="keywordtype">int</span> index = this->find_index(name, len); -00062 -00063 <span class="keywordflow">if</span> (index >= 0) -00064 { -00065 <span class="keywordflow">if</span> (value) -00066 *value = fArray[index].fValue; -00067 <span class="keywordflow">return</span> <span class="keyword">true</span>; -00068 } -00069 <span class="keywordflow">return</span> <span class="keyword">false</span>; -00070 } -00071 -00072 <span class="keywordtype">bool</span> findKey(T& value, <span class="keyword">const</span> <span class="keywordtype">char</span>** name)<span class="keyword"> const</span> -00073 <span class="keyword"> </span>{ -00074 Pair* end = fArray.end(); -00075 <span class="keywordflow">for</span> (Pair* pair = fArray.begin(); pair < end; pair++) { -00076 <span class="keywordflow">if</span> (pair->fValue != value) -00077 continue; -00078 *name = pair->fName; -00079 return true; -00080 } -00081 return false; -00082 } -00083 -00084 public: -00085 struct Pair { -00086 <span class="keyword">const</span> <span class="keywordtype">char</span>* fName; -00087 T fValue; -00088 -00089 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator<(<span class="keyword">const</span> Pair& a, <span class="keyword">const</span> Pair& b) -00090 { -00091 <span class="keywordflow">return</span> strcmp(a.fName, b.fName); -00092 } -00093 <span class="keyword">friend</span> <span class="keywordtype">int</span> operator!=(<span class="keyword">const</span> Pair& a, <span class="keyword">const</span> Pair& b) -00094 { -00095 <span class="keywordflow">return</span> strcmp(a.fName, b.fName); -00096 } -00097 }; -00098 <span class="keyword">friend</span> <span class="keyword">class </span>Iter; -00099 -00100 <span class="keyword">public</span>: -00101 <span class="keyword">class </span>Iter { -00102 <span class="keyword">public</span>: -00103 Iter(<span class="keyword">const</span> SkTDict<T>& dict) -00104 { -00105 fIter = dict.fArray.begin(); -00106 fStop = dict.fArray.end(); -00107 } -00108 <span class="keyword">const</span> <span class="keywordtype">char</span>* next(T* value) -00109 { -00110 <span class="keyword">const</span> <span class="keywordtype">char</span>* name = nil; -00111 <span class="keywordflow">if</span> (fIter < fStop) -00112 { -00113 name = fIter->fName; -00114 <span class="keywordflow">if</span> (value) -00115 *value = fIter->fValue; -00116 fIter += 1; -00117 } -00118 <span class="keywordflow">return</span> name; -00119 } -00120 <span class="keyword">private</span>: -00121 Pair* fIter; -00122 Pair* fStop; -00123 }; -00124 -00125 <span class="keyword">private</span>: -00126 SkTDArray<Pair> fArray; -00127 SkChunkAlloc fStrings; -00128 -00129 <span class="keywordtype">int</span> find_index(<span class="keyword">const</span> <span class="keywordtype">char</span> name[])<span class="keyword"> const</span> -00130 <span class="keyword"> </span>{ -00131 <span class="keywordflow">return</span> find_index(name, strlen(name)); -00132 } -00133 -00134 <span class="keywordtype">int</span> find_index(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], size_t len)<span class="keyword"> const</span> -00135 <span class="keyword"> </span>{ -00136 SkASSERT(name); -00137 -00138 <span class="keywordtype">int</span> count = fArray.count(); -00139 <span class="keywordtype">int</span> index = ~0; -00140 -00141 <span class="keywordflow">if</span> (count) -00142 index = SkStrSearch(&fArray.begin()->fName, count, name, len, sizeof(Pair)); -00143 return index; -00144 } -00145 friend class Iter; -00146 }; -00147 -00148 #endif -00149 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTSearch_8h-source.html b/sgl_doxygen/html/SkTSearch_8h-source.html deleted file mode 100644 index ff73350..0000000 --- a/sgl_doxygen/html/SkTSearch_8h-source.html +++ /dev/null @@ -1,67 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTSearch.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTSearch.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTSearch_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTSearch_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="keyword">template</span> <<span class="keyword">typename</span> T> -00007 <span class="keywordtype">int</span> SkTSearch(<span class="keyword">const</span> T* base, <span class="keywordtype">int</span> count, T target, size_t elemSize) -00008 { -00009 SkASSERT(base != nil); -00010 SkASSERT(count >= 0); -00011 -00012 <span class="keywordflow">if</span> (count <= 0) -00013 return ~0; -00014 -00015 <span class="keywordtype">int</span> lo = 0; -00016 <span class="keywordtype">int</span> hi = count - 1; -00017 -00018 while (lo < hi) -00019 { -00020 <span class="keywordtype">int</span> mid = (hi + lo) >> 1; -00021 <span class="keyword">const</span> T* elem = (<span class="keyword">const</span> T*)((<span class="keyword">const</span> <span class="keywordtype">char</span>*)base + mid * elemSize); -00022 -00023 <span class="keywordflow">if</span> (*elem < target) -00024 lo = mid + 1; -00025 else -00026 hi = mid; -00027 } -00028 -00029 const T* elem = (const T*)((const <span class="keywordtype">char</span>*)base + hi * elemSize); -00030 if (*elem != target) -00031 { -00032 <span class="keywordflow">if</span> (*elem < target) -00033 hi += 1; -00034 hi = ~hi; -00035 } -00036 return hi; -00037 } -00038 -00039 <span class="keywordtype">int</span> SkStrSearch(const <span class="keywordtype">char</span>*const* base, <span class="keywordtype">int</span> count, const <span class="keywordtype">char</span> target[], size_t target_len, size_t elemSize); -00040 <span class="keywordtype">int</span> SkStrSearch(const <span class="keywordtype">char</span>*const* base, <span class="keywordtype">int</span> count, const <span class="keywordtype">char</span> target[], size_t elemSize); -00041 -00045 <span class="keywordtype">int</span> SkStrLCSearch(const <span class="keywordtype">char</span>*const* base, <span class="keywordtype">int</span> count, const <span class="keywordtype">char</span> target[], size_t target_len, size_t elemSize); -00046 <span class="keywordtype">int</span> SkStrLCSearch(const <span class="keywordtype">char</span>*const* base, <span class="keywordtype">int</span> count, const <span class="keywordtype">char</span> target[], size_t elemSize); -00047 -00048 extern "C" { -00049 <span class="keyword">typedef</span> int (*SkQSortCompareProc)(<span class="keyword">const</span> <span class="keywordtype">void</span>*, <span class="keyword">const</span> <span class="keywordtype">void</span>*); -00050 <span class="keywordtype">void</span> SkQSort(<span class="keywordtype">void</span>* base, size_t count, size_t elemSize, SkQSortCompareProc); -00051 } -00052 -00053 SkDEBUGCODE(<span class="keywordtype">void</span> SkQSort_UnitTest();) -00054 -00055 #endif -00056 -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTextBox_8h-source.html b/sgl_doxygen/html/SkTextBox_8h-source.html deleted file mode 100644 index 1b18609..0000000 --- a/sgl_doxygen/html/SkTextBox_8h-source.html +++ /dev/null @@ -1,64 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTextBox.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTextBox.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTextBox_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTextBox_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkCanvas.h"</span> -00005 -<a name="l00017"></a><a class="code" href="classSkTextBox.html">00017</a> <span class="keyword">class </span><a class="code" href="classSkTextBox.html">SkTextBox</a> { -00018 <span class="keyword">public</span>: -00019 <a class="code" href="classSkTextBox.html">SkTextBox</a>(); -00020 -00021 <span class="keyword">enum</span> Mode { -00022 kOneLine_Mode, -00023 kLineBreak_Mode, -00024 -00025 kModeCount -00026 }; -00027 Mode getMode()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Mode)fMode; } -00028 <span class="keywordtype">void</span> setMode(Mode); -00029 -00030 <span class="keyword">enum</span> SpacingAlign { -00031 kStart_SpacingAlign, -00032 kCenter_SpacingAlign, -00033 kEnd_SpacingAlign, -00034 -00035 kSpacingAlignCount -00036 }; -00037 SpacingAlign getSpacingAlign()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (SpacingAlign)fSpacingAlign; } -00038 <span class="keywordtype">void</span> setSpacingAlign(SpacingAlign); -00039 -00040 <span class="keywordtype">void</span> getBox(SkRect*) <span class="keyword">const</span>; -00041 <span class="keywordtype">void</span> setBox(<span class="keyword">const</span> SkRect&); -00042 <span class="keywordtype">void</span> setBox(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom); -00043 -00044 <span class="keywordtype">void</span> getSpacing(SkScalar* mul, SkScalar* add) <span class="keyword">const</span>; -00045 <span class="keywordtype">void</span> setSpacing(SkScalar mul, SkScalar add); -00046 -00047 <span class="keywordtype">void</span> draw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*, <span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&); -00048 -00049 <span class="keyword">private</span>: -00050 SkRect fBox; -00051 SkScalar fSpacingMul, fSpacingAdd; -00052 U8 fMode, fSpacingAlign; -00053 }; -00054 -00055 <span class="keyword">class </span>SkTextLineBreaker { -00056 <span class="keyword">public</span>: -00057 <span class="keyword">static</span> <span class="keywordtype">int</span> CountLines(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len, <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>&, SkScalar width); -00058 }; -00059 -00060 <span class="preprocessor">#endif</span> -00061 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTime_8h-source.html b/sgl_doxygen/html/SkTime_8h-source.html deleted file mode 100644 index 5247e21..0000000 --- a/sgl_doxygen/html/SkTime_8h-source.html +++ /dev/null @@ -1,43 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTime.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTime.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTime_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTime_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -<a name="l00009"></a><a class="code" href="classSkTime.html">00009</a> <span class="keyword">class </span><a class="code" href="classSkTime.html">SkTime</a> { -00010 <span class="keyword">public</span>: -00011 <span class="keyword">struct </span>DateTime { -00012 U16 fYear; -00013 U8 fMonth; -00014 U8 fDayOfWeek; -00015 U8 fDay; -00016 U8 fHour; -00017 U8 fMinute; -00018 U8 fSecond; -00019 }; -00020 <span class="keyword">static</span> <span class="keywordtype">void</span> GetDateTime(DateTime*); -00021 -00022 <span class="keyword">static</span> SkMSec GetMSecs(); -00023 }; -00024 -00025 <span class="preprocessor">#if defined(SK_DEBUG) && defined(SK_BUILD_FOR_WIN32)</span> -00026 <span class="preprocessor"></span> <span class="keyword">extern</span> SkMSec gForceTickCount; -00027 <span class="preprocessor">#endif</span> -00028 <span class="preprocessor"></span> -00029 <span class="preprocessor">#define SK_TIME_FACTOR 1</span> -00030 <span class="preprocessor"></span> -00031 <span class="preprocessor">#endif</span> -00032 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkTransparentShader_8h-source.html b/sgl_doxygen/html/SkTransparentShader_8h-source.html deleted file mode 100644 index 1f46ac2..0000000 --- a/sgl_doxygen/html/SkTransparentShader_8h-source.html +++ /dev/null @@ -1,37 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTransparentShader.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkTransparentShader.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkTransparentShader_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkTransparentShader_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkShader.h"</span> -00005 -00006 <span class="keyword">class </span>SkTransparentShader : <span class="keyword">public</span> <a class="code" href="classSkShader.html">SkShader</a> { -00007 <span class="keyword">public</span>: -00008 <span class="keyword">virtual</span> U32 <a class="code" href="classSkShader.html#a4">getFlags</a>(); -00009 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkShader.html#a5">setContext</a>( <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& device, -00010 <span class="keyword">const</span> <a class="code" href="classSkPaint.html">SkPaint</a>& paint, -00011 <span class="keyword">const</span> SkMatrix& matrix); -00012 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a6">shadeSpan</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, SkPMColor[], <span class="keywordtype">int</span> count); -00013 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkShader.html#a7">shadeSpanOpaque16</a>(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, U16 span[], <span class="keywordtype">int</span> count); -00014 -00015 <span class="keyword">private</span>: -00016 <a class="code" href="classSkBitmap.html">SkBitmap</a> fDevice; -00017 U8 fAlpha; -00018 -00019 <span class="keyword">typedef</span> <a class="code" href="classSkShader.html">SkShader</a> INHERITED; -00020 }; -00021 -00022 <span class="preprocessor">#endif</span> -00023 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkUnitMapper_8h-source.html b/sgl_doxygen/html/SkUnitMapper_8h-source.html deleted file mode 100644 index 322f557..0000000 --- a/sgl_doxygen/html/SkUnitMapper_8h-source.html +++ /dev/null @@ -1,43 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkUnitMapper.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkUnitMapper.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkUnitMapper_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkUnitMapper_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkRefCnt.h"</span> -00005 <span class="preprocessor">#include "SkScalar.h"</span> -00006 -00007 <span class="keyword">class </span>SkUnitMapper : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00008 <span class="keyword">public</span>: -00011 <span class="keyword">virtual</span> U16CPU mapUnit16(U16CPU x) = 0; -00012 }; -00013 -<a name="l00016"></a><a class="code" href="classSkDiscreteMapper.html">00016</a> <span class="keyword">class </span><a class="code" href="classSkDiscreteMapper.html">SkDiscreteMapper</a> : <span class="keyword">public</span> SkUnitMapper { -00017 <span class="keyword">public</span>: -00018 <a class="code" href="classSkDiscreteMapper.html">SkDiscreteMapper</a>(<span class="keywordtype">unsigned</span> segments); -00019 <span class="comment">// override</span> -00020 <span class="keyword">virtual</span> U16CPU mapUnit16(U16CPU x); -00021 <span class="keyword">private</span>: -00022 <span class="keywordtype">unsigned</span> fSegments; -00023 SkFract fScale; -00024 }; -00025 -<a name="l00028"></a><a class="code" href="classSkFlipCosineMapper.html">00028</a> <span class="keyword">class </span><a class="code" href="classSkFlipCosineMapper.html">SkFlipCosineMapper</a> : <span class="keyword">public</span> SkUnitMapper { -00029 <span class="keyword">public</span>: -00030 <span class="comment">// override</span> -00031 <span class="keyword">virtual</span> U16CPU mapUnit16(U16CPU x); -00032 }; -00033 -00034 <span class="preprocessor">#endif</span> -00035 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkUtils_8h-source.html b/sgl_doxygen/html/SkUtils_8h-source.html deleted file mode 100644 index a30cd11..0000000 --- a/sgl_doxygen/html/SkUtils_8h-source.html +++ /dev/null @@ -1,83 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkUtils.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkUtils.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkUtils_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkUtils_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTypes.h"</span> -00005 -00006 <span class="preprocessor">#ifdef FMS_ARCH_ANDROID_ARM</span> -00007 <span class="preprocessor"></span><span class="preprocessor"> #include "utils/memory.h"</span> -00008 -00009 <span class="preprocessor"> #define SK_MEMSET16_REDIRECT(dst, value, count) android_memset16(dst, value, (count) << 1)</span> -00010 <span class="preprocessor"></span><span class="preprocessor"> #define SK_MEMSET32_REDIRECT(dst, value, count) android_memset32(dst, value, (count) << 2)</span> -00011 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00012 <span class="preprocessor"></span> -00014 -00015 <span class="preprocessor">#ifdef SK_MEMSET16_REDIRECT</span> -00016 <span class="preprocessor"></span><span class="preprocessor"> #define sk_memset16(dst, value, count) SK_MEMSET16_REDIRECT(dst, value, count)</span> -00017 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00018 <span class="preprocessor"></span> -00023 <span class="keywordtype">void</span> sk_memset16(uint16_t dst[], U16CPU value, <span class="keywordtype">int</span> count); -00024 <span class="preprocessor">#endif</span> -00025 <span class="preprocessor"></span> -00026 <span class="preprocessor">#ifdef SK_MEMSET32_REDIRECT</span> -00027 <span class="preprocessor"></span><span class="preprocessor"> #define sk_memset32(dst, value, count) SK_MEMSET32_REDIRECT(dst, value, count)</span> -00028 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00029 <span class="preprocessor"></span> -00034 <span class="keywordtype">void</span> sk_memset32(uint32_t dst[], uint32_t value, <span class="keywordtype">int</span> count); -00035 <span class="preprocessor">#endif</span> -00036 <span class="preprocessor"></span> -00037 -00039 -00040 <span class="preprocessor">#define kMaxBytesInUTF8Sequence 4</span> -00041 <span class="preprocessor"></span> -00042 <span class="preprocessor">#ifdef SK_DEBUG</span> -00043 <span class="preprocessor"></span> <span class="keywordtype">int</span> SkUTF8_LeadByteToCount(<span class="keywordtype">unsigned</span> c); -00044 <span class="preprocessor">#else</span> -00045 <span class="preprocessor"></span><span class="preprocessor"> #define SkUTF8_LeadByteToCount(c) ((((0xE5 << 24) >> ((unsigned)c >> 4 << 1)) & 3) + 1)</span> -00046 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00047 <span class="preprocessor"></span> -00048 <span class="keyword">inline</span> <span class="keywordtype">int</span> SkUTF8_CountUTF8Bytes(<span class="keyword">const</span> <span class="keywordtype">char</span> utf8[]) -00049 { -00050 SkASSERT(utf8); -00051 <span class="keywordflow">return</span> SkUTF8_LeadByteToCount(*(<span class="keyword">const</span> uint8_t*)utf8); -00052 } -00053 -00054 <span class="keywordtype">int</span> SkUTF8_CountUnichars(<span class="keyword">const</span> <span class="keywordtype">char</span> utf8[]); -00055 SkUnichar SkUTF8_ToUnichar(<span class="keyword">const</span> <span class="keywordtype">char</span> utf8[]); -00056 SkUnichar SkUTF8_NextUnichar(<span class="keyword">const</span> <span class="keywordtype">char</span>**); -00057 -00062 size_t SkUTF8_FromUnichar(SkUnichar uni, <span class="keywordtype">char</span> utf8[] = nil); -00063 -00065 -00066 <span class="preprocessor">#define SkUTF16_IsHighSurrogate(c) (((c) & 0xFC00) == 0xD800)</span> -00067 <span class="preprocessor"></span><span class="preprocessor">#define SkUTF16_IsLowSurrogate(c) (((c) & 0xFC00) == 0xDC00)</span> -00068 <span class="preprocessor"></span> -00069 <span class="keywordtype">int</span> SkUTF16_CountUnichars(<span class="keyword">const</span> uint16_t utf16[]); -00070 <span class="keywordtype">int</span> SkUTF16_CountUnichars(<span class="keyword">const</span> uint16_t utf16[], <span class="keywordtype">int</span> numberOf16BitValues); -00071 SkUnichar SkUTF16_NextUnichar(<span class="keyword">const</span> U16**); -00072 size_t SkUTF16_FromUnichar(SkUnichar uni, uint16_t utf16[] = nil); -00073 -00074 size_t SkUTF16_ToUTF8(<span class="keyword">const</span> uint16_t utf16[], <span class="keywordtype">int</span> numberOf16BitValues, <span class="keywordtype">char</span> utf8[] = nil); -00075 -00076 <span class="keyword">class </span>SkUtils { -00077 <span class="keyword">public</span>: -00078 <span class="preprocessor">#ifdef SK_DEBUG</span> -00079 <span class="preprocessor"></span> <span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest(); -00080 <span class="preprocessor">#endif</span> -00081 <span class="preprocessor"></span>}; -00082 -00083 <span class="preprocessor">#endif</span> -00084 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkViewInflate_8h-source.html b/sgl_doxygen/html/SkViewInflate_8h-source.html deleted file mode 100644 index 40a8449..0000000 --- a/sgl_doxygen/html/SkViewInflate_8h-source.html +++ /dev/null @@ -1,65 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkViewInflate.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkViewInflate.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkViewInflate_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkViewInflate_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkDOM.h"</span> -00005 <span class="preprocessor">#include "SkTDict.h"</span> -00006 <span class="preprocessor">#include "SkEvent.h"</span> -00007 -00008 <span class="keyword">class </span><a class="code" href="classSkView.html">SkView</a>; -00009 -00010 <span class="keyword">class </span>SkViewInflate { -00011 <span class="keyword">public</span>: -00012 SkViewInflate(); -00013 <span class="keyword">virtual</span> ~SkViewInflate(); -00014 -00020 <a class="code" href="classSkView.html">SkView</a>* inflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node, <a class="code" href="classSkView.html">SkView</a>* root = nil); -00021 <a class="code" href="classSkView.html">SkView</a>* inflate(<span class="keyword">const</span> <span class="keywordtype">char</span> xml[], size_t len, <a class="code" href="classSkView.html">SkView</a>* root = nil); -00022 -00026 <a class="code" href="classSkView.html">SkView</a>* findViewByID(<span class="keyword">const</span> <span class="keywordtype">char</span> <span class="keywordtype">id</span>[]) <span class="keyword">const</span>; -00027 -00028 SkDEBUGCODE(<span class="keywordtype">void</span> dump() <span class="keyword">const</span>;) -00029 -00030 <span class="keyword">protected</span>: -00031 <span class="comment">/* Override this in your subclass to handle instantiating views</span> -00032 <span class="comment"> Call the inherited version for nodes you don't recognize.</span> -00033 <span class="comment"></span> -00034 <span class="comment"> Do not call "inflate" on the view, just return it. This will</span> -00035 <span class="comment"> get called automatically after createView returns.</span> -00036 <span class="comment"> */</span> -00037 <span class="keyword">virtual</span> <a class="code" href="classSkView.html">SkView</a>* createView(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00042 <span class="keyword">virtual</span> <span class="keywordtype">void</span> inflateView(<a class="code" href="classSkView.html">SkView</a>* view, <span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00043 -00044 <span class="keyword">private</span>: -00045 <span class="keyword">enum</span> { -00046 kMinIDStrAlloc = 64 -00047 }; -00048 SkTDict<SkView*> fIDs; -00049 -00050 <span class="keyword">struct </span>IDStr { -00051 <a class="code" href="classSkView.html">SkView</a>* fView; -00052 <span class="keywordtype">char</span>* fStr; -00053 }; -00054 SkTDArray<IDStr> fListenTo, fBroadcastTo; -00055 SkChunkAlloc fStrings; -00056 -00057 <span class="keywordtype">void</span> addIDStr(SkTDArray<IDStr>* list, <a class="code" href="classSkView.html">SkView</a>*, <span class="keyword">const</span> <span class="keywordtype">char</span>* str); -00058 -00059 <span class="keywordtype">void</span> rInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node, <a class="code" href="classSkView.html">SkView</a>* parent); -00060 }; -00061 -00062 <span class="preprocessor">#endif</span> -00063 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkView_8h-source.html b/sgl_doxygen/html/SkView_8h-source.html deleted file mode 100644 index ec14259..0000000 --- a/sgl_doxygen/html/SkView_8h-source.html +++ /dev/null @@ -1,227 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkView.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkView.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkView_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkView_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkEventSink.h"</span> -00005 <span class="preprocessor">#include "SkRect.h"</span> -00006 <span class="preprocessor">#include "SkDOM.h"</span> -00007 <span class="preprocessor">#include "SkTDict.h"</span> -00008 -00009 <span class="keyword">class </span><a class="code" href="classSkCanvas.html">SkCanvas</a>; -00010 <span class="keyword">class </span>SkLayerView; -00011 -<a name="l00017"></a><a class="code" href="classSkView.html">00017</a> <span class="keyword">class </span><a class="code" href="classSkView.html">SkView</a> : <span class="keyword">public</span> <a class="code" href="classSkEventSink.html">SkEventSink</a> { -00018 <span class="keyword">public</span>: -00019 <span class="keyword">enum</span> Flag_Shift { -00020 kVisible_Shift, -00021 kEnabled_Shift, -00022 kFocusable_Shift, -00023 kFlexH_Shift, -00024 kFlexV_Shift, -00025 -00026 kFlagShiftCount -00027 }; -<a name="l00028"></a><a class="code" href="classSkView.html#w16">00028</a> <span class="keyword">enum</span> <a class="code" href="classSkView.html#w16">Flag_Mask</a> { -00029 <a class="code" href="classSkView.html#w16w6">kVisible_Mask</a> = 1 << kVisible_Shift, -00030 <a class="code" href="classSkView.html#w16w7">kEnabled_Mask</a> = 1 << kEnabled_Shift, -00031 <a class="code" href="classSkView.html#w16w8">kFocusable_Mask</a> = 1 << kFocusable_Shift, -00032 <a class="code" href="classSkView.html#w16w9">kFlexH_Mask</a> = 1 << kFlexH_Shift, -00033 <a class="code" href="classSkView.html#w16w10">kFlexV_Mask</a> = 1 << kFlexV_Shift, -00034 -00035 kAllFlagMasks = (U32)(0 - 1) >> (32 - kFlagShiftCount) -00036 }; -00037 -00038 <a class="code" href="classSkView.html">SkView</a>(U32 flags = 0); -00039 <span class="keyword">virtual</span> ~<a class="code" href="classSkView.html">SkView</a>(); -00040 -<a name="l00043"></a><a class="code" href="classSkView.html#a2">00043</a> U32 <a class="code" href="classSkView.html#a2">getFlags</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFlags; } -00046 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a3">setFlags</a>(U32 flags); -00047 -<a name="l00050"></a><a class="code" href="classSkView.html#a4">00050</a> <span class="keywordtype">int</span> <a class="code" href="classSkView.html#a4">isVisible</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFlags & <a class="code" href="classSkView.html#w16w6">kVisible_Mask</a>; } -00051 <span class="keywordtype">int</span> isEnabled()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFlags & kEnabled_Mask; } -00052 <span class="keywordtype">int</span> isFocusable()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fFlags & <a class="code" href="classSkView.html#w16w8">kFocusable_Mask</a>; } -00054 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a7">setVisibleP</a>(<span class="keywordtype">bool</span>); -00055 <span class="keywordtype">void</span> setEnabledP(<span class="keywordtype">bool</span>); -00056 <span class="keywordtype">void</span> setFocusableP(<span class="keywordtype">bool</span>); -00057 -<a name="l00059"></a><a class="code" href="classSkView.html#a10">00059</a> SkScalar <a class="code" href="classSkView.html#a10">width</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fWidth; } -<a name="l00061"></a><a class="code" href="classSkView.html#a11">00061</a> SkScalar <a class="code" href="classSkView.html#a11">height</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fHeight; } -00063 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a12">setSize</a>(SkScalar width, SkScalar height); -00064 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a12">setSize</a>(<span class="keyword">const</span> SkPoint& size) { this-><a class="code" href="classSkView.html#a12">setSize</a>(size.fX, size.fY); } -00065 <span class="keywordtype">void</span> setWidth(SkScalar width) { this-><a class="code" href="classSkView.html#a12">setSize</a>(width, fHeight); } -00066 <span class="keywordtype">void</span> setHeight(SkScalar height) { this-><a class="code" href="classSkView.html#a12">setSize</a>(fWidth, height); } -00068 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a16">getLocalBounds</a>(SkRect* bounds) <span class="keyword">const</span>; -00069 -<a name="l00071"></a><a class="code" href="classSkView.html#a17">00071</a> SkScalar <a class="code" href="classSkView.html#a17">locX</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fLoc.fX; } -<a name="l00073"></a><a class="code" href="classSkView.html#a18">00073</a> SkScalar <a class="code" href="classSkView.html#a18">locY</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fLoc.fY; } -00075 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a19">setLoc</a>(SkScalar x, SkScalar y); -00076 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a19">setLoc</a>(<span class="keyword">const</span> SkPoint& loc) { this-><a class="code" href="classSkView.html#a19">setLoc</a>(loc.fX, loc.fY); } -00077 <span class="keywordtype">void</span> setLocX(SkScalar x) { this-><a class="code" href="classSkView.html#a19">setLoc</a>(x, fLoc.fY); } -00078 <span class="keywordtype">void</span> setLocY(SkScalar y) { this-><a class="code" href="classSkView.html#a19">setLoc</a>(fLoc.fX, y); } -00080 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a23">offset</a>(SkScalar dx, SkScalar dy); -00081 -00083 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a24">draw</a>(<a class="code" href="classSkCanvas.html">SkCanvas</a>* canvas); -00088 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a25">inval</a>(SkRect* rectOrNil); -00089 -00090 <span class="comment">// Focus management</span> -00091 -00092 <a class="code" href="classSkView.html">SkView</a>* getFocusView() <span class="keyword">const</span>; -00093 <span class="keywordtype">bool</span> hasFocus() <span class="keyword">const</span>; -00094 -00095 <span class="keyword">enum</span> FocusDirection { -00096 kNext_FocusDirection, -00097 kPrev_FocusDirection, -00098 -00099 kFocusDirectionCount -00100 }; -00101 <span class="keywordtype">bool</span> acceptFocus(); -00102 <a class="code" href="classSkView.html">SkView</a>* moveFocus(FocusDirection); -00103 -00104 <span class="comment">// Click handling</span> -00105 -00106 <span class="keyword">class </span>Click { -00107 <span class="keyword">public</span>: -00108 Click(<a class="code" href="classSkView.html">SkView</a>* target); -00109 <span class="keyword">virtual</span> ~Click(); -00110 -00111 <span class="keyword">const</span> <span class="keywordtype">char</span>* getType()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fType; } -00112 <span class="keywordtype">bool</span> isType(<span class="keyword">const</span> <span class="keywordtype">char</span> type[]) <span class="keyword">const</span>; -00113 <span class="keywordtype">void</span> setType(<span class="keyword">const</span> <span class="keywordtype">char</span> type[]); <span class="comment">// does NOT make a copy of the string</span> -00114 <span class="keywordtype">void</span> copyType(<span class="keyword">const</span> <span class="keywordtype">char</span> type[]); <span class="comment">// makes a copy of the string</span> -00115 -00116 <span class="keyword">enum</span> State { -00117 kDown_State, -00118 kMoved_State, -00119 kUp_State -00120 }; -00121 SkPoint fOrig, fPrev, fCurr; -00122 SkIPoint fIOrig, fIPrev, fICurr; -00123 State fState; -00124 <span class="keyword">private</span>: -00125 SkEventSinkID fTargetID; -00126 <span class="keywordtype">char</span>* fType; -00127 <span class="keywordtype">bool</span> fWeOwnTheType; -00128 -00129 <span class="keywordtype">void</span> resetType(); -00130 -00131 <span class="keyword">friend</span> <span class="keyword">class </span><a class="code" href="classSkView.html">SkView</a>; -00132 }; -00133 Click* findClickHandler(SkScalar x, SkScalar y); -00134 -00135 <span class="keyword">static</span> <span class="keywordtype">void</span> DoClickDown(Click*, <span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y); -00136 <span class="keyword">static</span> <span class="keywordtype">void</span> DoClickMoved(Click*, <span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y); -00137 <span class="keyword">static</span> <span class="keywordtype">void</span> DoClickUp(Click*, <span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y); -00138 -00143 <a class="code" href="classSkView.html">SkView</a>* <a class="code" href="classSkView.html#a31">sendEventToParents</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -<a name="l00146"></a><a class="code" href="classSkView.html#a32">00146</a> <span class="keywordtype">bool</span> <a class="code" href="classSkView.html#a32">postEvent</a>(<a class="code" href="classSkEvent.html">SkEvent</a>* evt, SkEventSinkID sinkID, SkMSec delay) { <span class="keywordflow">return</span> evt->post(sinkID, delay); } -00147 -00148 <span class="comment">// View hierarchy management</span> -00149 -<a name="l00151"></a><a class="code" href="classSkView.html#a33">00151</a> <a class="code" href="classSkView.html">SkView</a>* <a class="code" href="classSkView.html#a33">getParent</a>()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fParent; } -00152 <a class="code" href="classSkView.html">SkView</a>* attachChildToFront(<a class="code" href="classSkView.html">SkView</a>* child); -00157 <a class="code" href="classSkView.html">SkView</a>* <a class="code" href="classSkView.html#a35">attachChildToBack</a>(<a class="code" href="classSkView.html">SkView</a>* child); -00161 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a36">detachFromParent</a>(); -00167 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a37">detachAllChildren</a>(); -00168 -<a name="l00171"></a><a class="code" href="classSkView.html#a38">00171</a> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a38">globalToLocal</a>(SkPoint* pt)<span class="keyword"> const </span>{ <span class="keywordflow">if</span> (pt) this-><a class="code" href="classSkView.html#a38">globalToLocal</a>(pt->fX, pt->fY, pt); } -00175 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a38">globalToLocal</a>(SkScalar globalX, SkScalar globalY, SkPoint* local) <span class="keyword">const</span>; -00176 -<a name="l00184"></a><a class="code" href="classSkView_1_1F2BIter.html">00184</a> <span class="keyword">class </span><a class="code" href="classSkView_1_1F2BIter.html">F2BIter</a> { -00185 <span class="keyword">public</span>: -00186 <a class="code" href="classSkView_1_1F2BIter.html">F2BIter</a>(<span class="keyword">const</span> <a class="code" href="classSkView.html">SkView</a>* parent); -00187 <a class="code" href="classSkView.html">SkView</a>* next(); -00188 <span class="keyword">private</span>: -00189 <a class="code" href="classSkView.html">SkView</a>* fFirstChild, *fChild; -00190 }; -00191 -<a name="l00199"></a><a class="code" href="classSkView_1_1B2FIter.html">00199</a> <span class="keyword">class </span><a class="code" href="classSkView_1_1B2FIter.html">B2FIter</a> { -00200 <span class="keyword">public</span>: -00201 <a class="code" href="classSkView_1_1B2FIter.html">B2FIter</a>(<span class="keyword">const</span> <a class="code" href="classSkView.html">SkView</a>* parent); -00202 <a class="code" href="classSkView.html">SkView</a>* next(); -00203 <span class="keyword">private</span>: -00204 <a class="code" href="classSkView.html">SkView</a>* fFirstChild, *fChild; -00205 }; -00206 -<a name="l00213"></a><a class="code" href="classSkView_1_1Artist.html">00213</a> <span class="keyword">class </span><a class="code" href="classSkView_1_1Artist.html">Artist</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00214 <span class="keyword">public</span>: -00215 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a24">draw</a>(<a class="code" href="classSkView.html">SkView</a>*, <a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00216 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a45">inflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00217 <span class="keyword">protected</span>: -00218 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkView.html">SkView</a>*, <a class="code" href="classSkCanvas.html">SkCanvas</a>*) = 0; -00219 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00220 }; -00224 <a class="code" href="classSkView_1_1Artist.html">Artist</a>* <a class="code" href="classSkView.html#a40">getArtist</a>() <span class="keyword">const</span>; -00229 <a class="code" href="classSkView_1_1Artist.html">Artist</a>* <a class="code" href="classSkView.html#a41">setArtist</a>(<a class="code" href="classSkView_1_1Artist.html">Artist</a>* artist); -00230 -<a name="l00237"></a><a class="code" href="classSkView_1_1Layout.html">00237</a> <span class="keyword">class </span><a class="code" href="classSkView_1_1Layout.html">Layout</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00238 <span class="keyword">public</span>: -00239 <span class="keywordtype">void</span> layoutChildren(<a class="code" href="classSkView.html">SkView</a>* parent); -00240 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a45">inflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00241 <span class="keyword">protected</span>: -00242 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onLayoutChildren(<a class="code" href="classSkView.html">SkView</a>* parent) = 0; -00243 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00244 }; -00245 -00249 <a class="code" href="classSkView_1_1Layout.html">Layout</a>* <a class="code" href="classSkView.html#a42">getLayout</a>() <span class="keyword">const</span>; -00254 <a class="code" href="classSkView_1_1Layout.html">Layout</a>* <a class="code" href="classSkView.html#a43">setLayout</a>(<a class="code" href="classSkView_1_1Layout.html">Layout</a>*, <span class="keywordtype">bool</span> invokeLayoutNow = <span class="keyword">true</span>); -00257 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a44">invokeLayout</a>(); -00258 -00261 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a45">inflate</a>(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00269 <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a46">postInflate</a>(<span class="keyword">const</span> SkTDict<SkView*>& ids); -00270 -00271 SkDEBUGCODE(<span class="keywordtype">void</span> dump(<span class="keywordtype">bool</span> recurse) <span class="keyword">const</span>;) -00272 -00273 <span class="keyword">protected</span>: -00275 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00277 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00282 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkView.html#a47">handleInval</a>(<span class="keyword">const</span> SkRect&); -00285 <span class="keyword">virtual</span> Click* <a class="code" href="classSkView.html#a48">onFindClickHandler</a>(SkScalar x, SkScalar y); -00289 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkView.html#a49">onClick</a>(Click*); -00291 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00295 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a51">onPostInflate</a>(<span class="keyword">const</span> SkTDict<SkView*>&); -00296 -00297 <span class="keyword">public</span>: -00298 <span class="comment">// default action is to inval the view</span> -00299 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onFocusChange(<span class="keywordtype">bool</span> gainFocusP); -00300 <span class="keyword">protected</span>: -00301 -00302 <span class="comment">// override these if you're acting as a layer/host</span> -00303 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onGetFocusView(<a class="code" href="classSkView.html">SkView</a>**)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> <span class="keyword">false</span>; } -00304 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onSetFocusView(<a class="code" href="classSkView.html">SkView</a>*) { <span class="keywordflow">return</span> <span class="keyword">false</span>; } -00305 -00306 <span class="keyword">private</span>: -00307 SkScalar fWidth, fHeight; -00308 SkPoint fLoc; -00309 <a class="code" href="classSkView.html">SkView</a>* fParent; -00310 <a class="code" href="classSkView.html">SkView</a>* fFirstChild; -00311 <a class="code" href="classSkView.html">SkView</a>* fNextSibling; -00312 <a class="code" href="classSkView.html">SkView</a>* fPrevSibling; -00313 -00314 U8 fFlags; -00315 U8 fContainsFocus; -00316 -00317 <span class="keyword">friend</span> <span class="keyword">class </span>B2FIter; -00318 <span class="keyword">friend</span> <span class="keyword">class </span>F2BIter; -00319 -00320 <span class="keyword">friend</span> <span class="keyword">class </span>SkLayerView; -00321 -00322 <span class="keywordtype">bool</span> setFocusView(<a class="code" href="classSkView.html">SkView</a>* fvOrNil); -00323 <a class="code" href="classSkView.html">SkView</a>* acceptFocus(FocusDirection); -00324 <span class="keywordtype">void</span> detachFromParent_NoLayout(); -00325 }; -00326 -00327 <span class="preprocessor">#endif</span> -00328 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkWidgetViews_8h-source.html b/sgl_doxygen/html/SkWidgetViews_8h-source.html deleted file mode 100644 index c1abf1f..0000000 --- a/sgl_doxygen/html/SkWidgetViews_8h-source.html +++ /dev/null @@ -1,259 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkWidgetViews.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkWidgetViews.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkWidgetViews_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkWidgetViews_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 -00006 -00007 <span class="keyword">enum</span> SkWidgetEnum { -00008 kBorder_WidgetEnum, -00009 kButton_WidgetEnum, -00010 kImage_WidgetEnum, -00011 kList_WidgetEnum, -00012 kProgress_WidgetEnum, -00013 kScroll_WidgetEnum, -00014 kText_WidgetEnum, -00015 -00016 kWidgetEnumCount -00017 }; -00018 -00019 <span class="comment">//determines which skin to use</span> -00020 <span class="keyword">enum</span> SkinEnum { -00021 kBorder_SkinEnum, -00022 kButton_SkinEnum, -00023 kProgress_SkinEnum, -00024 kScroll_SkinEnum, -00025 kStaticText_SkinEnum, -00026 -00027 kSkinEnumCount -00028 }; -00029 -00030 <span class="preprocessor">#include "SkAnimator.h"</span> -00031 <span class="comment">//used for inflates</span> -00032 <span class="keyword">const</span> <span class="keywordtype">char</span>* get_skin_enum_path(SkinEnum se); -00033 <span class="keywordtype">void</span> init_skin_anim(<span class="keyword">const</span> <span class="keywordtype">char</span> path[], <a class="code" href="classSkAnimator.html">SkAnimator</a>* anim); -00034 <span class="keywordtype">void</span> init_skin_anim(SkinEnum se, <a class="code" href="classSkAnimator.html">SkAnimator</a>* anim); -00035 <span class="keywordtype">void</span> init_skin_paint(SkinEnum se, <a class="code" href="classSkPaint.html">SkPaint</a>* paint); -00036 <span class="keywordtype">void</span> inflate_paint(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node, <a class="code" href="classSkPaint.html">SkPaint</a>* paint); -00037 -00041 <a class="code" href="classSkView.html">SkView</a>* SkWidgetFactory(SkWidgetEnum); -00046 <a class="code" href="classSkView.html">SkView</a>* SkWidgetFactory(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00047 -00049 -00050 <span class="keyword">class </span>SkWidgetView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00051 <span class="keyword">public</span>: -00052 SkWidgetView(); -00053 -00054 <span class="keyword">const</span> <span class="keywordtype">char</span>* getLabel() <span class="keyword">const</span>; -00055 <span class="keywordtype">void</span> getLabel(<a class="code" href="classSkString.html">SkString</a>* label) <span class="keyword">const</span>; -00056 -00057 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <span class="keywordtype">char</span>[]); -00058 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <span class="keywordtype">char</span>[], size_t len); -00059 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00060 -00061 <a class="code" href="classSkEvent.html">SkEvent</a>& event() { <span class="keywordflow">return</span> fEvent; } -00062 <span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>& event()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fEvent; } -00063 -00066 <span class="keywordtype">bool</span> postWidgetEvent(); -00067 -00070 <span class="keyword">static</span> SkEventSinkID GetWidgetEventSinkID(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00071 -00072 <span class="keyword">protected</span>: -00076 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onLabelChange(<span class="keyword">const</span> <span class="keywordtype">char</span> oldLabel[], <span class="keyword">const</span> <span class="keywordtype">char</span> newLabel[]); -00083 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onPrepareWidgetEvent(<a class="code" href="classSkEvent.html">SkEvent</a>* evt); -00084 -00085 <span class="comment">// overrides</span> -00086 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00087 -00088 <span class="keyword">private</span>: -00089 <a class="code" href="classSkString.html">SkString</a> fLabel; -00090 <a class="code" href="classSkEvent.html">SkEvent</a> fEvent; -00091 -00092 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00093 }; -00094 -00096 -00097 <span class="keyword">class </span>SkButtonView : <span class="keyword">public</span> SkWidgetView { -00098 <span class="keyword">public</span>: -00099 <span class="comment">// inflate: "sk-button"</span> -00100 -00101 <span class="keyword">protected</span>: -00102 <span class="comment">// overrides</span> -00103 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00104 }; -00105 -00107 -00108 <span class="keyword">class </span>SkCheckButtonView : <span class="keyword">public</span> SkWidgetView { -00109 <span class="keyword">public</span>: -00110 SkCheckButtonView(); -00111 -00112 <span class="comment">// inflate: "sk-checkbutton"</span> -00113 -00114 <span class="keyword">enum</span> CheckState { -00115 kOff_CheckState, -00116 kOn_CheckState, -00117 kUnknown_CheckState -00118 }; -00119 CheckState getCheckState()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (CheckState)fCheckState; } -00120 <span class="keywordtype">void</span> setCheckState(CheckState); -00121 -00127 static <span class="keywordtype">bool</span> GetWidgetEventCheckState(const <a class="code" href="classSkEvent.html">SkEvent</a>&, CheckState* state); -00128 -00129 protected: -00130 <span class="comment">// called when the check-state is about to change, but before it actually has</span> -00131 virtual <span class="keywordtype">void</span> onCheckStateChange(CheckState oldState, CheckState newState); -00132 -00133 <span class="comment">// overrides</span> -00134 virtual <span class="keywordtype">void</span> onInflate(const SkDOM& dom, const SkDOM::Node*); -00135 virtual <span class="keywordtype">bool</span> onPrepareWidgetEvent(SkEvent* evt); -00136 -00137 private: -00138 U8 fCheckState; -00139 -00140 typedef SkWidgetView INHERITED; -00141 }; -00142 -00144 #include "<a class="code" href="classSkTextBox.html">SkTextBox</a>.h" -00145 -00146 class SkStaticTextView : public <a class="code" href="classSkView.html">SkView</a> { -00147 <span class="keyword">public</span>: -00148 SkStaticTextView(); -00149 <span class="keyword">virtual</span> ~SkStaticTextView(); -00150 -00151 <span class="keyword">enum</span> Mode { -00152 kFixedSize_Mode, -00153 kAutoWidth_Mode, -00154 kAutoHeight_Mode, -00155 -00156 kModeCount -00157 }; -00158 Mode getMode()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Mode)fMode; } -00159 <span class="keywordtype">void</span> setMode(Mode); -00160 -00161 <a class="code" href="classSkTextBox.html">SkTextBox</a>::SpacingAlign getSpacingAlign()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (SkTextBox::SpacingAlign)fSpacingAlign; } -00162 <span class="keywordtype">void</span> setSpacingAlign(<a class="code" href="classSkTextBox.html">SkTextBox</a>::SpacingAlign); -00163 -00164 <span class="keywordtype">void</span> getMargin(SkPoint* margin) const; -00165 <span class="keywordtype">void</span> setMargin(SkScalar dx, SkScalar dy); -00166 -00167 size_t getText(<a class="code" href="classSkString.html">SkString</a>* text = nil) const; -00168 size_t getText(<span class="keywordtype">char</span> text[] = nil) const; -00169 <span class="keywordtype">void</span> setText(const <a class="code" href="classSkString.html">SkString</a>&); -00170 <span class="keywordtype">void</span> setText(const <span class="keywordtype">char</span> text[]); -00171 <span class="keywordtype">void</span> setText(const <span class="keywordtype">char</span> text[], size_t len); -00172 -00173 <span class="keywordtype">void</span> getPaint(<a class="code" href="classSkPaint.html">SkPaint</a>*) const; -00174 <span class="keywordtype">void</span> setPaint(const <a class="code" href="classSkPaint.html">SkPaint</a>&); -00175 -00176 protected: -00177 <span class="comment">// overrides</span> -00178 virtual <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00179 virtual <span class="keywordtype">void</span> onInflate(const SkDOM& dom, const SkDOM::Node*); -00180 -00181 private: -00182 SkPoint fMargin; -00183 SkString fText; -00184 SkPaint fPaint; -00185 U8 fMode; -00186 U8 fSpacingAlign; -00187 -00188 <span class="keywordtype">void</span> computeSize(); -00189 -00190 typedef SkView INHERITED; -00191 }; -00192 -00194 -00195 class <a class="code" href="classSkAnimator.html">SkAnimator</a>; -00196 class SkListSource; -00197 class SkScrollBarView; -00198 -00199 class SkListView : public SkWidgetView { -00200 <span class="keyword">public</span>: -00201 SkListView(); -00202 <span class="keyword">virtual</span> ~SkListView(); -00203 -00204 <span class="keywordtype">bool</span> hasScrollBar()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fScrollBar != nil; } -00205 <span class="keywordtype">void</span> setHasScrollBar(<span class="keywordtype">bool</span>); -00206 -00209 <span class="keywordtype">int</span> getVisibleRowCount()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fVisibleRowCount; } -00212 <span class="keywordtype">int</span> getSelection()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCurrIndex; } -00215 <span class="keywordtype">void</span> setSelection(<span class="keywordtype">int</span>); -00220 <span class="keywordtype">bool</span> moveSelectionUp(); -00225 <span class="keywordtype">bool</span> moveSelectionDown(); -00226 -00227 SkListSource* getListSource()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fSource; } -00228 SkListSource* setListSource(SkListSource*); -00229 -00234 <span class="keyword">static</span> <span class="keywordtype">int</span> GetWidgetEventListIndex(<span class="keyword">const</span> SkEvent&); -00235 -00236 <span class="keyword">protected</span>: -00237 <span class="comment">// overrides</span> -00238 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(SkCanvas*); -00239 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00240 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> SkEvent&); -00241 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00242 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onPrepareWidgetEvent(SkEvent*); -00243 -00244 <span class="keyword">private</span>: -00245 <span class="keyword">enum</span> DirtyFlags { -00246 kAnimCount_DirtyFlag = 0x01, -00247 kAnimContent_DirtyFlag = 0x02 -00248 }; -00249 <span class="keywordtype">void</span> dirtyCache(<span class="keywordtype">unsigned</span> dirtyFlags); -00250 <span class="keywordtype">bool</span> ensureCache(); -00251 -00252 <span class="keywordtype">int</span> logicalToVisualIndex(<span class="keywordtype">int</span> index)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> index - fScrollIndex; } -00253 <span class="keywordtype">void</span> invalSelection(); -00254 SkScalar getContentWidth() <span class="keyword">const</span>; -00255 <span class="keywordtype">bool</span> getRowRect(<span class="keywordtype">int</span> index, SkRect*) <span class="keyword">const</span>; -00256 <span class="keywordtype">void</span> ensureSelectionIsVisible(); -00257 <span class="keywordtype">void</span> ensureVisibleRowCount(); -00258 -00259 <span class="keyword">struct </span>BindingRec; -00260 -00261 <span class="keyword">enum</span> Heights { -00262 kNormal_Height, -00263 kSelected_Height -00264 }; -00265 SkListSource* fSource; -00266 SkScrollBarView* fScrollBar; -00267 SkAnimator* fAnims; -00268 BindingRec* fBindings; -00269 SkString fSkinName; -00270 SkScalar fHeights[2]; -00271 S16 fScrollIndex, fCurrIndex; -00272 U16 fVisibleRowCount, fBindingCount; -00273 SkBool8 fAnimContentDirty; -00274 SkBool8 fAnimFocusDirty; -00275 -00276 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00277 }; -00278 -00279 <span class="keyword">class </span>SkListSource : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00280 <span class="keyword">public</span>: -00281 <span class="keyword">virtual</span> <span class="keywordtype">int</span> countFields(); -00282 <span class="keyword">virtual</span> <span class="keywordtype">void</span> getFieldName(<span class="keywordtype">int</span> index, <a class="code" href="classSkString.html">SkString</a>* field); -00284 <span class="keyword">virtual</span> <span class="keywordtype">int</span> findFieldIndex(<span class="keyword">const</span> <span class="keywordtype">char</span> field[]); -00285 -00286 <span class="keyword">virtual</span> <span class="keywordtype">int</span> countRecords(); -00287 <span class="keyword">virtual</span> <span class="keywordtype">void</span> getRecord(<span class="keywordtype">int</span> rowIndex, <span class="keywordtype">int</span> fieldIndex, <a class="code" href="classSkString.html">SkString</a>* data); -00288 -00289 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> prepareWidgetEvent(SkEvent*, <span class="keywordtype">int</span> rowIndex); -00290 -00291 <span class="keyword">static</span> SkListSource* Factory(<span class="keyword">const</span> <span class="keywordtype">char</span> name[]); -00292 }; -00293 -00294 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkWidget_8h-source.html b/sgl_doxygen/html/SkWidget_8h-source.html deleted file mode 100644 index 3216eea..0000000 --- a/sgl_doxygen/html/SkWidget_8h-source.html +++ /dev/null @@ -1,454 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkWidget.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkWidget.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkWidget_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkWidget_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkBitmap.h"</span> -00006 <span class="preprocessor">#include "SkDOM.h"</span> -00007 <span class="preprocessor">#include "SkPaint.h"</span> -00008 <span class="preprocessor">#include "SkString.h"</span> -00009 <span class="preprocessor">#include "SkTDArray.h"</span> -00010 -00012 -00013 <span class="keyword">class </span>SkWidget : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00014 <span class="keyword">public</span>: -00015 SkWidget(U32 flags = 0) : <a class="code" href="classSkView.html">SkView</a>(flags | <a class="code" href="classSkView.html#w16w8">kFocusable_Mask</a> | <a class="code" href="classSkView.html#w16w7">kEnabled_Mask</a>) {} -00016 -00018 <span class="keywordtype">void</span> postWidgetEvent(); -00019 -00020 <span class="keyword">static</span> <span class="keywordtype">void</span> Init(); -00021 <span class="keyword">static</span> <span class="keywordtype">void</span> Term(); -00022 <span class="keyword">protected</span>: -00023 <span class="comment">// override to add slots to an event before posting</span> -00024 <span class="keyword">virtual</span> <span class="keywordtype">void</span> prepareWidgetEvent(<a class="code" href="classSkEvent.html">SkEvent</a>*); -00025 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onEnabledChange(); -00026 -00027 <span class="comment">// <event ...> to initialize the event from XML</span> -00028 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00029 -00030 <span class="keyword">private</span>: -00031 <a class="code" href="classSkEvent.html">SkEvent</a> fEvent; -00032 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00033 }; -00034 -00035 <span class="keyword">class </span>SkHasLabelWidget : <span class="keyword">public</span> SkWidget { -00036 <span class="keyword">public</span>: -00037 SkHasLabelWidget(U32 flags = 0) : SkWidget(flags) {} -00038 -00039 size_t getLabel(<a class="code" href="classSkString.html">SkString</a>* label = nil) <span class="keyword">const</span>; -00040 size_t getLabel(<span class="keywordtype">char</span> lable[] = nil) <span class="keyword">const</span>; -00041 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00042 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <span class="keywordtype">char</span> label[]); -00043 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <span class="keywordtype">char</span> label[], size_t len); -00044 -00045 <span class="keyword">protected</span>: -00046 <span class="comment">// called when the label changes</span> -00047 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onLabelChange(); -00048 -00049 <span class="comment">// overrides</span> -00050 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00051 -00052 <span class="keyword">private</span>: -00053 <a class="code" href="classSkString.html">SkString</a> fLabel; -00054 <span class="keyword">typedef</span> SkWidget INHERITED; -00055 }; -00056 -00057 <span class="keyword">class </span>SkButtonWidget : <span class="keyword">public</span> SkHasLabelWidget { -00058 <span class="keyword">public</span>: -00059 SkButtonWidget(U32 flags = 0) : SkHasLabelWidget(flags), fState(kOff_State) {} -00060 -00061 <span class="keyword">enum</span> State { -00062 kOff_State, -00063 kOn_State, -00064 kUnknown_State -00065 }; -00066 State getButtonState()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fState; } -00067 <span class="keywordtype">void</span> setButtonState(State); -00068 -00069 <span class="keyword">protected</span>: -00071 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onButtonStateChange(); -00072 -00073 <span class="comment">// overrides</span> -00074 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00075 -00076 <span class="keyword">private</span>: -00077 State fState; -00078 <span class="keyword">typedef</span> SkHasLabelWidget INHERITED; -00079 }; -00080 -00081 <span class="keyword">class </span>SkPushButtonWidget : <span class="keyword">public</span> SkButtonWidget { -00082 <span class="keyword">public</span>: -00083 SkPushButtonWidget(U32 flags = 0) : SkButtonWidget(flags) {} -00084 -00085 <span class="keyword">protected</span>: -00086 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00087 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00088 <span class="keyword">virtual</span> Click* onFindClickHandler(SkScalar x, SkScalar y); -00089 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onClick(Click* click); -00090 -00091 <span class="keyword">private</span>: -00092 <span class="keyword">typedef</span> SkButtonWidget INHERITED; -00093 }; -00094 -00095 <span class="keyword">class </span>SkCheckBoxWidget : <span class="keyword">public</span> SkButtonWidget { -00096 <span class="keyword">public</span>: -00097 SkCheckBoxWidget(U32 flags = 0); -00098 -00099 <span class="keyword">protected</span>: -00100 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00101 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00102 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00103 -00104 <span class="keyword">private</span>: -00105 <span class="keyword">typedef</span> SkButtonWidget INHERITED; -00106 }; -00107 -00108 <span class="preprocessor">#include "SkTextBox.h"</span> -00109 -00110 <span class="keyword">class </span>SkStaticTextView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00111 <span class="keyword">public</span>: -00112 SkStaticTextView(U32 flags = 0); -00113 <span class="keyword">virtual</span> ~SkStaticTextView(); -00114 -00115 <span class="keyword">enum</span> Mode { -00116 kFixedSize_Mode, -00117 kAutoWidth_Mode, -00118 kAutoHeight_Mode, -00119 -00120 kModeCount -00121 }; -00122 Mode getMode()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (Mode)fMode; } -00123 <span class="keywordtype">void</span> setMode(Mode); -00124 -00125 <a class="code" href="classSkTextBox.html">SkTextBox</a>::SpacingAlign getSpacingAlign()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> (SkTextBox::SpacingAlign)fSpacingAlign; } -00126 <span class="keywordtype">void</span> setSpacingAlign(<a class="code" href="classSkTextBox.html">SkTextBox</a>::SpacingAlign); -00127 -00128 <span class="keywordtype">void</span> getMargin(SkPoint* margin) const; -00129 <span class="keywordtype">void</span> setMargin(SkScalar dx, SkScalar dy); -00130 -00131 size_t getText(<a class="code" href="classSkString.html">SkString</a>* text = nil) const; -00132 size_t getText(<span class="keywordtype">char</span> text[] = nil) const; -00133 <span class="keywordtype">void</span> setText(const <a class="code" href="classSkString.html">SkString</a>&); -00134 <span class="keywordtype">void</span> setText(const <span class="keywordtype">char</span> text[]); -00135 <span class="keywordtype">void</span> setText(const <span class="keywordtype">char</span> text[], size_t len); -00136 -00137 <span class="keywordtype">void</span> getPaint(<a class="code" href="classSkPaint.html">SkPaint</a>*) const; -00138 <span class="keywordtype">void</span> setPaint(const <a class="code" href="classSkPaint.html">SkPaint</a>&); -00139 -00140 protected: -00141 <span class="comment">// overrides</span> -00142 virtual <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00143 virtual <span class="keywordtype">void</span> onInflate(const SkDOM& dom, const SkDOM::Node*); -00144 -00145 private: -00146 SkPoint fMargin; -00147 SkString fText; -00148 SkPaint fPaint; -00149 U8 fMode; -00150 U8 fSpacingAlign; -00151 -00152 <span class="keywordtype">void</span> computeSize(); -00153 -00154 typedef <a class="code" href="classSkView.html">SkView</a> INHERITED; -00155 }; -00156 -00157 class SkBitmapView : public <a class="code" href="classSkView.html">SkView</a> { -00158 <span class="keyword">public</span>: -00159 SkBitmapView(U32 flags = 0); -00160 <span class="keyword">virtual</span> ~SkBitmapView(); -00161 -00162 <span class="keywordtype">bool</span> getBitmap(<a class="code" href="classSkBitmap.html">SkBitmap</a>*) <span class="keyword">const</span>; -00163 <span class="keywordtype">void</span> setBitmap(<span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>*, <span class="keywordtype">bool</span> viewOwnsPixels); -00164 <span class="keywordtype">bool</span> loadBitmapFromFile(<span class="keyword">const</span> <span class="keywordtype">char</span> path[]); -00165 -00166 <span class="keyword">protected</span>: -00167 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(SkCanvas*); -00168 <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classSkView.html#a50">onInflate</a>(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*); -00169 -00170 <span class="keyword">private</span>: -00171 <a class="code" href="classSkBitmap.html">SkBitmap</a> fBitmap; -00172 <span class="keyword">typedef</span> SkView INHERITED; -00173 }; -00174 -00176 -00177 <span class="keyword">class </span><a class="code" href="classSkShader.html">SkShader</a>; -00178 <span class="keyword">class </span>SkInterpolator; -00179 -00180 <span class="keyword">class </span>SkWidgetView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00181 <span class="keyword">public</span>: -00182 SkWidgetView(U32 flags = 0); -00183 <span class="keyword">virtual</span> ~SkWidgetView(); -00184 -00185 <span class="keyword">static</span> <span class="keyword">const</span> <span class="keywordtype">char</span>* GetEventType(); -00186 }; -00187 -00188 <span class="keyword">class </span>SkSliderView : <span class="keyword">public</span> SkWidgetView { -00189 <span class="keyword">public</span>: -00190 SkSliderView(U32 flags = 0); -00191 -00192 U16 getValue()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fValue; } -00193 U16 getMax()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMax; } -00194 -00195 <span class="keywordtype">void</span> setMax(U16CPU max); -00196 <span class="keywordtype">void</span> setValue(U16CPU value); -00197 -00198 <span class="keyword">protected</span>: -00199 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00200 <span class="keyword">virtual</span> Click* onFindClickHandler(SkScalar x, SkScalar y); -00201 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onClick(Click*); -00202 -00203 <span class="keyword">private</span>: -00204 U16 fValue, fMax; -00205 -00206 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00207 }; -00208 -00210 -00211 <span class="keyword">class </span>SkHasLabelView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00212 <span class="keyword">public</span>: -00213 <span class="keywordtype">void</span> getLabel(<a class="code" href="classSkString.html">SkString</a>*) <span class="keyword">const</span>; -00214 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&); -00215 <span class="keywordtype">void</span> setLabel(<span class="keyword">const</span> <span class="keywordtype">char</span> label[]); -00216 -00217 <span class="keyword">protected</span>: -00218 <a class="code" href="classSkString.html">SkString</a> fLabel; -00219 -00220 <span class="comment">// called when the label changes</span> -00221 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onLabelChange(); -00222 -00223 <span class="comment">// overrides</span> -00224 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00225 }; -00226 -00227 <span class="keyword">class </span>SkPushButtonView : <span class="keyword">public</span> SkHasLabelView { -00228 <span class="keyword">public</span>: -00229 SkPushButtonView(U32 flags = 0); -00230 -00231 <span class="keyword">protected</span>: -00232 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00233 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00234 }; -00235 -00236 <span class="keyword">class </span>SkCheckBoxView : <span class="keyword">public</span> SkHasLabelView { -00237 <span class="keyword">public</span>: -00238 SkCheckBoxView(U32 flags = 0); -00239 -00240 <span class="keyword">enum</span> State { -00241 kOff_State, -00242 kOn_State, -00243 kMaybe_State -00244 }; -00245 State getState()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fState; } -00246 <span class="keywordtype">void</span> setState(State); -00247 -00248 <span class="keyword">protected</span>: -00249 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00250 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node*); -00251 -00252 <span class="keyword">private</span>: -00253 State fState; -00254 }; -00255 -00256 <span class="keyword">class </span>SkProgressView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00257 <span class="keyword">public</span>: -00258 SkProgressView(U32 flags = 0); -00259 <span class="keyword">virtual</span> ~SkProgressView(); -00260 -00261 U16 getValue()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fValue; } -00262 U16 getMax()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fMax; } -00263 -00264 <span class="keywordtype">void</span> setMax(U16CPU max); -00265 <span class="keywordtype">void</span> setValue(U16CPU value); -00266 -00267 <span class="keyword">protected</span>: -00268 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00269 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00270 -00271 <span class="keyword">private</span>: -00272 U16 fValue, fMax; -00273 <a class="code" href="classSkShader.html">SkShader</a>* fOnShader, *fOffShader; -00274 SkInterpolator* fInterp; -00275 <span class="keywordtype">bool</span> fDoInterp; -00276 -00277 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00278 }; -00279 -00280 <span class="keyword">class </span>SkTextView : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00281 <span class="keyword">public</span>: -00282 SkTextView(U32 flags = 0); -00283 <span class="keyword">virtual</span> ~SkTextView(); -00284 -00285 <span class="keyword">enum</span> AnimaDir { -00286 kNeutral_AnimDir, -00287 kForward_AnimDir, -00288 kBackward_AnimDir, -00289 kAnimDirCount -00290 }; -00291 -00292 <span class="keywordtype">void</span> getText(<a class="code" href="classSkString.html">SkString</a>*) <span class="keyword">const</span>; -00293 <span class="keywordtype">void</span> setText(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&, AnimaDir dir = kNeutral_AnimDir); -00294 <span class="keywordtype">void</span> setText(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], AnimaDir dir = kNeutral_AnimDir); -00295 <span class="keywordtype">void</span> setText(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], size_t len, AnimaDir dir = kNeutral_AnimDir); -00296 -00297 <span class="keywordtype">void</span> getMargin(SkPoint* margin) <span class="keyword">const</span>; -00298 <span class="keywordtype">void</span> setMargin(<span class="keyword">const</span> SkPoint&); -00299 -00300 <a class="code" href="classSkPaint.html">SkPaint</a>& paint() { <span class="keywordflow">return</span> fPaint; } -00301 -00302 <span class="keyword">protected</span>: -00303 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00304 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00305 -00306 <span class="keyword">private</span>: -00307 <a class="code" href="classSkString.html">SkString</a> fText; -00308 <a class="code" href="classSkPaint.html">SkPaint</a> fPaint; -00309 SkPoint fMargin; -00310 -00311 <span class="keyword">class </span>Interp; -00312 Interp* fInterp; -00313 <span class="keywordtype">bool</span> fDoInterp; -00314 <span class="comment">// called by the other setText methods. This guy does not check for !=</span> -00315 <span class="comment">// before doing the assign, so the caller must check for us</span> -00316 <span class="keywordtype">void</span> privSetText(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>&, AnimaDir dir); -00317 -00318 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00319 }; -00320 -00322 -00323 <span class="keyword">class </span><a class="code" href="classSkEvent.html">SkEvent</a>; -00324 -00325 <span class="keyword">class </span>SkListSource : <span class="keyword">public</span> <a class="code" href="classSkEventSink.html">SkEventSink</a> { -00326 <span class="keyword">public</span>: -00327 <span class="keyword">virtual</span> <span class="keywordtype">int</span> countRows() = 0; -00328 <span class="keyword">virtual</span> <span class="keywordtype">void</span> getRow(<span class="keywordtype">int</span> index, <a class="code" href="classSkString.html">SkString</a>* left, <a class="code" href="classSkString.html">SkString</a>* right) = 0; -00329 <span class="keyword">virtual</span> <a class="code" href="classSkEvent.html">SkEvent</a>* getEvent(<span class="keywordtype">int</span> index); -00330 -00331 <span class="keyword">static</span> SkListSource* CreateFromDir(<span class="keyword">const</span> <span class="keywordtype">char</span> path[], <span class="keyword">const</span> <span class="keywordtype">char</span> suffix[], -00332 <span class="keyword">const</span> <span class="keywordtype">char</span> targetPrefix[]); -00333 <span class="keyword">static</span> SkListSource* CreateFromDOM(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00334 }; -00335 -00336 <span class="keyword">class </span>SkListView : <span class="keyword">public</span> SkWidgetView { -00337 <span class="keyword">public</span>: -00338 SkListView(U32 flags = 0); -00339 <span class="keyword">virtual</span> ~SkListView(); -00340 -00341 SkScalar getRowHeight()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fRowHeight; } -00342 <span class="keywordtype">void</span> setRowHeight(SkScalar); -00343 -00346 <span class="keywordtype">int</span> getSelection()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCurrIndex; } -00349 <span class="keywordtype">void</span> setSelection(<span class="keywordtype">int</span>); -00350 -00351 <span class="keywordtype">void</span> moveSelectionUp(); -00352 <span class="keywordtype">void</span> moveSelectionDown(); -00353 -00354 <span class="keyword">enum</span> Attr { -00355 kBG_Attr, -00356 kNormalText_Attr, -00357 kHiliteText_Attr, -00358 kHiliteCell_Attr, -00359 kAttrCount -00360 }; -00361 <a class="code" href="classSkPaint.html">SkPaint</a>& paint(Attr); -00362 -00363 SkListSource* getListSource()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fSource; } -00364 SkListSource* setListSource(SkListSource*); -00365 -00366 <span class="preprocessor">#if 0</span> -00367 <span class="preprocessor"></span> <span class="keyword">enum</span> Action { -00368 kSelectionChange_Action, -00369 kSelectionPicked_Action, -00370 kActionCount -00371 }; -00377 <span class="keywordtype">void</span> setActionEvent(Action, <a class="code" href="classSkEvent.html">SkEvent</a>* event); -00378 <span class="preprocessor">#endif</span> -00379 <span class="preprocessor"></span> -00380 <span class="keyword">protected</span>: -00381 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00382 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00383 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00384 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00385 -00386 <span class="keyword">private</span>: -00387 <a class="code" href="classSkPaint.html">SkPaint</a> fPaint[kAttrCount]; -00388 SkListSource* fSource; -00389 SkScalar fRowHeight; -00390 <span class="keywordtype">int</span> fCurrIndex; <span class="comment">// logical index</span> -00391 <span class="keywordtype">int</span> fScrollIndex; <span class="comment">// logical index of top-most visible row</span> -00392 <span class="keywordtype">int</span> fVisibleRowCount; -00393 <a class="code" href="classSkString.html">SkString</a>* fStrCache; -00394 -00395 <span class="keywordtype">void</span> dirtyStrCache(); -00396 <span class="keywordtype">void</span> ensureStrCache(<span class="keywordtype">int</span> visibleCount); -00397 -00398 <span class="keywordtype">int</span> logicalToVisualIndex(<span class="keywordtype">int</span> index)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> index - fScrollIndex; } -00399 <span class="keywordtype">void</span> invalSelection(); -00400 <span class="keywordtype">bool</span> getRowRect(<span class="keywordtype">int</span> index, SkRect*) <span class="keyword">const</span>; -00401 <span class="keywordtype">void</span> ensureSelectionIsVisible(); -00402 -00403 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00404 }; -00405 -00407 -00408 <span class="keyword">class </span>SkGridView : <span class="keyword">public</span> SkWidgetView { -00409 <span class="keyword">public</span>: -00410 SkGridView(U32 flags = 0); -00411 <span class="keyword">virtual</span> ~SkGridView(); -00412 -00413 <span class="keywordtype">void</span> getCellSize(SkPoint*) <span class="keyword">const</span>; -00414 <span class="keywordtype">void</span> setCellSize(SkScalar x, SkScalar y); -00415 -00418 <span class="keywordtype">int</span> getSelection()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCurrIndex; } -00421 <span class="keywordtype">void</span> setSelection(<span class="keywordtype">int</span>); -00422 -00423 <span class="keywordtype">void</span> moveSelectionUp(); -00424 <span class="keywordtype">void</span> moveSelectionDown(); -00425 -00426 <span class="keyword">enum</span> Attr { -00427 kBG_Attr, -00428 kHiliteCell_Attr, -00429 kAttrCount -00430 }; -00431 <a class="code" href="classSkPaint.html">SkPaint</a>& paint(Attr); -00432 -00433 SkListSource* getListSource()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fSource; } -00434 SkListSource* setListSource(SkListSource*); -00435 -00436 <span class="keyword">protected</span>: -00437 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onDraw(<a class="code" href="classSkCanvas.html">SkCanvas</a>*); -00438 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onSizeChange(); -00439 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEvent(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00440 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onInflate(<span class="keyword">const</span> SkDOM& dom, <span class="keyword">const</span> SkDOM::Node* node); -00441 -00442 <span class="keyword">private</span>: -00443 <a class="code" href="classSkView.html">SkView</a>* fScrollBar; -00444 <a class="code" href="classSkPaint.html">SkPaint</a> fPaint[kAttrCount]; -00445 SkListSource* fSource; -00446 <span class="keywordtype">int</span> fCurrIndex; <span class="comment">// logical index</span> -00447 -00448 SkPoint fCellSize; -00449 SkIPoint fVisibleCount; -00450 -00451 <span class="keywordtype">int</span> logicalToVisualIndex(<span class="keywordtype">int</span> index)<span class="keyword"> const </span>{ <span class="keywordflow">return</span> index; } -00452 <span class="keywordtype">void</span> invalSelection(); -00453 <span class="keywordtype">bool</span> getCellRect(<span class="keywordtype">int</span> index, SkRect*) <span class="keyword">const</span>; -00454 <span class="keywordtype">void</span> ensureSelectionIsVisible(); -00455 -00456 <span class="keyword">typedef</span> SkWidgetView INHERITED; -00457 }; -00458 -00459 <span class="preprocessor">#endif</span> -00460 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkWindow_8h-source.html b/sgl_doxygen/html/SkWindow_8h-source.html deleted file mode 100644 index 8c84360..0000000 --- a/sgl_doxygen/html/SkWindow_8h-source.html +++ /dev/null @@ -1,97 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkWindow.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkWindow.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkWindow_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkWindow_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkView.h"</span> -00005 <span class="preprocessor">#include "SkBitmap.h"</span> -00006 <span class="preprocessor">#include "SkRegion.h"</span> -00007 <span class="preprocessor">#include "SkEvent.h"</span> -00008 <span class="preprocessor">#include "SkKey.h"</span> -00009 <span class="preprocessor">#include "SkTDArray.h"</span> -00010 -00011 <span class="preprocessor">#ifdef SK_BUILD_FOR_WINCEx</span> -00012 <span class="preprocessor"></span><span class="preprocessor"> #define SHOW_FPS</span> -00013 <span class="preprocessor"></span><span class="preprocessor">#endif</span> -00014 <span class="preprocessor"></span><span class="comment">//#define USE_GX_SCREEN</span> -00015 -00016 <span class="keyword">class </span>SkOSMenu; -00017 -00018 <span class="keyword">class </span>SkWindow : <span class="keyword">public</span> <a class="code" href="classSkView.html">SkView</a> { -00019 <span class="keyword">public</span>: -00020 SkWindow(); -00021 <span class="keyword">virtual</span> ~SkWindow(); -00022 -00023 <span class="keyword">const</span> <a class="code" href="classSkBitmap.html">SkBitmap</a>& getBitmap()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fBitmap; } -00024 -00025 <span class="keywordtype">void</span> setConfig(SkBitmap::Config); -00026 <span class="keywordtype">void</span> resize(<span class="keywordtype">int</span> width, <span class="keywordtype">int</span> height, SkBitmap::Config config = SkBitmap::kNo_Config); -00027 <span class="keywordtype">void</span> eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b); -00028 <span class="keywordtype">void</span> eraseRGB(U8CPU r, U8CPU g, U8CPU b); -00029 -00030 <span class="keywordtype">bool</span> isDirty()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> !fDirtyRgn.isEmpty(); } -00031 <span class="keywordtype">bool</span> update(SkRect16* updateArea); -00032 <span class="keywordtype">bool</span> handleClick(<span class="keywordtype">int</span> x, <span class="keywordtype">int</span> y, Click::State); -00033 <span class="keywordtype">bool</span> handleChar(SkUnichar); -00034 <span class="keywordtype">bool</span> handleKey(SkKey); -00035 <span class="keywordtype">bool</span> handleKeyUp(SkKey); -00036 <span class="keywordtype">bool</span> handleMenu(U32 os_cmd); -00037 -00038 <span class="keywordtype">void</span> addMenu(SkOSMenu*); -00039 -00040 <span class="keyword">protected</span>: -00041 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkEventSink.html#b0">onEvent</a>(<span class="keyword">const</span> <a class="code" href="classSkEvent.html">SkEvent</a>&); -00042 -00043 <span class="comment">// called if part of our bitmap is invalidated</span> -00044 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onHandleInval(<span class="keyword">const</span> SkRect16&); -00045 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onHandleChar(SkUnichar); -00046 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onHandleKey(SkKey); -00047 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onHandleKeyUp(SkKey); -00048 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddMenu(<span class="keyword">const</span> SkOSMenu*) {} -00049 -00050 <span class="comment">// overrides from SkView</span> -00051 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> <a class="code" href="classSkView.html#a47">handleInval</a>(<span class="keyword">const</span> SkRect&); -00052 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onGetFocusView(<a class="code" href="classSkView.html">SkView</a>** focus) <span class="keyword">const</span>; -00053 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onSetFocusView(<a class="code" href="classSkView.html">SkView</a>* focus); -00054 -00055 <span class="keyword">private</span>: -00056 <a class="code" href="classSkBitmap.html#w7">SkBitmap::Config</a> fConfig; -00057 <a class="code" href="classSkBitmap.html">SkBitmap</a> fBitmap; -00058 SkRegion fDirtyRgn; -00059 Click* fClick; <span class="comment">// to track clicks</span> -00060 -00061 SkTDArray<SkOSMenu*> fMenus; -00062 -00063 <a class="code" href="classSkView.html">SkView</a>* fFocusView; -00064 <span class="keywordtype">bool</span> fWaitingOnInval; -00065 -00066 <span class="keyword">typedef</span> <a class="code" href="classSkView.html">SkView</a> INHERITED; -00067 }; -00068 -00070 -00071 <span class="preprocessor">#ifndef SK_USE_WXWIDGETS</span> -00072 <span class="preprocessor"></span><span class="preprocessor">#ifdef SK_BUILD_FOR_MAC</span> -00073 <span class="preprocessor"></span><span class="preprocessor"> #include "SkOSWindow_Mac.h"</span> -00074 <span class="preprocessor">#elif defined(SK_BUILD_FOR_WIN)</span> -00075 <span class="preprocessor"></span><span class="preprocessor"> #include "SkOSWindow_Win.h"</span> -00076 <span class="preprocessor">#elif defined(SK_BUILD_FOR_UNIXx)</span> -00077 <span class="preprocessor"></span><span class="preprocessor"> #include "SkOSWindow_Unix.h"</span> -00078 <span class="preprocessor">#endif</span> -00079 <span class="preprocessor"></span><span class="preprocessor">#else</span> -00080 <span class="preprocessor"></span><span class="preprocessor"> #include "SkOSWindow_wxwidgets.h"</span> -00081 <span class="preprocessor">#endif</span> -00082 <span class="preprocessor"></span> -00083 <span class="preprocessor">#endif</span> -00084 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkXMLParser_8h-source.html b/sgl_doxygen/html/SkXMLParser_8h-source.html deleted file mode 100644 index c075b95..0000000 --- a/sgl_doxygen/html/SkXMLParser_8h-source.html +++ /dev/null @@ -1,91 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkXMLParser.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkXMLParser.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkXMLParser_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkXMLParser_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkMath.h"</span> -00005 <span class="preprocessor">#include "SkString.h"</span> -00006 -00007 <span class="keyword">class </span>SkStream; -00008 -00009 <span class="keyword">class </span>SkDOM; -00010 <span class="keyword">struct </span>SkDOMNode; -00011 -00012 <span class="keyword">class </span>SkXMLParserError { -00013 <span class="keyword">public</span>: -00014 <span class="keyword">enum</span> ErrorCode { -00015 kNoError, -00016 kEmptyFile, -00017 kUnknownElement, -00018 kUnknownAttributeName, -00019 kErrorInAttributeValue, -00020 kDuplicateIDs, -00021 kUnknownError -00022 }; -00023 -00024 SkXMLParserError(); -00025 <span class="keyword">virtual</span> ~SkXMLParserError(); -00026 ErrorCode getErrorCode()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCode; } -00027 <span class="keyword">virtual</span> <span class="keywordtype">void</span> getErrorString(<a class="code" href="classSkString.html">SkString</a>* str) <span class="keyword">const</span>; -00028 <span class="keywordtype">int</span> getLineNumber()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fLineNumber; } -00029 <span class="keywordtype">int</span> getNativeCode()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fNativeCode; } -00030 <span class="keywordtype">bool</span> hasError()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fCode != kNoError || fNativeCode != -1; } -00031 <span class="keywordtype">bool</span> hasNoun()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fNoun.size() > 0; } -00032 <span class="keywordtype">void</span> reset(); -00033 <span class="keywordtype">void</span> setCode(ErrorCode code) { fCode = code; } -00034 <span class="keywordtype">void</span> setNoun(<span class="keyword">const</span> <a class="code" href="classSkString.html">SkString</a>& str) { fNoun.set(str); } -00035 <span class="keywordtype">void</span> setNoun(<span class="keyword">const</span> <span class="keywordtype">char</span>* ch) { fNoun.set(ch); } -00036 <span class="keywordtype">void</span> setNoun(<span class="keyword">const</span> <span class="keywordtype">char</span>* ch, size_t len) { fNoun.set(ch, len); } -00037 <span class="keyword">protected</span>: -00038 ErrorCode fCode; -00039 <span class="keyword">private</span>: -00040 <span class="keywordtype">int</span> fLineNumber; -00041 <span class="keywordtype">int</span> fNativeCode; -00042 <a class="code" href="classSkString.html">SkString</a> fNoun; -00043 <span class="keyword">friend</span> <span class="keyword">class </span>SkXMLParser; -00044 }; -00045 -00046 <span class="keyword">class </span>SkXMLParser { -00047 <span class="keyword">public</span>: -00048 SkXMLParser(SkXMLParserError* parserError = nil); -00049 <span class="keyword">virtual</span> ~SkXMLParser(); -00050 -00053 <span class="keywordtype">bool</span> parse(<span class="keyword">const</span> <span class="keywordtype">char</span> doc[], size_t len); -00054 <span class="keywordtype">bool</span> parse(SkStream& docStream); -00055 <span class="keywordtype">bool</span> parse(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOMNode*); -00056 -00057 <span class="keyword">static</span> <span class="keywordtype">void</span> GetNativeErrorString(<span class="keywordtype">int</span> nativeErrorCode, <a class="code" href="classSkString.html">SkString</a>* str); -00058 -00059 <span class="keyword">protected</span>: -00060 <span class="comment">// override in subclasses; return true to stop parsing</span> -00061 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onStartElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00062 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onAddAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]); -00063 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onEndElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00064 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> onText(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], <span class="keywordtype">int</span> len); -00065 -00066 <span class="keyword">public</span>: -00067 <span class="comment">// public for ported implementation, not meant for clients to call</span> -00068 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> startElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00069 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> addAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]); -00070 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> endElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00071 <span class="keyword">virtual</span> <span class="keywordtype">bool</span> text(<span class="keyword">const</span> <span class="keywordtype">char</span> text[], <span class="keywordtype">int</span> len); -00072 <span class="keywordtype">void</span>* fParser; -00073 <span class="keyword">protected</span>: -00074 SkXMLParserError* fError; -00075 <span class="keyword">private</span>: -00076 <span class="keywordtype">void</span> reportError(<span class="keywordtype">void</span>* parser); -00077 }; -00078 -00079 <span class="preprocessor">#endif</span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkXMLWriter_8h-source.html b/sgl_doxygen/html/SkXMLWriter_8h-source.html deleted file mode 100644 index 7ed4cd2..0000000 --- a/sgl_doxygen/html/SkXMLWriter_8h-source.html +++ /dev/null @@ -1,91 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkXMLWriter.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkXMLWriter.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkXMLWriter_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkXMLWriter_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkTDArray.h"</span> -00005 <span class="preprocessor">#include "SkString.h"</span> -00006 <span class="preprocessor">#include "SkDOM.h"</span> -00007 -00008 <span class="keyword">class </span>SkWStream; -00009 <span class="keyword">class </span>SkXMLParser; -00010 -00011 <span class="keyword">class </span>SkXMLWriter { -00012 <span class="keyword">public</span>: -00013 SkXMLWriter(<span class="keywordtype">bool</span> doEscapeMarkup = <span class="keyword">true</span>); -00014 <span class="keyword">virtual</span> ~SkXMLWriter(); -00015 -00016 <span class="keywordtype">void</span> addS32Attribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], S32 value); -00017 <span class="keywordtype">void</span> addAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[]); -00018 <span class="keywordtype">void</span> addAttributeLen(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[], size_t length); -00019 <span class="keywordtype">void</span> addHexAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], U32 value, <span class="keywordtype">int</span> minDigits = 0); -00020 <span class="keywordtype">void</span> addScalarAttribute(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], SkScalar value); -00021 <span class="keywordtype">void</span> endElement() { this->onEndElement(); } -00022 <span class="keywordtype">void</span> startElement(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[]); -00023 <span class="keywordtype">void</span> startElementLen(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[], size_t length); -00024 <span class="keywordtype">void</span> writeDOM(<span class="keyword">const</span> SkDOM&, <span class="keyword">const</span> SkDOM::Node*, <span class="keywordtype">bool</span> skipRoot); -00025 <span class="keywordtype">void</span> flush(); -00026 <span class="keyword">virtual</span> <span class="keywordtype">void</span> writeHeader(); -00027 -00028 <span class="keyword">protected</span>: -00029 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onStartElementLen(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[], size_t length) = 0; -00030 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddAttributeLen(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[], size_t length) = 0; -00031 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onEndElement() = 0; -00032 -00033 <span class="keyword">struct </span>Elem { -00034 <a class="code" href="classSkString.html">SkString</a> fName; -00035 <span class="keywordtype">bool</span> fHasChildren; -00036 }; -00037 <span class="keywordtype">void</span> doEnd(Elem* elem); -00038 <span class="keywordtype">bool</span> doStart(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], size_t length); -00039 Elem* getEnd(); -00040 <span class="keyword">const</span> <span class="keywordtype">char</span>* getHeader(); -00041 SkTDArray<Elem*> fElems; -00042 -00043 <span class="keyword">private</span>: -00044 <span class="keywordtype">bool</span> fDoEscapeMarkup; -00045 <span class="comment">// illegal</span> -00046 SkXMLWriter& operator=(<span class="keyword">const</span> SkXMLWriter&); -00047 }; -00048 -00049 <span class="keyword">class </span>SkXMLStreamWriter : <span class="keyword">public</span> SkXMLWriter { -00050 <span class="keyword">public</span>: -00051 SkXMLStreamWriter(SkWStream*); -00052 <span class="keyword">virtual</span> ~SkXMLStreamWriter(); -00053 <span class="keyword">virtual</span> <span class="keywordtype">void</span> writeHeader(); -00054 SkDEBUGCODE(<span class="keyword">static</span> <span class="keywordtype">void</span> UnitTest();) -00055 <span class="keyword">protected</span>: -00056 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onStartElementLen(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[], size_t length); -00057 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onEndElement(); -00058 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddAttributeLen(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[], size_t length); -00059 <span class="keyword">private</span>: -00060 SkWStream& fStream; -00061 }; -00062 -00063 <span class="keyword">class </span>SkXMLParserWriter : <span class="keyword">public</span> SkXMLWriter { -00064 <span class="keyword">public</span>: -00065 SkXMLParserWriter(SkXMLParser*); -00066 <span class="keyword">virtual</span> ~SkXMLParserWriter(); -00067 <span class="keyword">protected</span>: -00068 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onStartElementLen(<span class="keyword">const</span> <span class="keywordtype">char</span> elem[], size_t length); -00069 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onEndElement(); -00070 <span class="keyword">virtual</span> <span class="keywordtype">void</span> onAddAttributeLen(<span class="keyword">const</span> <span class="keywordtype">char</span> name[], <span class="keyword">const</span> <span class="keywordtype">char</span> value[], size_t length); -00071 <span class="keyword">private</span>: -00072 SkXMLParser& fParser; -00073 }; -00074 -00075 -00076 <span class="preprocessor">#endif</span> -00077 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/SkXfermode_8h-source.html b/sgl_doxygen/html/SkXfermode_8h-source.html deleted file mode 100644 index f21fa44..0000000 --- a/sgl_doxygen/html/SkXfermode_8h-source.html +++ /dev/null @@ -1,48 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkXfermode.h Source File</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>SkXfermode.h</h1><div class="fragment"><pre class="fragment">00001 <span class="preprocessor">#ifndef SkXfermode_DEFINED</span> -00002 <span class="preprocessor"></span><span class="preprocessor">#define SkXfermode_DEFINED</span> -00003 <span class="preprocessor"></span> -00004 <span class="preprocessor">#include "SkRefCnt.h"</span> -00005 <span class="preprocessor">#include "<a class="code" href="SkColor_8h.html">SkColor.h</a>"</span> -00006 -<a name="l00015"></a><a class="code" href="classSkXfermode.html">00015</a> <span class="keyword">class </span><a class="code" href="classSkXfermode.html">SkXfermode</a> : <span class="keyword">public</span> <a class="code" href="classSkRefCnt.html">SkRefCnt</a> { -00016 <span class="keyword">public</span>: -00017 <span class="keyword">virtual</span> <span class="keywordtype">void</span> xfer32(<a class="code" href="SkColor_8h.html#a18">SkPMColor</a> dst[], <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> src[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a16">SkAlpha</a> aa[]); -00018 <span class="keyword">virtual</span> <span class="keywordtype">void</span> xfer16(uint16_t dst[], <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> src[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a16">SkAlpha</a> aa[]); -00019 <span class="keyword">virtual</span> <span class="keywordtype">void</span> xferA8(<a class="code" href="SkColor_8h.html#a16">SkAlpha</a> dst[], <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> src[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> <a class="code" href="SkColor_8h.html#a16">SkAlpha</a> aa[]); -00020 }; -00021 -00023 -00024 <span class="keyword">class </span>SkProcXfermode : <span class="keyword">public</span> <a class="code" href="classSkXfermode.html">SkXfermode</a> { -00025 <span class="keyword">public</span>: -00026 <span class="keyword">typedef</span> <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> (*Proc)(<a class="code" href="SkColor_8h.html#a18">SkPMColor</a> src, <a class="code" href="SkColor_8h.html#a18">SkPMColor</a> dst); -00027 -00028 SkProcXfermode(Proc proc = nil) : fProc(proc) {} -00029 -00030 Proc getProc()<span class="keyword"> const </span>{ <span class="keywordflow">return</span> fProc; } -00031 <span class="keywordtype">void</span> setProc(Proc proc) { fProc = proc; } -00032 -00033 <span class="comment">// overrides</span> -00034 <span class="keyword">virtual</span> <span class="keywordtype">void</span> xfer32(SkPMColor dst[], <span class="keyword">const</span> SkPMColor src[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> SkAlpha aa[]); -00035 <span class="keyword">virtual</span> <span class="keywordtype">void</span> xfer16(uint16_t dst[], <span class="keyword">const</span> SkPMColor src[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> SkAlpha aa[]); -00036 <span class="keyword">virtual</span> <span class="keywordtype">void</span> xferA8(SkAlpha dst[], <span class="keyword">const</span> SkPMColor src[], <span class="keywordtype">int</span> count, <span class="keyword">const</span> SkAlpha aa[]); -00037 -00038 <span class="keyword">private</span>: -00039 Proc fProc; -00040 }; -00041 -00042 <span class="preprocessor">#endif</span> -00043 <span class="preprocessor"></span> -</pre></div><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/annotated.html b/sgl_doxygen/html/annotated.html deleted file mode 100644 index 162c436..0000000 --- a/sgl_doxygen/html/annotated.html +++ /dev/null @@ -1,57 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Class List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindexHL" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SGL Class List</h1>Here are the classes, structs, unions and interfaces with brief descriptions:<table> - <tr><td class="indexkey"><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkAnimator_1_1Timeline.html">SkAnimator::Timeline</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkBounder.html">SkBounder</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkComposePathEffect.html">SkComposePathEffect</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkEvent.html">SkEvent</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkFlipCosineMapper.html">SkFlipCosineMapper</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkFontHost.html">SkFontHost</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkGradientShader.html">SkGradientShader</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="structSkMask.html">SkMask</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkPaint.html">SkPaint</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkPath.html">SkPath</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkShader.html">SkShader</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkString.html">SkString</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkStroke.html">SkStroke</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkSumPathEffect.html">SkSumPathEffect</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkTime.html">SkTime</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkView.html">SkView</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="classSkXfermode.html">SkXfermode</a></td><td class="indexvalue"></td></tr> -</table> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAnimator-members.html b/sgl_doxygen/html/classSkAnimator-members.html deleted file mode 100644 index 25b1581..0000000 --- a/sgl_doxygen/html/classSkAnimator-members.html +++ /dev/null @@ -1,113 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAnimator Member List</h1>This is the complete list of members for <a class="el" href="classSkAnimator.html">SkAnimator</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a2">addExtras</a>(SkExtras *extras)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a5">addListenerID</a>(SkEventSinkID sinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>addTagList</b>(SkTagList *) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a3">appendStream</a>(SkStream *stream)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a6">copyListeners</a>(const SkEventSink &from)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a6">decodeDOM</a>(const SkDOM &, const SkDOMNode *)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a4">decodeMemory</a>(const void *buffer, size_t size)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a5">decodeStream</a>(SkStream *stream)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a7">decodeURI</a>(const char uri[])</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#w4">DifferenceType</a> enum name</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a8">doCharEvent</a>(SkUnichar ch)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a9">doClickEvent</a>(int state, SkScalar x, SkScalar y)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a3">doEvent</a>(const SkEvent &)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#e0">DoEvent</a>(const SkEvent &, SkEventSinkID targetID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a10">doKeyEvent</a>(SkKey code)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>doKeyUpEvent</b>(SkKey code) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a4">doQuery</a>(SkEvent *query)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a12">doUserEvent</a>(const SkEvent &evt)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a13">draw</a>(SkCanvas *canvas, SkPaint *paint, SkMSec time)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a14">draw</a>(SkCanvas *canvas, SkMSec time)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3">EventResult</a> enum name</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a15">findClickEvent</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#e1">FindSink</a>(SkEventSinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>findTagList</b>(U8CPU tag) const (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a16">getAnimator</a>(const SkDisplayable *element) const </td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a17">getArrayInt</a>(const SkDisplayable *element, const SkMemberInfo *field, int index)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a18">getArrayInt</a>(const char *elementID, const char *fieldName, int index)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a19">getArrayScalar</a>(const SkDisplayable *element, const SkMemberInfo *field, int index)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a20">getArrayScalar</a>(const char *elementID, const char *fieldName, int index)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a21">getArrayString</a>(const SkDisplayable *element, const SkMemberInfo *field, int index)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a22">getArrayString</a>(const char *elementID, const char *fieldName, int index)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a23">getElement</a>(const char *elementID)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a24">getElementType</a>(const SkDisplayable *element)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a25">getElementType</a>(const char *elementID)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a26">getField</a>(const SkDisplayable *element, const char *fieldName)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a27">getField</a>(const char *elementID, const char *fieldName)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a28">getFieldType</a>(const SkMemberInfo *field)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a29">getFieldType</a>(const char *elementID, const char *fieldName)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getHostEventSinkID</b>() const (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a34">getInt</a>(const SkDisplayable *element, const SkMemberInfo *field)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a35">getInt</a>(const char *elementID, const char *fieldName)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a30">getInterval</a>()</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a31">getInvalBounds</a>(SkRect *inval)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a32">getParserError</a>()</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a33">getParserErrorString</a>()</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a36">getScalar</a>(const SkDisplayable *element, const SkMemberInfo *field)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a37">getScalar</a>(const char *elementID, const char *fieldName)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a2">getSinkID</a>() const </td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a38">getString</a>(const SkDisplayable *element, const SkMemberInfo *field)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a39">getString</a>(const char *elementID, const char *fieldName)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a40">getURIBase</a>()</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Handler</b> typedef (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a8">hasListeners</a>() const </td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Init</b>(bool runUnitTests) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a41">initialize</a>()</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kDifferent</b> enum value (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w0">kHandled_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kNotDifferent</b> enum value (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w1">kNotHandled_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kPartiallyDifferent</b> enum value (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w2">kSinkNotFound_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onEventPost</b>(SkEvent *, SkEventSinkID) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [protected, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onEventPostTime</b>(SkEvent *, SkEventSinkID, SkMSec time) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [protected, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onQuery</b>(SkEvent *) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected, virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a9">postToListeners</a>(const SkEvent &evt, SkMSec delay=0)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a7">removeListenerID</a>(SkEventSinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>removeTagList</b>(U8CPU tag) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a42">reset</a>()</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setHostEventSink</b>(SkEventSink *sink) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a51">setHostEventSinkID</a>(SkEventSinkID hostID)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setHostHandler</b>(Handler handler) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a43">setInt</a>(SkDisplayable *element, const SkMemberInfo *field, int32_t data)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a44">setInt</a>(const char *elementID, const char *fieldName, int32_t data)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setJavaOwner</b>(Handler owner) (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a45">setScalar</a>(SkDisplayable *element, const SkMemberInfo *field, SkScalar data)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a46">setScalar</a>(const char *elementID, const char *fieldName, SkScalar data)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a47">setString</a>(SkDisplayable *element, const SkMemberInfo *field, const char *data)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a48">setString</a>(const char *elementID, const char *fieldName, const char *data)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a49">setTimeline</a>(const Timeline &)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkAnimator.html#a50">setURIBase</a>(const char *path)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAnimateMaker</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAnimator</b>() (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAnimatorScript</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAnimatorScript2</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkApply</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkDisplayMovie</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkDisplayType</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkEventSink</b>() (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPost</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkXMLAnimatorWriter</b> (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Term</b>() (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkAnimator</b>() (defined in <a class="el" href="classSkAnimator.html">SkAnimator</a>)</td><td><a class="el" href="classSkAnimator.html">SkAnimator</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkEventSink</b>() (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAnimator.html b/sgl_doxygen/html/classSkAnimator.html deleted file mode 100644 index 10e341d..0000000 --- a/sgl_doxygen/html/classSkAnimator.html +++ /dev/null @@ -1,2198 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAnimator Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAnimator Class Reference</h1><code>#include <<a class="el" href="SkAnimator_8h-source.html">SkAnimator.h</a>></code> -<p> -<p>Inheritance diagram for SkAnimator: -<p><center><img src="classSkAnimator.png" usemap="#SkAnimator_map" border="0" alt=""></center> -<map name="SkAnimator_map"> -<area href="classSkEventSink.html" alt="SkEventSink" shape="rect" coords="0,56,82,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,82,24"> -</map> -<a href="classSkAnimator-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="w0" doxytag="SkAnimator::Handler"></a> -typedef void * </td><td class="memItemRight" valign="bottom"><b>Handler</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#w4">DifferenceType</a> { <b>kNotDifferent</b>, -<b>kDifferent</b>, -<b>kPartiallyDifferent</b> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a2">addExtras</a> (SkExtras *extras)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a3">appendStream</a> (SkStream *stream)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a4">decodeMemory</a> (const void *buffer, size_t size)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a5">decodeStream</a> (SkStream *stream)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a6">decodeDOM</a> (const SkDOM &, const SkDOMNode *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a7">decodeURI</a> (const char uri[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a8">doCharEvent</a> (SkUnichar ch)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a9">doClickEvent</a> (int state, SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a10">doKeyEvent</a> (SkKey code)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a11" doxytag="SkAnimator::doKeyUpEvent"></a> -bool </td><td class="memItemRight" valign="bottom"><b>doKeyUpEvent</b> (SkKey code)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a12">doUserEvent</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &evt)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkAnimator.html#w4">DifferenceType</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a13">draw</a> (<a class="el" href="classSkCanvas.html">SkCanvas</a> *canvas, <a class="el" href="classSkPaint.html">SkPaint</a> *paint, SkMSec time)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkAnimator.html#w4">DifferenceType</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a14">draw</a> (<a class="el" href="classSkCanvas.html">SkCanvas</a> *canvas, SkMSec time)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a15">findClickEvent</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const <a class="el" href="classSkAnimator.html">SkAnimator</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a16">getAnimator</a> (const SkDisplayable *element) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a17">getArrayInt</a> (const SkDisplayable *element, const SkMemberInfo *field, int index)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a18">getArrayInt</a> (const char *elementID, const char *fieldName, int index)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a19">getArrayScalar</a> (const SkDisplayable *element, const SkMemberInfo *field, int index)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a20">getArrayScalar</a> (const char *elementID, const char *fieldName, int index)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a21">getArrayString</a> (const SkDisplayable *element, const SkMemberInfo *field, int index)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a22">getArrayString</a> (const char *elementID, const char *fieldName, int index)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkDisplayable * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a23">getElement</a> (const char *elementID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkElementType </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a24">getElementType</a> (const SkDisplayable *element)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkElementType </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a25">getElementType</a> (const char *elementID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkMemberInfo * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a26">getField</a> (const SkDisplayable *element, const char *fieldName)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkMemberInfo * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a27">getField</a> (const char *elementID, const char *fieldName)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkFieldType </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a28">getFieldType</a> (const SkMemberInfo *field)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkFieldType </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a29">getFieldType</a> (const char *elementID, const char *fieldName)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkMSec </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a30">getInterval</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a31">getInvalBounds</a> (SkRect *inval)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkXMLParserError * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a32">getParserError</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a33">getParserErrorString</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a34">getInt</a> (const SkDisplayable *element, const SkMemberInfo *field)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a35">getInt</a> (const char *elementID, const char *fieldName)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a36">getScalar</a> (const SkDisplayable *element, const SkMemberInfo *field)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a37">getScalar</a> (const char *elementID, const char *fieldName)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a38">getString</a> (const SkDisplayable *element, const SkMemberInfo *field)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a39">getString</a> (const char *elementID, const char *fieldName)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a40">getURIBase</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a41">initialize</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a42">reset</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a43">setInt</a> (SkDisplayable *element, const SkMemberInfo *field, int32_t data)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a44">setInt</a> (const char *elementID, const char *fieldName, int32_t data)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a45">setScalar</a> (SkDisplayable *element, const SkMemberInfo *field, SkScalar data)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a46">setScalar</a> (const char *elementID, const char *fieldName, SkScalar data)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a47">setString</a> (SkDisplayable *element, const SkMemberInfo *field, const char *data)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a48">setString</a> (const char *elementID, const char *fieldName, const char *data)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a49">setTimeline</a> (const <a class="el" href="classSkAnimator_1_1Timeline.html">Timeline</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a50">setURIBase</a> (const char *path)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator.html#a51">setHostEventSinkID</a> (SkEventSinkID hostID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a52" doxytag="SkAnimator::getHostEventSinkID"></a> -SkEventSinkID </td><td class="memItemRight" valign="bottom"><b>getHostEventSinkID</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a53" doxytag="SkAnimator::setHostEventSink"></a> -void </td><td class="memItemRight" valign="bottom"><b>setHostEventSink</b> (<a class="el" href="classSkEventSink.html">SkEventSink</a> *sink)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a54" doxytag="SkAnimator::setHostHandler"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>setHostHandler</b> (Handler handler)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a55" doxytag="SkAnimator::setJavaOwner"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>setJavaOwner</b> (Handler owner)</td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e0" doxytag="SkAnimator::Init"></a> -static void </td><td class="memItemRight" valign="bottom"><b>Init</b> (bool runUnitTests)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e1" doxytag="SkAnimator::Term"></a> -static void </td><td class="memItemRight" valign="bottom"><b>Term</b> ()</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkAnimator::onEventPost"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onEventPost</b> (<a class="el" href="classSkEvent.html">SkEvent</a> *, SkEventSinkID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b1" doxytag="SkAnimator::onEventPostTime"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onEventPostTime</b> (<a class="el" href="classSkEvent.html">SkEvent</a> *, SkEventSinkID, SkMSec time)</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkAnimator::SkAnimateMaker"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkAnimateMaker</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n1" doxytag="SkAnimator::SkAnimatorScript"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkAnimatorScript</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n2" doxytag="SkAnimator::SkAnimatorScript2"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkAnimatorScript2</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n3" doxytag="SkAnimator::SkApply"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkApply</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n4" doxytag="SkAnimator::SkDisplayMovie"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkDisplayMovie</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n5" doxytag="SkAnimator::SkDisplayType"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkDisplayType</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n6" doxytag="SkAnimator::SkPost"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkPost</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n7" doxytag="SkAnimator::SkXMLAnimatorWriter"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkXMLAnimatorWriter</b></td></tr> - -<tr><td colspan="2"><br><h2>Classes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator_1_1Timeline.html">Timeline</a></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -The SkAnimator class decodes an XML stream into a display list. The display list can be drawn statically as a picture, or can drawn different elements at different times to form a moving animation.<p> -SkAnimator does not read the system time on its own; it relies on the caller to pass the current time. The caller can pause, speed up, or reverse the animation by varying the time passed in.<p> -The XML describing the display list must conform to the schema described by SkAnimateSchema.xsd.<p> -The XML must contain an <event> element to draw. Usually, it contains an <event kind="onload" /> block to add some drawing elements to the display list when the document is first decoded.<p> -Here's an "Hello World" XML sample:<p> -<screenplay> <event kind="onload" =""> <text text="Hello World" y="20" /> </event> </screenplay><p> -To read and draw this sample:<p> -choose one of these two SkAnimator animator; // declare an animator instance on the stack SkAnimator* animator = new SkAnimator() // or one could instantiate the class<p> -choose one of these three animator.decodeMemory(buffer, size); // to read from RAM animator.decodeStream(stream); // to read from a user-defined stream (e.g., a zip file) animator.decodeURI(filename); // to read from a web location, or from a local text file<p> -to draw to the current window: <a class="el" href="classSkCanvas.html">SkCanvas</a> canvas(getBitmap()); // create a canvas animator.draw(canvas, &paint, 0); // draw the scene -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w4" doxytag="SkAnimator::DifferenceType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkAnimator.html#w4">SkAnimator::DifferenceType</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -The possible results from the draw function. </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a2" doxytag="SkAnimator::addExtras"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::addExtras </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkExtras * </td> - <td class="mdname1" valign="top" nowrap> <em>extras</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a drawable extension to the graphics engine. Experimental. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>extras</em> </td><td>A derived class that implements methods that identify and instantiate the class</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkAnimator::appendStream"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::appendStream </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkStream * </td> - <td class="mdname1" valign="top" nowrap> <em>stream</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Read in XML from a stream, and append it to the current animator. Returns false if an error was encountered. Error diagnostics are stored in fErrorCode and fLineNumber. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>stream</em> </td><td>The stream to append. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the XML was parsed successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkAnimator::decodeDOM"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkAnimator::decodeDOM </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDOM & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkDOMNode * </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Parse the DOM tree starting at the specified node. Returns true if it can be parsed without error. Returns false if an error was encountered. Error diagnostics are stored in fErrorCode and fLineNumber. <dl compact><dt><b>Returns:</b></dt><dd>true if the DOM was parsed successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkAnimator::decodeMemory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::decodeMemory </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const void * </td> - <td class="mdname" nowrap> <em>buffer</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>size</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Read in XML from memory. Returns true if the file can be read without error. Returns false if an error was encountered. Error diagnostics are stored in fErrorCode and fLineNumber. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>buffer</em> </td><td>The XML text as UTF-8 characters. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>size</em> </td><td>The XML text length in bytes. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the XML was parsed successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkAnimator::decodeStream"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkAnimator::decodeStream </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkStream * </td> - <td class="mdname1" valign="top" nowrap> <em>stream</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Read in XML from a stream. Returns true if the file can be read without error. Returns false if an error was encountered. Error diagnostics are stored in fErrorCode and fLineNumber. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>stream</em> </td><td>The stream containg the XML text as UTF-8 characters. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the XML was parsed successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkAnimator::decodeURI"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::decodeURI </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname1" valign="top" nowrap> <em>uri</em>[] </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Read in XML from a URI. Returns true if the file can be read without error. Returns false if an error was encountered. Error diagnostics are stored in fErrorCode and fLineNumber. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>uri</em> </td><td>The complete url path to be read (either ftp, http or https). </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the XML was parsed successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkAnimator::doCharEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::doCharEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkUnichar </td> - <td class="mdname1" valign="top" nowrap> <em>ch</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Pass a char event, usually a keyboard symbol, to the animator. This triggers events of the form <event kind="keyChar" key="... /> <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>ch</em> </td><td>The character to match against <event> element "key" attributes. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the event was dispatched successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkAnimator::doClickEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::doClickEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>state</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Experimental: Pass a mouse click event along with the mouse coordinates to the animator. This triggers events of the form <event kind="mouseDown" ... /> and other mouse events. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>state</em> </td><td>The mouse state, described by SkView::Click::State : values are down == 0, moved == 1, up == 2 </td></tr> - <tr><td valign="top"></td><td valign="top"><em>x</em> </td><td>The x-position of the mouse </td></tr> - <tr><td valign="top"></td><td valign="top"><em>y</em> </td><td>The y-position of the mouse </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the event was dispatched successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkAnimator::doKeyEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::doKeyEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkKey </td> - <td class="mdname1" valign="top" nowrap> <em>code</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Pass a meta-key event, such as an arrow , to the animator. This triggers events of the form <event kind="keyPress" code="... /> <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>code</em> </td><td>The key to match against <event> element "code" attributes. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the event was dispatched successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a12" doxytag="SkAnimator::doUserEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::doUserEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>evt</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Send an event to the animator. The animator's clock is set relative to the current time. <dl compact><dt><b>Returns:</b></dt><dd>true if the event was dispatched successfully.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a14" doxytag="SkAnimator::draw"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkAnimator.html#w4">DifferenceType</a> SkAnimator::draw </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkCanvas.html">SkCanvas</a> * </td> - <td class="mdname" nowrap> <em>canvas</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkMSec </td> - <td class="mdname" nowrap> <em>time</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draws one frame of the animation, using a new Paint each time. The first call to draw always draws the initial frame of the animation. Subsequent calls draw the offset into the animation by subtracting the initial time from the current time. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>canvas</em> </td><td>The canvas to draw into. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>time</em> </td><td>The offset into the current animation. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>kNotDifferent if there are no active animations; kDifferent if there are active animations; and kPartiallyDifferent if the document contains an active <bounds> element that specifies a minimal redraw area.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a13" doxytag="SkAnimator::draw"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkAnimator.html#w4">DifferenceType</a> SkAnimator::draw </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkCanvas.html">SkCanvas</a> * </td> - <td class="mdname" nowrap> <em>canvas</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPaint.html">SkPaint</a> * </td> - <td class="mdname" nowrap> <em>paint</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkMSec </td> - <td class="mdname" nowrap> <em>time</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draws one frame of the animation. The first call to draw always draws the initial frame of the animation. Subsequent calls draw the offset into the animation by subtracting the initial time from the current time. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>canvas</em> </td><td>The canvas to draw into. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>paint</em> </td><td>The paint to draw with. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>time</em> </td><td>The offset into the current animation. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>kNotDifferent if there are no active animations; kDifferent if there are active animations; and kPartiallyDifferent if the document contains an active <bounds> element that specifies a minimal redraw area.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a15" doxytag="SkAnimator::findClickEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::findClickEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Experimental: Helper to choose whether to return a SkView::Click handler. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>x</em> </td><td>ignored </td></tr> - <tr><td valign="top"></td><td valign="top"><em>y</em> </td><td>ignored </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if a mouseDown event handler is enabled.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a16" doxytag="SkAnimator::getAnimator"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const <a class="el" href="classSkAnimator.html">SkAnimator</a>* SkAnimator::getAnimator </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname1" valign="top" nowrap> <em>element</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Get the nested animator associated with this element, if any. Use this to access a movie's event sink, to send events to movies. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>the value returned by getElement </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the internal animator.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkAnimator::getArrayInt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int32_t SkAnimator::getArrayInt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>index</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute[index] <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - <tr><td valign="top"></td><td valign="top"><em>index</em> </td><td>the array entry </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the integer value to retrieve, or SK_NaN32 if unsuccessful</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkAnimator::getArrayInt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int32_t SkAnimator::getArrayInt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>index</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute[index] <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>the value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>the value returned by getField </td></tr> - <tr><td valign="top"></td><td valign="top"><em>index</em> </td><td>the array entry </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the integer value to retrieve, or SK_NaN32 if unsuccessful</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a20" doxytag="SkAnimator::getArrayScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkAnimator::getArrayScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>index</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute[index] <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - <tr><td valign="top"></td><td valign="top"><em>index</em> </td><td>the array entry </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the scalar value to retrieve, or SK_ScalarNaN if unsuccessful</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a19" doxytag="SkAnimator::getArrayScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkAnimator::getArrayScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>index</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute[index] <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>the value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>the value returned by getField </td></tr> - <tr><td valign="top"></td><td valign="top"><em>index</em> </td><td>the array entry </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the scalar value to retrieve, or SK_ScalarNaN if unsuccessful</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a22" doxytag="SkAnimator::getArrayString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkAnimator::getArrayString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>index</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the string value of the specified element's attribute[index] <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - <tr><td valign="top"></td><td valign="top"><em>index</em> </td><td>the array entry </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the string value to retrieve, or null if unsuccessful</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkAnimator::getArrayString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkAnimator::getArrayString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>index</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the string value of the specified element's attribute[index] <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>is a value returned by getField </td></tr> - <tr><td valign="top"></td><td valign="top"><em>index</em> </td><td>the array entry </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the string value to retrieve, or null if unsuccessful</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a23" doxytag="SkAnimator::getElement"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkDisplayable* SkAnimator::getElement </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname1" valign="top" nowrap> <em>elementID</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the XML element corresponding to the given ID. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the element matching the ID, or nil if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a25" doxytag="SkAnimator::getElementType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkElementType SkAnimator::getElementType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname1" valign="top" nowrap> <em>elementID</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the element type corresponding to the given ID. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>element type, or 0 if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a24" doxytag="SkAnimator::getElementType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkElementType SkAnimator::getElementType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname1" valign="top" nowrap> <em>element</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the element type corresponding to the XML element. The element type matches the element name; for instance, <line> returns kElement_LineType <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>element type, or 0 if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a27" doxytag="SkAnimator::getField"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkMemberInfo* SkAnimator::getField </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the XML field of the named attribute in the XML element matching the elementID. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>is the attribute to return </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the attribute matching the fieldName, or nil if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a26" doxytag="SkAnimator::getField"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkMemberInfo* SkAnimator::getField </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the XML field of the named attribute in the XML element. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>is the attribute to return </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the attribute matching the fieldName, or nil if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a29" doxytag="SkAnimator::getFieldType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkFieldType SkAnimator::getFieldType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the value type coresponding to the element's attribute. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the attribute type, or 0 if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a28" doxytag="SkAnimator::getFieldType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkFieldType SkAnimator::getFieldType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkMemberInfo * </td> - <td class="mdname1" valign="top" nowrap> <em>field</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the value type coresponding to the element's attribute. The value type matches the XML schema: and may be kField_BooleanType, kField_ScalarType, etc. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>is a value returned by getField </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the attribute type, or 0 if the element can't be found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a35" doxytag="SkAnimator::getInt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int32_t SkAnimator::getInt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the integer value to retrieve, or SK_NaN32 if not found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a34" doxytag="SkAnimator::getInt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int32_t SkAnimator::getInt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>is a value returned by getField </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the integer value to retrieve, or SK_NaN32 if not found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a30" doxytag="SkAnimator::getInterval"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkMSec SkAnimator::getInterval </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the recommended animation interval. Returns zero if no interval is specified. </td> - </tr> -</table> -<a class="anchor" name="a31" doxytag="SkAnimator::getInvalBounds"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::getInvalBounds </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkRect * </td> - <td class="mdname1" valign="top" nowrap> <em>inval</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the partial rectangle to invalidate after drawing. Call after <a class="el" href="classSkAnimator.html#a13">draw()</a> returns kIsPartiallyDifferent to do a mimimal inval(). </td> - </tr> -</table> -<a class="anchor" name="a32" doxytag="SkAnimator::getParserError"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkXMLParserError* SkAnimator::getParserError </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the details of any error encountered while parsing the XML. </td> - </tr> -</table> -<a class="anchor" name="a33" doxytag="SkAnimator::getParserErrorString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkAnimator::getParserErrorString </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the details of any error encountered while parsing the XML as string. </td> - </tr> -</table> -<a class="anchor" name="a37" doxytag="SkAnimator::getScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkAnimator::getScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the scalar value to retrieve, or SK_ScalarNaN if not found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a36" doxytag="SkAnimator::getScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkAnimator::getScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>is a value returned by getField </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the scalar value to retrieve, or SK_ScalarNaN if not found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a39" doxytag="SkAnimator::getString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkAnimator::getString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the string value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the string value to retrieve, or null if not found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a38" doxytag="SkAnimator::getString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkAnimator::getString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the string value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>is a value returned by getField </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the string value to retrieve, or null if not found</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a40" doxytag="SkAnimator::getURIBase"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkAnimator::getURIBase </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Gets the file default directory of the URL base path set explicitly or by reading the last URL. </td> - </tr> -</table> -<a class="anchor" name="a41" doxytag="SkAnimator::initialize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::initialize </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Resets the animator to a newly created state with no animation data. </td> - </tr> -</table> -<a class="anchor" name="a42" doxytag="SkAnimator::reset"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::reset </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Experimental. Resets any active animations so that the next time passed is treated as time zero. </td> - </tr> -</table> -<a class="anchor" name="a51" doxytag="SkAnimator::setHostEventSinkID"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::setHostEventSinkID </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkEventSinkID </td> - <td class="mdname1" valign="top" nowrap> <em>hostID</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -The event sink events generated by the animation are posted to. Screenplay also posts an inval event to this event sink after processing an event to force a redraw. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>target</em> </td><td>the event sink id</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a44" doxytag="SkAnimator::setInt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::setInt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int32_t </td> - <td class="mdname" nowrap> <em>data</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - <tr><td valign="top"></td><td valign="top"><em>data</em> </td><td>the integer value to set </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the value was set successfully</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a43" doxytag="SkAnimator::setInt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::setInt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int32_t </td> - <td class="mdname" nowrap> <em>data</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>the value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>the value returned by getField </td></tr> - <tr><td valign="top"></td><td valign="top"><em>data</em> </td><td>the integer value to set </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the value was set successfully</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a46" doxytag="SkAnimator::setScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::setScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>data</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - <tr><td valign="top"></td><td valign="top"><em>data</em> </td><td>the scalar value to set </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the value was set successfully</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a45" doxytag="SkAnimator::setScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::setScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>data</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the scalar value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>the value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>the value returned by getField </td></tr> - <tr><td valign="top"></td><td valign="top"><em>data</em> </td><td>the scalar value to set </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the value was set successfully</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a48" doxytag="SkAnimator::setString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::setString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname" nowrap> <em>elementID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>fieldName</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>data</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the string value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>elementID</em> </td><td>is the value of the id attribute in the XML of this element </td></tr> - <tr><td valign="top"></td><td valign="top"><em>fieldName</em> </td><td>specifies the name of the attribute </td></tr> - <tr><td valign="top"></td><td valign="top"><em>data</em> </td><td>the string value to set </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the value was set successfully</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a47" doxytag="SkAnimator::setString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkAnimator::setString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkDisplayable * </td> - <td class="mdname" nowrap> <em>element</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMemberInfo * </td> - <td class="mdname" nowrap> <em>field</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char * </td> - <td class="mdname" nowrap> <em>data</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the string value of the specified element's attribute <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>element</em> </td><td>is a value returned by getElement </td></tr> - <tr><td valign="top"></td><td valign="top"><em>field</em> </td><td>is a value returned by getField </td></tr> - <tr><td valign="top"></td><td valign="top"><em>data</em> </td><td>the string value to set </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the value was set successfully</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a49" doxytag="SkAnimator::setTimeline"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::setTimeline </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkAnimator_1_1Timeline.html">Timeline</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets a user class to return the current time to the animator. Optional; if not called, the system clock will be used by calling SkTime::GetMSecs instead. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>callBack</em> </td><td>the time function</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a50" doxytag="SkAnimator::setURIBase"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkAnimator::setURIBase </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char * </td> - <td class="mdname1" valign="top" nowrap> <em>path</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Sets the file default directory of the URL base path <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>path</em> </td><td>the directory path</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkAnimator_8h-source.html">SkAnimator.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAnimator.png b/sgl_doxygen/html/classSkAnimator.png Binary files differdeleted file mode 100644 index 6affa96..0000000 --- a/sgl_doxygen/html/classSkAnimator.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkAnimator_1_1Timeline-members.html b/sgl_doxygen/html/classSkAnimator_1_1Timeline-members.html deleted file mode 100644 index a91db75..0000000 --- a/sgl_doxygen/html/classSkAnimator_1_1Timeline-members.html +++ /dev/null @@ -1,14 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAnimator::Timeline Member List</h1>This is the complete list of members for <a class="el" href="classSkAnimator_1_1Timeline.html">SkAnimator::Timeline</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkAnimator_1_1Timeline.html#a0">getMSecs</a>() const =0</td><td><a class="el" href="classSkAnimator_1_1Timeline.html">SkAnimator::Timeline</a></td><td><code> [pure virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAnimator_1_1Timeline.html b/sgl_doxygen/html/classSkAnimator_1_1Timeline.html deleted file mode 100644 index 5751552..0000000 --- a/sgl_doxygen/html/classSkAnimator_1_1Timeline.html +++ /dev/null @@ -1,55 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAnimator::Timeline Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="classSkAnimator.html">SkAnimator</a>::<a class="el" href="classSkAnimator_1_1Timeline.html">Timeline</a></div> -<h1>SkAnimator::Timeline Class Reference</h1><code>#include <<a class="el" href="SkAnimator_8h-source.html">SkAnimator.h</a>></code> -<p> -<a href="classSkAnimator_1_1Timeline-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual SkMSec </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkAnimator_1_1Timeline.html#a0">getMSecs</a> () const =0</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Returns current time to animator. To return a custom timeline, create a child class and override the getMSecs method. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a0" doxytag="SkAnimator::Timeline::getMSecs"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual SkMSec SkAnimator::Timeline::getMSecs </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [pure virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the current time in milliseconds </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkAnimator_8h-source.html">SkAnimator.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAutoCanvasRestore-members.html b/sgl_doxygen/html/classSkAutoCanvasRestore-members.html deleted file mode 100644 index ebbaa0f..0000000 --- a/sgl_doxygen/html/classSkAutoCanvasRestore-members.html +++ /dev/null @@ -1,15 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAutoCanvasRestore Member List</h1>This is the complete list of members for <a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>SkAutoCanvasRestore</b>(SkCanvas *canvas, bool doSave) (defined in <a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a>)</td><td><a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkAutoCanvasRestore</b>() (defined in <a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a>)</td><td><a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a></td><td><code> [inline]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAutoCanvasRestore.html b/sgl_doxygen/html/classSkAutoCanvasRestore.html deleted file mode 100644 index 85302b2..0000000 --- a/sgl_doxygen/html/classSkAutoCanvasRestore.html +++ /dev/null @@ -1,26 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAutoCanvasRestore Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAutoCanvasRestore Class Reference</h1><code>#include <<a class="el" href="SkCanvas_8h-source.html">SkCanvas.h</a>></code> -<p> -<a href="classSkAutoCanvasRestore-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkAutoCanvasRestore::SkAutoCanvasRestore"></a> - </td><td class="memItemRight" valign="bottom"><b>SkAutoCanvasRestore</b> (<a class="el" href="classSkCanvas.html">SkCanvas</a> *canvas, bool doSave)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Stack helper class to automatically call restoreToCount() on the canvas when this object goes out of scope. Use this to guarantee that the canvas is restored to a known state. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkCanvas_8h-source.html">SkCanvas.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAutoMaskImage-members.html b/sgl_doxygen/html/classSkAutoMaskImage-members.html deleted file mode 100644 index c889a30..0000000 --- a/sgl_doxygen/html/classSkAutoMaskImage-members.html +++ /dev/null @@ -1,15 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAutoMaskImage Member List</h1>This is the complete list of members for <a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>SkAutoMaskImage</b>(SkMask *mask, bool alloc) (defined in <a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a>)</td><td><a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkAutoMaskImage</b>() (defined in <a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a>)</td><td><a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a></td><td><code> [inline]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAutoMaskImage.html b/sgl_doxygen/html/classSkAutoMaskImage.html deleted file mode 100644 index a002d72..0000000 --- a/sgl_doxygen/html/classSkAutoMaskImage.html +++ /dev/null @@ -1,26 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAutoMaskImage Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAutoMaskImage Class Reference</h1><code>#include <<a class="el" href="SkMaskFilter_8h-source.html">SkMaskFilter.h</a>></code> -<p> -<a href="classSkAutoMaskImage-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkAutoMaskImage::SkAutoMaskImage"></a> - </td><td class="memItemRight" valign="bottom"><b>SkAutoMaskImage</b> (<a class="el" href="structSkMask.html">SkMask</a> *mask, bool alloc)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Stack class used to manage the fImage buffer in a <a class="el" href="structSkMask.html">SkMask</a>. When this object loses scope, the buffer is freed with SkMask::FreeImage(). -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkMaskFilter_8h-source.html">SkMaskFilter.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAutoUnref-members.html b/sgl_doxygen/html/classSkAutoUnref-members.html deleted file mode 100644 index 173c0c6..0000000 --- a/sgl_doxygen/html/classSkAutoUnref-members.html +++ /dev/null @@ -1,19 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAutoUnref Member List</h1>This is the complete list of members for <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>detach</b>() (defined in <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>)</td><td><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>get</b>() const (defined in <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>)</td><td><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>ref</b>() (defined in <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>)</td><td><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAutoUnref</b>(SkRefCnt *obj) (defined in <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>)</td><td><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>unref</b>() (defined in <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>)</td><td><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkAutoUnref</b>() (defined in <a class="el" href="classSkAutoUnref.html">SkAutoUnref</a>)</td><td><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkAutoUnref.html b/sgl_doxygen/html/classSkAutoUnref.html deleted file mode 100644 index 5814fa5..0000000 --- a/sgl_doxygen/html/classSkAutoUnref.html +++ /dev/null @@ -1,38 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkAutoUnref Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkAutoUnref Class Reference</h1><code>#include <<a class="el" href="SkRefCnt_8h-source.html">SkRefCnt.h</a>></code> -<p> -<a href="classSkAutoUnref-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkAutoUnref::SkAutoUnref"></a> - </td><td class="memItemRight" valign="bottom"><b>SkAutoUnref</b> (<a class="el" href="classSkRefCnt.html">SkRefCnt</a> *obj)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkAutoUnref::get"></a> -<a class="el" href="classSkRefCnt.html">SkRefCnt</a> * </td><td class="memItemRight" valign="bottom"><b>get</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkAutoUnref::ref"></a> -bool </td><td class="memItemRight" valign="bottom"><b>ref</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkAutoUnref::unref"></a> -bool </td><td class="memItemRight" valign="bottom"><b>unref</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkAutoUnref::detach"></a> -<a class="el" href="classSkRefCnt.html">SkRefCnt</a> * </td><td class="memItemRight" valign="bottom"><b>detach</b> ()</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkAutoUnref is a stack-helper class that will automatically call unref() on the object it points to when the SkAutoUnref object goes out of scope. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkRefCnt_8h-source.html">SkRefCnt.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBitmap-members.html b/sgl_doxygen/html/classSkBitmap-members.html deleted file mode 100644 index 0f2f18a..0000000 --- a/sgl_doxygen/html/classSkBitmap-members.html +++ /dev/null @@ -1,52 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBitmap Member List</h1>This is the complete list of members for <a class="el" href="classSkBitmap.html">SkBitmap</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a16">allocPixels</a>()</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a29">applyGamma</a>(const U8 red[256], const U8 green[256], const U8 blue[256])</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>applyGamma</b>(const U8 table[256]) (defined in <a class="el" href="classSkBitmap.html">SkBitmap</a>)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#w7">Config</a> enum name</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a21">eraseARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a23">eraseColor</a>(SkColor c)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a22">eraseRGB</a>(U8CPU r, U8CPU g, U8CPU b)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a28">getAddr1</a>(int x, int y) const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a25">getAddr16</a>(int x, int y) const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a24">getAddr32</a>(int x, int y) const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a26">getAddr8</a>(int x, int y) const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a19">getColorTable</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a5">getConfig</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a27">getIndex8Color</a>(int x, int y) const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a17">getOwnsPixels</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a9">getPixels</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a10">getSize</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a7">height</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a11">isOpaque</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#w7w1">kA1_Config</a> enum value</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#w7w2">kA8_Config</a> enum value</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#w7w5">kARGB_8888_Config</a> enum value</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kConfigCount</b> enum value (defined in <a class="el" href="classSkBitmap.html">SkBitmap</a>)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#w7w3">kIndex8_Config</a> enum value</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kNo_Config</b> enum value (defined in <a class="el" href="classSkBitmap.html">SkBitmap</a>)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#w7w4">kRGB_565_Config</a> enum value</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a3">operator=</a>(const SkBitmap &src)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a13">reset</a>()</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a8">rowBytes</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a20">setColorTable</a>(SkColorTable *ctable)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a14">setConfig</a>(Config, U16CPU width, U16CPU height, U16CPU rowBytes=0)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a12">setIsOpaque</a>(bool)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a18">setOwnsPixels</a>(bool ownsPixels)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a15">setPixels</a>(void *p)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a0">SkBitmap</a>()</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a1">SkBitmap</a>(const SkBitmap &src)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a4">swap</a>(SkBitmap &other)</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a6">width</a>() const </td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmap.html#a2">~SkBitmap</a>()</td><td><a class="el" href="classSkBitmap.html">SkBitmap</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBitmap.html b/sgl_doxygen/html/classSkBitmap.html deleted file mode 100644 index 18fd6d4..0000000 --- a/sgl_doxygen/html/classSkBitmap.html +++ /dev/null @@ -1,1084 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBitmap Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBitmap Class Reference</h1><code>#include <<a class="el" href="SkBitmap_8h-source.html">SkBitmap.h</a>></code> -<p> -<a href="classSkBitmap-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#w7">Config</a> { <br> - <b>kNo_Config</b>, -<a class="el" href="classSkBitmap.html#w7w1">kA1_Config</a>, -<a class="el" href="classSkBitmap.html#w7w2">kA8_Config</a>, -<a class="el" href="classSkBitmap.html#w7w3">kIndex8_Config</a>, -<br> - <a class="el" href="classSkBitmap.html#w7w4">kRGB_565_Config</a>, -<a class="el" href="classSkBitmap.html#w7w5">kARGB_8888_Config</a>, -<b>kConfigCount</b> -<br> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a0">SkBitmap</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a1">SkBitmap</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &src)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a2">~SkBitmap</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkBitmap.html">SkBitmap</a> & </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a3">operator=</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &src)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a4">swap</a> (<a class="el" href="classSkBitmap.html">SkBitmap</a> &other)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkBitmap.html#w7">Config</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a5">getConfig</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a6">width</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a7">height</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a8">rowBytes</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a9">getPixels</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a10">getSize</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a11">isOpaque</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a12">setIsOpaque</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a13">reset</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a14">setConfig</a> (<a class="el" href="classSkBitmap.html#w7">Config</a>, U16CPU width, U16CPU height, U16CPU rowBytes=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a15">setPixels</a> (void *p)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a16">allocPixels</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a17">getOwnsPixels</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a18">setOwnsPixels</a> (bool ownsPixels)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkColorTable.html">SkColorTable</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a19">getColorTable</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkColorTable.html">SkColorTable</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a20">setColorTable</a> (<a class="el" href="classSkColorTable.html">SkColorTable</a> *ctable)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a21">eraseARGB</a> (U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a22">eraseRGB</a> (U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a23">eraseColor</a> (<a class="el" href="SkColor_8h.html#a17">SkColor</a> c)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">uint32_t * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a24">getAddr32</a> (int x, int y) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">uint16_t * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a25">getAddr16</a> (int x, int y) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">uint8_t * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a26">getAddr8</a> (int x, int y) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a27">getIndex8Color</a> (int x, int y) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">uint8_t * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a28">getAddr1</a> (int x, int y) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmap.html#a29">applyGamma</a> (const U8 red[256], const U8 green[256], const U8 blue[256])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a30" doxytag="SkBitmap::applyGamma"></a> -void </td><td class="memItemRight" valign="bottom"><b>applyGamma</b> (const U8 table[256])</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -The SkBitmap class specifies a raster bitmap. A bitmap has an integer width and height, and a format (config), and a pointer to the actual pixels. Bitmaps can be drawn into a <a class="el" href="classSkCanvas.html">SkCanvas</a>, but they are also used to specify the target of a SkCanvas' drawing operations. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w7" doxytag="SkBitmap::Config"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkBitmap.html#w7">SkBitmap::Config</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w7w1" doxytag="kA1_Config"></a>kA1_Config</em> </td><td> -1-bit per pixel, (0 is transparent, 1 is opaque) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w7w2" doxytag="kA8_Config"></a>kA8_Config</em> </td><td> -8-bits per pixel, with only alpha specified (0 is transparent, 0xFF is opaque) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w7w3" doxytag="kIndex8_Config"></a>kIndex8_Config</em> </td><td> -8-bits per pixel, using <a class="el" href="classSkColorTable.html">SkColorTable</a> to specify the colors </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w7w4" doxytag="kRGB_565_Config"></a>kRGB_565_Config</em> </td><td> -16-bits per pixel, (see <a class="el" href="SkColorPriv_8h.html">SkColorPriv.h</a> for packing) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w7w5" doxytag="kARGB_8888_Config"></a>kARGB_8888_Config</em> </td><td> -32-bits per pixel, (see <a class="el" href="SkColorPriv_8h.html">SkColorPriv.h</a> for packing) </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkBitmap::SkBitmap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkBitmap::SkBitmap </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Default construct creates a bitmap with zero width and height, and no pixels. Its config is set to kNo_Config. </td> - </tr> -</table> -<a class="anchor" name="a1" doxytag="SkBitmap::SkBitmap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkBitmap::SkBitmap </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>src</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Constructor initializes the new bitmap by copying the src bitmap. All fields are copied, but ownership of the pixels remains with the src bitmap. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkBitmap::~SkBitmap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkBitmap::~<a class="el" href="classSkBitmap.html">SkBitmap</a> </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Destructor that, if <a class="el" href="classSkBitmap.html#a17">getOwnsPixels()</a> returns true, will delete the pixel's memory. </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a16" doxytag="SkBitmap::allocPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::allocPixels </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -If this is called, then the bitmap will dynamically allocate memory for its pixels based on rowBytes and height. The SkBitmap will remember that it allocated this, and will automatically free it as needed, thus <a class="el" href="classSkBitmap.html#a17">getOwnsPixels()</a> will now return true. </td> - </tr> -</table> -<a class="anchor" name="a29" doxytag="SkBitmap::applyGamma"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::applyGamma </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const U8 </td> - <td class="mdname" nowrap> <em>red</em>[256], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const U8 </td> - <td class="mdname" nowrap> <em>green</em>[256], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const U8 </td> - <td class="mdname" nowrap> <em>blue</em>[256]</td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call with a table of bytes. This will be applied to each R,G,B component of the image (e.g. R' = red[R]), automatically handling the case where the color component is less than 8 bits. The table assumes that each component is 8 bits. </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkBitmap::eraseARGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::eraseARGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>a</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Initialize the bitmap's pixels with the specified color+alpha, automatically converting into the correct format for the bitmap's config. If the config is kRGB_565_Config, then the alpha value is ignored. If the config is kA8_Config, then the r,g,b parameters are ignored. </td> - </tr> -</table> -<a class="anchor" name="a23" doxytag="SkBitmap::eraseColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::eraseColor </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - <td class="mdname1" valign="top" nowrap> <em>c</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Initialize the bitmap's pixels with the specified color, automatically converting into the correct format for the bitmap's config. If the config is kRGB_565_Config, then the color's alpha value is presumed to be 0xFF. If the config is kA8_Config, then only the color's alpha value is used. </td> - </tr> -</table> -<a class="anchor" name="a22" doxytag="SkBitmap::eraseRGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::eraseRGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Initialize the bitmap's pixels with the specified color+alpha, automatically converting into the correct format for the bitmap's config. If the config is kRGB_565_Config, then the alpha value is presumed to be 0xFF. If the config is kA8_Config, then the r,g,b parameters are ignored and the pixels are all set to 0xFF. </td> - </tr> -</table> -<a class="anchor" name="a28" doxytag="SkBitmap::getAddr1"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">uint8_t * SkBitmap::getAddr1 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the address of the byte containing the pixel specified by x,y. Asserts that x,y are in range, and that the bitmap's config is kA1_Config. </td> - </tr> -</table> -<a class="anchor" name="a25" doxytag="SkBitmap::getAddr16"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">uint16_t * SkBitmap::getAddr16 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the address of the pixel specified by x,y. Asserts that x,y are in range, and that the bitmap's config is kRGB_565_Config. </td> - </tr> -</table> -<a class="anchor" name="a24" doxytag="SkBitmap::getAddr32"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">uint32_t * SkBitmap::getAddr32 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the address of the pixel specified by x,y. Asserts that x,y are in range, and that the bitmap's config is either kARGB_8888_Config. </td> - </tr> -</table> -<a class="anchor" name="a26" doxytag="SkBitmap::getAddr8"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">uint8_t * SkBitmap::getAddr8 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the address of the pixel specified by x,y. Asserts that x,y are in range, and that the bitmap's config is either kA8_Config or kIndex8_Config. </td> - </tr> -</table> -<a class="anchor" name="a19" doxytag="SkBitmap::getColorTable"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkColorTable.html">SkColorTable</a>* SkBitmap::getColorTable </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the bitmap's colortable (if any). Does not affect the colortable's reference count. </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkBitmap::getConfig"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkBitmap.html#w7">Config</a> SkBitmap::getConfig </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the config for the bitmap. </td> - </tr> -</table> -<a class="anchor" name="a27" doxytag="SkBitmap::getIndex8Color"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> SkBitmap::getIndex8Color </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the color corresponding to the pixel specified by x,y. Asserts that x,y are in range, and that the bitmap's config is kIndex8_Config. </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkBitmap::getOwnsPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkBitmap::getOwnsPixels </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the current pixels have been allocated via <a class="el" href="classSkBitmap.html#a16">allocPixels()</a> or resizeAlloc(). </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkBitmap::getPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void* SkBitmap::getPixels </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the address of the pixels for this SkBitmap. This can be set either with <a class="el" href="classSkBitmap.html#a15">setPixels()</a>, where the caller owns the buffer, or with <a class="el" href="classSkBitmap.html#a16">allocPixels()</a> or resizeAlloc(), which marks the pixel memory to be owned by the SkBitmap (e.g. will be freed automatically when the bitmap is destroyed). </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkBitmap::getSize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">size_t SkBitmap::getSize </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the byte size of the pixels, based on the height and rowBytes </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkBitmap::height"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">unsigned SkBitmap::height </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the bitmap's height, in pixels. </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkBitmap::isOpaque"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkBitmap::isOpaque </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the bitmap is opaque (has no translucent/transparent pixels). </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkBitmap::operator="></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkBitmap.html">SkBitmap</a>& SkBitmap::operator= </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>src</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Copies the src bitmap into this bitmap. Ownership of the src bitmap's pixels remains with the src bitmap. </td> - </tr> -</table> -<a class="anchor" name="a13" doxytag="SkBitmap::reset"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::reset </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Reset the bitmap to its initial state (see default constructor). If <a class="el" href="classSkBitmap.html#a17">getOwnsPixels()</a> returned true, then the memory for the pixels is freed. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkBitmap::rowBytes"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">unsigned SkBitmap::rowBytes </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the number of bytes between subsequent rows of the bitmap. </td> - </tr> -</table> -<a class="anchor" name="a20" doxytag="SkBitmap::setColorTable"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkColorTable.html">SkColorTable</a>* SkBitmap::setColorTable </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkColorTable.html">SkColorTable</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>ctable</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Assign ctable to be the colortable for the bitmap, replacing any existing reference. The reference count of ctable (if it is not nil) is incremented, and any existing reference has its reference count decremented. NOTE: colortable's may be assigned to any bitmap, but are only interpreted for kIndex8_Config bitmaps, where they are required. <dl compact><dt><b>Returns:</b></dt><dd>the ctable argument</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a14" doxytag="SkBitmap::setConfig"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::setConfig </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkBitmap.html#w7">Config</a> </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U16CPU </td> - <td class="mdname" nowrap> <em>width</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U16CPU </td> - <td class="mdname" nowrap> <em>height</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U16CPU </td> - <td class="mdname" nowrap> <em>rowBytes</em> = <code>0</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the bitmap's config and dimensions. If rowBytes is 0, then an appropriate value is computed based on the bitmap's config and width. If <a class="el" href="classSkBitmap.html#a17">getOwnsPixels()</a> returned true, then the pixel's memory is freed. </td> - </tr> -</table> -<a class="anchor" name="a12" doxytag="SkBitmap::setIsOpaque"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::setIsOpaque </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Specify if this bitmap's pixels are all opaque or not. Is only meaningful for configs that support per-pixel alpha (RGB32, A1, A8). </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkBitmap::setOwnsPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::setOwnsPixels </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> <em>ownsPixels</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to explicitly change the ownership rule for the pixels. This may be called after one bitmap is copied into another, to specify which bitmap should handle freeing the memory. </td> - </tr> -</table> -<a class="anchor" name="a15" doxytag="SkBitmap::setPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::setPixels </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">void * </td> - <td class="mdname1" valign="top" nowrap> <em>p</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Use this to assign a new pixel address for an existing bitmap. If <a class="el" href="classSkBitmap.html#a17">getOwnsPixels()</a> returned true, then the previous pixel's memory is freed. The new address is "owned" by the called, and <a class="el" href="classSkBitmap.html#a17">getOwnsPixels()</a> will now return false. </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkBitmap::swap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkBitmap::swap </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>other</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Swap the fields of the two bitmaps. This routine is guaranteed to never fail or throw. </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkBitmap::width"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">unsigned SkBitmap::width </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the bitmap's width, in pixels. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkBitmap_8h-source.html">SkBitmap.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBitmapRef-members.html b/sgl_doxygen/html/classSkBitmapRef-members.html deleted file mode 100644 index e128d68..0000000 --- a/sgl_doxygen/html/classSkBitmapRef-members.html +++ /dev/null @@ -1,30 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBitmapRef Member List</h1>This is the complete list of members for <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>bitmap</b>() (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>create</b>(const SkBitmap &src, bool transferOwnsPixels) (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>DecodeFile</b>(const char file[], bool forceDecode) (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>DecodeMemory</b>(const void *bytes, size_t len) (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>DecodeStream</b>(SkStream *stream) (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmapRef.html#e4">PurgeCacheAll</a>()</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmapRef.html#e5">PurgeCacheOne</a>()</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBitmapRef.html#a0">SkBitmapRef</a>(const SkBitmap &src, bool transferOwnsPixels)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkBitmapRef_Globals</b> (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkBitmapRef</b>() (defined in <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a>)</td><td><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBitmapRef.html b/sgl_doxygen/html/classSkBitmapRef.html deleted file mode 100644 index 225ee6d..0000000 --- a/sgl_doxygen/html/classSkBitmapRef.html +++ /dev/null @@ -1,147 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBitmapRef Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBitmapRef Class Reference</h1><code>#include <<a class="el" href="SkBitmapRef_8h-source.html">SkBitmapRef.h</a>></code> -<p> -<p>Inheritance diagram for SkBitmapRef: -<p><center><img src="classSkBitmapRef.png" usemap="#SkBitmapRef_map" border="0" alt=""></center> -<map name="SkBitmapRef_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,82,24"> -</map> -<a href="classSkBitmapRef-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmapRef.html#a0">SkBitmapRef</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &src, bool transferOwnsPixels)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkBitmapRef::bitmap"></a> -const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td><td class="memItemRight" valign="bottom"><b>bitmap</b> ()</td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e0" doxytag="SkBitmapRef::create"></a> -static <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a> * </td><td class="memItemRight" valign="bottom"><b>create</b> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &src, bool transferOwnsPixels)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e1" doxytag="SkBitmapRef::DecodeFile"></a> -static <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a> * </td><td class="memItemRight" valign="bottom"><b>DecodeFile</b> (const char file[], bool forceDecode)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e2" doxytag="SkBitmapRef::DecodeMemory"></a> -static <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a> * </td><td class="memItemRight" valign="bottom"><b>DecodeMemory</b> (const void *bytes, size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e3" doxytag="SkBitmapRef::DecodeStream"></a> -static <a class="el" href="classSkBitmapRef.html">SkBitmapRef</a> * </td><td class="memItemRight" valign="bottom"><b>DecodeStream</b> (SkStream *stream)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmapRef.html#e4">PurgeCacheAll</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBitmapRef.html#e5">PurgeCacheOne</a> ()</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkBitmapRef::SkBitmapRef_Globals"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkBitmapRef_Globals</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Helper class to manage a cache of decoded images from the file system -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkBitmapRef::SkBitmapRef"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkBitmapRef::SkBitmapRef </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>transferOwnsPixels</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Create a non-cached bitmap, trasfering ownership of pixels if needed </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="e4" doxytag="SkBitmapRef::PurgeCacheAll"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkBitmapRef::PurgeCacheAll </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Frees all cached images, asserting that all references have been removed </td> - </tr> -</table> -<a class="anchor" name="e5" doxytag="SkBitmapRef::PurgeCacheOne"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkBitmapRef::PurgeCacheOne </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -frees one cached image, returning true, or returns false if none could be freed </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkBitmapRef_8h-source.html">SkBitmapRef.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBitmapRef.png b/sgl_doxygen/html/classSkBitmapRef.png Binary files differdeleted file mode 100644 index ff83a94..0000000 --- a/sgl_doxygen/html/classSkBitmapRef.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkBounder-members.html b/sgl_doxygen/html/classSkBounder-members.html deleted file mode 100644 index 9a2e215..0000000 --- a/sgl_doxygen/html/classSkBounder-members.html +++ /dev/null @@ -1,27 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBounder Member List</h1>This is the complete list of members for <a class="el" href="classSkBounder.html">SkBounder</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkBounder.html#b1">commit</a>()</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td><code> [protected, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>doHairline</b>(const SkPoint &, const SkPoint &, const SkPaint &, const SkRegion &) (defined in <a class="el" href="classSkBounder.html">SkBounder</a>)</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>doIRect</b>(const SkRect16 &, const SkRegion &) (defined in <a class="el" href="classSkBounder.html">SkBounder</a>)</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>doPath</b>(const SkPath &, const SkPaint &, const SkRegion &, SkScalar width) (defined in <a class="el" href="classSkBounder.html">SkBounder</a>)</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>doRect</b>(const SkRect &, const SkPaint &, const SkRegion &) (defined in <a class="el" href="classSkBounder.html">SkBounder</a>)</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBounder.html#b0">onIRect</a>(const SkRect16 &)=0</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td><code> [protected, pure virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAutoBounderCommit</b> (defined in <a class="el" href="classSkBounder.html">SkBounder</a>)</td><td><a class="el" href="classSkBounder.html">SkBounder</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBounder.html b/sgl_doxygen/html/classSkBounder.html deleted file mode 100644 index b172448..0000000 --- a/sgl_doxygen/html/classSkBounder.html +++ /dev/null @@ -1,105 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBounder Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBounder Class Reference</h1><code>#include <<a class="el" href="SkBounder_8h-source.html">SkBounder.h</a>></code> -<p> -<p>Inheritance diagram for SkBounder: -<p><center><img src="classSkBounder.png" usemap="#SkBounder_map" border="0" alt=""></center> -<map name="SkBounder_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,74,24"> -</map> -<a href="classSkBounder-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkBounder::doIRect"></a> -bool </td><td class="memItemRight" valign="bottom"><b>doIRect</b> (const SkRect16 &, const SkRegion &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkBounder::doHairline"></a> -bool </td><td class="memItemRight" valign="bottom"><b>doHairline</b> (const SkPoint &, const SkPoint &, const <a class="el" href="classSkPaint.html">SkPaint</a> &, const SkRegion &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkBounder::doRect"></a> -bool </td><td class="memItemRight" valign="bottom"><b>doRect</b> (const SkRect &, const <a class="el" href="classSkPaint.html">SkPaint</a> &, const SkRegion &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkBounder::doPath"></a> -bool </td><td class="memItemRight" valign="bottom"><b>doPath</b> (const <a class="el" href="classSkPath.html">SkPath</a> &, const <a class="el" href="classSkPaint.html">SkPaint</a> &, const SkRegion &, SkScalar width)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBounder.html#b0">onIRect</a> (const SkRect16 &)=0</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBounder.html#b1">commit</a> ()</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkBounder::SkAutoBounderCommit"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkAutoBounderCommit</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Base class for intercepting the device bounds of shapes before they are drawn. Install a subclass of this in your canvas. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="b1" doxytag="SkBounder::commit"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkBounder::commit </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [protected, virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called after each shape has been drawn. The default implementation does nothing, but your override could use this notification to signal itself that the offscreen being rendered into needs to be updated to the screen. </td> - </tr> -</table> -<a class="anchor" name="b0" doxytag="SkBounder::onIRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkBounder::onIRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect16 & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [protected, pure virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override in your subclass. This is called with the device bounds of an object (text, geometry, image) just before it is drawn. If your method returns false, the drawing for that shape is aborted. If your method returns true, drawing continues. The bounds your method receives have already been transformed in to device coordinates, and clipped to the current clip. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkBounder_8h-source.html">SkBounder.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBounder.png b/sgl_doxygen/html/classSkBounder.png Binary files differdeleted file mode 100644 index 2ecd70f..0000000 --- a/sgl_doxygen/html/classSkBounder.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkBufferStream-members.html b/sgl_doxygen/html/classSkBufferStream-members.html deleted file mode 100644 index 597184c..0000000 --- a/sgl_doxygen/html/classSkBufferStream-members.html +++ /dev/null @@ -1,19 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBufferStream Member List</h1>This is the complete list of members for <a class="el" href="classSkBufferStream.html">SkBufferStream</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>getFileName</b>() (defined in <a class="el" href="classSkBufferStream.html">SkBufferStream</a>)</td><td><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>read</b>(void *buffer, size_t size) (defined in <a class="el" href="classSkBufferStream.html">SkBufferStream</a>)</td><td><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>rewind</b>() (defined in <a class="el" href="classSkBufferStream.html">SkBufferStream</a>)</td><td><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBufferStream.html#a0">SkBufferStream</a>(SkStream &proxy, size_t bufferSize=0)</td><td><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkBufferStream.html#a1">SkBufferStream</a>(SkStream &proxy, void *buffer, size_t bufferSize)</td><td><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkBufferStream</b>() (defined in <a class="el" href="classSkBufferStream.html">SkBufferStream</a>)</td><td><a class="el" href="classSkBufferStream.html">SkBufferStream</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkBufferStream.html b/sgl_doxygen/html/classSkBufferStream.html deleted file mode 100644 index 2e69f7b..0000000 --- a/sgl_doxygen/html/classSkBufferStream.html +++ /dev/null @@ -1,117 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkBufferStream Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkBufferStream Class Reference</h1><code>#include <<a class="el" href="SkStream_8h-source.html">SkStream.h</a>></code> -<p> -<a href="classSkBufferStream-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBufferStream.html#a0">SkBufferStream</a> (SkStream &proxy, size_t bufferSize=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkBufferStream.html#a1">SkBufferStream</a> (SkStream &proxy, void *buffer, size_t bufferSize)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkBufferStream::rewind"></a> -virtual bool </td><td class="memItemRight" valign="bottom"><b>rewind</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkBufferStream::getFileName"></a> -virtual const char * </td><td class="memItemRight" valign="bottom"><b>getFileName</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkBufferStream::read"></a> -virtual size_t </td><td class="memItemRight" valign="bottom"><b>read</b> (void *buffer, size_t size)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -This is a wrapper class that adds buffering to another stream. The caller can provide the buffer, or ask SkBufferStream to allocated/free it automatically. -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkBufferStream::SkBufferStream"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkBufferStream::SkBufferStream </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkStream & </td> - <td class="mdname" nowrap> <em>proxy</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>bufferSize</em> = <code>0</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Provide the stream to be buffered (proxy), and the size of the buffer that should be used. This will be allocated and freed automatically. If bufferSize is 0, a default buffer size will be used. </td> - </tr> -</table> -<a class="anchor" name="a1" doxytag="SkBufferStream::SkBufferStream"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkBufferStream::SkBufferStream </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkStream & </td> - <td class="mdname" nowrap> <em>proxy</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>void * </td> - <td class="mdname" nowrap> <em>buffer</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>bufferSize</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Provide the stream to be buffered (proxy), and a buffer and size to be used. This buffer is owned by the caller, and must be at least bufferSize bytes big. Passing nil for buffer will cause the buffer to be allocated/freed automatically. If buffer is not nil, it is an error for bufferSize to be 0. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkStream_8h-source.html">SkStream.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkCanvas-members.html b/sgl_doxygen/html/classSkCanvas-members.html deleted file mode 100644 index fffab7a..0000000 --- a/sgl_doxygen/html/classSkCanvas-members.html +++ /dev/null @@ -1,58 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkCanvas Member List</h1>This is the complete list of members for <a class="el" href="classSkCanvas.html">SkCanvas</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a41">clipDeviceRgn</a>(const SkRegion &deviceRgn)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a16">clipPath</a>(const SkPath &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a14">clipRect</a>(const SkRect &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a15">clipRect</a>(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a13">concat</a>(const SkMatrix &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a21">drawARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a31">drawBitmap</a>(const SkBitmap &, SkScalar x, SkScalar y, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a32">drawBitmap</a>(const SkBitmap &, SkScalar x, SkScalar y)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a28">drawCircle</a>(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a22">drawColor</a>(SkColor)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a24">drawLine</a>(const SkPoint &start, const SkPoint &stop, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a25">drawLine</a>(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a27">drawOval</a>(const SkRect &oval, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a23">drawPaint</a>(const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a30">drawPath</a>(const SkPath &, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a26">drawRect</a>(const SkRect &, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a20">drawRGB</a>(U8CPU r, U8CPU g, U8CPU b)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a29">drawRoundRect</a>(const SkRect &, SkScalar rx, SkScalar ry, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a33">drawText</a>(const char text[], size_t byteLength, SkScalar x, SkScalar y, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a34">drawText16</a>(const U16 text[], size_t numberOf16BitValues, SkScalar x, SkScalar y, const SkPaint &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a36">drawText16OnPath</a>(const U16 text[], size_t numberOf16BitValues, const SkPath &path, SkScalar offset, const SkPaint &paint)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a35">drawTextOnPath</a>(const char text[], size_t byteLength, const SkPath &path, SkScalar offset, const SkPaint &paint)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a42">getBounder</a>() const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a38">getPaintClearBits</a>() const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a37">getPaintSetBits</a>() const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a3">getPixels</a>(SkBitmap *) const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a7">getSaveCount</a>() const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a40">orPaintSetClearBits</a>(U32 setBits, U32 clearBits)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a17">quickReject</a>(const SkRect &, bool antialiased=false) const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a18">quickReject</a>(const SkPath &, bool antialiased=false) const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a19">quickReject</a>(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, bool antialiased=false) const </td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a6">restore</a>()</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a8">restoreToCount</a>(int saveCount)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a11">rotate</a>(SkScalar degrees, SkScalar px, SkScalar py)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a5">save</a>()</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a10">scale</a>(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a43">setBounder</a>(SkBounder *)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a39">setPaintSetClearBits</a>(U32 setBits, U32 clrBits)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a4">setPixels</a>(const SkBitmap &)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkCanvas</b>() (defined in <a class="el" href="classSkCanvas.html">SkCanvas</a>)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkCanvas</b>(const SkBitmap &) (defined in <a class="el" href="classSkCanvas.html">SkCanvas</a>)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkDraw</b> (defined in <a class="el" href="classSkCanvas.html">SkCanvas</a>)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a12">skew</a>(SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCanvas.html#a9">translate</a>(SkScalar dx, SkScalar dy)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkCanvas</b>() (defined in <a class="el" href="classSkCanvas.html">SkCanvas</a>)</td><td><a class="el" href="classSkCanvas.html">SkCanvas</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkCanvas.html b/sgl_doxygen/html/classSkCanvas.html deleted file mode 100644 index 9c595ce..0000000 --- a/sgl_doxygen/html/classSkCanvas.html +++ /dev/null @@ -1,1787 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkCanvas Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkCanvas Class Reference</h1><code>#include <<a class="el" href="SkCanvas_8h-source.html">SkCanvas.h</a>></code> -<p> -<a href="classSkCanvas-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkCanvas::SkCanvas"></a> - </td><td class="memItemRight" valign="bottom"><b>SkCanvas</b> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a3">getPixels</a> (<a class="el" href="classSkBitmap.html">SkBitmap</a> *) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a4">setPixels</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a5">save</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a6">restore</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a7">getSaveCount</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a8">restoreToCount</a> (int saveCount)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a9">translate</a> (SkScalar dx, SkScalar dy)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a10">scale</a> (SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a11">rotate</a> (SkScalar degrees, SkScalar px, SkScalar py)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a12">skew</a> (SkScalar sx, SkScalar sy, SkScalar px, SkScalar py)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a13">concat</a> (const SkMatrix &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a14">clipRect</a> (const SkRect &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a15">clipRect</a> (SkScalar left, SkScalar top, SkScalar right, SkScalar bottom)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a16">clipPath</a> (const <a class="el" href="classSkPath.html">SkPath</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a17">quickReject</a> (const SkRect &, bool antialiased=false) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a18">quickReject</a> (const <a class="el" href="classSkPath.html">SkPath</a> &, bool antialiased=false) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a19">quickReject</a> (SkScalar left, SkScalar top, SkScalar right, SkScalar bottom, bool antialiased=false) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a20">drawRGB</a> (U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a21">drawARGB</a> (U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a22">drawColor</a> (<a class="el" href="SkColor_8h.html#a17">SkColor</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a23">drawPaint</a> (const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a24">drawLine</a> (const SkPoint &start, const SkPoint &stop, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a25">drawLine</a> (SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a26">drawRect</a> (const SkRect &, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a27">drawOval</a> (const SkRect &oval, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a28">drawCircle</a> (SkScalar cx, SkScalar cy, SkScalar radius, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a29">drawRoundRect</a> (const SkRect &, SkScalar rx, SkScalar ry, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a30">drawPath</a> (const <a class="el" href="classSkPath.html">SkPath</a> &, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a31">drawBitmap</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &, SkScalar x, SkScalar y, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a32">drawBitmap</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &, SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a33">drawText</a> (const char text[], size_t byteLength, SkScalar x, SkScalar y, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a34">drawText16</a> (const U16 text[], size_t numberOf16BitValues, SkScalar x, SkScalar y, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a35">drawTextOnPath</a> (const char text[], size_t byteLength, const <a class="el" href="classSkPath.html">SkPath</a> &path, SkScalar offset, const <a class="el" href="classSkPaint.html">SkPaint</a> &paint)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a36">drawText16OnPath</a> (const U16 text[], size_t numberOf16BitValues, const <a class="el" href="classSkPath.html">SkPath</a> &path, SkScalar offset, const <a class="el" href="classSkPaint.html">SkPaint</a> &paint)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a37">getPaintSetBits</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a38">getPaintClearBits</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a39">setPaintSetClearBits</a> (U32 setBits, U32 clrBits)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a40">orPaintSetClearBits</a> (U32 setBits, U32 clearBits)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a41">clipDeviceRgn</a> (const SkRegion &deviceRgn)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkBounder.html">SkBounder</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a42">getBounder</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkBounder.html">SkBounder</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCanvas.html#a43">setBounder</a> (<a class="el" href="classSkBounder.html">SkBounder</a> *)</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkCanvas::SkDraw"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkDraw</b></td></tr> - -<tr><td colspan="2"><br><h2>Classes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">struct </td><td class="memItemRight" valign="bottom"><b>MCRec</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -The SkCanvas class holds the "draw" calls. To draw something, you need 4 basic components: A <a class="el" href="classSkBitmap.html">SkBitmap</a> to hold the pixels, a SkCanvas to host the draw calls (writing into the bitmap), a drawing primitive (e.g. SkRect, <a class="el" href="classSkPath.html">SkPath</a>, text, <a class="el" href="classSkBitmap.html">SkBitmap</a>), and a <a class="el" href="classSkPaint.html">SkPaint</a> (to describe the colors and styles for the drawing). -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a41" doxytag="SkCanvas::clipDeviceRgn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::clipDeviceRgn </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRegion & </td> - <td class="mdname1" valign="top" nowrap> <em>deviceRgn</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Similar to <a class="el" href="classSkCanvas.html#a14">clipRect()</a> and <a class="el" href="classSkCanvas.html#a16">clipPath()</a>, this call restricts subsequent drawing to the intersection of the current clip and the specified region. NOTE: this region is specified in device coordinates, not local coordinates, and so unlike the parameters in <a class="el" href="classSkCanvas.html#a14">clipRect()</a> and <a class="el" href="classSkCanvas.html#a16">clipPath()</a>, this is NOT transformed by the CTM, but it is "removed" when <a class="el" href="classSkCanvas.html#a6">restore()</a> is called. </td> - </tr> -</table> -<a class="anchor" name="a16" doxytag="SkCanvas::clipPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::clipPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Intersect the current clip with the specified path. The path is first transformed by the current matrix. </td> - </tr> -</table> -<a class="anchor" name="a15" doxytag="SkCanvas::clipRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::clipRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>left</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>top</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>right</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>bottom</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Intersect the current clip with the specified rectangle. The rectangle is first transformed by the current matrix. </td> - </tr> -</table> -<a class="anchor" name="a14" doxytag="SkCanvas::clipRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::clipRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Intersect the current clip with the specified rectangle. The rectangle is first transformed by the current matrix. </td> - </tr> -</table> -<a class="anchor" name="a13" doxytag="SkCanvas::concat"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::concat </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkMatrix & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Preconcat the current matrix with the specified matrix. returns true if the operation succeeded (e.g. didn't overflow) </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkCanvas::drawARGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawARGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>a</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Fill the entire canvas' bitmap (restricted to the current clip) with the specified ARGB color. </td> - </tr> -</table> -<a class="anchor" name="a32" doxytag="SkCanvas::drawBitmap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawBitmap </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified bitmap, with its top/left corner at (x,y). </td> - </tr> -</table> -<a class="anchor" name="a31" doxytag="SkCanvas::drawBitmap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawBitmap </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified bitmap, with its top/left corner at (x,y), using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. </td> - </tr> -</table> -<a class="anchor" name="a28" doxytag="SkCanvas::drawCircle"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawCircle </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>cx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>cy</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>radius</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified circle using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. If radius is <= 0, then nothing will be drawn. The circle will be filled or framed based on the kStroke_Mask bit in the paint. </td> - </tr> -</table> -<a class="anchor" name="a22" doxytag="SkCanvas::drawColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawColor </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Fill the entire canvas' bitmap (restricted to the current clip) with the specified color. </td> - </tr> -</table> -<a class="anchor" name="a25" doxytag="SkCanvas::drawLine"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawLine </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x0</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y0</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw a line segment with the specified start and stop x,y coordinates, using the specified paint. NOTE: since a line is always "framed", the kStroke_Mask bit is ignored in the paint. </td> - </tr> -</table> -<a class="anchor" name="a24" doxytag="SkCanvas::drawLine"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawLine </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkPoint & </td> - <td class="mdname" nowrap> <em>start</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkPoint & </td> - <td class="mdname" nowrap> <em>stop</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw a line segment with the specified start and stop points, using the specified paint. NOTE: since a line is always "framed", the kStroke_Mask bit is ignored in the paint. </td> - </tr> -</table> -<a class="anchor" name="a27" doxytag="SkCanvas::drawOval"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawOval </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap> <em>oval</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified oval using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. The oval will be filled or framed based on the kStroke_Mask bit in the paint. </td> - </tr> -</table> -<a class="anchor" name="a23" doxytag="SkCanvas::drawPaint"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawPaint </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Fill the entire canvas' bitmap (restricted to the current clip) with the specified <a class="el" href="classSkPaint.html">SkPaint</a>. This is equivalent (but faster) to drawing an infinitely large rectangle with the specified paint. </td> - </tr> -</table> -<a class="anchor" name="a30" doxytag="SkCanvas::drawPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified path using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. The path will be filled or framed based on the kStroke_Mask bit in the paint. </td> - </tr> -</table> -<a class="anchor" name="a26" doxytag="SkCanvas::drawRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified SkRect using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. The rectangle will be filled or framed based on the kStroke_Mask bit in the paint. </td> - </tr> -</table> -<a class="anchor" name="a20" doxytag="SkCanvas::drawRGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawRGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Fill the entire canvas' bitmap (restricted to the current clip) with the specified RGB color. </td> - </tr> -</table> -<a class="anchor" name="a29" doxytag="SkCanvas::drawRoundRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawRoundRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>rx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>ry</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the specified round-rect using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. The round-rect will be filled or framed based on the kStroke_Mask bit in the paint. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>rx</em> </td><td>The X-radius of the oval used to round the corners </td></tr> - <tr><td valign="top"></td><td valign="top"><em>ry</em> </td><td>The Y-radius of the oval used to round the corners</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a33" doxytag="SkCanvas::drawText"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawText </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>byteLength</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the utf8-text, with origin at (x,y), using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. The origin is interpreted based on the Align setting in the <a class="el" href="classSkPaint.html">SkPaint</a>. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>text</em> </td><td>The UTF8 text to be drawn </td></tr> - <tr><td valign="top"></td><td valign="top"><em>byteLength</em> </td><td>The number of bytes to read from the text parameter </td></tr> - <tr><td valign="top"></td><td valign="top"><em>paint</em> </td><td>The paint used for the text (e.g. color, size, style)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a34" doxytag="SkCanvas::drawText16"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawText16 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const U16 </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>numberOf16BitValues</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the utf8-text, with origin at (x,y), using the specified <a class="el" href="classSkPaint.html">SkPaint</a>. The origin is interpreted based on the Align setting in the <a class="el" href="classSkPaint.html">SkPaint</a>. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>text</em> </td><td>The UTF16 text to be drawn </td></tr> - <tr><td valign="top"></td><td valign="top"><em>numberOf16BitValues</em> </td><td>The number of 16bit values to read from the text parameter </td></tr> - <tr><td valign="top"></td><td valign="top"><em>paint</em> </td><td>The paint used for the text (e.g. color, size, style)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a36" doxytag="SkCanvas::drawText16OnPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawText16OnPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const U16 </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>numberOf16BitValues</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>path</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>offset</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap> <em>paint</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the utf8-text, with origin at (x,y), using the specified <a class="el" href="classSkPaint.html">SkPaint</a>, along the specified path. The paint's Align setting determins where along the path to start the text. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>text</em> </td><td>The UTF16 text to be drawn </td></tr> - <tr><td valign="top"></td><td valign="top"><em>numberOf16BitValues</em> </td><td>The number of 16bit values to read from the text parameter </td></tr> - <tr><td valign="top"></td><td valign="top"><em>path</em> </td><td>The path the text should follow for its baseline </td></tr> - <tr><td valign="top"></td><td valign="top"><em>offset</em> </td><td>The distance along the path to add to the text's starting position </td></tr> - <tr><td valign="top"></td><td valign="top"><em>paint</em> </td><td>The paint used for the text (e.g. color, size, style)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a35" doxytag="SkCanvas::drawTextOnPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::drawTextOnPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>byteLength</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>path</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>offset</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap> <em>paint</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Draw the utf8-text, with origin at (x,y), using the specified <a class="el" href="classSkPaint.html">SkPaint</a>, along the specified path. The paint's Align setting determins where along the path to start the text. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>text</em> </td><td>The UTF8 text to be drawn </td></tr> - <tr><td valign="top"></td><td valign="top"><em>byteLength</em> </td><td>The number of bytes to read from the text parameter </td></tr> - <tr><td valign="top"></td><td valign="top"><em>path</em> </td><td>The path the text should follow for its baseline </td></tr> - <tr><td valign="top"></td><td valign="top"><em>offset</em> </td><td>The distance along the path to add to the text's starting position </td></tr> - <tr><td valign="top"></td><td valign="top"><em>paint</em> </td><td>The paint used for the text (e.g. color, size, style)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a42" doxytag="SkCanvas::getBounder"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkBounder.html">SkBounder</a>* SkCanvas::getBounder </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the installed bounder (or nil). Does not affect the bounder's reference count. </td> - </tr> -</table> -<a class="anchor" name="a38" doxytag="SkCanvas::getPaintClearBits"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U32 SkCanvas::getPaintClearBits </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the current clear mask, used to temporarily modify the paint's flags when something is being drawin. </td> - </tr> -</table> -<a class="anchor" name="a37" doxytag="SkCanvas::getPaintSetBits"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U32 SkCanvas::getPaintSetBits </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the current set mask, used to temporarily modify the paint's flags when something is being drawin. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkCanvas::getPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::getPixels </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkBitmap.html">SkBitmap</a> * </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a copy of the bitmap that the canvas draws into. This does not make a copy of the bitmap's pixels, but just returns the pixel's address. </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkCanvas::getSaveCount"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int SkCanvas::getSaveCount </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the number of matrix/clip states on the SkCanvas' private stack. This will equal # <a class="el" href="classSkCanvas.html#a5">save()</a> calls - # <a class="el" href="classSkCanvas.html#a6">restore()</a> calls. </td> - </tr> -</table> -<a class="anchor" name="a40" doxytag="SkCanvas::orPaintSetClearBits"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::orPaintSetClearBits </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U32 </td> - <td class="mdname" nowrap> <em>setBits</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U32 </td> - <td class="mdname" nowrap> <em>clearBits</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for getPaintSetClearBits/setPaintSetClearBits. The parameters are OR'd into the current values, rather than replacing them as with setPaintSetClearBits. </td> - </tr> -</table> -<a class="anchor" name="a19" doxytag="SkCanvas::quickReject"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::quickReject </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>left</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>top</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>right</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>bottom</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>antialiased</em> = <code>false</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper version of quickReject(const SkRect&, ...) </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkCanvas::quickReject"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::quickReject </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>antialiased</em> = <code>false</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return true if the specified path, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls). Note, for speed it may return false even if the path itself might not intersect the clip (i.e. the bounds of the path intersects, but the path doesnot). <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>path</em> </td><td>The path to check against </td></tr> - <tr><td valign="top"></td><td valign="top"><em>antialiased</em> </td><td>true if the path should be considered antialiased, since that means it may affect a larger area (more pixels) than non-antialiased. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the path (transformed by the canvas' matrix) does not intersect with the canvas' clip</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkCanvas::quickReject"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::quickReject </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>antialiased</em> = <code>false</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return true if the specified rectangle, after being transformed by the current matrix, would lie completely outside of the current clip. Call this to check if an area you intend to draw into is clipped out (and therefore you can skip making the draw calls). <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>rect</em> </td><td>the rect to check against </td></tr> - <tr><td valign="top"></td><td valign="top"><em>antialiased</em> </td><td>true if the rect should be considered antialiased, since that means it may affect a larger area (more pixels) than non-antialiased. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the rect (transformed by the canvas' matrix) does not intersect with the canvas' clip</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkCanvas::restore"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::restore </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -This call balances a previous call to <a class="el" href="classSkCanvas.html#a5">save()</a>, and is used to remove all modifications to the matrix/clip state since the last save call. It is an error to call <a class="el" href="classSkCanvas.html#a6">restore()</a> more times than <a class="el" href="classSkCanvas.html#a5">save()</a> was called. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkCanvas::restoreToCount"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::restoreToCount </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname1" valign="top" nowrap> <em>saveCount</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Efficient way to pop any calls to <a class="el" href="classSkCanvas.html#a5">save()</a> that happened after the save count reached saveCount. </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkCanvas::rotate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::rotate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>degrees</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>px</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>py</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Preconcat the current matrix with the specified rotation and pivot point. The pivot is the point that will remain unchanged after the rotation is applied. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>degrees</em> </td><td>The amount to rotate, in degrees </td></tr> - <tr><td valign="top"></td><td valign="top"><em>px</em> </td><td>The pivot's X coordinate </td></tr> - <tr><td valign="top"></td><td valign="top"><em>py</em> </td><td>The pivot's Y coordinate returns true if the operation succeeded (e.g. didn't overflow)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkCanvas::save"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::save </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -This call saves the current matrix and clip information, and pushes a copy onto a private stack. Subsequent calls to translate,scale,rotate,skew,concat or clipRect,clipPath all operate on this copy. When the balancing call to <a class="el" href="classSkCanvas.html#a6">restore()</a> is made, this copy is deleted and the previous matrix/clip state is restored. </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkCanvas::scale"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::scale </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>sx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>sy</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>px</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>py</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Preconcat the current matrix with the specified scale and pivot point. The pivot is the point that will remain unchanged after the scale is applied. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>sx</em> </td><td>The amount to scale in X, about the pivot point (px,py) </td></tr> - <tr><td valign="top"></td><td valign="top"><em>sy</em> </td><td>The amount to scale in Y, about the pivot point (px,py) </td></tr> - <tr><td valign="top"></td><td valign="top"><em>px</em> </td><td>The pivot's X coordinate </td></tr> - <tr><td valign="top"></td><td valign="top"><em>py</em> </td><td>The pivot's Y coordinate returns true if the operation succeeded (e.g. didn't overflow)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a43" doxytag="SkCanvas::setBounder"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkBounder.html">SkBounder</a>* SkCanvas::setBounder </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkBounder.html">SkBounder</a> * </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set a new bounder (or nil), incrementing the new bounder's reference count (if not nil) and decrementing the previous bounder's reference count (if not nil). <dl compact><dt><b>Returns:</b></dt><dd>the new bounder (or nil if nil was specified)</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a39" doxytag="SkCanvas::setPaintSetClearBits"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::setPaintSetClearBits </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U32 </td> - <td class="mdname" nowrap> <em>setBits</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U32 </td> - <td class="mdname" nowrap> <em>clrBits</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the current set and clear masks, used to temporarily modify the paint's flags when something is being drawin. The setBits are applied before the clrBits. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>setBits</em> </td><td>A mask of bits to be OR'd into the paint's flag bits </td></tr> - <tr><td valign="top"></td><td valign="top"><em>clrBits</em> </td><td>A mask of bits to be cleared from the paint's flag bits</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkCanvas::setPixels"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkCanvas::setPixels </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Specify a bitmap for the canvas to draw into. This routine makes a copy of the bitmap, but does not copy the actual pixels. Ownership of the bitmap's pixels stays with the caller's bitmap. </td> - </tr> -</table> -<a class="anchor" name="a12" doxytag="SkCanvas::skew"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::skew </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>sx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>sy</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>px</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>py</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Preconcat the current matrix with the specified skew and pivot point. The pivot is the point that will remain unchanged after the skew is applied. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>sx</em> </td><td>The amount to skew in X, about the pivot point (px,py) </td></tr> - <tr><td valign="top"></td><td valign="top"><em>sy</em> </td><td>The amount to skew in Y, about the pivot point (px,py) </td></tr> - <tr><td valign="top"></td><td valign="top"><em>px</em> </td><td>The pivot's X coordinate </td></tr> - <tr><td valign="top"></td><td valign="top"><em>py</em> </td><td>The pivot's Y coordinate returns true if the operation succeeded (e.g. didn't overflow)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkCanvas::translate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkCanvas::translate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>dx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>dy</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Preconcat the current matrix with the specified translation <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>dx</em> </td><td>The distance to translate in X </td></tr> - <tr><td valign="top"></td><td valign="top"><em>dy</em> </td><td>The distance to translate in Y returns true if the operation succeeded (e.g. didn't overflow)</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkCanvas_8h-source.html">SkCanvas.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkColorTable-members.html b/sgl_doxygen/html/classSkColorTable-members.html deleted file mode 100644 index 196d023..0000000 --- a/sgl_doxygen/html/classSkColorTable-members.html +++ /dev/null @@ -1,34 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkColorTable Member List</h1>This is the complete list of members for <a class="el" href="classSkColorTable.html">SkColorTable</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a4">count</a>() const </td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#w1">Flags</a> enum name</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a2">getFlags</a>() const </td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#w1w0">kColorsAreOpaque_Flag</a> enum value</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a10">lock16BitCache</a>()</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a8">lockColors</a>()</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a5">operator[]</a>(int index) const </td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a6">setColors</a>(int count)</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setColors</b>(const SkPMColor[], int count) (defined in <a class="el" href="classSkColorTable.html">SkColorTable</a>)</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a3">setFlags</a>(unsigned flags)</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a0">SkColorTable</a>()</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a11">unlock16BitCache</a>()</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkColorTable.html#a9">unlockColors</a>(bool changed)</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkColorTable</b>() (defined in <a class="el" href="classSkColorTable.html">SkColorTable</a>)</td><td><a class="el" href="classSkColorTable.html">SkColorTable</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkColorTable.html b/sgl_doxygen/html/classSkColorTable.html deleted file mode 100644 index dc6803a..0000000 --- a/sgl_doxygen/html/classSkColorTable.html +++ /dev/null @@ -1,361 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkColorTable Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkColorTable Class Reference</h1><code>#include <<a class="el" href="SkBitmap_8h-source.html">SkBitmap.h</a>></code> -<p> -<p>Inheritance diagram for SkColorTable: -<p><center><img src="classSkColorTable.png" usemap="#SkColorTable_map" border="0" alt=""></center> -<map name="SkColorTable_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,88,24"> -</map> -<a href="classSkColorTable-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#w1">Flags</a> { <a class="el" href="classSkColorTable.html#w1w0">kColorsAreOpaque_Flag</a> = 0x01 - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a0">SkColorTable</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">unsigned </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a2">getFlags</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a3">setFlags</a> (unsigned flags)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a4">count</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a5">operator[]</a> (int index) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a6">setColors</a> (int count)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a7" doxytag="SkColorTable::setColors"></a> -void </td><td class="memItemRight" valign="bottom"><b>setColors</b> (const <a class="el" href="SkColor_8h.html#a18">SkPMColor</a>[], int count)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a8">lockColors</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a9">unlockColors</a> (bool changed)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const uint16_t * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a10">lock16BitCache</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkColorTable.html#a11">unlock16BitCache</a> ()</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkColorTable holds an array SkPMColors (premultiplied 32-bit colors) used by 8-bit bitmaps, where the bitmap bytes are interpreted as indices into the colortable. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w1" doxytag="SkColorTable::Flags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkColorTable.html#w1">SkColorTable::Flags</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w1w0" doxytag="kColorsAreOpaque_Flag"></a>kColorsAreOpaque_Flag</em> </td><td> -if set, all of the colors in the table are opaque (alpha==0xFF) </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkColorTable::SkColorTable"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkColorTable::SkColorTable </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Constructs an empty color table (zero colors). </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a4" doxytag="SkColorTable::count"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int SkColorTable::count </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the number of colors in the table. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkColorTable::getFlags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">unsigned SkColorTable::getFlags </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the flag bits for the color table. These can be changed with <a class="el" href="classSkColorTable.html#a3">setFlags()</a>. </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkColorTable::lock16BitCache"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const uint16_t* SkColorTable::lock16BitCache </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Similar to <a class="el" href="classSkColorTable.html#a8">lockColors()</a>, <a class="el" href="classSkColorTable.html#a10">lock16BitCache()</a> returns the array of RGB16 colors that mirror the 32bit colors. However, this function will return nil if kColorsAreOpaque_Flag is not set. Also, unlike <a class="el" href="classSkColorTable.html#a8">lockColors()</a>, the returned array here cannot be modified. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkColorTable::lockColors"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a>* SkColorTable::lockColors </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the array of colors for reading and/or writing. This must be balanced by a call to unlockColors(changed?), telling the colortable if the colors were changed during the lock. </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkColorTable::operator[]"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> SkColorTable::operator[] </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname1" valign="top" nowrap> <em>index</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the specified color from the table. In the debug build, this asserts that the index is in range (0 <= index < count). </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkColorTable::setColors"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkColorTable::setColors </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname1" valign="top" nowrap> <em>count</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Specify the number of colors in the color table. This does not initialize the colors to any value, just allocates memory for them. To initialize the values, either call setColors(array, count), or follow setCount(count) with a call to <a class="el" href="classSkColorTable.html#a8">lockColors()</a>/{set the values}/unlockColors(true). </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkColorTable::setFlags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkColorTable::setFlags </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">unsigned </td> - <td class="mdname1" valign="top" nowrap> <em>flags</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the flags for the color table. See the Flags enum for possible values. </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkColorTable::unlock16BitCache"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkColorTable::unlock16BitCache </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Balancing call to <a class="el" href="classSkColorTable.html#a10">lock16BitCache()</a>. </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkColorTable::unlockColors"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkColorTable::unlockColors </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> <em>changed</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Balancing call to <a class="el" href="classSkColorTable.html#a8">lockColors()</a>. If the colors have been changed, pass true. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkBitmap_8h-source.html">SkBitmap.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkColorTable.png b/sgl_doxygen/html/classSkColorTable.png Binary files differdeleted file mode 100644 index dd103f2..0000000 --- a/sgl_doxygen/html/classSkColorTable.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkComposePathEffect-members.html b/sgl_doxygen/html/classSkComposePathEffect-members.html deleted file mode 100644 index fb9c765..0000000 --- a/sgl_doxygen/html/classSkComposePathEffect-members.html +++ /dev/null @@ -1,32 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkComposePathEffect Member List</h1>This is the complete list of members for <a class="el" href="classSkComposePathEffect.html">SkComposePathEffect</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkComposePathEffect.html#a1">filterPath</a>(SkPath *dst, const SkPath &src, SkScalar *width)</td><td><a class="el" href="classSkComposePathEffect.html">SkComposePathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fPE0</b> (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fPE1</b> (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkComposePathEffect.html#a2">getFactory</a>()</td><td><a class="el" href="classSkComposePathEffect.html">SkComposePathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a>(SkPathEffect *outer, SkPathEffect *inner)</td><td><a class="el" href="classSkComposePathEffect.html">SkComposePathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPairPathEffect</b>(SkPathEffect *pe0, SkPathEffect *pe1) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPairPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>() (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkPairPathEffect</b>() (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkComposePathEffect.html b/sgl_doxygen/html/classSkComposePathEffect.html deleted file mode 100644 index 249e027..0000000 --- a/sgl_doxygen/html/classSkComposePathEffect.html +++ /dev/null @@ -1,150 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkComposePathEffect Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkComposePathEffect Class Reference</h1><code>#include <<a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a>></code> -<p> -<p>Inheritance diagram for SkComposePathEffect: -<p><center><img src="classSkComposePathEffect.png" usemap="#SkComposePathEffect_map" border="0" alt=""></center> -<map name="SkComposePathEffect_map"> -<area href="classSkPairPathEffect.html" alt="SkPairPathEffect" shape="rect" coords="0,168,136,192"> -<area href="classSkPathEffect.html" alt="SkPathEffect" shape="rect" coords="0,112,136,136"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="0,56,136,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,136,24"> -</map> -<a href="classSkComposePathEffect-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a> (<a class="el" href="classSkPathEffect.html">SkPathEffect</a> *outer, <a class="el" href="classSkPathEffect.html">SkPathEffect</a> *inner)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkComposePathEffect.html#a1">filterPath</a> (<a class="el" href="classSkPath.html">SkPath</a> *dst, const <a class="el" href="classSkPath.html">SkPath</a> &src, SkScalar *width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual Factory </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkComposePathEffect.html#a2">getFactory</a> ()</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -This subclass of <a class="el" href="classSkPathEffect.html">SkPathEffect</a> composes its two arguments, to create a compound pathEffect. -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkComposePathEffect::SkComposePathEffect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkComposePathEffect::SkComposePathEffect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td> - <td class="mdname" nowrap> <em>outer</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td> - <td class="mdname" nowrap> <em>inner</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Construct a pathEffect whose effect is to apply first the inner pathEffect and the the outer pathEffect (e.g. outer(inner(path))) The reference counts for outer and inner are both incremented in the constructor, and decremented in the destructor. </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a1" doxytag="SkComposePathEffect::filterPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkComposePathEffect::filterPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>width</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a src path and a width value, return true if the patheffect has produced a new path (dst) and a new width value. If false is returned, ignore dst and width. On input, width >= 0 means the src should be stroked On output, width >= 0 means the dst should be stroked -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a1">SkPathEffect</a>. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkComposePathEffect::getFactory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual Factory SkComposePathEffect::getFactory </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -overrides for <a class="el" href="classSkFlattenable.html">SkFlattenable</a>. Subclasses should override this to (re)create their subclass -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a2">SkPathEffect</a>. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkComposePathEffect.png b/sgl_doxygen/html/classSkComposePathEffect.png Binary files differdeleted file mode 100644 index 4f9be93..0000000 --- a/sgl_doxygen/html/classSkComposePathEffect.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkCornerPathEffect-members.html b/sgl_doxygen/html/classSkCornerPathEffect-members.html deleted file mode 100644 index 27571ae..0000000 --- a/sgl_doxygen/html/classSkCornerPathEffect-members.html +++ /dev/null @@ -1,29 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkCornerPathEffect Member List</h1>This is the complete list of members for <a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCornerPathEffect.html#a2">filterPath</a>(SkPath *dst, const SkPath &src, SkScalar *width)</td><td><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer) (defined in <a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>)</td><td><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCornerPathEffect.html#a3">getFactory</a>()</td><td><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a>(SkScalar radius)</td><td><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkCornerPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>)</td><td><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>() (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkCornerPathEffect</b>() (defined in <a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a>)</td><td><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkCornerPathEffect.html b/sgl_doxygen/html/classSkCornerPathEffect.html deleted file mode 100644 index bef00e5..0000000 --- a/sgl_doxygen/html/classSkCornerPathEffect.html +++ /dev/null @@ -1,147 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkCornerPathEffect Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkCornerPathEffect Class Reference</h1><code>#include <<a class="el" href="SkCornerPathEffect_8h-source.html">SkCornerPathEffect.h</a>></code> -<p> -<p>Inheritance diagram for SkCornerPathEffect: -<p><center><img src="classSkCornerPathEffect.png" usemap="#SkCornerPathEffect_map" border="0" alt=""></center> -<map name="SkCornerPathEffect_map"> -<area href="classSkPathEffect.html" alt="SkPathEffect" shape="rect" coords="0,112,124,136"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="0,56,124,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,124,24"> -</map> -<a href="classSkCornerPathEffect-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a> (SkScalar radius)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCornerPathEffect.html#a2">filterPath</a> (<a class="el" href="classSkPath.html">SkPath</a> *dst, const <a class="el" href="classSkPath.html">SkPath</a> &src, SkScalar *width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual Factory </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkCornerPathEffect.html#a3">getFactory</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkCornerPathEffect::flatten"></a> -virtual U32 </td><td class="memItemRight" valign="bottom"><b>flatten</b> (void *buffer)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkCornerPathEffect::SkCornerPathEffect"></a> - </td><td class="memItemRight" valign="bottom"><b>SkCornerPathEffect</b> (const void *buffer)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkCornerPathEffect is a subclass of <a class="el" href="classSkPathEffect.html">SkPathEffect</a> that can turn sharp corners into various treatments (e.g. rounded corners) -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkCornerPathEffect::SkCornerPathEffect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkCornerPathEffect::SkCornerPathEffect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> <em>radius</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -radius must be > 0 to have an effect. It specifies the distance from each corner that should be "rounded". </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a2" doxytag="SkCornerPathEffect::filterPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkCornerPathEffect::filterPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>width</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a src path and a width value, return true if the patheffect has produced a new path (dst) and a new width value. If false is returned, ignore dst and width. On input, width >= 0 means the src should be stroked On output, width >= 0 means the dst should be stroked -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a1">SkPathEffect</a>. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkCornerPathEffect::getFactory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual Factory SkCornerPathEffect::getFactory </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -overrides for <a class="el" href="classSkFlattenable.html">SkFlattenable</a>. Subclasses should override this to (re)create their subclass -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a2">SkPathEffect</a>. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkCornerPathEffect_8h-source.html">SkCornerPathEffect.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkCornerPathEffect.png b/sgl_doxygen/html/classSkCornerPathEffect.png Binary files differdeleted file mode 100644 index ce231f6..0000000 --- a/sgl_doxygen/html/classSkCornerPathEffect.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkDashPathEffect-members.html b/sgl_doxygen/html/classSkDashPathEffect-members.html deleted file mode 100644 index 0a2dd13..0000000 --- a/sgl_doxygen/html/classSkDashPathEffect-members.html +++ /dev/null @@ -1,28 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkDashPathEffect Member List</h1>This is the complete list of members for <a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkDashPathEffect.html#a2">filterPath</a>(SkPath *dst, const SkPath &src, SkScalar *width)</td><td><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer) (defined in <a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a>)</td><td><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkDashPathEffect.html#a3">getFactory</a>()</td><td><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkDashPathEffect.html#a0">SkDashPathEffect</a>(const SkScalar intervals[], int count, SkScalar phase, bool scaleToFit=false)</td><td><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>() (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkDashPathEffect</b>() (defined in <a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a>)</td><td><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkDashPathEffect.html b/sgl_doxygen/html/classSkDashPathEffect.html deleted file mode 100644 index 270f57f..0000000 --- a/sgl_doxygen/html/classSkDashPathEffect.html +++ /dev/null @@ -1,164 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDashPathEffect Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkDashPathEffect Class Reference</h1><code>#include <<a class="el" href="SkDashPathEffect_8h-source.html">SkDashPathEffect.h</a>></code> -<p> -<p>Inheritance diagram for SkDashPathEffect: -<p><center><img src="classSkDashPathEffect.png" usemap="#SkDashPathEffect_map" border="0" alt=""></center> -<map name="SkDashPathEffect_map"> -<area href="classSkPathEffect.html" alt="SkPathEffect" shape="rect" coords="0,112,113,136"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="0,56,113,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,113,24"> -</map> -<a href="classSkDashPathEffect-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkDashPathEffect.html#a0">SkDashPathEffect</a> (const SkScalar intervals[], int count, SkScalar phase, bool scaleToFit=false)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkDashPathEffect.html#a2">filterPath</a> (<a class="el" href="classSkPath.html">SkPath</a> *dst, const <a class="el" href="classSkPath.html">SkPath</a> &src, SkScalar *width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual Factory </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkDashPathEffect.html#a3">getFactory</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkDashPathEffect::flatten"></a> -virtual U32 </td><td class="memItemRight" valign="bottom"><b>flatten</b> (void *buffer)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkDashPathEffect is a subclass of <a class="el" href="classSkPathEffect.html">SkPathEffect</a> that implements dashing -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkDashPathEffect::SkDashPathEffect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkDashPathEffect::SkDashPathEffect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkScalar </td> - <td class="mdname" nowrap> <em>intervals</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>phase</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>scaleToFit</em> = <code>false</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -The intervals array must contain an even number of entries (>=2), with the even indices specifying the "on" intervals, and the odd indices specifying the "off" intervals. phase is an offset into the intervals array (mod the sum of all of the intervals). Note: only affects framed paths </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a2" doxytag="SkDashPathEffect::filterPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkDashPathEffect::filterPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>width</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a src path and a width value, return true if the patheffect has produced a new path (dst) and a new width value. If false is returned, ignore dst and width. On input, width >= 0 means the src should be stroked On output, width >= 0 means the dst should be stroked -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a1">SkPathEffect</a>. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkDashPathEffect::getFactory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual Factory SkDashPathEffect::getFactory </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -overrides for <a class="el" href="classSkFlattenable.html">SkFlattenable</a>. Subclasses should override this to (re)create their subclass -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a2">SkPathEffect</a>. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkDashPathEffect_8h-source.html">SkDashPathEffect.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkDashPathEffect.png b/sgl_doxygen/html/classSkDashPathEffect.png Binary files differdeleted file mode 100644 index ae45727..0000000 --- a/sgl_doxygen/html/classSkDashPathEffect.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkDiscreteMapper-members.html b/sgl_doxygen/html/classSkDiscreteMapper-members.html deleted file mode 100644 index 4968637..0000000 --- a/sgl_doxygen/html/classSkDiscreteMapper-members.html +++ /dev/null @@ -1,15 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkDiscreteMapper Member List</h1>This is the complete list of members for <a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>mapUnit16</b>(U16CPU x) (defined in <a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a>)</td><td><a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkDiscreteMapper</b>(unsigned segments) (defined in <a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a>)</td><td><a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkDiscreteMapper.html b/sgl_doxygen/html/classSkDiscreteMapper.html deleted file mode 100644 index fc78ecb..0000000 --- a/sgl_doxygen/html/classSkDiscreteMapper.html +++ /dev/null @@ -1,29 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkDiscreteMapper Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkDiscreteMapper Class Reference</h1><code>#include <<a class="el" href="SkUnitMapper_8h-source.html">SkUnitMapper.h</a>></code> -<p> -<a href="classSkDiscreteMapper-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkDiscreteMapper::SkDiscreteMapper"></a> - </td><td class="memItemRight" valign="bottom"><b>SkDiscreteMapper</b> (unsigned segments)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkDiscreteMapper::mapUnit16"></a> -virtual U16CPU </td><td class="memItemRight" valign="bottom"><b>mapUnit16</b> (U16CPU x)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -This returns N values between [0...1] -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkUnitMapper_8h-source.html">SkUnitMapper.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkEvent-members.html b/sgl_doxygen/html/classSkEvent-members.html deleted file mode 100644 index 3d1c416..0000000 --- a/sgl_doxygen/html/classSkEvent-members.html +++ /dev/null @@ -1,61 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkEvent Member List</h1>This is the complete list of members for <a class="el" href="classSkEvent.html">SkEvent</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>delay</b> (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>findBool</b>(const char name[], bool *value) const (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a16">findPtr</a>(const char name[], void **value) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a12">findS32</a>(const char name[], S32 *value=nil) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a13">findScalar</a>(const char name[], SkScalar *value=nil) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a14">findScalars</a>(const char name[], int *count, SkScalar values[]=nil) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a15">findString</a>(const char name[]) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a10">getFast32</a>() const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a30">getMetaData</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a31">getMetaData</a>() const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a5">getType</a>(SkString *str) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>hasBool</b>(const char name[], bool value) const (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a21">hasPtr</a>(const char name[], void *value) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a18">hasS32</a>(const char name[], S32 value) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a19">hasScalar</a>(const char name[], SkScalar value) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a20">hasString</a>(const char name[], const char value[]) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a35">inflate</a>(const SkDOM &, const SkDOM::Node *)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e1">Init</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>isDebugTrace</b>() const (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a6">isType</a>(const SkString &str) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a7">isType</a>(const char type[], size_t len=0) const </td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a37">post</a>(SkEventSinkID sinkID, SkMSec delay=0)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e0">PostTime</a>(SkEvent *evt, SkEventSinkID targetID, SkMSec time)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>postTime</b>(SkEventSinkID sinkID, SkMSec time) (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e3">ProcessEvent</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e4">ServiceQueueTimer</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setBool</b>(const char name[], bool value) (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a11">setFast32</a>(U32 x)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a28">setPtr</a>(const char name[], void *value)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a23">setS32</a>(const char name[], S32 value)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a24">setScalar</a>(const char name[], SkScalar value)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a25">setScalars</a>(const char name[], int count, const SkScalar values[]=nil)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a26">setString</a>(const char name[], const SkString &value)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a27">setString</a>(const char name[], const char value[])</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a8">setType</a>(const SkString &)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a9">setType</a>(const char type[], size_t len=0)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e5">SignalNonEmptyQueue</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e6">SignalQueueTimer</a>(SkMSec delay)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a36">SkDEBUGCODE</a>(void dump(const char title[]=nil);) static bool Post(SkEvent *evt</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a0">SkEvent</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a1">SkEvent</a>(const SkString &type)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [explicit]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a2">SkEvent</a>(const char type[])</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [explicit]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#a3">SkEvent</a>(const SkEvent &src)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>targetID</b> (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEvent.html#e2">Term</a>()</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>troff</b>() (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>tron</b>() (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkEvent</b>() (defined in <a class="el" href="classSkEvent.html">SkEvent</a>)</td><td><a class="el" href="classSkEvent.html">SkEvent</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkEvent.html b/sgl_doxygen/html/classSkEvent.html deleted file mode 100644 index bca335a..0000000 --- a/sgl_doxygen/html/classSkEvent.html +++ /dev/null @@ -1,1374 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkEvent Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkEvent Class Reference</h1><code>#include <<a class="el" href="SkEvent_8h-source.html">SkEvent.h</a>></code> -<p> -<a href="classSkEvent-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a0">SkEvent</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a1">SkEvent</a> (const <a class="el" href="classSkString.html">SkString</a> &type)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a2">SkEvent</a> (const char type[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a3">SkEvent</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &src)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a5">getType</a> (<a class="el" href="classSkString.html">SkString</a> *str) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a6">isType</a> (const <a class="el" href="classSkString.html">SkString</a> &str) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a7">isType</a> (const char type[], size_t len=0) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a8">setType</a> (const <a class="el" href="classSkString.html">SkString</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a9">setType</a> (const char type[], size_t len=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a10">getFast32</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a11">setFast32</a> (U32 x)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a12">findS32</a> (const char name[], S32 *value=nil) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a13">findScalar</a> (const char name[], SkScalar *value=nil) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkScalar * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a14">findScalars</a> (const char name[], int *count, SkScalar values[]=nil) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const char * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a15">findString</a> (const char name[]) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a16">findPtr</a> (const char name[], void **value) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a17" doxytag="SkEvent::findBool"></a> -bool </td><td class="memItemRight" valign="bottom"><b>findBool</b> (const char name[], bool *value) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a18">hasS32</a> (const char name[], S32 value) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a19">hasScalar</a> (const char name[], SkScalar value) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a20">hasString</a> (const char name[], const char value[]) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a21">hasPtr</a> (const char name[], void *value) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a22" doxytag="SkEvent::hasBool"></a> -bool </td><td class="memItemRight" valign="bottom"><b>hasBool</b> (const char name[], bool value) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a23">setS32</a> (const char name[], S32 value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a24">setScalar</a> (const char name[], SkScalar value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a25">setScalars</a> (const char name[], int count, const SkScalar values[]=nil)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a26">setString</a> (const char name[], const <a class="el" href="classSkString.html">SkString</a> &value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a27">setString</a> (const char name[], const char value[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a28">setPtr</a> (const char name[], void *value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a29" doxytag="SkEvent::setBool"></a> -void </td><td class="memItemRight" valign="bottom"><b>setBool</b> (const char name[], bool value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkMetaData & </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a30">getMetaData</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkMetaData & </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a31">getMetaData</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a32" doxytag="SkEvent::tron"></a> -void </td><td class="memItemRight" valign="bottom"><b>tron</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a33" doxytag="SkEvent::troff"></a> -void </td><td class="memItemRight" valign="bottom"><b>troff</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a34" doxytag="SkEvent::isDebugTrace"></a> -bool </td><td class="memItemRight" valign="bottom"><b>isDebugTrace</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a35">inflate</a> (const SkDOM &, const SkDOM::Node *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a36">SkDEBUGCODE</a> (void dump(const char title[]=nil);) static bool Post(<a class="el" href="classSkEvent.html">SkEvent</a> *evt</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#a37">post</a> (SkEventSinkID sinkID, SkMSec delay=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a38" doxytag="SkEvent::postTime"></a> -void </td><td class="memItemRight" valign="bottom"><b>postTime</b> (SkEventSinkID sinkID, SkMSec time)</td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e0">PostTime</a> (<a class="el" href="classSkEvent.html">SkEvent</a> *evt, SkEventSinkID targetID, SkMSec time)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e1">Init</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e2">Term</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e3">ProcessEvent</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e4">ServiceQueueTimer</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e5">SignalNonEmptyQueue</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEvent.html#e6">SignalQueueTimer</a> (SkMSec delay)</td></tr> - -<tr><td colspan="2"><br><h2>Public Attributes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="o0" doxytag="SkEvent::targetID"></a> -SkEventSinkID </td><td class="memItemRight" valign="bottom"><b>targetID</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="o1" doxytag="SkEvent::delay"></a> -SkEventSinkID SkMSec </td><td class="memItemRight" valign="bottom"><b>delay</b> = 0)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkEvents are used to communicate type-safe information to SkEventSinks. SkEventSinks (including SkViews) each have a unique ID, which is stored in an event. This ID is used to target the event once it has been "posted". -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkEvent::SkEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkEvent::SkEvent </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Default construct, creating an empty event. </td> - </tr> -</table> -<a class="anchor" name="a1" doxytag="SkEvent::SkEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkEvent::SkEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkString.html">SkString</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>type</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [explicit]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Construct a new event with the specified type. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkEvent::SkEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkEvent::SkEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname1" valign="top" nowrap> <em>type</em>[] </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [explicit]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Construct a new event with the specified type. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkEvent::SkEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkEvent::SkEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>src</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Construct a new event by copying the fields from the src event. </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a16" doxytag="SkEvent::findPtr"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::findPtr </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>void ** </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return true if the event contains the named pointer field, and return the field in value (if value is non-nil). If there is no matching named field, return false and ignore the value parameter. </td> - </tr> -</table> -<a class="anchor" name="a12" doxytag="SkEvent::findS32"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::findS32 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>S32 * </td> - <td class="mdname" nowrap> <em>value</em> = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return true if the event contains the named 32bit field, and return the field in value (if value is non-nil). If there is no matching named field, return false and ignore the value parameter. </td> - </tr> -</table> -<a class="anchor" name="a13" doxytag="SkEvent::findScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::findScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>value</em> = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return true if the event contains the named SkScalar field, and return the field in value (if value is non-nil). If there is no matching named field, return false and ignore the value parameter. </td> - </tr> -</table> -<a class="anchor" name="a14" doxytag="SkEvent::findScalars"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkScalar* SkEvent::findScalars </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int * </td> - <td class="mdname" nowrap> <em>count</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>values</em>[] = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return true if the event contains the named SkScalar field, and return the fields in value[] (if value is non-nil), and return the number of SkScalars in count (if count is non-nil). If there is no matching named field, return false and ignore the value and count parameters. </td> - </tr> -</table> -<a class="anchor" name="a15" doxytag="SkEvent::findString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const char* SkEvent::findString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname1" valign="top" nowrap> <em>name</em>[] </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the value of the named string field, or if no matching named field exists, return nil. </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkEvent::getFast32"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U32 SkEvent::getFast32 </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the event's unnamed 32bit field. Default value is 0 </td> - </tr> -</table> -<a class="anchor" name="a31" doxytag="SkEvent::getMetaData"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkMetaData& SkEvent::getMetaData </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the underlying metadata object </td> - </tr> -</table> -<a class="anchor" name="a30" doxytag="SkEvent::getMetaData"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkMetaData& SkEvent::getMetaData </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the underlying metadata object </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkEvent::getType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::getType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkString.html">SkString</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>str</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Copy the event's type into the specified <a class="el" href="classSkString.html">SkString</a> parameter </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkEvent::hasPtr"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::hasPtr </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>void * </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if ethe event contains the named pointer field, and if it equals the specified value </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkEvent::hasS32"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::hasS32 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>S32 </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if ethe event contains the named 32bit field, and if it equals the specified value </td> - </tr> -</table> -<a class="anchor" name="a19" doxytag="SkEvent::hasScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::hasScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if ethe event contains the named SkScalar field, and if it equals the specified value </td> - </tr> -</table> -<a class="anchor" name="a20" doxytag="SkEvent::hasString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::hasString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char </td> - <td class="mdname" nowrap> <em>value</em>[]</td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if ethe event contains the named string field, and if it equals (using strcmp) the specified value </td> - </tr> -</table> -<a class="anchor" name="a35" doxytag="SkEvent::inflate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::inflate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDOM & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkDOM::Node * </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to initialize the event from the specified XML node </td> - </tr> -</table> -<a class="anchor" name="e1" doxytag="SkEvent::Init"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkEvent::Init </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Global initialization function for the SkEvent system. Should be called exactly once before any other event method is called, and should be called after the call to SkGraphics::Init(). </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkEvent::isType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::isType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>type</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>len</em> = <code>0</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the event's type matches exactly the specified type (case sensitive) </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkEvent::isType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::isType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkString.html">SkString</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>str</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the event's type matches exactly the specified type (case sensitive) </td> - </tr> -</table> -<a class="anchor" name="a37" doxytag="SkEvent::post"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEvent::post </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkEventSinkID </td> - <td class="mdname" nowrap> <em>sinkID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkMSec </td> - <td class="mdname" nowrap> <em>delay</em> = <code>0</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper method for calling <a class="el" href="classSkEvent.html#e0">SkEvent::PostTime</a>(this, ...), where the caller specifies a delay. The real "time" will be computed automatically by sampling the clock and adding its value to delay. </td> - </tr> -</table> -<a class="anchor" name="e0" doxytag="SkEvent::PostTime"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkEvent::PostTime </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkEvent.html">SkEvent</a> * </td> - <td class="mdname" nowrap> <em>evt</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkEventSinkID </td> - <td class="mdname" nowrap> <em>targetID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkMSec </td> - <td class="mdname" nowrap> <em>time</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Post the specified event to the event queue, targeting the specified eventsink, to be delivered on/after the specified millisecond time. The event must be dynamically allocated for this. It cannot be a global or on the stack. After this call, ownership is transfered to the system, so the caller must not retain the event's ptr. Returns false if the event could not be posted (which means it will have been deleted). </td> - </tr> -</table> -<a class="anchor" name="e3" doxytag="SkEvent::ProcessEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkEvent::ProcessEvent </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to process one event from the queue. If it returns true, there are more events to process. </td> - </tr> -</table> -<a class="anchor" name="e4" doxytag="SkEvent::ServiceQueueTimer"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkEvent::ServiceQueueTimer </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this whenever the requested timer has expired (requested by a call to SetQueueTimer). It will post any delayed events whose time as "expired" onto the event queue. It may also call <a class="el" href="classSkEvent.html#e6">SignalQueueTimer()</a> and <a class="el" href="classSkEvent.html#e5">SignalNonEmptyQueue()</a>. </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkEvent::setFast32"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setFast32 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U32 </td> - <td class="mdname1" valign="top" nowrap> <em>x</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the event's unnamed 32bit field. In XML, use the subelement <data fast32=... /> </td> - </tr> -</table> -<a class="anchor" name="a28" doxytag="SkEvent::setPtr"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setPtr </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>void * </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add/replace the named pointer field to the event. There is no XML equivalent for this call </td> - </tr> -</table> -<a class="anchor" name="a23" doxytag="SkEvent::setS32"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setS32 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>S32 </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add/replace the named 32bit field to the event. In XML use the subelement <data name=... s32=... /> </td> - </tr> -</table> -<a class="anchor" name="a24" doxytag="SkEvent::setScalar"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setScalar </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add/replace the named SkScalar field to the event. In XML use the subelement <data name=... scalar=... /> </td> - </tr> -</table> -<a class="anchor" name="a25" doxytag="SkEvent::setScalars"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar* SkEvent::setScalars </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkScalar </td> - <td class="mdname" nowrap> <em>values</em>[] = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add/replace the named SkScalar[] field to the event. </td> - </tr> -</table> -<a class="anchor" name="a27" doxytag="SkEvent::setString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char </td> - <td class="mdname" nowrap> <em>value</em>[]</td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add/replace the named string field to the event. In XML use the subelement <data name=... string=... </td> - </tr> -</table> -<a class="anchor" name="a26" doxytag="SkEvent::setString"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setString </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkString.html">SkString</a> & </td> - <td class="mdname" nowrap> <em>value</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add/replace the named string field to the event. In XML use the subelement <data name=... string=... </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkEvent::setType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>type</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>len</em> = <code>0</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the event's type to the specified string. In XML, use the "type" attribute. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkEvent::setType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEvent::setType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkString.html">SkString</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the event's type to the specified string. In XML, use the "type" attribute. </td> - </tr> -</table> -<a class="anchor" name="e5" doxytag="SkEvent::SignalNonEmptyQueue"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkEvent::SignalNonEmptyQueue </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called whenever an SkEvent is posted to an empty queue, so that the OS can be told to later call Dequeue(). </td> - </tr> -</table> -<a class="anchor" name="e6" doxytag="SkEvent::SignalQueueTimer"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkEvent::SignalQueueTimer </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkMSec </td> - <td class="mdname1" valign="top" nowrap> <em>delay</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called whenever the delay until the next delayed event changes. If zero is passed, then there are no more queued delay events. </td> - </tr> -</table> -<a class="anchor" name="a36" doxytag="SkEvent::SkDEBUGCODE"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkEvent::SkDEBUGCODE </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">void dump(const char title[]=nil); </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Post the specified event to the event queue, targeting the specified eventsink, with an optional delay. The event must be dynamically allocated for this. It cannot be a global or on the stack. After this call, ownership is transfered to the system, so the caller must not retain the event's ptr. Returns false if the event could not be posted (which means it will have been deleted). </td> - </tr> -</table> -<a class="anchor" name="e2" doxytag="SkEvent::Term"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkEvent::Term </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Global cleanup function for the SkEvent system. Should be called exactly once after all event methods have been called, and should be called before calling SkGraphics::Term(). </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkEvent_8h-source.html">SkEvent.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkEventSink-members.html b/sgl_doxygen/html/classSkEventSink-members.html deleted file mode 100644 index 31fe606..0000000 --- a/sgl_doxygen/html/classSkEventSink-members.html +++ /dev/null @@ -1,41 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkEventSink Member List</h1>This is the complete list of members for <a class="el" href="classSkEventSink.html">SkEventSink</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a5">addListenerID</a>(SkEventSinkID sinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>addTagList</b>(SkTagList *) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a6">copyListeners</a>(const SkEventSink &from)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#e0">DoEvent</a>(const SkEvent &, SkEventSinkID targetID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a3">doEvent</a>(const SkEvent &)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a4">doQuery</a>(SkEvent *query)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3">EventResult</a> enum name</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#e1">FindSink</a>(SkEventSinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>findTagList</b>(U8CPU tag) const (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a2">getSinkID</a>() const </td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a8">hasListeners</a>() const </td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w0">kHandled_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w1">kNotHandled_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w2">kSinkNotFound_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#b0">onEvent</a>(const SkEvent &)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onQuery</b>(SkEvent *) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected, virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a9">postToListeners</a>(const SkEvent &evt, SkMSec delay=0)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a7">removeListenerID</a>(SkEventSinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>removeTagList</b>(U8CPU tag) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkEventSink</b>() (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkEventSink</b>() (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkEventSink.html b/sgl_doxygen/html/classSkEventSink.html deleted file mode 100644 index f520b77..0000000 --- a/sgl_doxygen/html/classSkEventSink.html +++ /dev/null @@ -1,436 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkEventSink Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkEventSink Class Reference</h1><code>#include <<a class="el" href="SkEventSink_8h-source.html">SkEventSink.h</a>></code> -<p> -<p>Inheritance diagram for SkEventSink: -<p><center><img src="classSkEventSink.png" usemap="#SkEventSink_map" border="0" alt=""></center> -<map name="SkEventSink_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="118,0,226,24"> -<area href="classSkAnimator.html" alt="SkAnimator" shape="rect" coords="0,112,108,136"> -<area href="classSkView.html" alt="SkView" shape="rect" coords="236,112,344,136"> -</map> -<a href="classSkEventSink-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#w3">EventResult</a> { <a class="el" href="classSkEventSink.html#w3w0">kHandled_EventResult</a>, -<a class="el" href="classSkEventSink.html#w3w1">kNotHandled_EventResult</a>, -<a class="el" href="classSkEventSink.html#w3w2">kSinkNotFound_EventResult</a> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkEventSinkID </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a2">getSinkID</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a3">doEvent</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a4">doQuery</a> (<a class="el" href="classSkEvent.html">SkEvent</a> *query)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a5">addListenerID</a> (SkEventSinkID sinkID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a6">copyListeners</a> (const <a class="el" href="classSkEventSink.html">SkEventSink</a> &from)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a7">removeListenerID</a> (SkEventSinkID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a8">hasListeners</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#a9">postToListeners</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &evt, SkMSec delay=0)</td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">static <a class="el" href="classSkEventSink.html#w3">EventResult</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#e0">DoEvent</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &, SkEventSinkID targetID)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static <a class="el" href="classSkEventSink.html">SkEventSink</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#e1">FindSink</a> (SkEventSinkID)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkEventSink.html#b0">onEvent</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b1" doxytag="SkEventSink::onQuery"></a> -virtual bool </td><td class="memItemRight" valign="bottom"><b>onQuery</b> (<a class="el" href="classSkEvent.html">SkEvent</a> *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b2" doxytag="SkEventSink::findTagList"></a> -SkTagList * </td><td class="memItemRight" valign="bottom"><b>findTagList</b> (U8CPU tag) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b3" doxytag="SkEventSink::addTagList"></a> -void </td><td class="memItemRight" valign="bottom"><b>addTagList</b> (SkTagList *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b4" doxytag="SkEventSink::removeTagList"></a> -void </td><td class="memItemRight" valign="bottom"><b>removeTagList</b> (U8CPU tag)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkEventSink is the base class for all objects that receive SkEvents. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w3" doxytag="SkEventSink::EventResult"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkEventSink.html#w3">SkEventSink::EventResult</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w3w0" doxytag="kHandled_EventResult"></a>kHandled_EventResult</em> </td><td> -the eventsink returned true from its doEvent method </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w3w1" doxytag="kNotHandled_EventResult"></a>kNotHandled_EventResult</em> </td><td> -the eventsink returned false from its doEvent method </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w3w2" doxytag="kSinkNotFound_EventResult"></a>kSinkNotFound_EventResult</em> </td><td> -no matching eventsink was found for the event's getSink(). </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a5" doxytag="SkEventSink::addListenerID"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEventSink::addListenerID </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkEventSinkID </td> - <td class="mdname1" valign="top" nowrap> <em>sinkID</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add sinkID to the list of listeners, to receive events from calls to sendToListeners() and <a class="el" href="classSkEventSink.html#a9">postToListeners()</a>. If sinkID already exists in the listener list, no change is made. </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkEventSink::copyListeners"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEventSink::copyListeners </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEventSink.html">SkEventSink</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>from</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Copy listeners from one event sink to another, typically from parent to child. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>from</em> </td><td>the event sink to copy the listeners from</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="e0" doxytag="SkEventSink::DoEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static <a class="el" href="classSkEventSink.html#w3">EventResult</a> SkEventSink::DoEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkEventSinkID </td> - <td class="mdname" nowrap> <em>targetID</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -DoEvent handles searching for an eventsink object that matches the targetID. If one is found, it calls the sink's doEvent method, returning either kHandled_EventResult or kNotHandled_EventResult. If no matching eventsink is found, kSinkNotFound_EventResult is returned. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkEventSink::doEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEventSink::doEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to pass an event to this object for processing. Returns true if the event was handled. </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkEventSink::doQuery"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEventSink::doQuery </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkEvent.html">SkEvent</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>query</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the sink (or one of its subclasses) understands the event as a query. If so, the sink may modify the event to communicate its "answer". </td> - </tr> -</table> -<a class="anchor" name="e1" doxytag="SkEventSink::FindSink"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static <a class="el" href="classSkEventSink.html">SkEventSink</a>* SkEventSink::FindSink </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkEventSinkID </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the matching eventsink, or nil if not found </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkEventSink::getSinkID"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkEventSinkID SkEventSink::getSinkID </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns this eventsink's unique ID. Use this to post SkEvents to this eventsink. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkEventSink::hasListeners"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkEventSink::hasListeners </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if there are 1 or more listeners attached to this eventsink </td> - </tr> -</table> -<a class="anchor" name="b0" doxytag="SkEventSink::onEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkEventSink::onEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [protected, virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override this to handle events in your subclass. Be sure to call the inherited version for events that you don't handle. </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkEventSink::postToListeners"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEventSink::postToListeners </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname" nowrap> <em>evt</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkMSec </td> - <td class="mdname" nowrap> <em>delay</em> = <code>0</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Posts a copy of evt to each of the eventsinks in the lisener list. </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkEventSink::removeListenerID"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkEventSink::removeListenerID </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkEventSinkID </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Remove sinkID from the list of listeners. If sinkID does not appear in the list, no change is made. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkEventSink_8h-source.html">SkEventSink.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkEventSink.png b/sgl_doxygen/html/classSkEventSink.png Binary files differdeleted file mode 100644 index 3ad03ea..0000000 --- a/sgl_doxygen/html/classSkEventSink.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkFlattenable-members.html b/sgl_doxygen/html/classSkFlattenable-members.html deleted file mode 100644 index 236065b..0000000 --- a/sgl_doxygen/html/classSkFlattenable-members.html +++ /dev/null @@ -1,23 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkFlattenable Member List</h1>This is the complete list of members for <a class="el" href="classSkFlattenable.html">SkFlattenable</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer=nil) (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getFactory</b>() (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkFlattenable.html b/sgl_doxygen/html/classSkFlattenable.html deleted file mode 100644 index b996799..0000000 --- a/sgl_doxygen/html/classSkFlattenable.html +++ /dev/null @@ -1,43 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkFlattenable Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkFlattenable Class Reference</h1><code>#include <<a class="el" href="SkFlattenable_8h-source.html">SkFlattenable.h</a>></code> -<p> -<p>Inheritance diagram for SkFlattenable: -<p><center><img src="classSkFlattenable.png" usemap="#SkFlattenable_map" border="0" alt=""></center> -<map name="SkFlattenable_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="141,0,272,24"> -<area href="classSkMaskFilter.html" alt="SkMaskFilter" shape="rect" coords="0,112,131,136"> -<area href="classSkPathEffect.html" alt="SkPathEffect" shape="rect" coords="282,112,413,136"> -<area href="classSkCornerPathEffect.html" alt="SkCornerPathEffect" shape="rect" coords="423,280,554,304"> -<area href="classSkDashPathEffect.html" alt="SkDashPathEffect" shape="rect" coords="423,336,554,360"> -<area href="classSkPairPathEffect.html" alt="SkPairPathEffect" shape="rect" coords="423,448,554,472"> -</map> -<a href="classSkFlattenable-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="w0" doxytag="SkFlattenable::Factory"></a> -typedef <a class="el" href="classSkFlattenable.html">SkFlattenable</a> *(* </td><td class="memItemRight" valign="bottom"><b>Factory</b> )(const void *buffer)</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkFlattenable::getFactory"></a> -virtual Factory </td><td class="memItemRight" valign="bottom"><b>getFactory</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkFlattenable::flatten"></a> -virtual U32 </td><td class="memItemRight" valign="bottom"><b>flatten</b> (void *buffer=nil)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkFlattenable is the base class for objects that need to be flattened into a data stream for either transport or as part of the key to the font cache. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkFlattenable_8h-source.html">SkFlattenable.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkFlattenable.png b/sgl_doxygen/html/classSkFlattenable.png Binary files differdeleted file mode 100644 index ea8ed2c..0000000 --- a/sgl_doxygen/html/classSkFlattenable.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkFlipCosineMapper-members.html b/sgl_doxygen/html/classSkFlipCosineMapper-members.html deleted file mode 100644 index 8586523..0000000 --- a/sgl_doxygen/html/classSkFlipCosineMapper-members.html +++ /dev/null @@ -1,14 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkFlipCosineMapper Member List</h1>This is the complete list of members for <a class="el" href="classSkFlipCosineMapper.html">SkFlipCosineMapper</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>mapUnit16</b>(U16CPU x) (defined in <a class="el" href="classSkFlipCosineMapper.html">SkFlipCosineMapper</a>)</td><td><a class="el" href="classSkFlipCosineMapper.html">SkFlipCosineMapper</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkFlipCosineMapper.html b/sgl_doxygen/html/classSkFlipCosineMapper.html deleted file mode 100644 index 78cee2f..0000000 --- a/sgl_doxygen/html/classSkFlipCosineMapper.html +++ /dev/null @@ -1,26 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkFlipCosineMapper Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkFlipCosineMapper Class Reference</h1><code>#include <<a class="el" href="SkUnitMapper_8h-source.html">SkUnitMapper.h</a>></code> -<p> -<a href="classSkFlipCosineMapper-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkFlipCosineMapper::mapUnit16"></a> -virtual U16CPU </td><td class="memItemRight" valign="bottom"><b>mapUnit16</b> (U16CPU x)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -This returns 1 - cos(x), to simulate lighting a sphere -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkUnitMapper_8h-source.html">SkUnitMapper.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkFontHost-members.html b/sgl_doxygen/html/classSkFontHost-members.html deleted file mode 100644 index 7b4eb57..0000000 --- a/sgl_doxygen/html/classSkFontHost-members.html +++ /dev/null @@ -1,16 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkFontHost Member List</h1>This is the complete list of members for <a class="el" href="classSkFontHost.html">SkFontHost</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkFontHost.html#e2">CreateScalarContext</a>(const SkDescriptor *desc)</td><td><a class="el" href="classSkFontHost.html">SkFontHost</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkFontHost.html#e0">CreateTypeface</a>(const SkTypeface *family, const char name[], SkTypeface::Style)</td><td><a class="el" href="classSkFontHost.html">SkFontHost</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkFontHost.html#e1">FlattenTypeface</a>(const SkTypeface *face, void *buffer)</td><td><a class="el" href="classSkFontHost.html">SkFontHost</a></td><td><code> [static]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkFontHost.html b/sgl_doxygen/html/classSkFontHost.html deleted file mode 100644 index e4cab03..0000000 --- a/sgl_doxygen/html/classSkFontHost.html +++ /dev/null @@ -1,138 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkFontHost Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkFontHost Class Reference</h1><code>#include <<a class="el" href="SkFontHost_8h-source.html">SkFontHost.h</a>></code> -<p> -<a href="classSkFontHost-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">static SkTypeface * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkFontHost.html#e0">CreateTypeface</a> (const SkTypeface *family, const char name[], SkTypeface::Style)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static uint32_t </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkFontHost.html#e1">FlattenTypeface</a> (const SkTypeface *face, void *buffer)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static SkScalerContext * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkFontHost.html#e2">CreateScalarContext</a> (const SkDescriptor *desc)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -This class is ported to each environment. It is responsible for bridging the gap between SkTypeface and the resulting platform-specific instance of SkScalerContext. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="e2" doxytag="SkFontHost::CreateScalarContext"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static SkScalerContext* SkFontHost::CreateScalarContext </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDescriptor * </td> - <td class="mdname1" valign="top" nowrap> <em>desc</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a subclass of SkScalarContext </td> - </tr> -</table> -<a class="anchor" name="e0" doxytag="SkFontHost::CreateTypeface"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static SkTypeface* SkFontHost::CreateTypeface </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkTypeface * </td> - <td class="mdname" nowrap> <em>family</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const char </td> - <td class="mdname" nowrap> <em>name</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkTypeface::Style </td> - <td class="mdname" nowrap></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a subclass of SkTypeface, one that can be used by your scalaracontext (returned by <a class="el" href="classSkFontHost.html#e2">SkFontHost::CreateScalarContext</a>). 1) If family is nil, use name. 2) If name is nil, use family. 3) If both are nil, use default family. </td> - </tr> -</table> -<a class="anchor" name="e1" doxytag="SkFontHost::FlattenTypeface"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static uint32_t SkFontHost::FlattenTypeface </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkTypeface * </td> - <td class="mdname" nowrap> <em>face</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>void * </td> - <td class="mdname" nowrap> <em>buffer</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a typeface (or nil), return the number of bytes needed to flatten it into a buffer, for the purpose of communicating information to the scalercontext. If buffer is nil, then ignore it but still return the number of bytes that would be written. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkFontHost_8h-source.html">SkFontHost.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkGradientShader-members.html b/sgl_doxygen/html/classSkGradientShader-members.html deleted file mode 100644 index 16143d2..0000000 --- a/sgl_doxygen/html/classSkGradientShader-members.html +++ /dev/null @@ -1,54 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkGradientShader Member List</h1>This is the complete list of members for <a class="el" href="classSkGradientShader.html">SkGradientShader</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a9">canCallShadeSpanOpaque16</a>()</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#e0">CanCallShadeSpanOpaque16</a>(U32 flags)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>ComputeMatrixClass</b>(const SkMatrix &) (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected, static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#e1">CreateBitmapShader</a>(const SkBitmap &src, bool transferOwnershipOfPixels, SkPaint::FilterType ft, TileMode tm)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkGradientShader.html#e0">CreateLinear</a>(const SkPoint pts[2], const SkColor colors[], const SkScalar pos[], int count, TileMode mode, SkUnitMapper *mapper=nil)</td><td><a class="el" href="classSkGradientShader.html">SkGradientShader</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkGradientShader.html#e1">CreateRadial</a>(const SkPoint &center, SkScalar radius, const SkColor colors[], const SkScalar pos[], int count, TileMode mode, SkUnitMapper *mapper=nil)</td><td><a class="el" href="classSkGradientShader.html">SkGradientShader</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9">Flags</a> enum name</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getDeviceConfig</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a4">getFlags</a>()</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getInverseClass</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getInverseMapPtProc</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a2">getLocalMatrix</a>() const </td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getPaintAlpha</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getTotalInverse</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w0">kClamp_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w5">kConstAlpha_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFixedStepInX_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlagsMask</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w6">kHasSpan16_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kLinear_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w2">kMirror_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kPerspective_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w1">kRepeat_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kTileModeCount</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>MatrixClass</b> enum name (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a5">setContext</a>(const SkBitmap &device, const SkPaint &paint, const SkMatrix &matrix)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a3">setLocalMatrix</a>(const SkMatrix &)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a6">shadeSpan</a>(int x, int y, SkPMColor[], int count)=0</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [pure virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a8">shadeSpanAlpha</a>(int x, int y, U8 alpha[], int count)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a7">shadeSpanOpaque16</a>(int x, int y, U16[], int count)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkShader</b>() (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8">TileMode</a> enum name</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkShader</b>() (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkGradientShader.html b/sgl_doxygen/html/classSkGradientShader.html deleted file mode 100644 index d46fea5..0000000 --- a/sgl_doxygen/html/classSkGradientShader.html +++ /dev/null @@ -1,183 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkGradientShader Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkGradientShader Class Reference</h1><code>#include <<a class="el" href="SkGradientShader_8h-source.html">SkGradientShader.h</a>></code> -<p> -<p>Inheritance diagram for SkGradientShader: -<p><center><img src="classSkGradientShader.png" usemap="#SkGradientShader_map" border="0" alt=""></center> -<map name="SkGradientShader_map"> -<area href="classSkShader.html" alt="SkShader" shape="rect" coords="0,56,115,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,115,24"> -</map> -<a href="classSkGradientShader-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">static <a class="el" href="classSkShader.html">SkShader</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkGradientShader.html#e0">CreateLinear</a> (const SkPoint pts[2], const <a class="el" href="SkColor_8h.html#a17">SkColor</a> colors[], const SkScalar pos[], int count, <a class="el" href="classSkShader.html#w8">TileMode</a> mode, SkUnitMapper *mapper=nil)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static <a class="el" href="classSkShader.html">SkShader</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkGradientShader.html#e1">CreateRadial</a> (const SkPoint &center, SkScalar radius, const <a class="el" href="SkColor_8h.html#a17">SkColor</a> colors[], const SkScalar pos[], int count, <a class="el" href="classSkShader.html#w8">TileMode</a> mode, SkUnitMapper *mapper=nil)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkGradientShader hosts factories for creating subclasses of <a class="el" href="classSkShader.html">SkShader</a> that render linear and radial gradients. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="e0" doxytag="SkGradientShader::CreateLinear"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static <a class="el" href="classSkShader.html">SkShader</a>* SkGradientShader::CreateLinear </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkPoint </td> - <td class="mdname" nowrap> <em>pts</em>[2], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - <td class="mdname" nowrap> <em>colors</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkScalar </td> - <td class="mdname" nowrap> <em>pos</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkShader.html#w8">TileMode</a> </td> - <td class="mdname" nowrap> <em>mode</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkUnitMapper * </td> - <td class="mdname" nowrap> <em>mapper</em> = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns a subclass of <a class="el" href="classSkShader.html">SkShader</a> that generates a linear gradient between the two specified points. It is an error for colorCount to be < 2. The caller is responsible for decrementing the shader's reference count when it is through using the shader. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>pts</em> </td><td>The start and end points for the gradient. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>colors</em> </td><td>array[count] of colors, to be distributed between the two pts </td></tr> - <tr><td valign="top"></td><td valign="top"><em>pos</em> </td><td>array[count] of SkScalars, or nil, of the relative position of each corresponding color in the colors array. If this is nil, the the colors are distributed evenly between the start and end pt. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>count</em> </td><td>the number of colors (and pos if not nil) entries. Must be >= 2. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>mode</em> </td><td>The tiling mode </td></tr> - <tr><td valign="top"></td><td valign="top"><em>mapper</em> </td><td>(optional) callback to modify the spread of the colors</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="e1" doxytag="SkGradientShader::CreateRadial"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static <a class="el" href="classSkShader.html">SkShader</a>* SkGradientShader::CreateRadial </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkPoint & </td> - <td class="mdname" nowrap> <em>center</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>radius</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - <td class="mdname" nowrap> <em>colors</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkScalar </td> - <td class="mdname" nowrap> <em>pos</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkShader.html#w8">TileMode</a> </td> - <td class="mdname" nowrap> <em>mode</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkUnitMapper * </td> - <td class="mdname" nowrap> <em>mapper</em> = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns a subclass of <a class="el" href="classSkShader.html">SkShader</a> that generates a radial gradient given the center and radius. It is an error for colorCount to be < 2, or for radius to be <= 0. The caller is responsible for decrementing the shader's reference count when it is through using the shader. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>center</em> </td><td>the center of the circle for this gradient. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>radius</em> </td><td>the radius of the circle for this gradient. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>colors</em> </td><td>array[count] of colors, to be distributed between the center and edge of the circle </td></tr> - <tr><td valign="top"></td><td valign="top"><em>pos</em> </td><td>array[count] of SkScalars, or nil, of the relative position of each corresponding color in the colors array. If this is nil, the the colors are distributed evenly between the center and edge of the circle. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>count</em> </td><td>the number of colors (and pos if not nil) entries. Must be >= 2. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>mode</em> </td><td>The tiling mode </td></tr> - <tr><td valign="top"></td><td valign="top"><em>mapper</em> </td><td>(optional) callback to modify the spread of the colors</td></tr> - </table> -</dl> - </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkGradientShader_8h-source.html">SkGradientShader.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkGradientShader.png b/sgl_doxygen/html/classSkGradientShader.png Binary files differdeleted file mode 100644 index 5fe5d31..0000000 --- a/sgl_doxygen/html/classSkGradientShader.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkImageDecoder-members.html b/sgl_doxygen/html/classSkImageDecoder-members.html deleted file mode 100644 index 2af7bff..0000000 --- a/sgl_doxygen/html/classSkImageDecoder-members.html +++ /dev/null @@ -1,22 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkImageDecoder Member List</h1>This is the complete list of members for <a class="el" href="classSkImageDecoder.html">SkImageDecoder</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#e0">DecodeFile</a>(const char file[], SkBitmap *bitmap)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#e1">DecodeMemory</a>(const void *buffer, size_t size, SkBitmap *bitmap)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#e2">DecodeStream</a>(SkStream *, SkBitmap *bitmap)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#e3">DecodeURL</a>(const char url[], SkBitmap *bitmap)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#e4">GetDeviceConfig</a>()</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#b1">onDecode</a>(SkStream *, SkBitmap *bitmap)=0</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [protected, pure virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkImageDecoder.html#e5">SetDeviceConfig</a>(SkBitmap::Config)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkImageDecoder</b>() (defined in <a class="el" href="classSkImageDecoder.html">SkImageDecoder</a>)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkImageDecoder</b>() (defined in <a class="el" href="classSkImageDecoder.html">SkImageDecoder</a>)</td><td><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkImageDecoder.html b/sgl_doxygen/html/classSkImageDecoder.html deleted file mode 100644 index cad39fd..0000000 --- a/sgl_doxygen/html/classSkImageDecoder.html +++ /dev/null @@ -1,293 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkImageDecoder Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkImageDecoder Class Reference</h1><code>#include <<a class="el" href="SkImageDecoder_8h-source.html">SkImageDecoder.h</a>></code> -<p> -<p>Inheritance diagram for SkImageDecoder: -<p><center><img src="classSkImageDecoder.png" usemap="#SkImageDecoder_map" border="0" alt=""></center> -<map name="SkImageDecoder_map"> -</map> -<a href="classSkImageDecoder-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#e0">DecodeFile</a> (const char file[], <a class="el" href="classSkBitmap.html">SkBitmap</a> *bitmap)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#e1">DecodeMemory</a> (const void *buffer, size_t size, <a class="el" href="classSkBitmap.html">SkBitmap</a> *bitmap)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#e2">DecodeStream</a> (SkStream *, <a class="el" href="classSkBitmap.html">SkBitmap</a> *bitmap)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#e3">DecodeURL</a> (const char url[], <a class="el" href="classSkBitmap.html">SkBitmap</a> *bitmap)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static <a class="el" href="classSkBitmap.html#w7">SkBitmap::Config</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#e4">GetDeviceConfig</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#e5">SetDeviceConfig</a> (<a class="el" href="classSkBitmap.html#w7">SkBitmap::Config</a>)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkImageDecoder.html#b1">onDecode</a> (SkStream *, <a class="el" href="classSkBitmap.html">SkBitmap</a> *bitmap)=0</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Base class for decoding compressed images into a <a class="el" href="classSkBitmap.html">SkBitmap</a> -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="e0" doxytag="SkImageDecoder::DecodeFile"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkImageDecoder::DecodeFile </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>file</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkBitmap.html">SkBitmap</a> * </td> - <td class="mdname" nowrap> <em>bitmap</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Decode the image stored in the specified file, and store the result in bitmap. Return true for success or false on failure.<p> -On input the bitmap's config is consulted. If it is kNo_Config, then the decoder is free to choose the most natural config given the image data. If the bitmap's config is something other than kNo_Config, the decoder will attempt to decode the image into that format, unless there is a conflict (e.g. the image has per-pixel alpha and the bitmap's config does not support that), in which case the decoder will choose a closest match configuration. </td> - </tr> -</table> -<a class="anchor" name="e1" doxytag="SkImageDecoder::DecodeMemory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkImageDecoder::DecodeMemory </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const void * </td> - <td class="mdname" nowrap> <em>buffer</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>size</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkBitmap.html">SkBitmap</a> * </td> - <td class="mdname" nowrap> <em>bitmap</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Decode the image stored in the specified memory buffer, and store the result in bitmap. Return true for success or false on failure.<p> -On input the bitmap's config is consulted. If it is kNo_Config, then the decoder is free to choose the most natural config given the image data. If the bitmap's config is something other than kNo_Config, the decoder will attempt to decode the image into that format, unless there is a conflict (e.g. the image has per-pixel alpha and the bitmap's config does not support that), in which case the decoder will choose a closest match configuration. </td> - </tr> -</table> -<a class="anchor" name="e2" doxytag="SkImageDecoder::DecodeStream"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkImageDecoder::DecodeStream </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkStream * </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkBitmap.html">SkBitmap</a> * </td> - <td class="mdname" nowrap> <em>bitmap</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Decode the image stored in the specified SkStream, and store the result in bitmap. Return true for success or false on failure.<p> -On input the bitmap's config is consulted. If it is kNo_Config, then the decoder is free to choose the most natural config given the image data. If the bitmap's config is something other than kNo_Config, the decoder will attempt to decode the image into that format, unless there is a conflict (e.g. the image has per-pixel alpha and the bitmap's config does not support that), in which case the decoder will choose a closest match configuration. </td> - </tr> -</table> -<a class="anchor" name="e3" doxytag="SkImageDecoder::DecodeURL"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkImageDecoder::DecodeURL </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>url</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkBitmap.html">SkBitmap</a> * </td> - <td class="mdname" nowrap> <em>bitmap</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Decode the image stored at the specified URL, and store the result in bitmap. Return true for success or false on failure. The URL restrictions are device dependent. On Win32 and WinCE, the URL may be ftp, http or https.<p> -On input the bitmap's config is consulted. If it is kNo_Config, then the decoder is free to choose the most natural config given the image data. If the bitmap's config is something other than kNo_Config, the decoder will attempt to decode the image into that format, unless there is a conflict (e.g. the image has per-pixel alpha and the bitmap's config does not support that), in which case the decoder will choose a closest match configuration. </td> - </tr> -</table> -<a class="anchor" name="e4" doxytag="SkImageDecoder::GetDeviceConfig"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static <a class="el" href="classSkBitmap.html#w7">SkBitmap::Config</a> SkImageDecoder::GetDeviceConfig </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the default config for the running device. Currently this used as a suggestion to image decoders that need to guess what config they should decode into. Default is kNo_Config, but this can be changed with <a class="el" href="classSkImageDecoder.html#e5">SetDeviceConfig()</a> </td> - </tr> -</table> -<a class="anchor" name="b1" doxytag="SkImageDecoder::onDecode"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkImageDecoder::onDecode </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkStream * </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkBitmap.html">SkBitmap</a> * </td> - <td class="mdname" nowrap> <em>bitmap</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [protected, pure virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a stream, decode it into the specified bitmap. The bitmap should be treated as uninitialized, except that its getConfig() might return a preferred config. If the decoder can decompress the image, it should call setConfig() on the bitmap, and then call allocPixels(), which will allocated offscreen memory for the pixels. It can then set the pixels with the decompressed image. If the image cannot be decompressed, return false and leave the bitmap unchanged. </td> - </tr> -</table> -<a class="anchor" name="e5" doxytag="SkImageDecoder::SetDeviceConfig"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static void SkImageDecoder::SetDeviceConfig </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkBitmap.html#w7">SkBitmap::Config</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the default config for the running device. Currently this used as a suggestion to image decoders that need to guess what config they should decode into. Default is kNo_Config. This can be queried with <a class="el" href="classSkImageDecoder.html#e4">GetDeviceConfig()</a> </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkImageDecoder_8h-source.html">SkImageDecoder.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkImageDecoder.png b/sgl_doxygen/html/classSkImageDecoder.png Binary files differdeleted file mode 100644 index a6f3e2a..0000000 --- a/sgl_doxygen/html/classSkImageDecoder.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkLightShader-members.html b/sgl_doxygen/html/classSkLightShader-members.html deleted file mode 100644 index cfe7ed6..0000000 --- a/sgl_doxygen/html/classSkLightShader-members.html +++ /dev/null @@ -1,55 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkLightShader Member List</h1>This is the complete list of members for <a class="el" href="classSkLightShader.html">SkLightShader</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a9">canCallShadeSpanOpaque16</a>()</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#e0">CanCallShadeSpanOpaque16</a>(U32 flags)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>ComputeMatrixClass</b>(const SkMatrix &) (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected, static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#e1">CreateBitmapShader</a>(const SkBitmap &src, bool transferOwnershipOfPixels, SkPaint::FilterType ft, TileMode tm)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9">Flags</a> enum name</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getDeviceConfig</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkLightShader.html#a3">getFlags</a>()</td><td><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getInverseClass</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getInverseMapPtProc</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a2">getLocalMatrix</a>() const </td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getPaintAlpha</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getTotalInverse</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w0">kClamp_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w5">kConstAlpha_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFixedStepInX_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlagsMask</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w6">kHasSpan16_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kLinear_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w2">kMirror_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kPerspective_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w1">kRepeat_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kTileModeCount</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>MatrixClass</b> enum name (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkLightShader.html#a4">setContext</a>(const SkBitmap &device, const SkPaint &paint, const SkMatrix &matrix)</td><td><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a3">setLocalMatrix</a>(const SkMatrix &)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkLightShader.html#a5">shadeSpan</a>(int x, int y, SkPMColor span[], int count)</td><td><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a8">shadeSpanAlpha</a>(int x, int y, U8 alpha[], int count)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a7">shadeSpanOpaque16</a>(int x, int y, U16[], int count)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkLightShader</b>(SkShader *proxy, U8CPU mul, U8CPU add) (defined in <a class="el" href="classSkLightShader.html">SkLightShader</a>)</td><td><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkLightShader.html#a1">SkLightShader</a>(SkShader *proxy, const U8 mul[3], const U8 add[3])</td><td><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkShader</b>() (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8">TileMode</a> enum name</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkLightShader</b>() (defined in <a class="el" href="classSkLightShader.html">SkLightShader</a>)</td><td><a class="el" href="classSkLightShader.html">SkLightShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkShader</b>() (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkLightShader.html b/sgl_doxygen/html/classSkLightShader.html deleted file mode 100644 index a8b5a88..0000000 --- a/sgl_doxygen/html/classSkLightShader.html +++ /dev/null @@ -1,210 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkLightShader Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkLightShader Class Reference</h1><code>#include <<a class="el" href="SkLightShader_8h-source.html">SkLightShader.h</a>></code> -<p> -<p>Inheritance diagram for SkLightShader: -<p><center><img src="classSkLightShader.png" usemap="#SkLightShader_map" border="0" alt=""></center> -<map name="SkLightShader_map"> -<area href="classSkShader.html" alt="SkShader" shape="rect" coords="0,56,94,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,94,24"> -</map> -<a href="classSkLightShader-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkLightShader::SkLightShader"></a> - </td><td class="memItemRight" valign="bottom"><b>SkLightShader</b> (<a class="el" href="classSkShader.html">SkShader</a> *proxy, U8CPU mul, U8CPU add)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkLightShader.html#a1">SkLightShader</a> (<a class="el" href="classSkShader.html">SkShader</a> *proxy, const U8 mul[3], const U8 add[3])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkLightShader.html#a3">getFlags</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkLightShader.html#a4">setContext</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &device, const <a class="el" href="classSkPaint.html">SkPaint</a> &paint, const SkMatrix &matrix)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkLightShader.html#a5">shadeSpan</a> (int x, int y, <a class="el" href="SkColor_8h.html#a18">SkPMColor</a> span[], int count)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkLightShader applies a simple lighting equation (color * mul + add) to the colors it is given. Those colors can either be the SkPaint's color if proxy is nil, or the colors are those returned from the proxy shader. -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a1" doxytag="SkLightShader::SkLightShader"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkLightShader::SkLightShader </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkShader.html">SkShader</a> * </td> - <td class="mdname" nowrap> <em>proxy</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const U8 </td> - <td class="mdname" nowrap> <em>mul</em>[3], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const U8 </td> - <td class="mdname" nowrap> <em>add</em>[3]</td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -The mul[] and add[] parameters either hold 3 values (R,G,B), or they are nil, in which case default values are used (255 for mul, 0 for add) </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a3" doxytag="SkLightShader::getFlags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual U32 SkLightShader::getFlags </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called sometimes before drawing with this shader. Return the type of alpha your shader will return. The default implementation returns 0. Your subclass should override if it can (even sometimes) report a non-zero value, since that will enable various blitters to perform faster. -<p> -Reimplemented from <a class="el" href="classSkShader.html#a4">SkShader</a>. </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkLightShader::setContext"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkLightShader::setContext </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname" nowrap> <em>device</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap> <em>paint</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMatrix & </td> - <td class="mdname" nowrap> <em>matrix</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called once before drawing, with the current paint and device matrix. Return true if your shader supports these parameters, or false if not. If false is returned, nothing will be drawn. -<p> -Reimplemented from <a class="el" href="classSkShader.html#a5">SkShader</a>. </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkLightShader::shadeSpan"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkLightShader::shadeSpan </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td> - <td class="mdname" nowrap> <em>span</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called for each span of the object being drawn. Your subclass should set the appropriate colors (with premultiplied alpha) that correspond to the specified device coordinates. -<p> -Implements <a class="el" href="classSkShader.html#a6">SkShader</a>. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkLightShader_8h-source.html">SkLightShader.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkLightShader.png b/sgl_doxygen/html/classSkLightShader.png Binary files differdeleted file mode 100644 index 14a5dae..0000000 --- a/sgl_doxygen/html/classSkLightShader.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkMaskFilter-members.html b/sgl_doxygen/html/classSkMaskFilter-members.html deleted file mode 100644 index de8ede7..0000000 --- a/sgl_doxygen/html/classSkMaskFilter-members.html +++ /dev/null @@ -1,26 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkMaskFilter Member List</h1>This is the complete list of members for <a class="el" href="classSkMaskFilter.html">SkMaskFilter</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkMaskFilter.html#a1">filterMask</a>(SkMask *dst, const SkMask &src, const SkMatrix &, SkIPoint *margin)</td><td><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkMaskFilter.html#a2">filterPath</a>(const SkPath &devPath, const SkMatrix &devMatrix, const SkRegion &devClip, SkBounder *, SkBlitter *blitter)</td><td><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer=nil) (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getFactory</b>() (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkMaskFilter.html#a0">getFormat</a>()=0</td><td><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a></td><td><code> [pure virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkMaskFilter.html b/sgl_doxygen/html/classSkMaskFilter.html deleted file mode 100644 index ca52e0f..0000000 --- a/sgl_doxygen/html/classSkMaskFilter.html +++ /dev/null @@ -1,177 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkMaskFilter Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkMaskFilter Class Reference</h1><code>#include <<a class="el" href="SkMaskFilter_8h-source.html">SkMaskFilter.h</a>></code> -<p> -<p>Inheritance diagram for SkMaskFilter: -<p><center><img src="classSkMaskFilter.png" usemap="#SkMaskFilter_map" border="0" alt=""></center> -<map name="SkMaskFilter_map"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="138,56,266,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="138,0,266,24"> -</map> -<a href="classSkMaskFilter-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual <a class="el" href="structSkMask.html#w3">SkMask::Format</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkMaskFilter.html#a0">getFormat</a> ()=0</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkMaskFilter.html#a1">filterMask</a> (<a class="el" href="structSkMask.html">SkMask</a> *dst, const <a class="el" href="structSkMask.html">SkMask</a> &src, const SkMatrix &, SkIPoint *margin)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkMaskFilter.html#a2">filterPath</a> (const <a class="el" href="classSkPath.html">SkPath</a> &devPath, const SkMatrix &devMatrix, const SkRegion &devClip, <a class="el" href="classSkBounder.html">SkBounder</a> *, SkBlitter *blitter)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkMaskFilter is the base class for object that perform transformations on an alpha-channel mask before drawing it. A subclass of SkMaskFilter may be installed into a <a class="el" href="classSkPaint.html">SkPaint</a>. Once there, each time a primitive is drawn, it is first scan converted into a <a class="el" href="structSkMask.html#w3w1">SkMask::kA8_Format</a> mask, and handed to the filter, calling its <a class="el" href="classSkMaskFilter.html#a1">filterMask()</a> method. If this returns true, then the new mask is used to render into the device.<p> -Blur and emboss are implemented as subclasses of SkMaskFilter. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a1" doxytag="SkMaskFilter::filterMask"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkMaskFilter::filterMask </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="structSkMask.html">SkMask</a> * </td> - <td class="mdname" nowrap> <em>dst</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="structSkMask.html">SkMask</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMatrix & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkIPoint * </td> - <td class="mdname" nowrap> <em>margin</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Create a new mask by filter the src mask. If src.fImage == nil, then do not allocate or create the dst image but do fill out the other fields in dstMask. If you do allocate a dst image, use SkMask::AllocImage() If this returns false, dst mask is ignored. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>dst</em> </td><td>the result of the filter. If src.fImage == nil, dst should not allocate its image </td></tr> - <tr><td valign="top"></td><td valign="top"><em>src</em> </td><td>the original image to be filtered. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>matrix</em> </td><td>the CTM </td></tr> - <tr><td valign="top"></td><td valign="top"><em>margin</em> </td><td>if not nil, return the buffer dx/dy need when calculating the effect. Used when drawing a clipped object to know how much larger to allocate the src before applying the filter. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the dst mask was correctly created.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkMaskFilter::filterPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkMaskFilter::filterPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>devPath</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMatrix & </td> - <td class="mdname" nowrap> <em>devMatrix</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkRegion & </td> - <td class="mdname" nowrap> <em>devClip</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkBounder.html">SkBounder</a> * </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkBlitter * </td> - <td class="mdname" nowrap> <em>blitter</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper method that, given a path in device space, will rasterize it into a kA8_Format mask and then call <a class="el" href="classSkMaskFilter.html#a1">filterMask()</a>. If this returns true, the specified blitter will be called to render that mask. Returns false if <a class="el" href="classSkMaskFilter.html#a1">filterMask()</a> returned false. </td> - </tr> -</table> -<a class="anchor" name="a0" doxytag="SkMaskFilter::getFormat"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual <a class="el" href="structSkMask.html#w3">SkMask::Format</a> SkMaskFilter::getFormat </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [pure virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the format of the resulting mask that this subclass will return when its <a class="el" href="classSkMaskFilter.html#a1">filterMask()</a> method is called. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkMaskFilter_8h-source.html">SkMaskFilter.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkMaskFilter.png b/sgl_doxygen/html/classSkMaskFilter.png Binary files differdeleted file mode 100644 index fe2f069..0000000 --- a/sgl_doxygen/html/classSkMaskFilter.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkPaint-members.html b/sgl_doxygen/html/classSkPaint-members.html deleted file mode 100644 index 70a096d..0000000 --- a/sgl_doxygen/html/classSkPaint-members.html +++ /dev/null @@ -1,123 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPaint Member List</h1>This is the complete list of members for <a class="el" href="classSkPaint.html">SkPaint</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Align</b> enum name (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a59">ascent</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w36">Cap</a> enum name</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>descent</b>() const (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w38">FilterType</a> enum name</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w34">FlagMask</a> enum name</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w33">FlagShift</a> enum name</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a22">getAlpha</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a21">getColor</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a34">getFilterType</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getFlags</b>() const (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a43">getMaskFilter</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a41">getPathEffect</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a36">getShader</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a30">getStrokeCap</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a32">getStrokeJoin</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a28">getStrokeMiter</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a26">getStrokeWidth</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a17">getStyle</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a64">getText16Path</a>(const U16 text[], size_t numberOf16BitValues, SkScalar x, SkScalar y, SkPath *path) const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a47">getTextAlign</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a63">getTextPath</a>(const char text[], size_t length, SkScalar x, SkScalar y, SkPath *path) const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a51">getTextScaleX</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a49">getTextSize</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a53">getTextSkewX</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a55">getTextTracking</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a45">getTypeface</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a38">getXfermode</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a7">isAntiAliasOn</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a15">isFakeBoldTextOn</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a9">isLinearTextOn</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a13">isStrikeThruTextOn</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>isStrokeOn</b>() const (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a11">isUnderlineTextOn</a>() const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w37">Join</a> enum name</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kAlignCount</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kAllFlagMasks</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w34w6">kAntiAlias_Mask</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w33w0">kAntiAlias_Shift</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w37w23">kBevel_Join</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w38w27">kBilinear_FilterType</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w36w16">kButt_Cap</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kCapCount</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kCenter_Align</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kDefault_Cap</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kDefault_Join</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w34w10">kFakeBoldText_Mask</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w33w4">kFakeBoldText_Shift</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w35w12">kFill_Style</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFilterTypeCount</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlagShiftCount</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kJoinCount</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kLeft_Align</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w34w7">kLinearText_Mask</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w33w1">kLinearText_Shift</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w37w21">kMiter_Join</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w38w26">kNo_FilterType</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kRight_Align</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w36w17">kRound_Cap</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w37w22">kRound_Join</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w36w18">kSquare_Cap</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w34w9">kStrikeThruText_Mask</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w33w3">kStrikeThruText_Shift</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w35w13">kStroke_Style</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w35w14">kStrokeAndFill_Style</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kStyleCount</b> enum value (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w34w8">kUnderlineText_Mask</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w33w2">kUnderlineText_Shift</a> enum value</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a57">measureText</a>(const char utf8[], size_t length, SkScalar *above, SkScalar *below) const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a61">measureText</a>(const char text[], size_t length) const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a58">measureText16</a>(const U16 utf16[], size_t numberOf16BitValues, SkScalar *above, SkScalar *below) const </td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>measureText16</b>(const U16 utf16[], size_t numberOf16BitValues) const (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator!=</b> (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator=</b>(const SkPaint &) (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator==</b> (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a4">reset</a>()</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a24">setAlpha</a>(U8CPU a)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a8">setAntiAliasOn</a>(bool)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a25">setARGB</a>(U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a23">setColor</a>(SkColor)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a16">setFakeBoldTextOn</a>(bool)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a35">setFilterType</a>(FilterType)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setFlags</b>(U32) (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a10">setLinearTextOn</a>(bool)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a44">setMaskFilter</a>(SkMaskFilter *maskfilter)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a42">setPathEffect</a>(SkPathEffect *effect)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setPorterDuffXfermode</b>(SkPorterDuff::Mode) (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a37">setShader</a>(SkShader *shader)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a14">setStrikeThruTextOn</a>(bool)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a31">setStrokeCap</a>(Cap)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a33">setStrokeJoin</a>(Join)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a29">setStrokeMiter</a>(SkScalar)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setStrokeOn</b>(bool on) (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a27">setStrokeWidth</a>(SkScalar)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a18">setStyle</a>(Style)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a48">setTextAlign</a>(Align)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a52">setTextScaleX</a>(SkScalar scaleX)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a50">setTextSize</a>(SkScalar)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a54">setTextSkewX</a>(SkScalar skewX)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a56">setTextTracking</a>(SkScalar tracking)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a46">setTypeface</a>(SkTypeface *typeface)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a12">setUnderlineTextOn</a>(bool)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#a39">setXfermode</a>(SkXfermode *xfermode)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkDraw</b> (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkGlyphCache</b> (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPaint</b>() (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPaint</b>(const SkPaint &) (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkTextToPathIter</b> (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPaint.html#w35">Style</a> enum name</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkPaint</b>() (defined in <a class="el" href="classSkPaint.html">SkPaint</a>)</td><td><a class="el" href="classSkPaint.html">SkPaint</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPaint.html b/sgl_doxygen/html/classSkPaint.html deleted file mode 100644 index 8221ac1..0000000 --- a/sgl_doxygen/html/classSkPaint.html +++ /dev/null @@ -1,2099 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPaint Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPaint Class Reference</h1><code>#include <<a class="el" href="SkPaint_8h-source.html">SkPaint.h</a>></code> -<p> -<a href="classSkPaint-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#w33">FlagShift</a> { <br> - <a class="el" href="classSkPaint.html#w33w0">kAntiAlias_Shift</a>, -<a class="el" href="classSkPaint.html#w33w1">kLinearText_Shift</a>, -<a class="el" href="classSkPaint.html#w33w2">kUnderlineText_Shift</a>, -<a class="el" href="classSkPaint.html#w33w3">kStrikeThruText_Shift</a>, -<br> - <a class="el" href="classSkPaint.html#w33w4">kFakeBoldText_Shift</a>, -<b>kFlagShiftCount</b> -<br> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#w34">FlagMask</a> { <br> - <a class="el" href="classSkPaint.html#w34w6">kAntiAlias_Mask</a> = 1 << kAntiAlias_Shift, -<a class="el" href="classSkPaint.html#w34w7">kLinearText_Mask</a> = 1 << kLinearText_Shift, -<a class="el" href="classSkPaint.html#w34w8">kUnderlineText_Mask</a> = 1 << kUnderlineText_Shift, -<a class="el" href="classSkPaint.html#w34w9">kStrikeThruText_Mask</a> = 1 << kStrikeThruText_Shift, -<br> - <a class="el" href="classSkPaint.html#w34w10">kFakeBoldText_Mask</a> = 1 << kFakeBoldText_Shift, -<b>kAllFlagMasks</b> = (1 << kFlagShiftCount) - 1 -<br> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#w35">Style</a> { <a class="el" href="classSkPaint.html#w35w12">kFill_Style</a>, -<a class="el" href="classSkPaint.html#w35w13">kStroke_Style</a>, -<a class="el" href="classSkPaint.html#w35w14">kStrokeAndFill_Style</a>, -<b>kStyleCount</b> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#w36">Cap</a> { <br> - <a class="el" href="classSkPaint.html#w36w16">kButt_Cap</a>, -<a class="el" href="classSkPaint.html#w36w17">kRound_Cap</a>, -<a class="el" href="classSkPaint.html#w36w18">kSquare_Cap</a>, -<b>kCapCount</b>, -<br> - <b>kDefault_Cap</b> = kButt_Cap -<br> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#w37">Join</a> { <br> - <a class="el" href="classSkPaint.html#w37w21">kMiter_Join</a>, -<a class="el" href="classSkPaint.html#w37w22">kRound_Join</a>, -<a class="el" href="classSkPaint.html#w37w23">kBevel_Join</a>, -<b>kJoinCount</b>, -<br> - <b>kDefault_Join</b> = kMiter_Join -<br> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#w38">FilterType</a> { <a class="el" href="classSkPaint.html#w38w26">kNo_FilterType</a>, -<a class="el" href="classSkPaint.html#w38w27">kBilinear_FilterType</a>, -<b>kFilterTypeCount</b> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><b>Align</b> { <b>kLeft_Align</b>, -<b>kCenter_Align</b>, -<b>kRight_Align</b>, -<b>kAlignCount</b> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkPaint::SkPaint"></a> - </td><td class="memItemRight" valign="bottom"><b>SkPaint</b> (const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkPaint::operator="></a> -<a class="el" href="classSkPaint.html">SkPaint</a> & </td><td class="memItemRight" valign="bottom"><b>operator=</b> (const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a4">reset</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkPaint::getFlags"></a> -U32 </td><td class="memItemRight" valign="bottom"><b>getFlags</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a6" doxytag="SkPaint::setFlags"></a> -void </td><td class="memItemRight" valign="bottom"><b>setFlags</b> (U32)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a7">isAntiAliasOn</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a8">setAntiAliasOn</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a9">isLinearTextOn</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a10">setLinearTextOn</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a11">isUnderlineTextOn</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a12">setUnderlineTextOn</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a13">isStrikeThruTextOn</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a14">setStrikeThruTextOn</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a15">isFakeBoldTextOn</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a16">setFakeBoldTextOn</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPaint.html#w35">Style</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a17">getStyle</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a18">setStyle</a> (<a class="el" href="classSkPaint.html#w35">Style</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a19" doxytag="SkPaint::isStrokeOn"></a> -bool </td><td class="memItemRight" valign="bottom"><b>isStrokeOn</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a20" doxytag="SkPaint::setStrokeOn"></a> -void </td><td class="memItemRight" valign="bottom"><b>setStrokeOn</b> (bool on)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a21">getColor</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U8 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a22">getAlpha</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a23">setColor</a> (<a class="el" href="SkColor_8h.html#a17">SkColor</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a24">setAlpha</a> (U8CPU a)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a25">setARGB</a> (U8CPU a, U8CPU r, U8CPU g, U8CPU b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a26">getStrokeWidth</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a27">setStrokeWidth</a> (SkScalar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a28">getStrokeMiter</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a29">setStrokeMiter</a> (SkScalar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPaint.html#w36">Cap</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a30">getStrokeCap</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a31">setStrokeCap</a> (<a class="el" href="classSkPaint.html#w36">Cap</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPaint.html#w37">Join</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a32">getStrokeJoin</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a33">setStrokeJoin</a> (<a class="el" href="classSkPaint.html#w37">Join</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPaint.html#w38">FilterType</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a34">getFilterType</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a35">setFilterType</a> (<a class="el" href="classSkPaint.html#w38">FilterType</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkShader.html">SkShader</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a36">getShader</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkShader.html">SkShader</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a37">setShader</a> (<a class="el" href="classSkShader.html">SkShader</a> *shader)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkXfermode.html">SkXfermode</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a38">getXfermode</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkXfermode.html">SkXfermode</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a39">setXfermode</a> (<a class="el" href="classSkXfermode.html">SkXfermode</a> *xfermode)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a40" doxytag="SkPaint::setPorterDuffXfermode"></a> -<a class="el" href="classSkXfermode.html">SkXfermode</a> * </td><td class="memItemRight" valign="bottom"><b>setPorterDuffXfermode</b> (SkPorterDuff::Mode)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a41">getPathEffect</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a42">setPathEffect</a> (<a class="el" href="classSkPathEffect.html">SkPathEffect</a> *effect)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a43">getMaskFilter</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a44">setMaskFilter</a> (<a class="el" href="classSkMaskFilter.html">SkMaskFilter</a> *maskfilter)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkTypeface * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a45">getTypeface</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkTypeface * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a46">setTypeface</a> (SkTypeface *typeface)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">Align </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a47">getTextAlign</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a48">setTextAlign</a> (Align)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a49">getTextSize</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a50">setTextSize</a> (SkScalar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a51">getTextScaleX</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a52">setTextScaleX</a> (SkScalar scaleX)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a53">getTextSkewX</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a54">setTextSkewX</a> (SkScalar skewX)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a55">getTextTracking</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a56">setTextTracking</a> (SkScalar tracking)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a57">measureText</a> (const char utf8[], size_t length, SkScalar *above, SkScalar *below) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a58">measureText16</a> (const U16 utf16[], size_t numberOf16BitValues, SkScalar *above, SkScalar *below) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a59">ascent</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a60" doxytag="SkPaint::descent"></a> -SkScalar </td><td class="memItemRight" valign="bottom"><b>descent</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a61">measureText</a> (const char text[], size_t length) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a62" doxytag="SkPaint::measureText16"></a> -SkScalar </td><td class="memItemRight" valign="bottom"><b>measureText16</b> (const U16 utf16[], size_t numberOf16BitValues) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a63">getTextPath</a> (const char text[], size_t length, SkScalar x, SkScalar y, <a class="el" href="classSkPath.html">SkPath</a> *path) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPaint.html#a64">getText16Path</a> (const U16 text[], size_t numberOf16BitValues, SkScalar x, SkScalar y, <a class="el" href="classSkPath.html">SkPath</a> *path) const </td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkPaint::SkGlyphCache"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkGlyphCache</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n1" doxytag="SkPaint::SkDraw"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkDraw</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n2" doxytag="SkPaint::SkTextToPathIter"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkTextToPathIter</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n3" doxytag="SkPaint::operator=="></a> -int </td><td class="memItemRight" valign="bottom"><b>operator==</b> (const <a class="el" href="classSkPaint.html">SkPaint</a> &a, const <a class="el" href="classSkPaint.html">SkPaint</a> &b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n4" doxytag="SkPaint::operator!="></a> -int </td><td class="memItemRight" valign="bottom"><b>operator!=</b> (const <a class="el" href="classSkPaint.html">SkPaint</a> &a, const <a class="el" href="classSkPaint.html">SkPaint</a> &b)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -The SkPaint class holds the style and color information about how to draw geometries, text and bitmaps. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w36" doxytag="SkPaint::Cap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPaint.html#w36">SkPaint::Cap</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w36w16" doxytag="kButt_Cap"></a>kButt_Cap</em> </td><td> -begin and end a contour with no extension </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w36w17" doxytag="kRound_Cap"></a>kRound_Cap</em> </td><td> -begin and end a contour with a semi-circle extension </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w36w18" doxytag="kSquare_Cap"></a>kSquare_Cap</em> </td><td> -begin and end a contour with a half square extension </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w38" doxytag="SkPaint::FilterType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPaint.html#w38">SkPaint::FilterType</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w38w26" doxytag="kNo_FilterType"></a>kNo_FilterType</em> </td><td> -draw bitmaps using nearest-neighbor sampling </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w38w27" doxytag="kBilinear_FilterType"></a>kBilinear_FilterType</em> </td><td> -draw bitmaps using bilinear sampling </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w34" doxytag="SkPaint::FlagMask"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPaint.html#w34">SkPaint::FlagMask</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w34w6" doxytag="kAntiAlias_Mask"></a>kAntiAlias_Mask</em> </td><td> -bit mask for the flag enabling antialiasing </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w34w7" doxytag="kLinearText_Mask"></a>kLinearText_Mask</em> </td><td> -bit mask for the flag enabling linear-text (no gridding) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w34w8" doxytag="kUnderlineText_Mask"></a>kUnderlineText_Mask</em> </td><td> -bit mask for the flag enabling underline text </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w34w9" doxytag="kStrikeThruText_Mask"></a>kStrikeThruText_Mask</em> </td><td> -bit mask for the flag enabling strike-thru text </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w34w10" doxytag="kFakeBoldText_Mask"></a>kFakeBoldText_Mask</em> </td><td> -bit mask for the flag enabling fake-bold text </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w33" doxytag="SkPaint::FlagShift"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPaint.html#w33">SkPaint::FlagShift</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w33w0" doxytag="kAntiAlias_Shift"></a>kAntiAlias_Shift</em> </td><td> -bit position for the flag enabling antialiasing </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w33w1" doxytag="kLinearText_Shift"></a>kLinearText_Shift</em> </td><td> -bit position for the flag enabling linear-text (no gridding) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w33w2" doxytag="kUnderlineText_Shift"></a>kUnderlineText_Shift</em> </td><td> -bit position for the flag enabling underline text </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w33w3" doxytag="kStrikeThruText_Shift"></a>kStrikeThruText_Shift</em> </td><td> -bit position for the flag enabling strike-thru text </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w33w4" doxytag="kFakeBoldText_Shift"></a>kFakeBoldText_Shift</em> </td><td> -bit position for the flag enabling fake-bold text </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w37" doxytag="SkPaint::Join"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPaint.html#w37">SkPaint::Join</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w37w21" doxytag="kMiter_Join"></a>kMiter_Join</em> </td><td> -connect path segments with a sharp join (respects miter-limit) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w37w22" doxytag="kRound_Join"></a>kRound_Join</em> </td><td> -connect path segments with a round join </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w37w23" doxytag="kBevel_Join"></a>kBevel_Join</em> </td><td> -connect path segments with a flat bevel join </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w35" doxytag="SkPaint::Style"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPaint.html#w35">SkPaint::Style</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Styles apply to rect, oval, path, and text. Bitmaps are always drawn in "fill", and lines are always drawn in "stroke"<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w35w12" doxytag="kFill_Style"></a>kFill_Style</em> </td><td> -fill with the paint's color </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w35w13" doxytag="kStroke_Style"></a>kStroke_Style</em> </td><td> -stroke with the paint's color </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w35w14" doxytag="kStrokeAndFill_Style"></a>kStrokeAndFill_Style</em> </td><td> -fill and stroke with the paint's color </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a59" doxytag="SkPaint::ascent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::ascent </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -In java we cannot use these parameters to pass back the ascent and descent, so I'm creating new functions to return them. These should be edited by the tool so I can use them in java </td> - </tr> -</table> -<a class="anchor" name="a22" doxytag="SkPaint::getAlpha"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U8 SkPaint::getAlpha </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper to <a class="el" href="classSkPaint.html#a21">getColor()</a> that just returns the color's alpha value. </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkPaint::getColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> SkPaint::getColor </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's color. Note that the color is a 32bit value containing alpha as well as r,g,b. This 32bit value is not premultiplied, meaning that its alpha can be any value, regardless of the values of r,g,b. </td> - </tr> -</table> -<a class="anchor" name="a34" doxytag="SkPaint::getFilterType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w38">FilterType</a> SkPaint::getFilterType </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's bitmap filter type. This setting affects drawBitmap() and bitmaps that appear inside a bitmap shader. </td> - </tr> -</table> -<a class="anchor" name="a43" doxytag="SkPaint::getMaskFilter"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a>* SkPaint::getMaskFilter </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Returns:</b></dt><dd>the paint's maskfilter (nor nil) without affecting the maskfilter's reference count</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a41" doxytag="SkPaint::getPathEffect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a>* SkPaint::getPathEffect </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Returns:</b></dt><dd>the paint's patheffect (nor nil) without affecting the patheffect's reference count</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a36" doxytag="SkPaint::getShader"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkShader.html">SkShader</a>* SkPaint::getShader </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Returns:</b></dt><dd>the paint's shader (nor nil) without affecting the shader's reference count</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a30" doxytag="SkPaint::getStrokeCap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w36">Cap</a> SkPaint::getStrokeCap </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's stroke cap type. </td> - </tr> -</table> -<a class="anchor" name="a32" doxytag="SkPaint::getStrokeJoin"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w37">Join</a> SkPaint::getStrokeJoin </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's stroke join type. </td> - </tr> -</table> -<a class="anchor" name="a28" doxytag="SkPaint::getStrokeMiter"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::getStrokeMiter </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's stroke miter value. This is used to control the behavior of miter joins when the joins angle is sharp. </td> - </tr> -</table> -<a class="anchor" name="a26" doxytag="SkPaint::getStrokeWidth"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::getStrokeWidth </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the width for framing. 0 indicates framing in hairline mode, which always draws a single pixel independent of the current matrix. </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkPaint::getStyle"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w35">Style</a> SkPaint::getStyle </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's style, used for controlling how primitives' geometries are interpreted (except for drawBitmap, which always assumes kFill_Style). </td> - </tr> -</table> -<a class="anchor" name="a64" doxytag="SkPaint::getText16Path"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::getText16Path </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const U16 </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>numberOf16BitValues</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>path</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the path (outline) for the specified text. Note: just like <a class="el" href="classSkCanvas.html#a33">SkCanvas::drawText</a>, this will respect the Align setting in the paint. </td> - </tr> -</table> -<a class="anchor" name="a47" doxytag="SkPaint::getTextAlign"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">Align SkPaint::getTextAlign </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's text alignment. </td> - </tr> -</table> -<a class="anchor" name="a63" doxytag="SkPaint::getTextPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::getTextPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>length</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>path</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the path (outline) for the specified text. Note: just like <a class="el" href="classSkCanvas.html#a33">SkCanvas::drawText</a>, this will respect the Align setting in the paint. </td> - </tr> -</table> -<a class="anchor" name="a51" doxytag="SkPaint::getTextScaleX"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::getTextScaleX </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's horizontal scale factor for text. The default value is 1.0. </td> - </tr> -</table> -<a class="anchor" name="a49" doxytag="SkPaint::getTextSize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::getTextSize </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's text size. </td> - </tr> -</table> -<a class="anchor" name="a53" doxytag="SkPaint::getTextSkewX"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::getTextSkewX </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's horizontal skew factor for text. The default value is 0. </td> - </tr> -</table> -<a class="anchor" name="a55" doxytag="SkPaint::getTextTracking"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::getTextTracking </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's text tracking value. The defautl value is 0. This value is used to add/subtract space between characters in a line of text. </td> - </tr> -</table> -<a class="anchor" name="a45" doxytag="SkPaint::getTypeface"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkTypeface* SkPaint::getTypeface </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's typeface object (or nil for the default font). This object identifies which font to use when drawing or measuring text. If a previous maskfilter exists, its reference count is decremented. If maskfilter is non-nil, its reference count is incremented. </td> - </tr> -</table> -<a class="anchor" name="a38" doxytag="SkPaint::getXfermode"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkXfermode.html">SkXfermode</a>* SkPaint::getXfermode </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Returns:</b></dt><dd>the paint's xfermode (nor nil) without affecting the xfermode's reference count</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkPaint::isAntiAliasOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPaint::isAntiAliasOn </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for getFlags(), returning true if kAntiAlias_Mask bit is set </td> - </tr> -</table> -<a class="anchor" name="a15" doxytag="SkPaint::isFakeBoldTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPaint::isFakeBoldTextOn </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for getFlags(), returning true if kFakeBoldText_Mask bit is set </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkPaint::isLinearTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPaint::isLinearTextOn </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for getFlags(), returning true if kLinearText_Mask bit is set </td> - </tr> -</table> -<a class="anchor" name="a13" doxytag="SkPaint::isStrikeThruTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPaint::isStrikeThruTextOn </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for getFlags(), returning true if kStrikeThruText_Mask bit is set </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkPaint::isUnderlineTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPaint::isUnderlineTextOn </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for getFlags(), returning true if kUnderlineText_Mask bit is set </td> - </tr> -</table> -<a class="anchor" name="a61" doxytag="SkPaint::measureText"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::measureText </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>text</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>length</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the width of the utf8 text. </td> - </tr> -</table> -<a class="anchor" name="a57" doxytag="SkPaint::measureText"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::measureText </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const char </td> - <td class="mdname" nowrap> <em>utf8</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>length</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>above</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>below</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the width of the utf8 text. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>utf8</em> </td><td>Address of the utf8 text </td></tr> - <tr><td valign="top"></td><td valign="top"><em>length</em> </td><td>Number of bytes of utf8 text to measure </td></tr> - <tr><td valign="top"></td><td valign="top"><em>above</em> </td><td>If not nil, returns the distance above the baseline (ascent) </td></tr> - <tr><td valign="top"></td><td valign="top"><em>below</em> </td><td>If not nil, returns the distance below the baseline (descent) </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>The width of the utf8 text</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a58" doxytag="SkPaint::measureText16"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkPaint::measureText16 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const U16 </td> - <td class="mdname" nowrap> <em>utf16</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>size_t </td> - <td class="mdname" nowrap> <em>numberOf16BitValues</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>above</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>below</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the width of the utf16 text. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>utf16</em> </td><td>Address of the utf16 text </td></tr> - <tr><td valign="top"></td><td valign="top"><em>numberOf16BitValues</em> </td><td>Number of 16bit values to measure </td></tr> - <tr><td valign="top"></td><td valign="top"><em>above</em> </td><td>If not nil, returns the distance above the baseline (ascent) </td></tr> - <tr><td valign="top"></td><td valign="top"><em>below</em> </td><td>If not nil, returns the distance below the baseline (descent) </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>The width of the text</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkPaint::reset"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::reset </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Restores the paint to its initial settings. </td> - </tr> -</table> -<a class="anchor" name="a24" doxytag="SkPaint::setAlpha"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setAlpha </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname1" valign="top" nowrap> <em>a</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper to <a class="el" href="classSkPaint.html#a23">setColor()</a>, that only assigns the color's alpha value, leaving its r,g,b values unchanged. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkPaint::setAntiAliasOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setAntiAliasOn </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for setFlags(), setting or clearing the kAntiAlias_Mask bit </td> - </tr> -</table> -<a class="anchor" name="a25" doxytag="SkPaint::setARGB"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setARGB </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U8CPU </td> - <td class="mdname" nowrap> <em>a</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>r</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>g</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8CPU </td> - <td class="mdname" nowrap> <em>b</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper to <a class="el" href="classSkPaint.html#a23">setColor()</a>, that takes a,r,g,b and constructs the color value using <a class="el" href="SkColor_8h.html#a19">SkColorSetARGB()</a> </td> - </tr> -</table> -<a class="anchor" name="a23" doxytag="SkPaint::setColor"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setColor </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="SkColor_8h.html#a17">SkColor</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's color. Note that the color is a 32bit value containing alpha as well as r,g,b. This 32bit value is not premultiplied, meaning that its alpha can be any value, regardless of the values of r,g,b. </td> - </tr> -</table> -<a class="anchor" name="a16" doxytag="SkPaint::setFakeBoldTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setFakeBoldTextOn </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for setFlags(), setting or clearing the kStrikeThruText_Mask bit </td> - </tr> -</table> -<a class="anchor" name="a35" doxytag="SkPaint::setFilterType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setFilterType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w38">FilterType</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's bitmap filter type. This setting affects drawBitmap() and bitmaps that appear inside a bitmap shader. </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkPaint::setLinearTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setLinearTextOn </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for setFlags(), setting or clearing the kLinearText_Mask bit </td> - </tr> -</table> -<a class="anchor" name="a44" doxytag="SkPaint::setMaskFilter"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a>* SkPaint::setMaskFilter </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>maskfilter</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set a maskfilter object into the SkPaint, or nil to clear any previous maskfilter. If a previous maskfilter exists, its reference count is decremented. If maskfilter is non-nil, its reference count is incremented. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>maskfilter</em> </td><td>the new filter (or nil) to be installed into the paint </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>its parameter (maskfilter)</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a42" doxytag="SkPaint::setPathEffect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a>* SkPaint::setPathEffect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>effect</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set a patheffect object into the SkPaint, or nil to clear any previous patheffect. If a previous patheffect exists, its reference count is decremented. If patheffect is non-nil, its reference count is incremented. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>effect</em> </td><td>the new path effect (or nil) to be installed in the paint </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>its parameter (effect)</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a37" doxytag="SkPaint::setShader"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkShader.html">SkShader</a>* SkPaint::setShader </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkShader.html">SkShader</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>shader</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set a shader object into the SkPaint, or nil to clear any previous shader. If a previous shader exists, its reference count is decremented. If shader is non-nil, its reference count is incremented. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>shader</em> </td><td>the new shader (or nil) to be installed in the paint </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>its parameter (shader)</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a14" doxytag="SkPaint::setStrikeThruTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setStrikeThruTextOn </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for setFlags(), setting or clearing the kStrikeThruText_Mask bit </td> - </tr> -</table> -<a class="anchor" name="a31" doxytag="SkPaint::setStrokeCap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setStrokeCap </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w36">Cap</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's stroke cap type. </td> - </tr> -</table> -<a class="anchor" name="a33" doxytag="SkPaint::setStrokeJoin"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setStrokeJoin </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w37">Join</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's stroke join type. </td> - </tr> -</table> -<a class="anchor" name="a29" doxytag="SkPaint::setStrokeMiter"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setStrokeMiter </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's stroke miter value. This is used to control the behavior of miter joins when the joins angle is sharp. This value must be >= 0. </td> - </tr> -</table> -<a class="anchor" name="a27" doxytag="SkPaint::setStrokeWidth"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setStrokeWidth </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the width for framing. 0 indicates framing in hairline mode, which always draws a single pixel independent of the current matrix. This value must be >= 0. </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkPaint::setStyle"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setStyle </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPaint.html#w35">Style</a> </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's style, used for controlling how primitives' geometries are interpreted (except for drawBitmap, which always assumes kFill_Style). </td> - </tr> -</table> -<a class="anchor" name="a48" doxytag="SkPaint::setTextAlign"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setTextAlign </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">Align </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's text alignment. </td> - </tr> -</table> -<a class="anchor" name="a52" doxytag="SkPaint::setTextScaleX"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setTextScaleX </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> <em>scaleX</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's horizontal scale factor for text. The default value is 1.0. Values > 1.0 will stretch the text wider. Values < 1.0 will stretch the text narrower. </td> - </tr> -</table> -<a class="anchor" name="a50" doxytag="SkPaint::setTextSize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setTextSize </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's text size. This value must be > 0 </td> - </tr> -</table> -<a class="anchor" name="a54" doxytag="SkPaint::setTextSkewX"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setTextSkewX </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> <em>skewX</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's horizontal skew factor for text. The default value is 0. For approximating oblique text, use values around -0.25 </td> - </tr> -</table> -<a class="anchor" name="a56" doxytag="SkPaint::setTextTracking"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setTextTracking </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname1" valign="top" nowrap> <em>tracking</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the paint's text tracking value. The defautl value is 0. This value is used to add/subtract space between characters in a line of text. </td> - </tr> -</table> -<a class="anchor" name="a46" doxytag="SkPaint::setTypeface"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkTypeface* SkPaint::setTypeface </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkTypeface * </td> - <td class="mdname1" valign="top" nowrap> <em>typeface</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the paint's typeface object (or nil for the default font). This object identifies which font to use when drawing or measuring text. If a previous typeface exists, its reference count is decremented. If typeface is non-nil, its reference count is incremented. </td> - </tr> -</table> -<a class="anchor" name="a12" doxytag="SkPaint::setUnderlineTextOn"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPaint::setUnderlineTextOn </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper for setFlags(), setting or clearing the kUnderlineText_Mask bit </td> - </tr> -</table> -<a class="anchor" name="a39" doxytag="SkPaint::setXfermode"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkXfermode.html">SkXfermode</a>* SkPaint::setXfermode </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkXfermode.html">SkXfermode</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>xfermode</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set a xfermode object into the SkPaint, or nil to clear any previous xfermode. If a previous xfermode exists, its reference count is decremented. If xfermode is non-nil, its reference count is incremented. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>xfermode</em> </td><td>the new xfermode (or nil) to be installed in the paint </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>its parameter (xfermode)</dd></dl> - </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPaint_8h-source.html">SkPaint.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPairPathEffect-members.html b/sgl_doxygen/html/classSkPairPathEffect-members.html deleted file mode 100644 index da5f9bf..0000000 --- a/sgl_doxygen/html/classSkPairPathEffect-members.html +++ /dev/null @@ -1,31 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPairPathEffect Member List</h1>This is the complete list of members for <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPathEffect.html#a1">filterPath</a>(SkPath *dst, const SkPath &src, SkScalar *width)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fPE0</b> (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fPE1</b> (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPathEffect.html#a2">getFactory</a>()</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPairPathEffect</b>(SkPathEffect *pe0, SkPathEffect *pe1) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPairPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>() (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkPairPathEffect</b>() (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPairPathEffect.html b/sgl_doxygen/html/classSkPairPathEffect.html deleted file mode 100644 index a247e98..0000000 --- a/sgl_doxygen/html/classSkPairPathEffect.html +++ /dev/null @@ -1,49 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPairPathEffect Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPairPathEffect Class Reference</h1><code>#include <<a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a>></code> -<p> -<p>Inheritance diagram for SkPairPathEffect: -<p><center><img src="classSkPairPathEffect.png" usemap="#SkPairPathEffect_map" border="0" alt=""></center> -<map name="SkPairPathEffect_map"> -<area href="classSkPathEffect.html" alt="SkPathEffect" shape="rect" coords="73,112,209,136"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="73,56,209,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="73,0,209,24"> -<area href="classSkComposePathEffect.html" alt="SkComposePathEffect" shape="rect" coords="0,224,136,248"> -<area href="classSkSumPathEffect.html" alt="SkSumPathEffect" shape="rect" coords="146,224,282,248"> -</map> -<a href="classSkPairPathEffect-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkPairPathEffect::SkPairPathEffect"></a> - </td><td class="memItemRight" valign="bottom"><b>SkPairPathEffect</b> (<a class="el" href="classSkPathEffect.html">SkPathEffect</a> *pe0, <a class="el" href="classSkPathEffect.html">SkPathEffect</a> *pe1)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkPairPathEffect::flatten"></a> -virtual U32 </td><td class="memItemRight" valign="bottom"><b>flatten</b> (void *buffer)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkPairPathEffect::SkPairPathEffect"></a> - </td><td class="memItemRight" valign="bottom"><b>SkPairPathEffect</b> (const void *buffer)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Attributes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="p0" doxytag="SkPairPathEffect::fPE0"></a> -<a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td><td class="memItemRight" valign="bottom"><b>fPE0</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="p1" doxytag="SkPairPathEffect::fPE1"></a> -<a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td><td class="memItemRight" valign="bottom"><b>fPE1</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Common baseclass for Compose and Sum. This subclass manages two pathEffects, including flattening them. It does nothing in filterPath, and is only useful for managing the lifetimes of its two arguments. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPairPathEffect.png b/sgl_doxygen/html/classSkPairPathEffect.png Binary files differdeleted file mode 100644 index 835501d..0000000 --- a/sgl_doxygen/html/classSkPairPathEffect.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkPath-members.html b/sgl_doxygen/html/classSkPath-members.html deleted file mode 100644 index cf0decf..0000000 --- a/sgl_doxygen/html/classSkPath-members.html +++ /dev/null @@ -1,74 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPath Member List</h1>This is the complete list of members for <a class="el" href="classSkPath.html">SkPath</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a28">addCircle</a>(SkScalar x, SkScalar y, SkScalar radius, Direction dir=kCW_Direction)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a27">addOval</a>(const SkRect &, Direction dir=kCW_Direction)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a30">addPath</a>(const SkPath &src, SkScalar dx, SkScalar dy)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a31">addPath</a>(const SkPath &src)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a32">addPath</a>(const SkPath &src, const SkMatrix &matrix)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a26">addRect</a>(const SkRect &, Direction dir=kCW_Direction)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a29">addRoundRect</a>(const SkRect &, SkScalar rx, SkScalar ry, Direction dir=kCW_Direction)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w13">BoundsType</a> enum name</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a21">close</a>()</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a11">computeBounds</a>(SkRect *bounds, BoundsType btype) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a19">cubicTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>cubicTo</b>(const SkPoint &p1, const SkPoint &p2, const SkPoint &p3) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w14">Direction</a> enum name</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w12">FillType</a> enum name</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a39">flatten</a>(void *bufferOrNil) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a4">getFillType</a>() const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a36">getLastPt</a>(SkPoint *lastPt) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a9">getPoints</a>(SkPoint points[], int max) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>incReserve</b>(U16CPU extraPtCount) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a7">isEmpty</a>() const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a8">isRect</a>(SkRect *rect) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Iter</b> (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w14w5">kCCW_Direction</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15w10">kClose_Verb</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15w9">kCubic_Verb</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w14w4">kCW_Direction</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15w11">kDone_Verb</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w12w1">kEvenOdd_FillType</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w13w3">kExact_BoundsType</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w13w2">kFast_BoundsType</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15w7">kLine_Verb</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15w6">kMove_Verb</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15w8">kQuad_Verb</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w12w0">kWinding_FillType</a> enum value</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a15">lineTo</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>lineTo</b>(const SkPoint &p1) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a13">moveTo</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>moveTo</b>(const SkPoint &p) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a33">offset</a>(SkScalar dx, SkScalar dy)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator=</b>(const SkPath &) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a17">quadTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>quadTo</b>(const SkPoint &p1, const SkPoint &p2) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a20">rCubicTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a6">reset</a>()</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a16">rLineTo</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a14">rMoveTo</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a18">rQuadTo</a>(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a5">setFillType</a>(FillType ft)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a37">setLastPt</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setLastPt</b>(const SkPoint &pt) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>sk_get_path_points</b> (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPath</b>() (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPath</b>(const SkPath &) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathStroker</b> (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a41">subdivide</a>(SkScalar dist, bool bendLines, SkPath *dst=nil) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a10">swap</a>(SkPath &other)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a34">transform</a>(const SkMatrix &, SkPath *dst) const </td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#a35">transform</a>(const SkMatrix &map)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>unflatten</b>(const void *buffer) (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath.html#w15">Verb</a> enum name</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkPath</b>() (defined in <a class="el" href="classSkPath.html">SkPath</a>)</td><td><a class="el" href="classSkPath.html">SkPath</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPath.html b/sgl_doxygen/html/classSkPath.html deleted file mode 100644 index f689cc4..0000000 --- a/sgl_doxygen/html/classSkPath.html +++ /dev/null @@ -1,1422 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPath Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPath Class Reference</h1><code>#include <<a class="el" href="SkPath_8h-source.html">SkPath.h</a>></code> -<p> -<a href="classSkPath-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#w12">FillType</a> { <a class="el" href="classSkPath.html#w12w0">kWinding_FillType</a>, -<a class="el" href="classSkPath.html#w12w1">kEvenOdd_FillType</a> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#w13">BoundsType</a> { <a class="el" href="classSkPath.html#w13w2">kFast_BoundsType</a>, -<a class="el" href="classSkPath.html#w13w3">kExact_BoundsType</a> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#w14">Direction</a> { <a class="el" href="classSkPath.html#w14w4">kCW_Direction</a>, -<a class="el" href="classSkPath.html#w14w5">kCCW_Direction</a> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#w15">Verb</a> { <br> - <a class="el" href="classSkPath.html#w15w6">kMove_Verb</a>, -<a class="el" href="classSkPath.html#w15w7">kLine_Verb</a>, -<a class="el" href="classSkPath.html#w15w8">kQuad_Verb</a>, -<a class="el" href="classSkPath.html#w15w9">kCubic_Verb</a>, -<br> - <a class="el" href="classSkPath.html#w15w10">kClose_Verb</a>, -<a class="el" href="classSkPath.html#w15w11">kDone_Verb</a> -<br> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkPath::SkPath"></a> - </td><td class="memItemRight" valign="bottom"><b>SkPath</b> (const <a class="el" href="classSkPath.html">SkPath</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkPath::operator="></a> -<a class="el" href="classSkPath.html">SkPath</a> & </td><td class="memItemRight" valign="bottom"><b>operator=</b> (const <a class="el" href="classSkPath.html">SkPath</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkPath.html#w12">FillType</a> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a4">getFillType</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a5">setFillType</a> (<a class="el" href="classSkPath.html#w12">FillType</a> ft)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a6">reset</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a7">isEmpty</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a8">isRect</a> (SkRect *rect) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a9">getPoints</a> (SkPoint points[], int max) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a10" doxytag="SkPath::swap"></a> -void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a10">swap</a> (<a class="el" href="classSkPath.html">SkPath</a> &other)</td></tr> - -<tr><td class="mdescLeft"> </td><td class="mdescRight">Swap contents of this and other. Guaranteed not to throw. <br></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a11">computeBounds</a> (SkRect *bounds, <a class="el" href="classSkPath.html#w13">BoundsType</a> btype) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a12" doxytag="SkPath::incReserve"></a> -void </td><td class="memItemRight" valign="bottom"><b>incReserve</b> (U16CPU extraPtCount)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a13">moveTo</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a14">rMoveTo</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a15">lineTo</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a16">rLineTo</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a17">quadTo</a> (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a18">rQuadTo</a> (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a19">cubicTo</a> (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a20">rCubicTo</a> (SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar x3, SkScalar y3)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a21">close</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a22" doxytag="SkPath::moveTo"></a> -void </td><td class="memItemRight" valign="bottom"><b>moveTo</b> (const SkPoint &p)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a23" doxytag="SkPath::lineTo"></a> -void </td><td class="memItemRight" valign="bottom"><b>lineTo</b> (const SkPoint &p1)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a24" doxytag="SkPath::quadTo"></a> -void </td><td class="memItemRight" valign="bottom"><b>quadTo</b> (const SkPoint &p1, const SkPoint &p2)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a25" doxytag="SkPath::cubicTo"></a> -void </td><td class="memItemRight" valign="bottom"><b>cubicTo</b> (const SkPoint &p1, const SkPoint &p2, const SkPoint &p3)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a26">addRect</a> (const SkRect &, <a class="el" href="classSkPath.html#w14">Direction</a> dir=kCW_Direction)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a27">addOval</a> (const SkRect &, <a class="el" href="classSkPath.html#w14">Direction</a> dir=kCW_Direction)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a28">addCircle</a> (SkScalar x, SkScalar y, SkScalar radius, <a class="el" href="classSkPath.html#w14">Direction</a> dir=kCW_Direction)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a29">addRoundRect</a> (const SkRect &, SkScalar rx, SkScalar ry, <a class="el" href="classSkPath.html#w14">Direction</a> dir=kCW_Direction)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a30">addPath</a> (const <a class="el" href="classSkPath.html">SkPath</a> &src, SkScalar dx, SkScalar dy)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a31">addPath</a> (const <a class="el" href="classSkPath.html">SkPath</a> &src)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a32">addPath</a> (const <a class="el" href="classSkPath.html">SkPath</a> &src, const SkMatrix &matrix)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a33">offset</a> (SkScalar dx, SkScalar dy)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a34">transform</a> (const SkMatrix &, <a class="el" href="classSkPath.html">SkPath</a> *dst) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a35">transform</a> (const SkMatrix &map)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a36">getLastPt</a> (SkPoint *lastPt) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a37">setLastPt</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a38" doxytag="SkPath::setLastPt"></a> -void </td><td class="memItemRight" valign="bottom"><b>setLastPt</b> (const SkPoint &pt)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a39">flatten</a> (void *bufferOrNil) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a40" doxytag="SkPath::unflatten"></a> -void </td><td class="memItemRight" valign="bottom"><b>unflatten</b> (const void *buffer)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath.html#a41">subdivide</a> (SkScalar dist, bool bendLines, <a class="el" href="classSkPath.html">SkPath</a> *dst=nil) const </td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkPath::Iter"></a> -class </td><td class="memItemRight" valign="bottom"><b>Iter</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n1" doxytag="SkPath::SkPathStroker"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkPathStroker</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n2" doxytag="SkPath::sk_get_path_points"></a> -const SkPoint * </td><td class="memItemRight" valign="bottom"><b>sk_get_path_points</b> (const <a class="el" href="classSkPath.html">SkPath</a> &, int index)</td></tr> - -<tr><td colspan="2"><br><h2>Classes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath_1_1Iter.html">Iter</a></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -The SkPath class encapsulates compound (multiple contour) geometric paths consisting of straight line segments, quadratic curves, and cubic curves. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w13" doxytag="SkPath::BoundsType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPath.html#w13">SkPath::BoundsType</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w13w2" doxytag="kFast_BoundsType"></a>kFast_BoundsType</em> </td><td> -compute the bounds of the path's control points, may be larger than with kExact_BoundsType, but may be faster to compute </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w13w3" doxytag="kExact_BoundsType"></a>kExact_BoundsType</em> </td><td> -compute the exact bounds of the path, may be smaller than with kFast_BoundsType, but may be slower to compute </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w14" doxytag="SkPath::Direction"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPath.html#w14">SkPath::Direction</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w14w4" doxytag="kCW_Direction"></a>kCW_Direction</em> </td><td> -clockwise direction for adding closed contours </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w14w5" doxytag="kCCW_Direction"></a>kCCW_Direction</em> </td><td> -counter-clockwise direction for adding closed contours </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w12" doxytag="SkPath::FillType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPath.html#w12">SkPath::FillType</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w12w0" doxytag="kWinding_FillType"></a>kWinding_FillType</em> </td><td> -Specifies that "inside" is computed by a non-zero sum of signed edge crossings. </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w12w1" doxytag="kEvenOdd_FillType"></a>kEvenOdd_FillType</em> </td><td> -Specifies that "inside" is computed by an odd number of edge crossings. </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w15" doxytag="SkPath::Verb"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkPath.html#w15">SkPath::Verb</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w15w6" doxytag="kMove_Verb"></a>kMove_Verb</em> </td><td> -iter.next returns 1 point </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w15w7" doxytag="kLine_Verb"></a>kLine_Verb</em> </td><td> -iter.next returns 2 points </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w15w8" doxytag="kQuad_Verb"></a>kQuad_Verb</em> </td><td> -iter.next returns 3 points </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w15w9" doxytag="kCubic_Verb"></a>kCubic_Verb</em> </td><td> -iter.next returns 4 points </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w15w10" doxytag="kClose_Verb"></a>kClose_Verb</em> </td><td> -iter.next returns 1 point (the last point) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w15w11" doxytag="kDone_Verb"></a>kDone_Verb</em> </td><td> -iter.next returns 0 points </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a28" doxytag="SkPath::addCircle"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addCircle </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>radius</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html#w14">Direction</a> </td> - <td class="mdname" nowrap> <em>dir</em> = <code>kCW_Direction</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a closed circle contour to the path </td> - </tr> -</table> -<a class="anchor" name="a27" doxytag="SkPath::addOval"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addOval </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html#w14">Direction</a> </td> - <td class="mdname" nowrap> <em>dir</em> = <code>kCW_Direction</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a closed oval contour to the path </td> - </tr> -</table> -<a class="anchor" name="a32" doxytag="SkPath::addPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMatrix & </td> - <td class="mdname" nowrap> <em>matrix</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a copy of src to the path, transformed by matrix </td> - </tr> -</table> -<a class="anchor" name="a31" doxytag="SkPath::addPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>src</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a copy of src to the path </td> - </tr> -</table> -<a class="anchor" name="a30" doxytag="SkPath::addPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>dx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>dy</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a copy of src to the path, offset by (dx,dy) </td> - </tr> -</table> -<a class="anchor" name="a26" doxytag="SkPath::addRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html#w14">Direction</a> </td> - <td class="mdname" nowrap> <em>dir</em> = <code>kCW_Direction</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a closed rectangle contour to the path </td> - </tr> -</table> -<a class="anchor" name="a29" doxytag="SkPath::addRoundRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::addRoundRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>rx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>ry</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html#w14">Direction</a> </td> - <td class="mdname" nowrap> <em>dir</em> = <code>kCW_Direction</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a closed round-rectangle contour to the path </td> - </tr> -</table> -<a class="anchor" name="a21" doxytag="SkPath::close"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::close </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Close the current contour. If the current point is not equal to the first point of the contour, a line segment is automatically added. </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkPath::computeBounds"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::computeBounds </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkRect * </td> - <td class="mdname" nowrap> <em>bounds</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html#w13">BoundsType</a> </td> - <td class="mdname" nowrap> <em>btype</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Compute the bounds of the path, and write the answer into bounds. If the path contains 0 or 1 points, the bounds is set to (0,0,0,0) </td> - </tr> -</table> -<a class="anchor" name="a19" doxytag="SkPath::cubicTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::cubicTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x2</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y2</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x3</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y3</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a cubic curve from the current point, through (x1,y1) and (x2,y2), to the point (x3,y3), and then set theh current point to (x3,y3). If no <a class="el" href="classSkPath.html#a13">moveTo()</a> call has been made for this contour, the first point is automatically set to (0,0). </td> - </tr> -</table> -<a class="anchor" name="a39" doxytag="SkPath::flatten"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U32 SkPath::flatten </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">void * </td> - <td class="mdname1" valign="top" nowrap> <em>bufferOrNil</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the number of bytes (padded to a multiple of 4) needed to flatten the path into a block of memory. If bufferOrNil is not nil, the path is written into it. The format of the buffer is private, and can be used to create a new path by calling unflatten(). </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkPath::getFillType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html#w12">FillType</a> SkPath::getFillType </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the path's fill type. This is used to define how "inside" is computed. The default value is kWinding_FillType. </td> - </tr> -</table> -<a class="anchor" name="a36" doxytag="SkPath::getLastPt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::getLastPt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkPoint * </td> - <td class="mdname1" valign="top" nowrap> <em>lastPt</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the last point on the contour. If no points have been added, (0,0) is returned. </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkPath::getPoints"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int SkPath::getPoints </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkPoint </td> - <td class="mdname" nowrap> <em>points</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>max</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the number of points in the path. Up to max points are copied. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>points</em> </td><td>If not nil, receives up to max points </td></tr> - <tr><td valign="top"></td><td valign="top"><em>max</em> </td><td>The maximum number of points to return </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>the number of points in the path</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkPath::isEmpty"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPath::isEmpty </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the path is empty (contains no lines or curves) </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkPath::isRect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPath::isRect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkRect * </td> - <td class="mdname1" valign="top" nowrap> <em>rect</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns true if the path specifies a rectangle. If so, and if rect is not nil, set rect to the bounds of the path. If the path does not specify a rectangle, return false and ignore rect. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>rect</em> </td><td>If not nil, returns the bounds of the path if it specifies a rectangle </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>true if the path specifies a rectangle</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a15" doxytag="SkPath::lineTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::lineTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a line from the current point to the point (x,y), and then set the current point to (x,y). If no <a class="el" href="classSkPath.html#a13">moveTo()</a> call has been made for this contour, the first point is automatically set to (0,0). </td> - </tr> -</table> -<a class="anchor" name="a13" doxytag="SkPath::moveTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::moveTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the beginning of the next contour to the point (x,y). </td> - </tr> -</table> -<a class="anchor" name="a33" doxytag="SkPath::offset"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPath::offset </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>dx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>dy</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Offset the path by (dx,dy), returning true on success </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkPath::quadTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::quadTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x2</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y2</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Add a quadratic curve from the current point, through (x1,y1), to the point (x2,y2), and then set theh current point to (x2,y2). If no <a class="el" href="classSkPath.html#a13">moveTo()</a> call has been made for this contour, the first point is automatically set to (0,0). </td> - </tr> -</table> -<a class="anchor" name="a20" doxytag="SkPath::rCubicTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::rCubicTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x2</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y2</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x3</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y3</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Same as cubicTo, but the coordinates are considered relative to the last point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically. </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkPath::reset"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::reset </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Clear any lines and curves from the path, making it empty. This does NOT change the fill-type setting. </td> - </tr> -</table> -<a class="anchor" name="a16" doxytag="SkPath::rLineTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::rLineTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Same as lineTo, but the coordinates are considered relative to the last point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically. </td> - </tr> -</table> -<a class="anchor" name="a14" doxytag="SkPath::rMoveTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::rMoveTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the beginning of the next contour relative to the last point on the previous contour. If there is no previous contour, this is treated the same as <a class="el" href="classSkPath.html#a13">moveTo()</a>. </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkPath::rQuadTo"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::rQuadTo </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y1</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>x2</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y2</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Same as quadTo, but the coordinates are considered relative to the last point on this contour. If there is no previous point, then a moveTo(0,0) is inserted automatically. </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkPath::setFillType"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::setFillType </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html#w12">FillType</a> </td> - <td class="mdname1" valign="top" nowrap> <em>ft</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the path's fill type. This is used to define how "inside" is computed. The default value is kWinding_FillType. </td> - </tr> -</table> -<a class="anchor" name="a37" doxytag="SkPath::setLastPt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::setLastPt </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the last point on the contour. If no points have been added, moveTo(x,y) is automatically called. </td> - </tr> -</table> -<a class="anchor" name="a41" doxytag="SkPath::subdivide"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkPath::subdivide </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>dist</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>bendLines</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em> = <code>nil</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Subdivide the path so that no segment is longer that dist. If bendLines is true, then turn all line segments into curves. If dst == nil, then the original path itself is modified (not const!) </td> - </tr> -</table> -<a class="anchor" name="a35" doxytag="SkPath::transform"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPath::transform </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkMatrix & </td> - <td class="mdname1" valign="top" nowrap> <em>map</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Transform the points in this path by matrix, and write the answer back into the path, returning true on success </td> - </tr> -</table> -<a class="anchor" name="a34" doxytag="SkPath::transform"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPath::transform </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkMatrix & </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Transform the points in this path by matrix, and write the answer into dst, returning true on success </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPath_8h-source.html">SkPath.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPathEffect-members.html b/sgl_doxygen/html/classSkPathEffect-members.html deleted file mode 100644 index 8e54486..0000000 --- a/sgl_doxygen/html/classSkPathEffect-members.html +++ /dev/null @@ -1,26 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPathEffect Member List</h1>This is the complete list of members for <a class="el" href="classSkPathEffect.html">SkPathEffect</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPathEffect.html#a1">filterPath</a>(SkPath *dst, const SkPath &src, SkScalar *width)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer=nil) (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPathEffect.html#a2">getFactory</a>()</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>() (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPathEffect.html b/sgl_doxygen/html/classSkPathEffect.html deleted file mode 100644 index 52245d0..0000000 --- a/sgl_doxygen/html/classSkPathEffect.html +++ /dev/null @@ -1,120 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPathEffect Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPathEffect Class Reference</h1><code>#include <<a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a>></code> -<p> -<p>Inheritance diagram for SkPathEffect: -<p><center><img src="classSkPathEffect.png" usemap="#SkPathEffect_map" border="0" alt=""></center> -<map name="SkPathEffect_map"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="438,56,574,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="438,0,574,24"> -<area href="classSkCornerPathEffect.html" alt="SkCornerPathEffect" shape="rect" coords="292,168,428,192"> -<area href="classSkDashPathEffect.html" alt="SkDashPathEffect" shape="rect" coords="438,168,574,192"> -<area href="classSkPairPathEffect.html" alt="SkPairPathEffect" shape="rect" coords="730,168,866,192"> -<area href="classSkComposePathEffect.html" alt="SkComposePathEffect" shape="rect" coords="657,224,793,248"> -<area href="classSkSumPathEffect.html" alt="SkSumPathEffect" shape="rect" coords="803,224,939,248"> -</map> -<a href="classSkPathEffect-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPathEffect.html#a1">filterPath</a> (<a class="el" href="classSkPath.html">SkPath</a> *dst, const <a class="el" href="classSkPath.html">SkPath</a> &src, SkScalar *width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual Factory </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPathEffect.html#a2">getFactory</a> ()</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkPathEffect::SkPathEffect"></a> - </td><td class="memItemRight" valign="bottom"><b>SkPathEffect</b> (const void *buffer)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkPathEffect is the base class for objects in the <a class="el" href="classSkPaint.html">SkPaint</a> that affect the geometry of a drawing primitive before it is transformed by the canvas' matrix and drawn.<p> -Dashing is implemented as a subclass of SkPathEffect. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a1" doxytag="SkPathEffect::filterPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkPathEffect::filterPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>width</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a src path and a width value, return true if the patheffect has produced a new path (dst) and a new width value. If false is returned, ignore dst and width. On input, width >= 0 means the src should be stroked On output, width >= 0 means the dst should be stroked -<p> -Reimplemented in <a class="el" href="classSkCornerPathEffect.html#a2">SkCornerPathEffect</a>, <a class="el" href="classSkDashPathEffect.html#a2">SkDashPathEffect</a>, <a class="el" href="classSkComposePathEffect.html#a1">SkComposePathEffect</a>, and <a class="el" href="classSkSumPathEffect.html#a1">SkSumPathEffect</a>. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkPathEffect::getFactory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual Factory SkPathEffect::getFactory </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -overrides for <a class="el" href="classSkFlattenable.html">SkFlattenable</a>. Subclasses should override this to (re)create their subclass -<p> -Reimplemented from <a class="el" href="classSkFlattenable.html">SkFlattenable</a>. -<p> -Reimplemented in <a class="el" href="classSkCornerPathEffect.html#a3">SkCornerPathEffect</a>, <a class="el" href="classSkDashPathEffect.html#a3">SkDashPathEffect</a>, <a class="el" href="classSkComposePathEffect.html#a2">SkComposePathEffect</a>, and <a class="el" href="classSkSumPathEffect.html#a2">SkSumPathEffect</a>. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPathEffect.png b/sgl_doxygen/html/classSkPathEffect.png Binary files differdeleted file mode 100644 index 65bae6a..0000000 --- a/sgl_doxygen/html/classSkPathEffect.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkPath_1_1Iter-members.html b/sgl_doxygen/html/classSkPath_1_1Iter-members.html deleted file mode 100644 index f573874..0000000 --- a/sgl_doxygen/html/classSkPath_1_1Iter-members.html +++ /dev/null @@ -1,19 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkPath::Iter Member List</h1>This is the complete list of members for <a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>isClosedContour</b>() const (defined in <a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a>)</td><td><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkPath_1_1Iter.html#a4">isCloseLine</a>() const </td><td><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Iter</b>() (defined in <a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a>)</td><td><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Iter</b>(const SkPath &, bool forceClose) (defined in <a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a>)</td><td><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>next</b>(SkPoint pts[4]) (defined in <a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a>)</td><td><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setPath</b>(const SkPath &, bool forceClose) (defined in <a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a>)</td><td><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkPath_1_1Iter.html b/sgl_doxygen/html/classSkPath_1_1Iter.html deleted file mode 100644 index 4d24c93..0000000 --- a/sgl_doxygen/html/classSkPath_1_1Iter.html +++ /dev/null @@ -1,67 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkPath::Iter Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="classSkPath.html">SkPath</a>::<a class="el" href="classSkPath_1_1Iter.html">Iter</a></div> -<h1>SkPath::Iter Class Reference</h1><code>#include <<a class="el" href="SkPath_8h-source.html">SkPath.h</a>></code> -<p> -<a href="classSkPath_1_1Iter-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkPath::Iter::Iter"></a> - </td><td class="memItemRight" valign="bottom"><b>Iter</b> (const <a class="el" href="classSkPath.html">SkPath</a> &, bool forceClose)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkPath::Iter::setPath"></a> -void </td><td class="memItemRight" valign="bottom"><b>setPath</b> (const <a class="el" href="classSkPath.html">SkPath</a> &, bool forceClose)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkPath::Iter::next"></a> -<a class="el" href="classSkPath.html#w15">Verb</a> </td><td class="memItemRight" valign="bottom"><b>next</b> (SkPoint pts[4])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkPath_1_1Iter.html#a4">isCloseLine</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkPath::Iter::isClosedContour"></a> -bool </td><td class="memItemRight" valign="bottom"><b>isClosedContour</b> () const </td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Iterate through all of the segments (lines, quadratics, cubics) of each contours in a path. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a4" doxytag="SkPath::Iter::isCloseLine"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkPath::Iter::isCloseLine </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -If next() returns kLine_Verb, then this query returns true if the line was the result of a <a class="el" href="classSkPath.html#a21">close()</a> command (i.e. the end point is the initial moveto for this contour). If next() returned a different verb, this returns an undefined value. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPath_8h-source.html">SkPath.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkRefCnt-members.html b/sgl_doxygen/html/classSkRefCnt-members.html deleted file mode 100644 index 2da187b..0000000 --- a/sgl_doxygen/html/classSkRefCnt-members.html +++ /dev/null @@ -1,20 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkRefCnt Member List</h1>This is the complete list of members for <a class="el" href="classSkRefCnt.html">SkRefCnt</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkRefCnt.html b/sgl_doxygen/html/classSkRefCnt.html deleted file mode 100644 index f8f7bc3..0000000 --- a/sgl_doxygen/html/classSkRefCnt.html +++ /dev/null @@ -1,241 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkRefCnt Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkRefCnt Class Reference</h1><code>#include <<a class="el" href="SkRefCnt_8h-source.html">SkRefCnt.h</a>></code> -<p> -<p>Inheritance diagram for SkRefCnt: -<p><center><img src="classSkRefCnt.png" usemap="#SkRefCnt_map" border="0" alt=""></center> -<map name="SkRefCnt_map"> -<area href="classSkBitmapRef.html" alt="SkBitmapRef" shape="rect" coords="108,56,206,80"> -<area href="classSkBounder.html" alt="SkBounder" shape="rect" coords="108,112,206,136"> -<area href="classSkColorTable.html" alt="SkColorTable" shape="rect" coords="108,168,206,192"> -<area href="classSkEventSink.html" alt="SkEventSink" shape="rect" coords="108,224,206,248"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="108,280,206,304"> -<area href="classSkShader.html" alt="SkShader" shape="rect" coords="108,392,206,416"> -<area href="classSkView_1_1Artist.html" alt="SkView::Artist" shape="rect" coords="108,560,206,584"> -<area href="classSkView_1_1Layout.html" alt="SkView::Layout" shape="rect" coords="108,616,206,640"> -<area href="classSkXfermode.html" alt="SkXfermode" shape="rect" coords="108,672,206,696"> -</map> -<a href="classSkRefCnt-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a3">ref</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a4">unref</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a5">safeRef</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkRefCnt.html#a6">safeUnref</a> () const </td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkRefCnt is the base class for objects that may be shared by multiple objects. When a new owner wants a reference, it calls <a class="el" href="classSkRefCnt.html#a3">ref()</a>. When an owner wants to release its reference, it calls <a class="el" href="classSkRefCnt.html#a4">unref()</a>. When the shared object's reference count goes to zero as the result of an <a class="el" href="classSkRefCnt.html#a4">unref()</a> call, its (virtual) destructor is called. It is an error for the destructor to be called explicitly (or via the object going out of scope on the stack or calling delete) if <a class="el" href="classSkRefCnt.html#a2">getRefCnt()</a> > 1. -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkRefCnt::SkRefCnt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkRefCnt::SkRefCnt </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Default construct, initializing the reference count to 1. </td> - </tr> -</table> -<a class="anchor" name="a1" doxytag="SkRefCnt::~SkRefCnt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual SkRefCnt::~<a class="el" href="classSkRefCnt.html">SkRefCnt</a> </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline, virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Destruct, asserting that the reference count is 1. </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a2" doxytag="SkRefCnt::getRefCnt"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int SkRefCnt::getRefCnt </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the reference count. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkRefCnt::ref"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkRefCnt::ref </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Increment the reference count. Must be balanced by a call to <a class="el" href="classSkRefCnt.html#a4">unref()</a>. </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkRefCnt::safeRef"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkRefCnt::safeRef </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper version of <a class="el" href="classSkRefCnt.html#a3">ref()</a>, that first checks to see if this is not nil. If this is nil, then do nothing. </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkRefCnt::safeUnref"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkRefCnt::safeUnref </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper version of <a class="el" href="classSkRefCnt.html#a4">unref()</a>, that first checks to see if this is not nil. If this is nil, then do nothing. </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkRefCnt::unref"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkRefCnt::unref </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Decrement the reference count. If the reference count is 1 before the decrement, then call delete on the object. Note that if this is the case, then the object needs to have been allocated via new, and not on the stack. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkRefCnt_8h-source.html">SkRefCnt.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkRefCnt.png b/sgl_doxygen/html/classSkRefCnt.png Binary files differdeleted file mode 100644 index d7e6e80..0000000 --- a/sgl_doxygen/html/classSkRefCnt.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkShader-members.html b/sgl_doxygen/html/classSkShader-members.html deleted file mode 100644 index 07587f7..0000000 --- a/sgl_doxygen/html/classSkShader-members.html +++ /dev/null @@ -1,53 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkShader Member List</h1>This is the complete list of members for <a class="el" href="classSkShader.html">SkShader</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a9">canCallShadeSpanOpaque16</a>()</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#e0">CanCallShadeSpanOpaque16</a>(U32 flags)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>ComputeMatrixClass</b>(const SkMatrix &) (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected, static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#e1">CreateBitmapShader</a>(const SkBitmap &src, bool transferOwnershipOfPixels, SkPaint::FilterType ft, TileMode tm)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9">Flags</a> enum name</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getDeviceConfig</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a4">getFlags</a>()</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getInverseClass</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getInverseMapPtProc</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a2">getLocalMatrix</a>() const </td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getPaintAlpha</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getTotalInverse</b>() const (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w0">kClamp_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w5">kConstAlpha_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFixedStepInX_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlagsMask</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w6">kHasSpan16_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kLinear_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w2">kMirror_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kPerspective_MatrixClass</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8w1">kRepeat_TileMode</a> enum value</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kTileModeCount</b> enum value (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>MatrixClass</b> enum name (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a5">setContext</a>(const SkBitmap &device, const SkPaint &paint, const SkMatrix &matrix)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a3">setLocalMatrix</a>(const SkMatrix &)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a6">shadeSpan</a>(int x, int y, SkPMColor[], int count)=0</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [pure virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a8">shadeSpanAlpha</a>(int x, int y, U8 alpha[], int count)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#a7">shadeSpanOpaque16</a>(int x, int y, U16[], int count)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkAutoBitmapShaderInstall</b> (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkShader</b>() (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkShader.html#w8">TileMode</a> enum name</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkShader</b>() (defined in <a class="el" href="classSkShader.html">SkShader</a>)</td><td><a class="el" href="classSkShader.html">SkShader</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkShader.html b/sgl_doxygen/html/classSkShader.html deleted file mode 100644 index 52fb34a..0000000 --- a/sgl_doxygen/html/classSkShader.html +++ /dev/null @@ -1,553 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkShader Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkShader Class Reference</h1><code>#include <<a class="el" href="SkShader_8h-source.html">SkShader.h</a>></code> -<p> -<p>Inheritance diagram for SkShader: -<p><center><img src="classSkShader.png" usemap="#SkShader_map" border="0" alt=""></center> -<map name="SkShader_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="217,0,352,24"> -<area href="classSkGradientShader.html" alt="SkGradientShader" shape="rect" coords="0,112,135,136"> -<area href="classSkLightShader.html" alt="SkLightShader" shape="rect" coords="145,112,280,136"> -</map> -<a href="classSkShader-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#w8">TileMode</a> { <a class="el" href="classSkShader.html#w8w0">kClamp_TileMode</a>, -<a class="el" href="classSkShader.html#w8w1">kRepeat_TileMode</a>, -<a class="el" href="classSkShader.html#w8w2">kMirror_TileMode</a>, -<b>kTileModeCount</b> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#w9">Flags</a> { <a class="el" href="classSkShader.html#w9w4">kOpaqueAlpha_Flag</a> = 0x01, -<a class="el" href="classSkShader.html#w9w5">kConstAlpha_Flag</a> = 0x02, -<a class="el" href="classSkShader.html#w9w6">kHasSpan16_Flag</a> = 0x04, -<b>kFlagsMask</b> = kOpaqueAlpha_Flag | kConstAlpha_Flag | kHasSpan16_Flag - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">const SkMatrix * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a2">getLocalMatrix</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a3">setLocalMatrix</a> (const SkMatrix &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a4">getFlags</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a5">setContext</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &device, const <a class="el" href="classSkPaint.html">SkPaint</a> &paint, const SkMatrix &matrix)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a6">shadeSpan</a> (int x, int y, <a class="el" href="SkColor_8h.html#a18">SkPMColor</a>[], int count)=0</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a7">shadeSpanOpaque16</a> (int x, int y, U16[], int count)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a8">shadeSpanAlpha</a> (int x, int y, U8 alpha[], int count)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#a9">canCallShadeSpanOpaque16</a> ()</td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">static bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#e0">CanCallShadeSpanOpaque16</a> (U32 flags)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">static <a class="el" href="classSkShader.html">SkShader</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkShader.html#e1">CreateBitmapShader</a> (const <a class="el" href="classSkBitmap.html">SkBitmap</a> &src, bool transferOwnershipOfPixels, <a class="el" href="classSkPaint.html#w38">SkPaint::FilterType</a> ft, <a class="el" href="classSkShader.html#w8">TileMode</a> tm)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><b>MatrixClass</b> { <b>kLinear_MatrixClass</b>, -<b>kFixedStepInX_MatrixClass</b>, -<b>kPerspective_MatrixClass</b> - }</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkShader::getPaintAlpha"></a> -U8 </td><td class="memItemRight" valign="bottom"><b>getPaintAlpha</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b1" doxytag="SkShader::getDeviceConfig"></a> -<a class="el" href="classSkBitmap.html#w7">SkBitmap::Config</a> </td><td class="memItemRight" valign="bottom"><b>getDeviceConfig</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b2" doxytag="SkShader::getTotalInverse"></a> -const SkMatrix & </td><td class="memItemRight" valign="bottom"><b>getTotalInverse</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b3" doxytag="SkShader::getInverseClass"></a> -MatrixClass </td><td class="memItemRight" valign="bottom"><b>getInverseClass</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b4" doxytag="SkShader::getInverseMapPtProc"></a> -SkMatrix::MapPtProc </td><td class="memItemRight" valign="bottom"><b>getInverseMapPtProc</b> () const </td></tr> - -<tr><td colspan="2"><br><h2>Static Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="f0" doxytag="SkShader::ComputeMatrixClass"></a> -static MatrixClass </td><td class="memItemRight" valign="bottom"><b>ComputeMatrixClass</b> (const SkMatrix &)</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkShader::SkAutoBitmapShaderInstall"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkAutoBitmapShaderInstall</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkShader is the based class for objects that return horizontal spans of colors during drawing. A subclass of SkShader is installed in a <a class="el" href="classSkPaint.html">SkPaint</a> calling paint.setShader(shader). After that any object (other than a bitmap) that is drawn with that paint will get its color(s) from the shader. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w9" doxytag="SkShader::Flags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkShader.html#w9">SkShader::Flags</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w9w4" doxytag="kOpaqueAlpha_Flag"></a>kOpaqueAlpha_Flag</em> </td><td> -set if all of the colors will be opaque (if so, kConstAlpha_Flag will not be set) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w9w5" doxytag="kConstAlpha_Flag"></a>kConstAlpha_Flag</em> </td><td> -set if all of the colors have the same (non-opaque) alpha </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w9w6" doxytag="kHasSpan16_Flag"></a>kHasSpan16_Flag</em> </td><td> -set if this shader's <a class="el" href="classSkShader.html#a7">shadeSpanOpaque16()</a> method can be called </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<a class="anchor" name="w8" doxytag="SkShader::TileMode"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkShader.html#w8">SkShader::TileMode</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w8w0" doxytag="kClamp_TileMode"></a>kClamp_TileMode</em> </td><td> -replicate the edge color if the shader draws outside of its original bounds </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w8w1" doxytag="kRepeat_TileMode"></a>kRepeat_TileMode</em> </td><td> -repeat the shader's image horizontally and vertically </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w8w2" doxytag="kMirror_TileMode"></a>kMirror_TileMode</em> </td><td> -repeat the shader's image horizontally and vertically, alternating mirror images so that adjacent images always seam </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="e0" doxytag="SkShader::CanCallShadeSpanOpaque16"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static bool SkShader::CanCallShadeSpanOpaque16 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U32 </td> - <td class="mdname1" valign="top" nowrap> <em>flags</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline, static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper to check the flags to know if it is legal to call <a class="el" href="classSkShader.html#a7">shadeSpanOpaque16()</a> </td> - </tr> -</table> -<a class="anchor" name="a9" doxytag="SkShader::canCallShadeSpanOpaque16"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkShader::canCallShadeSpanOpaque16 </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper function that returns true if this shader's <a class="el" href="classSkShader.html#a7">shadeSpanOpaque16()</a> method can be called. </td> - </tr> -</table> -<a class="anchor" name="e1" doxytag="SkShader::CreateBitmapShader"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">static <a class="el" href="classSkShader.html">SkShader</a>* SkShader::CreateBitmapShader </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>transferOwnershipOfPixels</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPaint.html#w38">SkPaint::FilterType</a> </td> - <td class="mdname" nowrap> <em>ft</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkShader.html#w8">TileMode</a> </td> - <td class="mdname" nowrap> <em>tm</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [static]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to create a new shader that will draw with the specified bitmap. <dl compact><dt><b>Parameters:</b></dt><dd> - <table border="0" cellspacing="2" cellpadding="0"> - <tr><td valign="top"></td><td valign="top"><em>src</em> </td><td>The bitmap to use inside the shader </td></tr> - <tr><td valign="top"></td><td valign="top"><em>transferOwnershipOfPixels</em> </td><td>If true, the shader will call setOwnsPixels(true) on its private bitmap and setOwnsPixels(false) on the src bitmap, resulting in the bitmap's pixels being disposed when the shader is deleted. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>ft</em> </td><td>The filter type to be used when scaling or rotating the bitmap when it is drawn. </td></tr> - <tr><td valign="top"></td><td valign="top"><em>tm</em> </td><td>The tiling mode to draw the bitmap in. </td></tr> - </table> -</dl> -<dl compact><dt><b>Returns:</b></dt><dd>Returns a new shader object. Note: this function never returns nil.</dd></dl> - </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkShader::getFlags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual U32 SkShader::getFlags </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called sometimes before drawing with this shader. Return the type of alpha your shader will return. The default implementation returns 0. Your subclass should override if it can (even sometimes) report a non-zero value, since that will enable various blitters to perform faster. -<p> -Reimplemented in <a class="el" href="classSkLightShader.html#a3">SkLightShader</a>. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkShader::getLocalMatrix"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">const SkMatrix* SkShader::getLocalMatrix </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the shader's optional local matrix, or nil. </td> - </tr> -</table> -<a class="anchor" name="a5" doxytag="SkShader::setContext"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkShader::setContext </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkBitmap.html">SkBitmap</a> & </td> - <td class="mdname" nowrap> <em>device</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPaint.html">SkPaint</a> & </td> - <td class="mdname" nowrap> <em>paint</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkMatrix & </td> - <td class="mdname" nowrap> <em>matrix</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called once before drawing, with the current paint and device matrix. Return true if your shader supports these parameters, or false if not. If false is returned, nothing will be drawn. -<p> -Reimplemented in <a class="el" href="classSkLightShader.html#a4">SkLightShader</a>. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkShader::setLocalMatrix"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkShader::setLocalMatrix </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkMatrix & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the shader's optional local matrix. If the specified matrix is identity, then <a class="el" href="classSkShader.html#a2">getLocalMatrix()</a> will return nil. </td> - </tr> -</table> -<a class="anchor" name="a6" doxytag="SkShader::shadeSpan"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkShader::shadeSpan </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="SkColor_8h.html#a18">SkPMColor</a> </td> - <td class="mdname" nowrap>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [pure virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called for each span of the object being drawn. Your subclass should set the appropriate colors (with premultiplied alpha) that correspond to the specified device coordinates. -<p> -Implemented in <a class="el" href="classSkLightShader.html#a5">SkLightShader</a>. </td> - </tr> -</table> -<a class="anchor" name="a8" doxytag="SkShader::shadeSpanAlpha"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkShader::shadeSpanAlpha </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U8 </td> - <td class="mdname" nowrap> <em>alpha</em>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Similar to shadeSpan, but only returns the alpha-channel for a span. The default implementation calls <a class="el" href="classSkShader.html#a6">shadeSpan()</a> and then extracts the alpha values from the returned colors. </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkShader::shadeSpanOpaque16"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkShader::shadeSpanOpaque16 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>U16 </td> - <td class="mdname" nowrap>[], </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>count</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Called only for 16bit devices when <a class="el" href="classSkShader.html#a4">getFlags()</a> returns kOpaqueAlphaFlag | kHasSpan16_Flag </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkShader_8h-source.html">SkShader.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkShader.png b/sgl_doxygen/html/classSkShader.png Binary files differdeleted file mode 100644 index 7a37a4e..0000000 --- a/sgl_doxygen/html/classSkShader.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkString-members.html b/sgl_doxygen/html/classSkString-members.html deleted file mode 100644 index e44ed82..0000000 --- a/sgl_doxygen/html/classSkString-members.html +++ /dev/null @@ -1,61 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkString Member List</h1>This is the complete list of members for <a class="el" href="classSkString.html">SkString</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>append</b>(const SkString &str) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>append</b>(const char text[]) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>append</b>(const char text[], size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>appendHex</b>(U32 value, int minDigits=0) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>appendS32</b>(S32 value) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>appendScalar</b>(SkScalar value) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>appendUnichar</b>(SkUnichar uni) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>c_str</b>() const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>endsWith</b>(const char suffix[]) const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>equals</b>(const SkString &) const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>equals</b>(const char text[]) const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>equals</b>(const char text[], size_t len) const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insert</b>(size_t offset, const SkString &src) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insert</b>(size_t offset, const char text[]) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insert</b>(size_t offset, const char text[], size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insertHex</b>(size_t offset, U32 value, int minDigits=0) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insertS32</b>(size_t offset, S32 value) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insertScalar</b>(size_t offset, SkScalar) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>insertUnichar</b>(size_t offset, SkUnichar) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>isEmpty</b>() const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator!=</b> (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator=</b>(const SkString &) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>operator==</b> (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prepend</b>(const SkString &str) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prepend</b>(const char text[]) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prepend</b>(const char text[], size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prependHex</b>(U32 value, int minDigits=0) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prependS32</b>(S32 value) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prependScalar</b>(SkScalar value) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>prependUnichar</b>(SkUnichar uni) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>printf</b>(const char format[],...) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>remove</b>(size_t offset, size_t length) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>reset</b>() (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>resize</b>(size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>set</b>(const SkString &src) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>set</b>(const char text[]) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>set</b>(const char text[], size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setUTF16</b>(const U16[]) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>size</b>() const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkString</b>() (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkString</b>(size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [explicit]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkString</b>(const char text[]) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [explicit]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkString</b>(const char text[], size_t len) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkString</b>(const SkString &) (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [explicit]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>startsWith</b>(const char prefix[]) const (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkString.html#a45">swap</a>(SkString &other)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>writable_str</b>() (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkString</b>() (defined in <a class="el" href="classSkString.html">SkString</a>)</td><td><a class="el" href="classSkString.html">SkString</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkString.html b/sgl_doxygen/html/classSkString.html deleted file mode 100644 index 4dd3702..0000000 --- a/sgl_doxygen/html/classSkString.html +++ /dev/null @@ -1,193 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkString Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkString Class Reference</h1><code>#include <<a class="el" href="SkString_8h-source.html">SkString.h</a>></code> -<p> -<a href="classSkString-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkString::SkString"></a> - </td><td class="memItemRight" valign="bottom"><b>SkString</b> (size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkString::SkString"></a> - </td><td class="memItemRight" valign="bottom"><b>SkString</b> (const char text[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkString::SkString"></a> - </td><td class="memItemRight" valign="bottom"><b>SkString</b> (const char text[], size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkString::SkString"></a> - </td><td class="memItemRight" valign="bottom"><b>SkString</b> (const <a class="el" href="classSkString.html">SkString</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a6" doxytag="SkString::isEmpty"></a> -bool </td><td class="memItemRight" valign="bottom"><b>isEmpty</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a7" doxytag="SkString::size"></a> -size_t </td><td class="memItemRight" valign="bottom"><b>size</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a8" doxytag="SkString::c_str"></a> -const char * </td><td class="memItemRight" valign="bottom"><b>c_str</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a9" doxytag="SkString::equals"></a> -bool </td><td class="memItemRight" valign="bottom"><b>equals</b> (const <a class="el" href="classSkString.html">SkString</a> &) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a10" doxytag="SkString::equals"></a> -bool </td><td class="memItemRight" valign="bottom"><b>equals</b> (const char text[]) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a11" doxytag="SkString::equals"></a> -bool </td><td class="memItemRight" valign="bottom"><b>equals</b> (const char text[], size_t len) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a12" doxytag="SkString::startsWith"></a> -bool </td><td class="memItemRight" valign="bottom"><b>startsWith</b> (const char prefix[]) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a13" doxytag="SkString::endsWith"></a> -bool </td><td class="memItemRight" valign="bottom"><b>endsWith</b> (const char suffix[]) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a14" doxytag="SkString::operator="></a> -<a class="el" href="classSkString.html">SkString</a> & </td><td class="memItemRight" valign="bottom"><b>operator=</b> (const <a class="el" href="classSkString.html">SkString</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a15" doxytag="SkString::writable_str"></a> -char * </td><td class="memItemRight" valign="bottom"><b>writable_str</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a16" doxytag="SkString::reset"></a> -void </td><td class="memItemRight" valign="bottom"><b>reset</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a17" doxytag="SkString::resize"></a> -void </td><td class="memItemRight" valign="bottom"><b>resize</b> (size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a18" doxytag="SkString::set"></a> -void </td><td class="memItemRight" valign="bottom"><b>set</b> (const <a class="el" href="classSkString.html">SkString</a> &src)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a19" doxytag="SkString::set"></a> -void </td><td class="memItemRight" valign="bottom"><b>set</b> (const char text[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a20" doxytag="SkString::set"></a> -void </td><td class="memItemRight" valign="bottom"><b>set</b> (const char text[], size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a21" doxytag="SkString::setUTF16"></a> -void </td><td class="memItemRight" valign="bottom"><b>setUTF16</b> (const U16[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a22" doxytag="SkString::insert"></a> -void </td><td class="memItemRight" valign="bottom"><b>insert</b> (size_t offset, const <a class="el" href="classSkString.html">SkString</a> &src)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a23" doxytag="SkString::insert"></a> -void </td><td class="memItemRight" valign="bottom"><b>insert</b> (size_t offset, const char text[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a24" doxytag="SkString::insert"></a> -void </td><td class="memItemRight" valign="bottom"><b>insert</b> (size_t offset, const char text[], size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a25" doxytag="SkString::insertUnichar"></a> -void </td><td class="memItemRight" valign="bottom"><b>insertUnichar</b> (size_t offset, SkUnichar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a26" doxytag="SkString::insertS32"></a> -void </td><td class="memItemRight" valign="bottom"><b>insertS32</b> (size_t offset, S32 value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a27" doxytag="SkString::insertHex"></a> -void </td><td class="memItemRight" valign="bottom"><b>insertHex</b> (size_t offset, U32 value, int minDigits=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a28" doxytag="SkString::insertScalar"></a> -void </td><td class="memItemRight" valign="bottom"><b>insertScalar</b> (size_t offset, SkScalar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a29" doxytag="SkString::append"></a> -void </td><td class="memItemRight" valign="bottom"><b>append</b> (const <a class="el" href="classSkString.html">SkString</a> &str)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a30" doxytag="SkString::append"></a> -void </td><td class="memItemRight" valign="bottom"><b>append</b> (const char text[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a31" doxytag="SkString::append"></a> -void </td><td class="memItemRight" valign="bottom"><b>append</b> (const char text[], size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a32" doxytag="SkString::appendUnichar"></a> -void </td><td class="memItemRight" valign="bottom"><b>appendUnichar</b> (SkUnichar uni)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a33" doxytag="SkString::appendS32"></a> -void </td><td class="memItemRight" valign="bottom"><b>appendS32</b> (S32 value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a34" doxytag="SkString::appendHex"></a> -void </td><td class="memItemRight" valign="bottom"><b>appendHex</b> (U32 value, int minDigits=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a35" doxytag="SkString::appendScalar"></a> -void </td><td class="memItemRight" valign="bottom"><b>appendScalar</b> (SkScalar value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a36" doxytag="SkString::prepend"></a> -void </td><td class="memItemRight" valign="bottom"><b>prepend</b> (const <a class="el" href="classSkString.html">SkString</a> &str)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a37" doxytag="SkString::prepend"></a> -void </td><td class="memItemRight" valign="bottom"><b>prepend</b> (const char text[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a38" doxytag="SkString::prepend"></a> -void </td><td class="memItemRight" valign="bottom"><b>prepend</b> (const char text[], size_t len)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a39" doxytag="SkString::prependUnichar"></a> -void </td><td class="memItemRight" valign="bottom"><b>prependUnichar</b> (SkUnichar uni)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a40" doxytag="SkString::prependS32"></a> -void </td><td class="memItemRight" valign="bottom"><b>prependS32</b> (S32 value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a41" doxytag="SkString::prependHex"></a> -void </td><td class="memItemRight" valign="bottom"><b>prependHex</b> (U32 value, int minDigits=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a42" doxytag="SkString::prependScalar"></a> -void </td><td class="memItemRight" valign="bottom"><b>prependScalar</b> (SkScalar value)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a43" doxytag="SkString::printf"></a> -void </td><td class="memItemRight" valign="bottom"><b>printf</b> (const char format[],...)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a44" doxytag="SkString::remove"></a> -void </td><td class="memItemRight" valign="bottom"><b>remove</b> (size_t offset, size_t length)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkString.html#a45">swap</a> (<a class="el" href="classSkString.html">SkString</a> &other)</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkString::operator=="></a> -int </td><td class="memItemRight" valign="bottom"><b>operator==</b> (const <a class="el" href="classSkString.html">SkString</a> &a, const <a class="el" href="classSkString.html">SkString</a> &b)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n1" doxytag="SkString::operator!="></a> -int </td><td class="memItemRight" valign="bottom"><b>operator!=</b> (const <a class="el" href="classSkString.html">SkString</a> &a, const <a class="el" href="classSkString.html">SkString</a> &b)</td></tr> - -<tr><td colspan="2"><br><h2>Classes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">struct </td><td class="memItemRight" valign="bottom"><b>Rec</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Light weight class for managing strings. Uses reference counting to make string assignments and copies very fast with no extra RAM cost. Assumes UTF8 encoding. -<p> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a45" doxytag="SkString::swap"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkString::swap </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkString.html">SkString</a> & </td> - <td class="mdname1" valign="top" nowrap> <em>other</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Swap contents between this and other. This function is guaranteed to never fail or throw. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkString_8h-source.html">SkString.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkStroke-members.html b/sgl_doxygen/html/classSkStroke-members.html deleted file mode 100644 index fcd0c96..0000000 --- a/sgl_doxygen/html/classSkStroke-members.html +++ /dev/null @@ -1,30 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkStroke Member List</h1>This is the complete list of members for <a class="el" href="classSkStroke.html">SkStroke</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>getCap</b>() const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getDoFill</b>() const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getJoin</b>() const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setCap</b>(SkPaint::Cap) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setDoFill</b>(bool doFill) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setJoin</b>(SkPaint::Join) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setMiterLimit</b>(SkScalar) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setWidth</b>(SkScalar) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPaint</b> (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkStroke</b>() (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkStroke</b>(const SkPaint &) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkStroke</b>(const SkPaint &, SkScalar width) (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>strokeLine</b>(const SkPoint &start, const SkPoint &end, SkPath *) const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>strokeOval</b>(const SkRect &oval, SkPath *) const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>strokePath</b>(const SkPath &path, SkPath *) const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>strokeRect</b>(const SkRect &rect, SkPath *) const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>strokeRRect</b>(const SkRect &rect, SkScalar rx, SkScalar ry, SkPath *) const (defined in <a class="el" href="classSkStroke.html">SkStroke</a>)</td><td><a class="el" href="classSkStroke.html">SkStroke</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkStroke.html b/sgl_doxygen/html/classSkStroke.html deleted file mode 100644 index 8f71bbe..0000000 --- a/sgl_doxygen/html/classSkStroke.html +++ /dev/null @@ -1,72 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkStroke Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkStroke Class Reference</h1><code>#include <<a class="el" href="SkStroke_8h-source.html">SkStroke.h</a>></code> -<p> -<a href="classSkStroke-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkStroke::SkStroke"></a> - </td><td class="memItemRight" valign="bottom"><b>SkStroke</b> (const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkStroke::SkStroke"></a> - </td><td class="memItemRight" valign="bottom"><b>SkStroke</b> (const <a class="el" href="classSkPaint.html">SkPaint</a> &, SkScalar width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkStroke::getCap"></a> -<a class="el" href="classSkPaint.html#w36">SkPaint::Cap</a> </td><td class="memItemRight" valign="bottom"><b>getCap</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkStroke::setCap"></a> -void </td><td class="memItemRight" valign="bottom"><b>setCap</b> (<a class="el" href="classSkPaint.html#w36">SkPaint::Cap</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkStroke::getJoin"></a> -<a class="el" href="classSkPaint.html#w37">SkPaint::Join</a> </td><td class="memItemRight" valign="bottom"><b>getJoin</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a6" doxytag="SkStroke::setJoin"></a> -void </td><td class="memItemRight" valign="bottom"><b>setJoin</b> (<a class="el" href="classSkPaint.html#w37">SkPaint::Join</a>)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a7" doxytag="SkStroke::setMiterLimit"></a> -void </td><td class="memItemRight" valign="bottom"><b>setMiterLimit</b> (SkScalar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a8" doxytag="SkStroke::setWidth"></a> -void </td><td class="memItemRight" valign="bottom"><b>setWidth</b> (SkScalar)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a9" doxytag="SkStroke::getDoFill"></a> -bool </td><td class="memItemRight" valign="bottom"><b>getDoFill</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a10" doxytag="SkStroke::setDoFill"></a> -void </td><td class="memItemRight" valign="bottom"><b>setDoFill</b> (bool doFill)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a11" doxytag="SkStroke::strokeLine"></a> -void </td><td class="memItemRight" valign="bottom"><b>strokeLine</b> (const SkPoint &start, const SkPoint &end, <a class="el" href="classSkPath.html">SkPath</a> *) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a12" doxytag="SkStroke::strokeRect"></a> -void </td><td class="memItemRight" valign="bottom"><b>strokeRect</b> (const SkRect &rect, <a class="el" href="classSkPath.html">SkPath</a> *) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a13" doxytag="SkStroke::strokeOval"></a> -void </td><td class="memItemRight" valign="bottom"><b>strokeOval</b> (const SkRect &oval, <a class="el" href="classSkPath.html">SkPath</a> *) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a14" doxytag="SkStroke::strokeRRect"></a> -void </td><td class="memItemRight" valign="bottom"><b>strokeRRect</b> (const SkRect &rect, SkScalar rx, SkScalar ry, <a class="el" href="classSkPath.html">SkPath</a> *) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a15" doxytag="SkStroke::strokePath"></a> -void </td><td class="memItemRight" valign="bottom"><b>strokePath</b> (const <a class="el" href="classSkPath.html">SkPath</a> &path, <a class="el" href="classSkPath.html">SkPath</a> *) const </td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkStroke::SkPaint"></a> -class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkStroke.html#n0">SkPaint</a></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkStroke is the utility class that constructs paths by stroking geometries (lines, rects, ovals, roundrects, paths). This is invoked when a geometry or text is drawn in a canvas with the kStroke_Mask bit set in the paint. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkStroke_8h-source.html">SkStroke.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkSumPathEffect-members.html b/sgl_doxygen/html/classSkSumPathEffect-members.html deleted file mode 100644 index c215f53..0000000 --- a/sgl_doxygen/html/classSkSumPathEffect-members.html +++ /dev/null @@ -1,32 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkSumPathEffect Member List</h1>This is the complete list of members for <a class="el" href="classSkSumPathEffect.html">SkSumPathEffect</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>Factory</b> typedef (defined in <a class="el" href="classSkFlattenable.html">SkFlattenable</a>)</td><td><a class="el" href="classSkFlattenable.html">SkFlattenable</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkSumPathEffect.html#a1">filterPath</a>(SkPath *dst, const SkPath &src, SkScalar *width)</td><td><a class="el" href="classSkSumPathEffect.html">SkSumPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>flatten</b>(void *buffer) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fPE0</b> (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fPE1</b> (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkSumPathEffect.html#a2">getFactory</a>()</td><td><a class="el" href="classSkSumPathEffect.html">SkSumPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPairPathEffect</b>(SkPathEffect *pe0, SkPathEffect *pe1) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPairPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [protected]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>() (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkPathEffect</b>(const void *buffer) (defined in <a class="el" href="classSkPathEffect.html">SkPathEffect</a>)</td><td><a class="el" href="classSkPathEffect.html">SkPathEffect</a></td><td><code> [inline, protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a>(SkPathEffect *first, SkPathEffect *second)</td><td><a class="el" href="classSkSumPathEffect.html">SkSumPathEffect</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkPairPathEffect</b>() (defined in <a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a>)</td><td><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkSumPathEffect.html b/sgl_doxygen/html/classSkSumPathEffect.html deleted file mode 100644 index b35ed87..0000000 --- a/sgl_doxygen/html/classSkSumPathEffect.html +++ /dev/null @@ -1,150 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkSumPathEffect Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkSumPathEffect Class Reference</h1><code>#include <<a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a>></code> -<p> -<p>Inheritance diagram for SkSumPathEffect: -<p><center><img src="classSkSumPathEffect.png" usemap="#SkSumPathEffect_map" border="0" alt=""></center> -<map name="SkSumPathEffect_map"> -<area href="classSkPairPathEffect.html" alt="SkPairPathEffect" shape="rect" coords="0,168,108,192"> -<area href="classSkPathEffect.html" alt="SkPathEffect" shape="rect" coords="0,112,108,136"> -<area href="classSkFlattenable.html" alt="SkFlattenable" shape="rect" coords="0,56,108,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,108,24"> -</map> -<a href="classSkSumPathEffect-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"> </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a> (<a class="el" href="classSkPathEffect.html">SkPathEffect</a> *first, <a class="el" href="classSkPathEffect.html">SkPathEffect</a> *second)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkSumPathEffect.html#a1">filterPath</a> (<a class="el" href="classSkPath.html">SkPath</a> *dst, const <a class="el" href="classSkPath.html">SkPath</a> &src, SkScalar *width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual Factory </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkSumPathEffect.html#a2">getFactory</a> ()</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -This subclass of <a class="el" href="classSkPathEffect.html">SkPathEffect</a> applies two pathEffects, one after the other. Its <a class="el" href="classSkSumPathEffect.html#a1">filterPath()</a> returns true if either of the effects succeeded. -<p> -<hr><h2>Constructor & Destructor Documentation</h2> -<a class="anchor" name="a0" doxytag="SkSumPathEffect::SkSumPathEffect"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkSumPathEffect::SkSumPathEffect </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td> - <td class="mdname" nowrap> <em>first</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap><a class="el" href="classSkPathEffect.html">SkPathEffect</a> * </td> - <td class="mdname" nowrap> <em>second</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Construct a pathEffect whose effect is to apply two effects, in sequence. (e.g. first(path) + second(path)) The reference counts for first and second are both incremented in the constructor, and decremented in the destructor. </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a1" doxytag="SkSumPathEffect::filterPath"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkSumPathEffect::filterPath </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkPath.html">SkPath</a> * </td> - <td class="mdname" nowrap> <em>dst</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const <a class="el" href="classSkPath.html">SkPath</a> & </td> - <td class="mdname" nowrap> <em>src</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar * </td> - <td class="mdname" nowrap> <em>width</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Given a src path and a width value, return true if the patheffect has produced a new path (dst) and a new width value. If false is returned, ignore dst and width. On input, width >= 0 means the src should be stroked On output, width >= 0 means the dst should be stroked -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a1">SkPathEffect</a>. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkSumPathEffect::getFactory"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual Factory SkSumPathEffect::getFactory </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -overrides for <a class="el" href="classSkFlattenable.html">SkFlattenable</a>. Subclasses should override this to (re)create their subclass -<p> -Reimplemented from <a class="el" href="classSkPathEffect.html#a2">SkPathEffect</a>. </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkPathEffect_8h-source.html">SkPathEffect.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkSumPathEffect.png b/sgl_doxygen/html/classSkSumPathEffect.png Binary files differdeleted file mode 100644 index 6eafc3f..0000000 --- a/sgl_doxygen/html/classSkSumPathEffect.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkTextBox-members.html b/sgl_doxygen/html/classSkTextBox-members.html deleted file mode 100644 index 0b2af3c..0000000 --- a/sgl_doxygen/html/classSkTextBox-members.html +++ /dev/null @@ -1,33 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkTextBox Member List</h1>This is the complete list of members for <a class="el" href="classSkTextBox.html">SkTextBox</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>draw</b>(SkCanvas *, const char text[], size_t len, const SkPaint &) (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getBox</b>(SkRect *) const (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getMode</b>() const (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getSpacing</b>(SkScalar *mul, SkScalar *add) const (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getSpacingAlign</b>() const (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kCenter_SpacingAlign</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kEnd_SpacingAlign</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kLineBreak_Mode</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kModeCount</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kOneLine_Mode</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kSpacingAlignCount</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kStart_SpacingAlign</b> enum value (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Mode</b> enum name (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setBox</b>(const SkRect &) (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setBox</b>(SkScalar left, SkScalar top, SkScalar right, SkScalar bottom) (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setMode</b>(Mode) (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setSpacing</b>(SkScalar mul, SkScalar add) (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setSpacingAlign</b>(SpacingAlign) (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkTextBox</b>() (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SpacingAlign</b> enum name (defined in <a class="el" href="classSkTextBox.html">SkTextBox</a>)</td><td><a class="el" href="classSkTextBox.html">SkTextBox</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkTextBox.html b/sgl_doxygen/html/classSkTextBox.html deleted file mode 100644 index 8a12528..0000000 --- a/sgl_doxygen/html/classSkTextBox.html +++ /dev/null @@ -1,66 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTextBox Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkTextBox Class Reference</h1><code>#include <<a class="el" href="SkTextBox_8h-source.html">SkTextBox.h</a>></code> -<p> -<a href="classSkTextBox-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><b>Mode</b> { <b>kOneLine_Mode</b>, -<b>kLineBreak_Mode</b>, -<b>kModeCount</b> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><b>SpacingAlign</b> { <b>kStart_SpacingAlign</b>, -<b>kCenter_SpacingAlign</b>, -<b>kEnd_SpacingAlign</b>, -<b>kSpacingAlignCount</b> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkTextBox::getMode"></a> -Mode </td><td class="memItemRight" valign="bottom"><b>getMode</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkTextBox::setMode"></a> -void </td><td class="memItemRight" valign="bottom"><b>setMode</b> (Mode)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a3" doxytag="SkTextBox::getSpacingAlign"></a> -SpacingAlign </td><td class="memItemRight" valign="bottom"><b>getSpacingAlign</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a4" doxytag="SkTextBox::setSpacingAlign"></a> -void </td><td class="memItemRight" valign="bottom"><b>setSpacingAlign</b> (SpacingAlign)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkTextBox::getBox"></a> -void </td><td class="memItemRight" valign="bottom"><b>getBox</b> (SkRect *) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a6" doxytag="SkTextBox::setBox"></a> -void </td><td class="memItemRight" valign="bottom"><b>setBox</b> (const SkRect &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a7" doxytag="SkTextBox::setBox"></a> -void </td><td class="memItemRight" valign="bottom"><b>setBox</b> (SkScalar left, SkScalar top, SkScalar right, SkScalar bottom)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a8" doxytag="SkTextBox::getSpacing"></a> -void </td><td class="memItemRight" valign="bottom"><b>getSpacing</b> (SkScalar *mul, SkScalar *add) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a9" doxytag="SkTextBox::setSpacing"></a> -void </td><td class="memItemRight" valign="bottom"><b>setSpacing</b> (SkScalar mul, SkScalar add)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a10" doxytag="SkTextBox::draw"></a> -void </td><td class="memItemRight" valign="bottom"><b>draw</b> (<a class="el" href="classSkCanvas.html">SkCanvas</a> *, const char text[], size_t len, const <a class="el" href="classSkPaint.html">SkPaint</a> &)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -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.<p> -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 -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkTextBox_8h-source.html">SkTextBox.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkTime-members.html b/sgl_doxygen/html/classSkTime-members.html deleted file mode 100644 index ecc9628..0000000 --- a/sgl_doxygen/html/classSkTime-members.html +++ /dev/null @@ -1,15 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkTime Member List</h1>This is the complete list of members for <a class="el" href="classSkTime.html">SkTime</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>GetDateTime</b>(DateTime *) (defined in <a class="el" href="classSkTime.html">SkTime</a>)</td><td><a class="el" href="classSkTime.html">SkTime</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>GetMSecs</b>() (defined in <a class="el" href="classSkTime.html">SkTime</a>)</td><td><a class="el" href="classSkTime.html">SkTime</a></td><td><code> [static]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkTime.html b/sgl_doxygen/html/classSkTime.html deleted file mode 100644 index 69d4335..0000000 --- a/sgl_doxygen/html/classSkTime.html +++ /dev/null @@ -1,32 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkTime Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkTime Class Reference</h1><code>#include <<a class="el" href="SkTime_8h-source.html">SkTime.h</a>></code> -<p> -<a href="classSkTime-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e0" doxytag="SkTime::GetDateTime"></a> -static void </td><td class="memItemRight" valign="bottom"><b>GetDateTime</b> (DateTime *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e1" doxytag="SkTime::GetMSecs"></a> -static SkMSec </td><td class="memItemRight" valign="bottom"><b>GetMSecs</b> ()</td></tr> - -<tr><td colspan="2"><br><h2>Classes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">struct </td><td class="memItemRight" valign="bottom"><b>DateTime</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Platform-implemented utilities to return time of day, and millisecond counter. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkTime_8h-source.html">SkTime.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView-members.html b/sgl_doxygen/html/classSkView-members.html deleted file mode 100644 index f734239..0000000 --- a/sgl_doxygen/html/classSkView-members.html +++ /dev/null @@ -1,120 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkView Member List</h1>This is the complete list of members for <a class="el" href="classSkView.html">SkView</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>acceptFocus</b>() (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a5">addListenerID</a>(SkEventSinkID sinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>addTagList</b>(SkTagList *) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a35">attachChildToBack</a>(SkView *child)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>attachChildToFront</b>(SkView *child) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>B2FIter</b> (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a6">copyListeners</a>(const SkEventSink &from)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a37">detachAllChildren</a>()</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a36">detachFromParent</a>()</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>DoClickDown</b>(Click *, int x, int y) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>DoClickMoved</b>(Click *, int x, int y) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>DoClickUp</b>(Click *, int x, int y) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a3">doEvent</a>(const SkEvent &)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#e0">DoEvent</a>(const SkEvent &, SkEventSinkID targetID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a4">doQuery</a>(SkEvent *query)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a24">draw</a>(SkCanvas *canvas)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3">EventResult</a> enum name</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>F2BIter</b> (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [friend]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>findClickHandler</b>(SkScalar x, SkScalar y) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#e1">FindSink</a>(SkEventSinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>findTagList</b>(U8CPU tag) const (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#w16">Flag_Mask</a> enum name</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>Flag_Shift</b> enum name (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>FocusDirection</b> enum name (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a40">getArtist</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a2">getFlags</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>getFocusView</b>() const (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a42">getLayout</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a16">getLocalBounds</a>(SkRect *bounds) const </td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a33">getParent</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a2">getSinkID</a>() const </td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a38">globalToLocal</a>(SkPoint *pt) const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a39">globalToLocal</a>(SkScalar globalX, SkScalar globalY, SkPoint *local) const </td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a47">handleInval</a>(const SkRect &)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>hasFocus</b>() const (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a8">hasListeners</a>() const </td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a11">height</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a45">inflate</a>(const SkDOM &dom, const SkDOM::Node *node)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a25">inval</a>(SkRect *rectOrNil)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a44">invokeLayout</a>()</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>isEnabled</b>() const (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>isFocusable</b>() const (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a4">isVisible</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kAllFlagMasks</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#w16w7">kEnabled_Mask</a> enum value</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kEnabled_Shift</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlagShiftCount</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#w16w9">kFlexH_Mask</a> enum value</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlexH_Shift</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#w16w10">kFlexV_Mask</a> enum value</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFlexV_Shift</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#w16w8">kFocusable_Mask</a> enum value</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFocusable_Shift</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kFocusDirectionCount</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w0">kHandled_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kNext_FocusDirection</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w1">kNotHandled_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kPrev_FocusDirection</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#w3w2">kSinkNotFound_EventResult</a> enum value</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#w16w6">kVisible_Mask</a> enum value</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>kVisible_Shift</b> enum value (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a17">locX</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a18">locY</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>moveFocus</b>(FocusDirection) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a23">offset</a>(SkScalar dx, SkScalar dy)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a49">onClick</a>(Click *)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#b0">onEvent</a>(const SkEvent &)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected, virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a48">onFindClickHandler</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onFocusChange</b>(bool gainFocusP) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onGetFocusView</b>(SkView **) const (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline, protected, virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a50">onInflate</a>(const SkDOM &dom, const SkDOM::Node *node)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a51">onPostInflate</a>(const SkTDict< SkView * > &)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onQuery</b>(SkEvent *) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onSetFocusView</b>(SkView *) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline, protected, virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a32">postEvent</a>(SkEvent *evt, SkEventSinkID sinkID, SkMSec delay)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a46">postInflate</a>(const SkTDict< SkView * > &ids)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a9">postToListeners</a>(const SkEvent &evt, SkMSec delay=0)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkEventSink.html#a7">removeListenerID</a>(SkEventSinkID)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>removeTagList</b>(U8CPU tag) (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [protected]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a31">sendEventToParents</a>(const SkEvent &)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a41">setArtist</a>(Artist *artist)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setEnabledP</b>(bool) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a3">setFlags</a>(U32 flags)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setFocusableP</b>(bool) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setHeight</b>(SkScalar height) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a43">setLayout</a>(Layout *, bool invokeLayoutNow=true)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a19">setLoc</a>(SkScalar x, SkScalar y)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setLoc</b>(const SkPoint &loc) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setLocX</b>(SkScalar x) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setLocY</b>(SkScalar y) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a12">setSize</a>(SkScalar width, SkScalar height)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setSize</b>(const SkPoint &size) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a7">setVisibleP</a>(bool)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>setWidth</b>(SkScalar width) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkEventSink</b>() (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkLayerView</b> (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [friend]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>SkView</b>(U32 flags=0) (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkView.html#a10">width</a>() const </td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkEventSink</b>() (defined in <a class="el" href="classSkEventSink.html">SkEventSink</a>)</td><td><a class="el" href="classSkEventSink.html">SkEventSink</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>~SkView</b>() (defined in <a class="el" href="classSkView.html">SkView</a>)</td><td><a class="el" href="classSkView.html">SkView</a></td><td><code> [virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView.html b/sgl_doxygen/html/classSkView.html deleted file mode 100644 index c878ac0..0000000 --- a/sgl_doxygen/html/classSkView.html +++ /dev/null @@ -1,1290 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkView Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkView Class Reference</h1><code>#include <<a class="el" href="SkView_8h-source.html">SkView.h</a>></code> -<p> -<p>Inheritance diagram for SkView: -<p><center><img src="classSkView.png" usemap="#SkView_map" border="0" alt=""></center> -<map name="SkView_map"> -<area href="classSkEventSink.html" alt="SkEventSink" shape="rect" coords="0,56,108,80"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,108,24"> -</map> -<a href="classSkView-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><b>Flag_Shift</b> { <br> - <b>kVisible_Shift</b>, -<b>kEnabled_Shift</b>, -<b>kFocusable_Shift</b>, -<b>kFlexH_Shift</b>, -<br> - <b>kFlexV_Shift</b>, -<b>kFlagShiftCount</b> -<br> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#w16">Flag_Mask</a> { <br> - <a class="el" href="classSkView.html#w16w6">kVisible_Mask</a> = 1 << kVisible_Shift, -<a class="el" href="classSkView.html#w16w7">kEnabled_Mask</a> = 1 << kEnabled_Shift, -<a class="el" href="classSkView.html#w16w8">kFocusable_Mask</a> = 1 << kFocusable_Shift, -<a class="el" href="classSkView.html#w16w9">kFlexH_Mask</a> = 1 << kFlexH_Shift, -<br> - <a class="el" href="classSkView.html#w16w10">kFlexV_Mask</a> = 1 << kFlexV_Shift, -<b>kAllFlagMasks</b> = (U32)(0 - 1) >> (32 - kFlagShiftCount) -<br> - }</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><b>FocusDirection</b> { <b>kNext_FocusDirection</b>, -<b>kPrev_FocusDirection</b>, -<b>kFocusDirectionCount</b> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkView::SkView"></a> - </td><td class="memItemRight" valign="bottom"><b>SkView</b> (U32 flags=0)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U32 </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a2">getFlags</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a3">setFlags</a> (U32 flags)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">int </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a4">isVisible</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a5" doxytag="SkView::isEnabled"></a> -int </td><td class="memItemRight" valign="bottom"><b>isEnabled</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a6" doxytag="SkView::isFocusable"></a> -int </td><td class="memItemRight" valign="bottom"><b>isFocusable</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a7">setVisibleP</a> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a8" doxytag="SkView::setEnabledP"></a> -void </td><td class="memItemRight" valign="bottom"><b>setEnabledP</b> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a9" doxytag="SkView::setFocusableP"></a> -void </td><td class="memItemRight" valign="bottom"><b>setFocusableP</b> (bool)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a10">width</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a11">height</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a12">setSize</a> (SkScalar width, SkScalar height)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a13" doxytag="SkView::setSize"></a> -void </td><td class="memItemRight" valign="bottom"><b>setSize</b> (const SkPoint &size)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a14" doxytag="SkView::setWidth"></a> -void </td><td class="memItemRight" valign="bottom"><b>setWidth</b> (SkScalar width)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a15" doxytag="SkView::setHeight"></a> -void </td><td class="memItemRight" valign="bottom"><b>setHeight</b> (SkScalar height)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a16">getLocalBounds</a> (SkRect *bounds) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a17">locX</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">SkScalar </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a18">locY</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a19">setLoc</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a20" doxytag="SkView::setLoc"></a> -void </td><td class="memItemRight" valign="bottom"><b>setLoc</b> (const SkPoint &loc)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a21" doxytag="SkView::setLocX"></a> -void </td><td class="memItemRight" valign="bottom"><b>setLocX</b> (SkScalar x)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a22" doxytag="SkView::setLocY"></a> -void </td><td class="memItemRight" valign="bottom"><b>setLocY</b> (SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a23">offset</a> (SkScalar dx, SkScalar dy)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a24">draw</a> (<a class="el" href="classSkCanvas.html">SkCanvas</a> *canvas)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a25">inval</a> (SkRect *rectOrNil)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a26" doxytag="SkView::getFocusView"></a> -<a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><b>getFocusView</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a27" doxytag="SkView::hasFocus"></a> -bool </td><td class="memItemRight" valign="bottom"><b>hasFocus</b> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a28" doxytag="SkView::acceptFocus"></a> -bool </td><td class="memItemRight" valign="bottom"><b>acceptFocus</b> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a29" doxytag="SkView::moveFocus"></a> -<a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><b>moveFocus</b> (FocusDirection)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a30" doxytag="SkView::findClickHandler"></a> -Click * </td><td class="memItemRight" valign="bottom"><b>findClickHandler</b> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a31">sendEventToParents</a> (const <a class="el" href="classSkEvent.html">SkEvent</a> &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a32">postEvent</a> (<a class="el" href="classSkEvent.html">SkEvent</a> *evt, SkEventSinkID sinkID, SkMSec delay)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a33">getParent</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a34" doxytag="SkView::attachChildToFront"></a> -<a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><b>attachChildToFront</b> (<a class="el" href="classSkView.html">SkView</a> *child)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a35">attachChildToBack</a> (<a class="el" href="classSkView.html">SkView</a> *child)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a36">detachFromParent</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a37">detachAllChildren</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a38">globalToLocal</a> (SkPoint *pt) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a39">globalToLocal</a> (SkScalar globalX, SkScalar globalY, SkPoint *local) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView_1_1Artist.html">Artist</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a40">getArtist</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView_1_1Artist.html">Artist</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a41">setArtist</a> (<a class="el" href="classSkView_1_1Artist.html">Artist</a> *artist)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView_1_1Layout.html">Layout</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a42">getLayout</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="el" href="classSkView_1_1Layout.html">Layout</a> * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a43">setLayout</a> (<a class="el" href="classSkView_1_1Layout.html">Layout</a> *, bool invokeLayoutNow=true)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a44">invokeLayout</a> ()</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a45">inflate</a> (const SkDOM &dom, const SkDOM::Node *node)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a46">postInflate</a> (const SkTDict< <a class="el" href="classSkView.html">SkView</a> * > &ids)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a47">handleInval</a> (const SkRect &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual Click * </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a48">onFindClickHandler</a> (SkScalar x, SkScalar y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual bool </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a49">onClick</a> (Click *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a50">onInflate</a> (const SkDOM &dom, const SkDOM::Node *node)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">virtual void </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView.html#a51">onPostInflate</a> (const SkTDict< <a class="el" href="classSkView.html">SkView</a> * > &)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a52" doxytag="SkView::onFocusChange"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onFocusChange</b> (bool gainFocusP)</td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e0" doxytag="SkView::DoClickDown"></a> -static void </td><td class="memItemRight" valign="bottom"><b>DoClickDown</b> (Click *, int x, int y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e1" doxytag="SkView::DoClickMoved"></a> -static void </td><td class="memItemRight" valign="bottom"><b>DoClickMoved</b> (Click *, int x, int y)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e2" doxytag="SkView::DoClickUp"></a> -static void </td><td class="memItemRight" valign="bottom"><b>DoClickUp</b> (Click *, int x, int y)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkView::onGetFocusView"></a> -virtual bool </td><td class="memItemRight" valign="bottom"><b>onGetFocusView</b> (<a class="el" href="classSkView.html">SkView</a> **) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b1" doxytag="SkView::onSetFocusView"></a> -virtual bool </td><td class="memItemRight" valign="bottom"><b>onSetFocusView</b> (<a class="el" href="classSkView.html">SkView</a> *)</td></tr> - -<tr><td colspan="2"><br><h2>Friends</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n0" doxytag="SkView::B2FIter"></a> -class </td><td class="memItemRight" valign="bottom"><b>B2FIter</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n1" doxytag="SkView::F2BIter"></a> -class </td><td class="memItemRight" valign="bottom"><b>F2BIter</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="n2" doxytag="SkView::SkLayerView"></a> -class </td><td class="memItemRight" valign="bottom"><b>SkLayerView</b></td></tr> - -<tr><td colspan="2"><br><h2>Classes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView_1_1Artist.html">Artist</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView_1_1B2FIter.html">B2FIter</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><b>Click</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView_1_1F2BIter.html">F2BIter</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">class </td><td class="memItemRight" valign="bottom"><a class="el" href="classSkView_1_1Layout.html">Layout</a></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkView is the base class for screen management. All widgets and controls inherit from SkView. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w16" doxytag="SkView::Flag_Mask"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="classSkView.html#w16">SkView::Flag_Mask</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w16w6" doxytag="kVisible_Mask"></a>kVisible_Mask</em> </td><td> -set if the view is visible </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w16w7" doxytag="kEnabled_Mask"></a>kEnabled_Mask</em> </td><td> -set if the view is enabled </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w16w8" doxytag="kFocusable_Mask"></a>kFocusable_Mask</em> </td><td> -set if the view can receive focus </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w16w9" doxytag="kFlexH_Mask"></a>kFlexH_Mask</em> </td><td> -set if the view's width is stretchable </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w16w10" doxytag="kFlexV_Mask"></a>kFlexV_Mask</em> </td><td> -set if the view's height is stretchable </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a35" doxytag="SkView::attachChildToBack"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView.html">SkView</a>* SkView::attachChildToBack </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkView.html">SkView</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>child</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Attach the child view to this view, and increment the child's reference count. The child view is added such that it will be drawn before all other child views. The child view parameter is returned. </td> - </tr> -</table> -<a class="anchor" name="a37" doxytag="SkView::detachAllChildren"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::detachAllChildren </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Detach all child views from this view. </td> - </tr> -</table> -<a class="anchor" name="a36" doxytag="SkView::detachFromParent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::detachFromParent </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -If the view has a parent, detach the view from its parent and decrement the view's reference count. If the parent was the only owner of the view, this will cause the view to be deleted. </td> - </tr> -</table> -<a class="anchor" name="a24" doxytag="SkView::draw"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::draw </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkCanvas.html">SkCanvas</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>canvas</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to have the view draw into the specified canvas. </td> - </tr> -</table> -<a class="anchor" name="a40" doxytag="SkView::getArtist"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView_1_1Artist.html">Artist</a>* SkView::getArtist </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the artist attached to this view (or nil). The artist's reference count is not affected. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkView::getFlags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U32 SkView::getFlags </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the flags associated with the view </td> - </tr> -</table> -<a class="anchor" name="a42" doxytag="SkView::getLayout"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView_1_1Layout.html">Layout</a>* SkView::getLayout </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the layout attached to this view (or nil). The layout's reference count is not affected. </td> - </tr> -</table> -<a class="anchor" name="a16" doxytag="SkView::getLocalBounds"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::getLocalBounds </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkRect * </td> - <td class="mdname1" valign="top" nowrap> <em>bounds</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return a rectangle set to [0, 0, width, height] </td> - </tr> -</table> -<a class="anchor" name="a33" doxytag="SkView::getParent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView.html">SkView</a>* SkView::getParent </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the view's parent, or nil if it has none. This does not affect the parent's reference count. </td> - </tr> -</table> -<a class="anchor" name="a39" doxytag="SkView::globalToLocal"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::globalToLocal </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>globalX</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>globalY</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkPoint * </td> - <td class="mdname" nowrap> <em>local</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Convert the specified x,y from global coordinates into view-local coordinates, returning the answer in the local parameter. </td> - </tr> -</table> -<a class="anchor" name="a38" doxytag="SkView::globalToLocal"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::globalToLocal </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkPoint * </td> - <td class="mdname1" valign="top" nowrap> <em>pt</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Convert the specified point from global coordinates into view-local coordinates </td> - </tr> -</table> -<a class="anchor" name="a47" doxytag="SkView::handleInval"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkView::handleInval </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkRect & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override this if you want to handle an inval request from this view or one of its children. Tyically this is only overridden by the by the "window". If your subclass does handle the request, return true so the request will not continue to propogate to the parent. </td> - </tr> -</table> -<a class="anchor" name="a11" doxytag="SkView::height"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkView::height </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the view's height </td> - </tr> -</table> -<a class="anchor" name="a45" doxytag="SkView::inflate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::inflate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDOM & </td> - <td class="mdname" nowrap> <em>dom</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkDOM::Node * </td> - <td class="mdname" nowrap> <em>node</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to initialize this view based on the specified XML node </td> - </tr> -</table> -<a class="anchor" name="a25" doxytag="SkView::inval"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::inval </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkRect * </td> - <td class="mdname1" valign="top" nowrap> <em>rectOrNil</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Call this to invalidate part of all of a view, requesting that the view's draw method be called. The rectangle parameter specifies the part of the view that should be redrawn. If it is nil, it specifies the entire view bounds. </td> - </tr> -</table> -<a class="anchor" name="a44" doxytag="SkView::invokeLayout"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::invokeLayout </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -If a layout is attached to this view, call its layoutChildren() method </td> - </tr> -</table> -<a class="anchor" name="a4" doxytag="SkView::isVisible"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">int SkView::isVisible </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper that returns non-zero if the kVisible_Mask bit is set in the view's flags </td> - </tr> -</table> -<a class="anchor" name="a17" doxytag="SkView::locX"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkView::locX </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the view's left edge </td> - </tr> -</table> -<a class="anchor" name="a18" doxytag="SkView::locY"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkView::locY </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the view's top edge </td> - </tr> -</table> -<a class="anchor" name="a23" doxytag="SkView::offset"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::offset </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>dx</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>dy</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Offset (move) the view by the specified dx and dy. This does not affect the view's size </td> - </tr> -</table> -<a class="anchor" name="a49" doxytag="SkView::onClick"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual bool SkView::onClick </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">Click * </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override this to track clicks, returning true as long as you want to track the pen/mouse. </td> - </tr> -</table> -<a class="anchor" name="a48" doxytag="SkView::onFindClickHandler"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual Click* SkView::onFindClickHandler </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override this if you might handle the click </td> - </tr> -</table> -<a class="anchor" name="a50" doxytag="SkView::onInflate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkView::onInflate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkDOM & </td> - <td class="mdname" nowrap> <em>dom</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>const SkDOM::Node * </td> - <td class="mdname" nowrap> <em>node</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override this to initialize your subclass from the XML node. Be sure to call the inherited version too </td> - </tr> -</table> -<a class="anchor" name="a51" doxytag="SkView::onPostInflate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">virtual void SkView::onPostInflate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkTDict< <a class="el" href="classSkView.html">SkView</a> * > & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap><code> [virtual]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Override this if you want to perform post initialization work based on the ID dictionary built during XML parsing. Be sure to call the inherited version too. </td> - </tr> -</table> -<a class="anchor" name="a32" doxytag="SkView::postEvent"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">bool SkView::postEvent </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkEvent.html">SkEvent</a> * </td> - <td class="mdname" nowrap> <em>evt</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkEventSinkID </td> - <td class="mdname" nowrap> <em>sinkID</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkMSec </td> - <td class="mdname" nowrap> <em>delay</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"><code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Depricated helper function. Just call event->post(sinkID, delay); </td> - </tr> -</table> -<a class="anchor" name="a46" doxytag="SkView::postInflate"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::postInflate </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const SkTDict< <a class="el" href="classSkView.html">SkView</a> * > & </td> - <td class="mdname1" valign="top" nowrap> <em>ids</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -After a view hierarchy is inflated, this may be called with a dictionary containing pairs of <name, view*>, where the name string was the view's "id" attribute when it was inflated.<p> -This will call the virtual onPostInflate for this view, and the recursively call postInflate on all of the view's children. </td> - </tr> -</table> -<a class="anchor" name="a31" doxytag="SkView::sendEventToParents"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView.html">SkView</a>* SkView::sendEventToParents </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">const <a class="el" href="classSkEvent.html">SkEvent</a> & </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Send the event to the view's parent, and its parent etc. until one of them returns true from its onEvent call. This view is returned. If no parent handles the event, nil is returned. </td> - </tr> -</table> -<a class="anchor" name="a41" doxytag="SkView::setArtist"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView_1_1Artist.html">Artist</a>* SkView::setArtist </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkView_1_1Artist.html">Artist</a> * </td> - <td class="mdname1" valign="top" nowrap> <em>artist</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Attach the specified artist (or nil) to the view, replacing any existing artist. If the new artist is not nil, its reference count is incremented. The artist parameter is returned. </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkView::setFlags"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::setFlags </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">U32 </td> - <td class="mdname1" valign="top" nowrap> <em>flags</em> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the flags associated with the view </td> - </tr> -</table> -<a class="anchor" name="a43" doxytag="SkView::setLayout"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top"><a class="el" href="classSkView_1_1Layout.html">Layout</a>* SkView::setLayout </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top"><a class="el" href="classSkView_1_1Layout.html">Layout</a> * </td> - <td class="mdname" nowrap>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>bool </td> - <td class="mdname" nowrap> <em>invokeLayoutNow</em> = <code>true</code></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Attach the specified layout (or nil) to the view, replacing any existing layout. If the new layout is not nil, its reference count is incremented. The layout parameter is returned. </td> - </tr> -</table> -<a class="anchor" name="a19" doxytag="SkView::setLoc"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::setLoc </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the view's left and top edge. This does not affect the view's size </td> - </tr> -</table> -<a class="anchor" name="a12" doxytag="SkView::setSize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::setSize </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">SkScalar </td> - <td class="mdname" nowrap> <em>width</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>SkScalar </td> - <td class="mdname" nowrap> <em>height</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Set the view's width and height. These must both be >= 0. This does not affect the view's loc </td> - </tr> -</table> -<a class="anchor" name="a7" doxytag="SkView::setVisibleP"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">void SkView::setVisibleP </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">bool </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Helper to set/clear the view's kVisible_Mask flag </td> - </tr> -</table> -<a class="anchor" name="a10" doxytag="SkView::width"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">SkScalar SkView::width </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the view's width </td> - </tr> -</table> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkView_8h-source.html">SkView.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView.png b/sgl_doxygen/html/classSkView.png Binary files differdeleted file mode 100644 index 94dbe6c..0000000 --- a/sgl_doxygen/html/classSkView.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkView_1_1Artist-members.html b/sgl_doxygen/html/classSkView_1_1Artist-members.html deleted file mode 100644 index 4c67da5..0000000 --- a/sgl_doxygen/html/classSkView_1_1Artist-members.html +++ /dev/null @@ -1,24 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkView::Artist Member List</h1>This is the complete list of members for <a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>draw</b>(SkView *, SkCanvas *) (defined in <a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a>)</td><td><a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>inflate</b>(const SkDOM &, const SkDOM::Node *) (defined in <a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a>)</td><td><a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onDraw</b>(SkView *, SkCanvas *)=0 (defined in <a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a>)</td><td><a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a></td><td><code> [protected, pure virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onInflate</b>(const SkDOM &, const SkDOM::Node *) (defined in <a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a>)</td><td><a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a></td><td><code> [protected, virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1Artist.html b/sgl_doxygen/html/classSkView_1_1Artist.html deleted file mode 100644 index 15f1ccb..0000000 --- a/sgl_doxygen/html/classSkView_1_1Artist.html +++ /dev/null @@ -1,43 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkView::Artist Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="classSkView.html">SkView</a>::<a class="el" href="classSkView_1_1Artist.html">Artist</a></div> -<h1>SkView::Artist Class Reference</h1><code>#include <<a class="el" href="SkView_8h-source.html">SkView.h</a>></code> -<p> -<p>Inheritance diagram for SkView::Artist: -<p><center><img src="classSkView_1_1Artist.png" usemap="#SkView::Artist_map" border="0" alt=""></center> -<map name="SkView::Artist_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,100,24"> -</map> -<a href="classSkView_1_1Artist-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkView::Artist::draw"></a> -void </td><td class="memItemRight" valign="bottom"><b>draw</b> (<a class="el" href="classSkView.html">SkView</a> *, <a class="el" href="classSkCanvas.html">SkCanvas</a> *)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkView::Artist::inflate"></a> -void </td><td class="memItemRight" valign="bottom"><b>inflate</b> (const SkDOM &, const SkDOM::Node *)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkView::Artist::onDraw"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onDraw</b> (<a class="el" href="classSkView.html">SkView</a> *, <a class="el" href="classSkCanvas.html">SkCanvas</a> *)=0</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b1" doxytag="SkView::Artist::onInflate"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onInflate</b> (const SkDOM &, const SkDOM::Node *)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Install a subclass of this in a view (calling <a class="el" href="classSkView.html#a41">setArtist()</a>), and then the default implementation of that view's onDraw() will invoke this object automatically. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkView_8h-source.html">SkView.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1Artist.png b/sgl_doxygen/html/classSkView_1_1Artist.png Binary files differdeleted file mode 100644 index f2e0d41..0000000 --- a/sgl_doxygen/html/classSkView_1_1Artist.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkView_1_1B2FIter-members.html b/sgl_doxygen/html/classSkView_1_1B2FIter-members.html deleted file mode 100644 index f8c6671..0000000 --- a/sgl_doxygen/html/classSkView_1_1B2FIter-members.html +++ /dev/null @@ -1,15 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkView::B2FIter Member List</h1>This is the complete list of members for <a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>B2FIter</b>(const SkView *parent) (defined in <a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a>)</td><td><a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>next</b>() (defined in <a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a>)</td><td><a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1B2FIter.html b/sgl_doxygen/html/classSkView_1_1B2FIter.html deleted file mode 100644 index 6703392..0000000 --- a/sgl_doxygen/html/classSkView_1_1B2FIter.html +++ /dev/null @@ -1,31 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkView::B2FIter Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="classSkView.html">SkView</a>::<a class="el" href="classSkView_1_1B2FIter.html">B2FIter</a></div> -<h1>SkView::B2FIter Class Reference</h1><code>#include <<a class="el" href="SkView_8h-source.html">SkView.h</a>></code> -<p> -<a href="classSkView_1_1B2FIter-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkView::B2FIter::B2FIter"></a> - </td><td class="memItemRight" valign="bottom"><b>B2FIter</b> (const <a class="el" href="classSkView.html">SkView</a> *parent)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkView::B2FIter::next"></a> -<a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><b>next</b> ()</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Iterator that will return each of this view's children, in back-to-front order (the order they are drawn). The first call to next() returns the back-most child view. When next() returns nil, there are no more child views. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkView_8h-source.html">SkView.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1F2BIter-members.html b/sgl_doxygen/html/classSkView_1_1F2BIter-members.html deleted file mode 100644 index b0bebf3..0000000 --- a/sgl_doxygen/html/classSkView_1_1F2BIter-members.html +++ /dev/null @@ -1,15 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkView::F2BIter Member List</h1>This is the complete list of members for <a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>F2BIter</b>(const SkView *parent) (defined in <a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a>)</td><td><a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>next</b>() (defined in <a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a>)</td><td><a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1F2BIter.html b/sgl_doxygen/html/classSkView_1_1F2BIter.html deleted file mode 100644 index 86d7f55..0000000 --- a/sgl_doxygen/html/classSkView_1_1F2BIter.html +++ /dev/null @@ -1,31 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkView::F2BIter Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="classSkView.html">SkView</a>::<a class="el" href="classSkView_1_1F2BIter.html">F2BIter</a></div> -<h1>SkView::F2BIter Class Reference</h1><code>#include <<a class="el" href="SkView_8h-source.html">SkView.h</a>></code> -<p> -<a href="classSkView_1_1F2BIter-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkView::F2BIter::F2BIter"></a> - </td><td class="memItemRight" valign="bottom"><b>F2BIter</b> (const <a class="el" href="classSkView.html">SkView</a> *parent)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkView::F2BIter::next"></a> -<a class="el" href="classSkView.html">SkView</a> * </td><td class="memItemRight" valign="bottom"><b>next</b> ()</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Iterator that will return each of this view's children, in front-to-back order (the order used for clicking). The first call to next() returns the front-most child view. When next() returns nil, there are no more child views. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkView_8h-source.html">SkView.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1Layout-members.html b/sgl_doxygen/html/classSkView_1_1Layout-members.html deleted file mode 100644 index 95d1bcc..0000000 --- a/sgl_doxygen/html/classSkView_1_1Layout-members.html +++ /dev/null @@ -1,24 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkView::Layout Member List</h1>This is the complete list of members for <a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>inflate</b>(const SkDOM &, const SkDOM::Node *) (defined in <a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a>)</td><td><a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>layoutChildren</b>(SkView *parent) (defined in <a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a>)</td><td><a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onInflate</b>(const SkDOM &, const SkDOM::Node *) (defined in <a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a>)</td><td><a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a></td><td><code> [protected, virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>onLayoutChildren</b>(SkView *parent)=0 (defined in <a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a>)</td><td><a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a></td><td><code> [protected, pure virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1Layout.html b/sgl_doxygen/html/classSkView_1_1Layout.html deleted file mode 100644 index a1ca4e7..0000000 --- a/sgl_doxygen/html/classSkView_1_1Layout.html +++ /dev/null @@ -1,43 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkView::Layout Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="classSkView.html">SkView</a>::<a class="el" href="classSkView_1_1Layout.html">Layout</a></div> -<h1>SkView::Layout Class Reference</h1><code>#include <<a class="el" href="SkView_8h-source.html">SkView.h</a>></code> -<p> -<p>Inheritance diagram for SkView::Layout: -<p><center><img src="classSkView_1_1Layout.png" usemap="#SkView::Layout_map" border="0" alt=""></center> -<map name="SkView::Layout_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="66,0,189,24"> -</map> -<a href="classSkView_1_1Layout-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkView::Layout::layoutChildren"></a> -void </td><td class="memItemRight" valign="bottom"><b>layoutChildren</b> (<a class="el" href="classSkView.html">SkView</a> *parent)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkView::Layout::inflate"></a> -void </td><td class="memItemRight" valign="bottom"><b>inflate</b> (const SkDOM &, const SkDOM::Node *)</td></tr> - -<tr><td colspan="2"><br><h2>Protected Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b0" doxytag="SkView::Layout::onLayoutChildren"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onLayoutChildren</b> (<a class="el" href="classSkView.html">SkView</a> *parent)=0</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="b1" doxytag="SkView::Layout::onInflate"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>onInflate</b> (const SkDOM &, const SkDOM::Node *)</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -Install a subclass of this in a view (calling <a class="el" href="classSkView.html#a43">setLayout()</a>), and then the default implementation of that view's onLayoutChildren() will invoke this object automatically. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkView_8h-source.html">SkView.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkView_1_1Layout.png b/sgl_doxygen/html/classSkView_1_1Layout.png Binary files differdeleted file mode 100644 index 8f48ef9..0000000 --- a/sgl_doxygen/html/classSkView_1_1Layout.png +++ /dev/null diff --git a/sgl_doxygen/html/classSkXfermode-members.html b/sgl_doxygen/html/classSkXfermode-members.html deleted file mode 100644 index 6c91311..0000000 --- a/sgl_doxygen/html/classSkXfermode-members.html +++ /dev/null @@ -1,23 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkXfermode Member List</h1>This is the complete list of members for <a class="el" href="classSkXfermode.html">SkXfermode</a>, including all inherited members.<p><table> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a2">getRefCnt</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a3">ref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a5">safeRef</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a6">safeUnref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a4">unref</a>() const </td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>xfer16</b>(uint16_t dst[], const SkPMColor src[], int count, const SkAlpha aa[]) (defined in <a class="el" href="classSkXfermode.html">SkXfermode</a>)</td><td><a class="el" href="classSkXfermode.html">SkXfermode</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>xfer32</b>(SkPMColor dst[], const SkPMColor src[], int count, const SkAlpha aa[]) (defined in <a class="el" href="classSkXfermode.html">SkXfermode</a>)</td><td><a class="el" href="classSkXfermode.html">SkXfermode</a></td><td><code> [virtual]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>xferA8</b>(SkAlpha dst[], const SkPMColor src[], int count, const SkAlpha aa[]) (defined in <a class="el" href="classSkXfermode.html">SkXfermode</a>)</td><td><a class="el" href="classSkXfermode.html">SkXfermode</a></td><td><code> [virtual]</code></td></tr> - <tr class="memlist"><td><a class="el" href="classSkRefCnt.html#a1">~SkRefCnt</a>()</td><td><a class="el" href="classSkRefCnt.html">SkRefCnt</a></td><td><code> [inline, virtual]</code></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkXfermode.html b/sgl_doxygen/html/classSkXfermode.html deleted file mode 100644 index 3534112..0000000 --- a/sgl_doxygen/html/classSkXfermode.html +++ /dev/null @@ -1,37 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkXfermode Class Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkXfermode Class Reference</h1><code>#include <<a class="el" href="SkXfermode_8h-source.html">SkXfermode.h</a>></code> -<p> -<p>Inheritance diagram for SkXfermode: -<p><center><img src="classSkXfermode.png" usemap="#SkXfermode_map" border="0" alt=""></center> -<map name="SkXfermode_map"> -<area href="classSkRefCnt.html" alt="SkRefCnt" shape="rect" coords="0,0,108,24"> -</map> -<a href="classSkXfermode-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a0" doxytag="SkXfermode::xfer32"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>xfer32</b> (<a class="el" href="SkColor_8h.html#a18">SkPMColor</a> dst[], const <a class="el" href="SkColor_8h.html#a18">SkPMColor</a> src[], int count, const <a class="el" href="SkColor_8h.html#a16">SkAlpha</a> aa[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a1" doxytag="SkXfermode::xfer16"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>xfer16</b> (uint16_t dst[], const <a class="el" href="SkColor_8h.html#a18">SkPMColor</a> src[], int count, const <a class="el" href="SkColor_8h.html#a16">SkAlpha</a> aa[])</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="a2" doxytag="SkXfermode::xferA8"></a> -virtual void </td><td class="memItemRight" valign="bottom"><b>xferA8</b> (<a class="el" href="SkColor_8h.html#a16">SkAlpha</a> dst[], const <a class="el" href="SkColor_8h.html#a18">SkPMColor</a> src[], int count, const <a class="el" href="SkColor_8h.html#a16">SkAlpha</a> aa[])</td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkXfermode is the base class for objects that are called to implement custom "transfer-modes" in the drawing pipeline. The static function Create(Modes) can be called to return an instance of any of the predefined subclasses as specified in the Modes enum. When an SkXfermode is assigned to an <a class="el" href="classSkPaint.html">SkPaint</a>, then objects drawn with that paint have the xfermode applied. -<p> -<hr>The documentation for this class was generated from the following file:<ul> -<li><a class="el" href="SkXfermode_8h-source.html">SkXfermode.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/classSkXfermode.png b/sgl_doxygen/html/classSkXfermode.png Binary files differdeleted file mode 100644 index 57cb88d..0000000 --- a/sgl_doxygen/html/classSkXfermode.png +++ /dev/null diff --git a/sgl_doxygen/html/dir_000000.html b/sgl_doxygen/html/dir_000000.html deleted file mode 100644 index a8cbe43..0000000 --- a/sgl_doxygen/html/dir_000000.html +++ /dev/null @@ -1,20 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: /home/phanna/android/device/include/ Directory Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a></div> -<h1>include Directory Reference</h1><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Directories</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">directory </td><td class="memItemRight" valign="bottom"><a class="el" href="dir_000001.html">skia</a></td></tr> - -</table> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/dir_000001.html b/sgl_doxygen/html/dir_000001.html deleted file mode 100644 index 9ca2117..0000000 --- a/sgl_doxygen/html/dir_000001.html +++ /dev/null @@ -1,208 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: /home/phanna/android/device/include/skia/ Directory Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="nav"> -<a class="el" href="dir_000000.html">include</a> / <a class="el" href="dir_000001.html">skia</a></div> -<h1>skia Directory Reference</h1><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Files</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>Sk1DPathEffect.h</b> <a href="Sk1DPathEffect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>Sk2DPathEffect.h</b> <a href="Sk2DPathEffect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkAnimator.h</b> <a href="SkAnimator_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkAnimatorView.h</b> <a href="SkAnimatorView_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkApplication.h</b> <a href="SkApplication_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBGViewArtist.h</b> <a href="SkBGViewArtist_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBitmap.h</b> <a href="SkBitmap_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBitmapRef.h</b> <a href="SkBitmapRef_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBlurMaskFilter.h</b> <a href="SkBlurMaskFilter_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBML_WXMLParser.h</b> <a href="SkBML__WXMLParser_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBML_XMLParser.h</b> <a href="SkBML__XMLParser_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBorderView.h</b> <a href="SkBorderView_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkBounder.h</b> <a href="SkBounder_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkCamera.h</b> <a href="SkCamera_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkCanvas.h</b> <a href="SkCanvas_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><a class="el" href="SkColor_8h.html">SkColor.h</a> <a href="SkColor_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkColorPriv.h</b> <a href="SkColorPriv_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkCornerPathEffect.h</b> <a href="SkCornerPathEffect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkDashPathEffect.h</b> <a href="SkDashPathEffect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkDeque.h</b> <a href="SkDeque_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkDescriptor.h</b> <a href="SkDescriptor_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkDiscretePathEffect.h</b> <a href="SkDiscretePathEffect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkDOM.h</b> <a href="SkDOM_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkEmbossMaskFilter.h</b> <a href="SkEmbossMaskFilter_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkEvent.h</b> <a href="SkEvent_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkEventSink.h</b> <a href="SkEventSink_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkFlattenable.h</b> <a href="SkFlattenable_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkFontCodec.h</b> <a href="SkFontCodec_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkFontHost.h</b> <a href="SkFontHost_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkGIFImageDecoder.h</b> <a href="SkGIFImageDecoder_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkGlobals.h</b> <a href="SkGlobals_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkGradientShader.h</b> <a href="SkGradientShader_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkGraphics.h</b> <a href="SkGraphics_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkImageDecoder.h</b> <a href="SkImageDecoder_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkImageView.h</b> <a href="SkImageView_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkInterpolator.h</b> <a href="SkInterpolator_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkJPEGImageDecoder.h</b> <a href="SkJPEGImageDecoder_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkJS.h</b> <a href="SkJS_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkKey.h</b> <a href="SkKey_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkLayersMaskFilter.h</b> <a href="SkLayersMaskFilter_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkLightShader.h</b> <a href="SkLightShader_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkMask.h</b> <a href="SkMask_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkMaskFilter.h</b> <a href="SkMaskFilter_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkMetaData.h</b> <a href="SkMetaData_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSFile.h</b> <a href="SkOSFile_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSMenu.h</b> <a href="SkOSMenu_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSSound.h</b> <a href="SkOSSound_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSWindow_Mac.h</b> <a href="SkOSWindow__Mac_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSWindow_Unix.h</b> <a href="SkOSWindow__Unix_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSWindow_Win.h</b> <a href="SkOSWindow__Win_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkOSWindow_wxwidgets.h</b> <a href="SkOSWindow__wxwidgets_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPaint.h</b> <a href="SkPaint_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkParse.h</b> <a href="SkParse_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkParsePaint.h</b> <a href="SkParsePaint_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPath.h</b> <a href="SkPath_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPathEffect.h</b> <a href="SkPathEffect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPathMeasure.h</b> <a href="SkPathMeasure_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPNGImageDecoder.h</b> <a href="SkPNGImageDecoder_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPorterDuff.h</b> <a href="SkPorterDuff_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPrefix_Debug_Fixed.h</b> <a href="SkPrefix__Debug__Fixed_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkPrefix_Release_Fixed.h</b> <a href="SkPrefix__Release__Fixed_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkProgressBarView.h</b> <a href="SkProgressBarView_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkRefCnt.h</b> <a href="SkRefCnt_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkScalerContext.h</b> <a href="SkScalerContext_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkScrollBarView.h</b> <a href="SkScrollBarView_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkShader.h</b> <a href="SkShader_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkStackViewLayout.h</b> <a href="SkStackViewLayout_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkStdLib_Redirect.h</b> <a href="SkStdLib__Redirect_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkStream.h</b> <a href="SkStream_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkStream_Win.h</b> <a href="SkStream__Win_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkString.h</b> <a href="SkString_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkStroke.h</b> <a href="SkStroke_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkSVGAttribute.h</b> <a href="SkSVGAttribute_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkSVGBase.h</b> <a href="SkSVGBase_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkSVGPaintState.h</b> <a href="SkSVGPaintState_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkSVGParser.h</b> <a href="SkSVGParser_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkSVGTypes.h</b> <a href="SkSVGTypes_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkSystemEventTypes.h</b> <a href="SkSystemEventTypes_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTDArray.h</b> <a href="SkTDArray_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTDict.h</b> <a href="SkTDict_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTDStack.h</b> <a href="SkTDStack_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTextBox.h</b> <a href="SkTextBox_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTime.h</b> <a href="SkTime_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTransparentShader.h</b> <a href="SkTransparentShader_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkTSearch.h</b> <a href="SkTSearch_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkUnitMapper.h</b> <a href="SkUnitMapper_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkUtils.h</b> <a href="SkUtils_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkView.h</b> <a href="SkView_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkViewInflate.h</b> <a href="SkViewInflate_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkWidget.h</b> <a href="SkWidget_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkWidgetViews.h</b> <a href="SkWidgetViews_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkWindow.h</b> <a href="SkWindow_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkXfermode.h</b> <a href="SkXfermode_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkXMLParser.h</b> <a href="SkXMLParser_8h-source.html">[code]</a></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">file </td><td class="memItemRight" valign="bottom"><b>SkXMLWriter.h</b> <a href="SkXMLWriter_8h-source.html">[code]</a></td></tr> - -</table> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/dirs.html b/sgl_doxygen/html/dirs.html deleted file mode 100644 index f7c59ab..0000000 --- a/sgl_doxygen/html/dirs.html +++ /dev/null @@ -1,18 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Directory Hierarchy</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindexHL" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SGL Directories</h1>This directory hierarchy is sorted roughly, but not completely, alphabetically:<ul> -<li><a class="el" href="dir_000000.html">include</a> -<ul> -<li><a class="el" href="dir_000001.html">skia</a> -</ul> -</ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/doxygen.css b/sgl_doxygen/html/doxygen.css deleted file mode 100644 index e5272cd..0000000 --- a/sgl_doxygen/html/doxygen.css +++ /dev/null @@ -1,297 +0,0 @@ -BODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { - font-family: Geneva, Arial, Helvetica, sans-serif; -} -BODY,TD { - font-size: 90%; -} -H1 { - text-align: center; - font-size: 160%; -} -H2 { - font-size: 120%; -} -H3 { - font-size: 110%; -} -CAPTION { font-weight: bold } -DIV.qindex { - width: 100%; - background-color: #eeeeff; - border: 1px solid #b0b0b0; - text-align: center; - margin: 2px; - padding: 2px; - line-height: 140%; -} -DIV.nav { - width: 100%; - background-color: #eeeeff; - border: 1px solid #b0b0b0; - text-align: center; - margin: 2px; - padding: 2px; - line-height: 140%; -} -A.qindex { - text-decoration: none; - font-weight: bold; - color: #1A419D; -} -A.qindex:visited { - text-decoration: none; - font-weight: bold; - color: #1A419D -} -A.qindex:hover { - text-decoration: none; - background-color: #ddddff; -} -A.qindexHL { - text-decoration: none; - font-weight: bold; - background-color: #6666cc; - color: #ffffff; - border: 1px double #9295C2; -} -A.qindexHL:hover { - text-decoration: none; - background-color: #6666cc; - color: #ffffff; -} -A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } -A.el { text-decoration: none; font-weight: bold } -A.elRef { font-weight: bold } -A.code:link { text-decoration: none; font-weight: normal; color: #0000FF} -A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF} -A.codeRef:link { font-weight: normal; color: #0000FF} -A.codeRef:visited { font-weight: normal; color: #0000FF} -A:hover { text-decoration: none; background-color: #f2f2ff } -DL.el { margin-left: -1cm } -.fragment { - font-family: monospace -} -PRE.fragment { - border: 1px solid #CCCCCC; - background-color: #f5f5f5; - margin-top: 4px; - margin-bottom: 4px; - margin-left: 2px; - margin-right: 8px; - padding-left: 6px; - padding-right: 6px; - padding-top: 4px; - padding-bottom: 4px; -} -DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } -TD.md { background-color: #F4F4FB; font-weight: bold; } -TD.mdPrefix { - background-color: #F4F4FB; - color: #606060; - font-size: 80%; -} -TD.mdname1 { background-color: #F4F4FB; font-weight: bold; color: #602020; } -TD.mdname { background-color: #F4F4FB; font-weight: bold; color: #602020; width: 600px; } -DIV.groupHeader { - margin-left: 16px; - margin-top: 12px; - margin-bottom: 6px; - font-weight: bold; -} -DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } -BODY { - background: white; - color: black; - margin-right: 20px; - margin-left: 20px; -} -TD.indexkey { - background-color: #eeeeff; - font-weight: bold; - padding-right : 10px; - padding-top : 2px; - padding-left : 10px; - padding-bottom : 2px; - margin-left : 0px; - margin-right : 0px; - margin-top : 2px; - margin-bottom : 2px; - border: 1px solid #CCCCCC; -} -TD.indexvalue { - background-color: #eeeeff; - font-style: italic; - padding-right : 10px; - padding-top : 2px; - padding-left : 10px; - padding-bottom : 2px; - margin-left : 0px; - margin-right : 0px; - margin-top : 2px; - margin-bottom : 2px; - border: 1px solid #CCCCCC; -} -TR.memlist { - background-color: #f0f0f0; -} -P.formulaDsp { text-align: center; } -IMG.formulaDsp { } -IMG.formulaInl { vertical-align: middle; } -SPAN.keyword { color: #008000 } -SPAN.keywordtype { color: #604020 } -SPAN.keywordflow { color: #e08000 } -SPAN.comment { color: #800000 } -SPAN.preprocessor { color: #806020 } -SPAN.stringliteral { color: #002080 } -SPAN.charliteral { color: #008080 } -.mdTable { - border: 1px solid #868686; - background-color: #F4F4FB; -} -.mdRow { - padding: 8px 10px; -} -.mdescLeft { - padding: 0px 8px 4px 8px; - font-size: 80%; - font-style: italic; - background-color: #FAFAFA; - border-top: 1px none #E0E0E0; - border-right: 1px none #E0E0E0; - border-bottom: 1px none #E0E0E0; - border-left: 1px none #E0E0E0; - margin: 0px; -} -.mdescRight { - padding: 0px 8px 4px 8px; - font-size: 80%; - font-style: italic; - background-color: #FAFAFA; - border-top: 1px none #E0E0E0; - border-right: 1px none #E0E0E0; - border-bottom: 1px none #E0E0E0; - border-left: 1px none #E0E0E0; - margin: 0px; -} -.memItemLeft { - padding: 1px 0px 0px 8px; - margin: 4px; - border-top-width: 1px; - border-right-width: 1px; - border-bottom-width: 1px; - border-left-width: 1px; - border-top-color: #E0E0E0; - border-right-color: #E0E0E0; - border-bottom-color: #E0E0E0; - border-left-color: #E0E0E0; - border-top-style: solid; - border-right-style: none; - border-bottom-style: none; - border-left-style: none; - background-color: #FAFAFA; - font-size: 80%; -} -.memItemRight { - padding: 1px 8px 0px 8px; - margin: 4px; - border-top-width: 1px; - border-right-width: 1px; - border-bottom-width: 1px; - border-left-width: 1px; - border-top-color: #E0E0E0; - border-right-color: #E0E0E0; - border-bottom-color: #E0E0E0; - border-left-color: #E0E0E0; - border-top-style: solid; - border-right-style: none; - border-bottom-style: none; - border-left-style: none; - background-color: #FAFAFA; - font-size: 80%; -} -.memTemplItemLeft { - padding: 1px 0px 0px 8px; - margin: 4px; - border-top-width: 1px; - border-right-width: 1px; - border-bottom-width: 1px; - border-left-width: 1px; - border-top-color: #E0E0E0; - border-right-color: #E0E0E0; - border-bottom-color: #E0E0E0; - border-left-color: #E0E0E0; - border-top-style: none; - border-right-style: none; - border-bottom-style: none; - border-left-style: none; - background-color: #FAFAFA; - font-size: 80%; -} -.memTemplItemRight { - padding: 1px 8px 0px 8px; - margin: 4px; - border-top-width: 1px; - border-right-width: 1px; - border-bottom-width: 1px; - border-left-width: 1px; - border-top-color: #E0E0E0; - border-right-color: #E0E0E0; - border-bottom-color: #E0E0E0; - border-left-color: #E0E0E0; - border-top-style: none; - border-right-style: none; - border-bottom-style: none; - border-left-style: none; - background-color: #FAFAFA; - font-size: 80%; -} -.memTemplParams { - padding: 1px 0px 0px 8px; - margin: 4px; - border-top-width: 1px; - border-right-width: 1px; - border-bottom-width: 1px; - border-left-width: 1px; - border-top-color: #E0E0E0; - border-right-color: #E0E0E0; - border-bottom-color: #E0E0E0; - border-left-color: #E0E0E0; - border-top-style: solid; - border-right-style: none; - border-bottom-style: none; - border-left-style: none; - color: #606060; - background-color: #FAFAFA; - font-size: 80%; -} -.search { color: #003399; - font-weight: bold; -} -FORM.search { - margin-bottom: 0px; - margin-top: 0px; -} -INPUT.search { font-size: 75%; - color: #000080; - font-weight: normal; - background-color: #eeeeff; -} -TD.tiny { font-size: 75%; -} -a { - color: #252E78; -} -a:visited { - color: #3D2185; -} -.dirtab { padding: 4px; - border-collapse: collapse; - border: 1px solid #b0b0b0; -} -TH.dirtab { background: #eeeeff; - font-weight: bold; -} -HR { height: 1px; - border: none; - border-top: 1px solid black; -} diff --git a/sgl_doxygen/html/doxygen.png b/sgl_doxygen/html/doxygen.png Binary files differdeleted file mode 100644 index f0a274b..0000000 --- a/sgl_doxygen/html/doxygen.png +++ /dev/null diff --git a/sgl_doxygen/html/files.html b/sgl_doxygen/html/files.html deleted file mode 100644 index 17d4ad0..0000000 --- a/sgl_doxygen/html/files.html +++ /dev/null @@ -1,109 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: File Index</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindexHL" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SGL File List</h1>Here is a list of all documented files with brief descriptions:<table> - <tr><td class="indexkey"><b>Sk1DPathEffect.h</b> <a href="Sk1DPathEffect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>Sk2DPathEffect.h</b> <a href="Sk2DPathEffect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkAnimator.h</b> <a href="SkAnimator_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkAnimatorView.h</b> <a href="SkAnimatorView_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkApplication.h</b> <a href="SkApplication_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBGViewArtist.h</b> <a href="SkBGViewArtist_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBitmap.h</b> <a href="SkBitmap_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBitmapRef.h</b> <a href="SkBitmapRef_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBlurMaskFilter.h</b> <a href="SkBlurMaskFilter_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBML_WXMLParser.h</b> <a href="SkBML__WXMLParser_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBML_XMLParser.h</b> <a href="SkBML__XMLParser_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBorderView.h</b> <a href="SkBorderView_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkBounder.h</b> <a href="SkBounder_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkCamera.h</b> <a href="SkCamera_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkCanvas.h</b> <a href="SkCanvas_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><a class="el" href="SkColor_8h.html">SkColor.h</a> <a href="SkColor_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkColorPriv.h</b> <a href="SkColorPriv_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkCornerPathEffect.h</b> <a href="SkCornerPathEffect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkDashPathEffect.h</b> <a href="SkDashPathEffect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkDeque.h</b> <a href="SkDeque_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkDescriptor.h</b> <a href="SkDescriptor_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkDiscretePathEffect.h</b> <a href="SkDiscretePathEffect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkDOM.h</b> <a href="SkDOM_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkEmbossMaskFilter.h</b> <a href="SkEmbossMaskFilter_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkEvent.h</b> <a href="SkEvent_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkEventSink.h</b> <a href="SkEventSink_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkFlattenable.h</b> <a href="SkFlattenable_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkFontCodec.h</b> <a href="SkFontCodec_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkFontHost.h</b> <a href="SkFontHost_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkGIFImageDecoder.h</b> <a href="SkGIFImageDecoder_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkGlobals.h</b> <a href="SkGlobals_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkGradientShader.h</b> <a href="SkGradientShader_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkGraphics.h</b> <a href="SkGraphics_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkImageDecoder.h</b> <a href="SkImageDecoder_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkImageView.h</b> <a href="SkImageView_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkInterpolator.h</b> <a href="SkInterpolator_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkJPEGImageDecoder.h</b> <a href="SkJPEGImageDecoder_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkJS.h</b> <a href="SkJS_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkKey.h</b> <a href="SkKey_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkLayersMaskFilter.h</b> <a href="SkLayersMaskFilter_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkLightShader.h</b> <a href="SkLightShader_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkMask.h</b> <a href="SkMask_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkMaskFilter.h</b> <a href="SkMaskFilter_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkMetaData.h</b> <a href="SkMetaData_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSFile.h</b> <a href="SkOSFile_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSMenu.h</b> <a href="SkOSMenu_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSSound.h</b> <a href="SkOSSound_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSWindow_Mac.h</b> <a href="SkOSWindow__Mac_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSWindow_Unix.h</b> <a href="SkOSWindow__Unix_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSWindow_Win.h</b> <a href="SkOSWindow__Win_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkOSWindow_wxwidgets.h</b> <a href="SkOSWindow__wxwidgets_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPaint.h</b> <a href="SkPaint_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkParse.h</b> <a href="SkParse_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkParsePaint.h</b> <a href="SkParsePaint_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPath.h</b> <a href="SkPath_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPathEffect.h</b> <a href="SkPathEffect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPathMeasure.h</b> <a href="SkPathMeasure_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPNGImageDecoder.h</b> <a href="SkPNGImageDecoder_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPorterDuff.h</b> <a href="SkPorterDuff_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPrefix_Debug_Fixed.h</b> <a href="SkPrefix__Debug__Fixed_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkPrefix_Release_Fixed.h</b> <a href="SkPrefix__Release__Fixed_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkProgressBarView.h</b> <a href="SkProgressBarView_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkRefCnt.h</b> <a href="SkRefCnt_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkScalerContext.h</b> <a href="SkScalerContext_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkScrollBarView.h</b> <a href="SkScrollBarView_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkShader.h</b> <a href="SkShader_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkStackViewLayout.h</b> <a href="SkStackViewLayout_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkStdLib_Redirect.h</b> <a href="SkStdLib__Redirect_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkStream.h</b> <a href="SkStream_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkStream_Win.h</b> <a href="SkStream__Win_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkString.h</b> <a href="SkString_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkStroke.h</b> <a href="SkStroke_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkSVGAttribute.h</b> <a href="SkSVGAttribute_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkSVGBase.h</b> <a href="SkSVGBase_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkSVGPaintState.h</b> <a href="SkSVGPaintState_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkSVGParser.h</b> <a href="SkSVGParser_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkSVGTypes.h</b> <a href="SkSVGTypes_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkSystemEventTypes.h</b> <a href="SkSystemEventTypes_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTDArray.h</b> <a href="SkTDArray_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTDict.h</b> <a href="SkTDict_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTDStack.h</b> <a href="SkTDStack_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTextBox.h</b> <a href="SkTextBox_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTime.h</b> <a href="SkTime_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTransparentShader.h</b> <a href="SkTransparentShader_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkTSearch.h</b> <a href="SkTSearch_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkUnitMapper.h</b> <a href="SkUnitMapper_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkUtils.h</b> <a href="SkUtils_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkView.h</b> <a href="SkView_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkViewInflate.h</b> <a href="SkViewInflate_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkWidget.h</b> <a href="SkWidget_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkWidgetViews.h</b> <a href="SkWidgetViews_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkWindow.h</b> <a href="SkWindow_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkXfermode.h</b> <a href="SkXfermode_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkXMLParser.h</b> <a href="SkXMLParser_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> - <tr><td class="indexkey"><b>SkXMLWriter.h</b> <a href="SkXMLWriter_8h-source.html">[code]</a></td><td class="indexvalue"></td></tr> -</table> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/functions.html b/sgl_doxygen/html/functions.html deleted file mode 100644 index f2c58bb..0000000 --- a/sgl_doxygen/html/functions.html +++ /dev/null @@ -1,437 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Class Members</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindexHL" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindexHL" href="functions.html">All</a> | <a class="qindex" href="functions_func.html">Functions</a> | <a class="qindex" href="functions_enum.html">Enumerations</a> | <a class="qindex" href="functions_eval.html">Enumeration values</a></div> -<div class="qindex"><a class="qindex" href="#index_a">a</a> | <a class="qindex" href="#index_b">b</a> | <a class="qindex" href="#index_c">c</a> | <a class="qindex" href="#index_d">d</a> | <a class="qindex" href="#index_e">e</a> | <a class="qindex" href="#index_f">f</a> | <a class="qindex" href="#index_g">g</a> | <a class="qindex" href="#index_h">h</a> | <a class="qindex" href="#index_i">i</a> | <a class="qindex" href="#index_j">j</a> | <a class="qindex" href="#index_k">k</a> | <a class="qindex" href="#index_l">l</a> | <a class="qindex" href="#index_m">m</a> | <a class="qindex" href="#index_o">o</a> | <a class="qindex" href="#index_p">p</a> | <a class="qindex" href="#index_q">q</a> | <a class="qindex" href="#index_r">r</a> | <a class="qindex" href="#index_s">s</a> | <a class="qindex" href="#index_t">t</a> | <a class="qindex" href="#index_u">u</a> | <a class="qindex" href="#index_v">v</a> | <a class="qindex" href="#index_w">w</a> | <a class="qindex" href="#index_~">~</a></div> - -<p> - -<p> -Here is a list of all documented class members with links to the class documentation for each member:<h3><a class="anchor" name="index_a">- a -</a></h3><ul> -<li>addCircle() -: <a class="el" href="classSkPath.html#a28">SkPath</a><li>addExtras() -: <a class="el" href="classSkAnimator.html#a2">SkAnimator</a><li>addListenerID() -: <a class="el" href="classSkEventSink.html#a5">SkEventSink</a><li>addOval() -: <a class="el" href="classSkPath.html#a27">SkPath</a><li>addPath() -: <a class="el" href="classSkPath.html#a32">SkPath</a><li>addRect() -: <a class="el" href="classSkPath.html#a26">SkPath</a><li>addRoundRect() -: <a class="el" href="classSkPath.html#a29">SkPath</a><li>allocPixels() -: <a class="el" href="classSkBitmap.html#a16">SkBitmap</a><li>appendStream() -: <a class="el" href="classSkAnimator.html#a3">SkAnimator</a><li>applyGamma() -: <a class="el" href="classSkBitmap.html#a29">SkBitmap</a><li>ascent() -: <a class="el" href="classSkPaint.html#a59">SkPaint</a><li>attachChildToBack() -: <a class="el" href="classSkView.html#a35">SkView</a></ul> -<h3><a class="anchor" name="index_b">- b -</a></h3><ul> -<li>BoundsType -: <a class="el" href="classSkPath.html#w13">SkPath</a></ul> -<h3><a class="anchor" name="index_c">- c -</a></h3><ul> -<li>canCallShadeSpanOpaque16() -: <a class="el" href="classSkShader.html#a9">SkShader</a><li>CanCallShadeSpanOpaque16() -: <a class="el" href="classSkShader.html#e0">SkShader</a><li>Cap -: <a class="el" href="classSkPaint.html#w36">SkPaint</a><li>clipDeviceRgn() -: <a class="el" href="classSkCanvas.html#a41">SkCanvas</a><li>clipPath() -: <a class="el" href="classSkCanvas.html#a16">SkCanvas</a><li>clipRect() -: <a class="el" href="classSkCanvas.html#a15">SkCanvas</a><li>close() -: <a class="el" href="classSkPath.html#a21">SkPath</a><li>commit() -: <a class="el" href="classSkBounder.html#b1">SkBounder</a><li>computeBounds() -: <a class="el" href="classSkPath.html#a11">SkPath</a><li>computeImageSize() -: <a class="el" href="structSkMask.html#a0">SkMask</a><li>computeTotalImageSize() -: <a class="el" href="structSkMask.html#a1">SkMask</a><li>concat() -: <a class="el" href="classSkCanvas.html#a13">SkCanvas</a><li>Config -: <a class="el" href="classSkBitmap.html#w7">SkBitmap</a><li>copyListeners() -: <a class="el" href="classSkEventSink.html#a6">SkEventSink</a><li>count() -: <a class="el" href="classSkColorTable.html#a4">SkColorTable</a><li>CreateBitmapShader() -: <a class="el" href="classSkShader.html#e1">SkShader</a><li>CreateLinear() -: <a class="el" href="classSkGradientShader.html#e0">SkGradientShader</a><li>CreateRadial() -: <a class="el" href="classSkGradientShader.html#e1">SkGradientShader</a><li>CreateScalarContext() -: <a class="el" href="classSkFontHost.html#e2">SkFontHost</a><li>CreateTypeface() -: <a class="el" href="classSkFontHost.html#e0">SkFontHost</a><li>cubicTo() -: <a class="el" href="classSkPath.html#a19">SkPath</a></ul> -<h3><a class="anchor" name="index_d">- d -</a></h3><ul> -<li>decodeDOM() -: <a class="el" href="classSkAnimator.html#a6">SkAnimator</a><li>DecodeFile() -: <a class="el" href="classSkImageDecoder.html#e0">SkImageDecoder</a><li>decodeMemory() -: <a class="el" href="classSkAnimator.html#a4">SkAnimator</a><li>DecodeMemory() -: <a class="el" href="classSkImageDecoder.html#e1">SkImageDecoder</a><li>decodeStream() -: <a class="el" href="classSkAnimator.html#a5">SkAnimator</a><li>DecodeStream() -: <a class="el" href="classSkImageDecoder.html#e2">SkImageDecoder</a><li>decodeURI() -: <a class="el" href="classSkAnimator.html#a7">SkAnimator</a><li>DecodeURL() -: <a class="el" href="classSkImageDecoder.html#e3">SkImageDecoder</a><li>detachAllChildren() -: <a class="el" href="classSkView.html#a37">SkView</a><li>detachFromParent() -: <a class="el" href="classSkView.html#a36">SkView</a><li>DifferenceType -: <a class="el" href="classSkAnimator.html#w4">SkAnimator</a><li>Direction -: <a class="el" href="classSkPath.html#w14">SkPath</a><li>doCharEvent() -: <a class="el" href="classSkAnimator.html#a8">SkAnimator</a><li>doClickEvent() -: <a class="el" href="classSkAnimator.html#a9">SkAnimator</a><li>doEvent() -: <a class="el" href="classSkEventSink.html#a3">SkEventSink</a><li>DoEvent() -: <a class="el" href="classSkEventSink.html#e0">SkEventSink</a><li>doKeyEvent() -: <a class="el" href="classSkAnimator.html#a10">SkAnimator</a><li>doQuery() -: <a class="el" href="classSkEventSink.html#a4">SkEventSink</a><li>doUserEvent() -: <a class="el" href="classSkAnimator.html#a12">SkAnimator</a><li>draw() -: <a class="el" href="classSkView.html#a24">SkView</a>, <a class="el" href="classSkAnimator.html#a14">SkAnimator</a><li>drawARGB() -: <a class="el" href="classSkCanvas.html#a21">SkCanvas</a><li>drawBitmap() -: <a class="el" href="classSkCanvas.html#a32">SkCanvas</a><li>drawCircle() -: <a class="el" href="classSkCanvas.html#a28">SkCanvas</a><li>drawColor() -: <a class="el" href="classSkCanvas.html#a22">SkCanvas</a><li>drawLine() -: <a class="el" href="classSkCanvas.html#a25">SkCanvas</a><li>drawOval() -: <a class="el" href="classSkCanvas.html#a27">SkCanvas</a><li>drawPaint() -: <a class="el" href="classSkCanvas.html#a23">SkCanvas</a><li>drawPath() -: <a class="el" href="classSkCanvas.html#a30">SkCanvas</a><li>drawRect() -: <a class="el" href="classSkCanvas.html#a26">SkCanvas</a><li>drawRGB() -: <a class="el" href="classSkCanvas.html#a20">SkCanvas</a><li>drawRoundRect() -: <a class="el" href="classSkCanvas.html#a29">SkCanvas</a><li>drawText() -: <a class="el" href="classSkCanvas.html#a33">SkCanvas</a><li>drawText16() -: <a class="el" href="classSkCanvas.html#a34">SkCanvas</a><li>drawText16OnPath() -: <a class="el" href="classSkCanvas.html#a36">SkCanvas</a><li>drawTextOnPath() -: <a class="el" href="classSkCanvas.html#a35">SkCanvas</a></ul> -<h3><a class="anchor" name="index_e">- e -</a></h3><ul> -<li>eraseARGB() -: <a class="el" href="classSkBitmap.html#a21">SkBitmap</a><li>eraseColor() -: <a class="el" href="classSkBitmap.html#a23">SkBitmap</a><li>eraseRGB() -: <a class="el" href="classSkBitmap.html#a22">SkBitmap</a><li>EventResult -: <a class="el" href="classSkEventSink.html#w3">SkEventSink</a></ul> -<h3><a class="anchor" name="index_f">- f -</a></h3><ul> -<li>FillType -: <a class="el" href="classSkPath.html#w12">SkPath</a><li>filterMask() -: <a class="el" href="classSkMaskFilter.html#a1">SkMaskFilter</a><li>filterPath() -: <a class="el" href="classSkSumPathEffect.html#a1">SkSumPathEffect</a>, <a class="el" href="classSkComposePathEffect.html#a1">SkComposePathEffect</a>, <a class="el" href="classSkPathEffect.html#a1">SkPathEffect</a>, <a class="el" href="classSkMaskFilter.html#a2">SkMaskFilter</a>, <a class="el" href="classSkDashPathEffect.html#a2">SkDashPathEffect</a>, <a class="el" href="classSkCornerPathEffect.html#a2">SkCornerPathEffect</a><li>FilterType -: <a class="el" href="classSkPaint.html#w38">SkPaint</a><li>findClickEvent() -: <a class="el" href="classSkAnimator.html#a15">SkAnimator</a><li>findPtr() -: <a class="el" href="classSkEvent.html#a16">SkEvent</a><li>findS32() -: <a class="el" href="classSkEvent.html#a12">SkEvent</a><li>findScalar() -: <a class="el" href="classSkEvent.html#a13">SkEvent</a><li>findScalars() -: <a class="el" href="classSkEvent.html#a14">SkEvent</a><li>FindSink() -: <a class="el" href="classSkEventSink.html#e1">SkEventSink</a><li>findString() -: <a class="el" href="classSkEvent.html#a15">SkEvent</a><li>Flag_Mask -: <a class="el" href="classSkView.html#w16">SkView</a><li>FlagMask -: <a class="el" href="classSkPaint.html#w34">SkPaint</a><li>Flags -: <a class="el" href="classSkShader.html#w9">SkShader</a>, <a class="el" href="classSkColorTable.html#w1">SkColorTable</a><li>FlagShift -: <a class="el" href="classSkPaint.html#w33">SkPaint</a><li>flatten() -: <a class="el" href="classSkPath.html#a39">SkPath</a><li>FlattenTypeface() -: <a class="el" href="classSkFontHost.html#e1">SkFontHost</a><li>Format -: <a class="el" href="structSkMask.html#w3">SkMask</a></ul> -<h3><a class="anchor" name="index_g">- g -</a></h3><ul> -<li>getAddr() -: <a class="el" href="structSkMask.html#a3">SkMask</a><li>getAddr1() -: <a class="el" href="structSkMask.html#a2">SkMask</a>, <a class="el" href="classSkBitmap.html#a28">SkBitmap</a><li>getAddr16() -: <a class="el" href="classSkBitmap.html#a25">SkBitmap</a><li>getAddr32() -: <a class="el" href="classSkBitmap.html#a24">SkBitmap</a><li>getAddr8() -: <a class="el" href="classSkBitmap.html#a26">SkBitmap</a><li>getAlpha() -: <a class="el" href="classSkPaint.html#a22">SkPaint</a><li>getAnimator() -: <a class="el" href="classSkAnimator.html#a16">SkAnimator</a><li>getArrayInt() -: <a class="el" href="classSkAnimator.html#a18">SkAnimator</a><li>getArrayScalar() -: <a class="el" href="classSkAnimator.html#a20">SkAnimator</a><li>getArrayString() -: <a class="el" href="classSkAnimator.html#a22">SkAnimator</a><li>getArtist() -: <a class="el" href="classSkView.html#a40">SkView</a><li>getBounder() -: <a class="el" href="classSkCanvas.html#a42">SkCanvas</a><li>getColor() -: <a class="el" href="classSkPaint.html#a21">SkPaint</a><li>getColorTable() -: <a class="el" href="classSkBitmap.html#a19">SkBitmap</a><li>getConfig() -: <a class="el" href="classSkBitmap.html#a5">SkBitmap</a><li>GetDeviceConfig() -: <a class="el" href="classSkImageDecoder.html#e4">SkImageDecoder</a><li>getElement() -: <a class="el" href="classSkAnimator.html#a23">SkAnimator</a><li>getElementType() -: <a class="el" href="classSkAnimator.html#a25">SkAnimator</a><li>getFactory() -: <a class="el" href="classSkSumPathEffect.html#a2">SkSumPathEffect</a>, <a class="el" href="classSkComposePathEffect.html#a2">SkComposePathEffect</a>, <a class="el" href="classSkPathEffect.html#a2">SkPathEffect</a>, <a class="el" href="classSkDashPathEffect.html#a3">SkDashPathEffect</a>, <a class="el" href="classSkCornerPathEffect.html#a3">SkCornerPathEffect</a><li>getFast32() -: <a class="el" href="classSkEvent.html#a10">SkEvent</a><li>getField() -: <a class="el" href="classSkAnimator.html#a27">SkAnimator</a><li>getFieldType() -: <a class="el" href="classSkAnimator.html#a29">SkAnimator</a><li>getFillType() -: <a class="el" href="classSkPath.html#a4">SkPath</a><li>getFilterType() -: <a class="el" href="classSkPaint.html#a34">SkPaint</a><li>getFlags() -: <a class="el" href="classSkView.html#a2">SkView</a>, <a class="el" href="classSkShader.html#a4">SkShader</a>, <a class="el" href="classSkLightShader.html#a3">SkLightShader</a>, <a class="el" href="classSkColorTable.html#a2">SkColorTable</a><li>getFormat() -: <a class="el" href="classSkMaskFilter.html#a0">SkMaskFilter</a><li>getIndex8Color() -: <a class="el" href="classSkBitmap.html#a27">SkBitmap</a><li>getInt() -: <a class="el" href="classSkAnimator.html#a35">SkAnimator</a><li>getInterval() -: <a class="el" href="classSkAnimator.html#a30">SkAnimator</a><li>getInvalBounds() -: <a class="el" href="classSkAnimator.html#a31">SkAnimator</a><li>getLastPt() -: <a class="el" href="classSkPath.html#a36">SkPath</a><li>getLayout() -: <a class="el" href="classSkView.html#a42">SkView</a><li>getLocalBounds() -: <a class="el" href="classSkView.html#a16">SkView</a><li>getLocalMatrix() -: <a class="el" href="classSkShader.html#a2">SkShader</a><li>getMaskFilter() -: <a class="el" href="classSkPaint.html#a43">SkPaint</a><li>getMetaData() -: <a class="el" href="classSkEvent.html#a31">SkEvent</a><li>getMSecs() -: <a class="el" href="classSkAnimator_1_1Timeline.html#a0">SkAnimator::Timeline</a><li>getOwnsPixels() -: <a class="el" href="classSkBitmap.html#a17">SkBitmap</a><li>getPaintClearBits() -: <a class="el" href="classSkCanvas.html#a38">SkCanvas</a><li>getPaintSetBits() -: <a class="el" href="classSkCanvas.html#a37">SkCanvas</a><li>getParent() -: <a class="el" href="classSkView.html#a33">SkView</a><li>getParserError() -: <a class="el" href="classSkAnimator.html#a32">SkAnimator</a><li>getParserErrorString() -: <a class="el" href="classSkAnimator.html#a33">SkAnimator</a><li>getPathEffect() -: <a class="el" href="classSkPaint.html#a41">SkPaint</a><li>getPixels() -: <a class="el" href="classSkCanvas.html#a3">SkCanvas</a>, <a class="el" href="classSkBitmap.html#a9">SkBitmap</a><li>getPoints() -: <a class="el" href="classSkPath.html#a9">SkPath</a><li>getRefCnt() -: <a class="el" href="classSkRefCnt.html#a2">SkRefCnt</a><li>getSaveCount() -: <a class="el" href="classSkCanvas.html#a7">SkCanvas</a><li>getScalar() -: <a class="el" href="classSkAnimator.html#a37">SkAnimator</a><li>getShader() -: <a class="el" href="classSkPaint.html#a36">SkPaint</a><li>getSinkID() -: <a class="el" href="classSkEventSink.html#a2">SkEventSink</a><li>getSize() -: <a class="el" href="classSkBitmap.html#a10">SkBitmap</a><li>getString() -: <a class="el" href="classSkAnimator.html#a39">SkAnimator</a><li>getStrokeCap() -: <a class="el" href="classSkPaint.html#a30">SkPaint</a><li>getStrokeJoin() -: <a class="el" href="classSkPaint.html#a32">SkPaint</a><li>getStrokeMiter() -: <a class="el" href="classSkPaint.html#a28">SkPaint</a><li>getStrokeWidth() -: <a class="el" href="classSkPaint.html#a26">SkPaint</a><li>getStyle() -: <a class="el" href="classSkPaint.html#a17">SkPaint</a><li>getText16Path() -: <a class="el" href="classSkPaint.html#a64">SkPaint</a><li>getTextAlign() -: <a class="el" href="classSkPaint.html#a47">SkPaint</a><li>getTextPath() -: <a class="el" href="classSkPaint.html#a63">SkPaint</a><li>getTextScaleX() -: <a class="el" href="classSkPaint.html#a51">SkPaint</a><li>getTextSize() -: <a class="el" href="classSkPaint.html#a49">SkPaint</a><li>getTextSkewX() -: <a class="el" href="classSkPaint.html#a53">SkPaint</a><li>getTextTracking() -: <a class="el" href="classSkPaint.html#a55">SkPaint</a><li>getType() -: <a class="el" href="classSkEvent.html#a5">SkEvent</a><li>getTypeface() -: <a class="el" href="classSkPaint.html#a45">SkPaint</a><li>getURIBase() -: <a class="el" href="classSkAnimator.html#a40">SkAnimator</a><li>getXfermode() -: <a class="el" href="classSkPaint.html#a38">SkPaint</a><li>globalToLocal() -: <a class="el" href="classSkView.html#a39">SkView</a></ul> -<h3><a class="anchor" name="index_h">- h -</a></h3><ul> -<li>handleInval() -: <a class="el" href="classSkView.html#a47">SkView</a><li>hasListeners() -: <a class="el" href="classSkEventSink.html#a8">SkEventSink</a><li>hasPtr() -: <a class="el" href="classSkEvent.html#a21">SkEvent</a><li>hasS32() -: <a class="el" href="classSkEvent.html#a18">SkEvent</a><li>hasScalar() -: <a class="el" href="classSkEvent.html#a19">SkEvent</a><li>hasString() -: <a class="el" href="classSkEvent.html#a20">SkEvent</a><li>height() -: <a class="el" href="classSkView.html#a11">SkView</a>, <a class="el" href="classSkBitmap.html#a7">SkBitmap</a></ul> -<h3><a class="anchor" name="index_i">- i -</a></h3><ul> -<li>inflate() -: <a class="el" href="classSkView.html#a45">SkView</a>, <a class="el" href="classSkEvent.html#a35">SkEvent</a><li>Init() -: <a class="el" href="classSkEvent.html#e1">SkEvent</a><li>initialize() -: <a class="el" href="classSkAnimator.html#a41">SkAnimator</a><li>inval() -: <a class="el" href="classSkView.html#a25">SkView</a><li>invokeLayout() -: <a class="el" href="classSkView.html#a44">SkView</a><li>isAntiAliasOn() -: <a class="el" href="classSkPaint.html#a7">SkPaint</a><li>isCloseLine() -: <a class="el" href="classSkPath_1_1Iter.html#a4">SkPath::Iter</a><li>isEmpty() -: <a class="el" href="classSkPath.html#a7">SkPath</a><li>isFakeBoldTextOn() -: <a class="el" href="classSkPaint.html#a15">SkPaint</a><li>isLinearTextOn() -: <a class="el" href="classSkPaint.html#a9">SkPaint</a><li>isOpaque() -: <a class="el" href="classSkBitmap.html#a11">SkBitmap</a><li>isRect() -: <a class="el" href="classSkPath.html#a8">SkPath</a><li>isStrikeThruTextOn() -: <a class="el" href="classSkPaint.html#a13">SkPaint</a><li>isType() -: <a class="el" href="classSkEvent.html#a7">SkEvent</a><li>isUnderlineTextOn() -: <a class="el" href="classSkPaint.html#a11">SkPaint</a><li>isVisible() -: <a class="el" href="classSkView.html#a4">SkView</a></ul> -<h3><a class="anchor" name="index_j">- j -</a></h3><ul> -<li>Join -: <a class="el" href="classSkPaint.html#w37">SkPaint</a></ul> -<h3><a class="anchor" name="index_k">- k -</a></h3><ul> -<li>k3D_Format -: <a class="el" href="structSkMask.html#w3w2">SkMask</a><li>kA1_Config -: <a class="el" href="classSkBitmap.html#w7w1">SkBitmap</a><li>kA8_Config -: <a class="el" href="classSkBitmap.html#w7w2">SkBitmap</a><li>kA8_Format -: <a class="el" href="structSkMask.html#w3w1">SkMask</a><li>kAntiAlias_Mask -: <a class="el" href="classSkPaint.html#w34w6">SkPaint</a><li>kAntiAlias_Shift -: <a class="el" href="classSkPaint.html#w33w0">SkPaint</a><li>kARGB_8888_Config -: <a class="el" href="classSkBitmap.html#w7w5">SkBitmap</a><li>kBevel_Join -: <a class="el" href="classSkPaint.html#w37w23">SkPaint</a><li>kBilinear_FilterType -: <a class="el" href="classSkPaint.html#w38w27">SkPaint</a><li>kButt_Cap -: <a class="el" href="classSkPaint.html#w36w16">SkPaint</a><li>kBW_Format -: <a class="el" href="structSkMask.html#w3w0">SkMask</a><li>kCCW_Direction -: <a class="el" href="classSkPath.html#w14w5">SkPath</a><li>kClamp_TileMode -: <a class="el" href="classSkShader.html#w8w0">SkShader</a><li>kClose_Verb -: <a class="el" href="classSkPath.html#w15w10">SkPath</a><li>kColorsAreOpaque_Flag -: <a class="el" href="classSkColorTable.html#w1w0">SkColorTable</a><li>kConstAlpha_Flag -: <a class="el" href="classSkShader.html#w9w5">SkShader</a><li>kCubic_Verb -: <a class="el" href="classSkPath.html#w15w9">SkPath</a><li>kCW_Direction -: <a class="el" href="classSkPath.html#w14w4">SkPath</a><li>kDone_Verb -: <a class="el" href="classSkPath.html#w15w11">SkPath</a><li>kEnabled_Mask -: <a class="el" href="classSkView.html#w16w7">SkView</a><li>kEvenOdd_FillType -: <a class="el" href="classSkPath.html#w12w1">SkPath</a><li>kExact_BoundsType -: <a class="el" href="classSkPath.html#w13w3">SkPath</a><li>kFakeBoldText_Mask -: <a class="el" href="classSkPaint.html#w34w10">SkPaint</a><li>kFakeBoldText_Shift -: <a class="el" href="classSkPaint.html#w33w4">SkPaint</a><li>kFast_BoundsType -: <a class="el" href="classSkPath.html#w13w2">SkPath</a><li>kFill_Style -: <a class="el" href="classSkPaint.html#w35w12">SkPaint</a><li>kFlexH_Mask -: <a class="el" href="classSkView.html#w16w9">SkView</a><li>kFlexV_Mask -: <a class="el" href="classSkView.html#w16w10">SkView</a><li>kFocusable_Mask -: <a class="el" href="classSkView.html#w16w8">SkView</a><li>kHandled_EventResult -: <a class="el" href="classSkEventSink.html#w3w0">SkEventSink</a><li>kHasSpan16_Flag -: <a class="el" href="classSkShader.html#w9w6">SkShader</a><li>kIndex8_Config -: <a class="el" href="classSkBitmap.html#w7w3">SkBitmap</a><li>kLine_Verb -: <a class="el" href="classSkPath.html#w15w7">SkPath</a><li>kLinearText_Mask -: <a class="el" href="classSkPaint.html#w34w7">SkPaint</a><li>kLinearText_Shift -: <a class="el" href="classSkPaint.html#w33w1">SkPaint</a><li>kMirror_TileMode -: <a class="el" href="classSkShader.html#w8w2">SkShader</a><li>kMiter_Join -: <a class="el" href="classSkPaint.html#w37w21">SkPaint</a><li>kMove_Verb -: <a class="el" href="classSkPath.html#w15w6">SkPath</a><li>kNo_FilterType -: <a class="el" href="classSkPaint.html#w38w26">SkPaint</a><li>kNotHandled_EventResult -: <a class="el" href="classSkEventSink.html#w3w1">SkEventSink</a><li>kOpaqueAlpha_Flag -: <a class="el" href="classSkShader.html#w9w4">SkShader</a><li>kQuad_Verb -: <a class="el" href="classSkPath.html#w15w8">SkPath</a><li>kRepeat_TileMode -: <a class="el" href="classSkShader.html#w8w1">SkShader</a><li>kRGB_565_Config -: <a class="el" href="classSkBitmap.html#w7w4">SkBitmap</a><li>kRound_Cap -: <a class="el" href="classSkPaint.html#w36w17">SkPaint</a><li>kRound_Join -: <a class="el" href="classSkPaint.html#w37w22">SkPaint</a><li>kSinkNotFound_EventResult -: <a class="el" href="classSkEventSink.html#w3w2">SkEventSink</a><li>kSquare_Cap -: <a class="el" href="classSkPaint.html#w36w18">SkPaint</a><li>kStrikeThruText_Mask -: <a class="el" href="classSkPaint.html#w34w9">SkPaint</a><li>kStrikeThruText_Shift -: <a class="el" href="classSkPaint.html#w33w3">SkPaint</a><li>kStroke_Style -: <a class="el" href="classSkPaint.html#w35w13">SkPaint</a><li>kStrokeAndFill_Style -: <a class="el" href="classSkPaint.html#w35w14">SkPaint</a><li>kUnderlineText_Mask -: <a class="el" href="classSkPaint.html#w34w8">SkPaint</a><li>kUnderlineText_Shift -: <a class="el" href="classSkPaint.html#w33w2">SkPaint</a><li>kVisible_Mask -: <a class="el" href="classSkView.html#w16w6">SkView</a><li>kWinding_FillType -: <a class="el" href="classSkPath.html#w12w0">SkPath</a></ul> -<h3><a class="anchor" name="index_l">- l -</a></h3><ul> -<li>lineTo() -: <a class="el" href="classSkPath.html#a15">SkPath</a><li>lock16BitCache() -: <a class="el" href="classSkColorTable.html#a10">SkColorTable</a><li>lockColors() -: <a class="el" href="classSkColorTable.html#a8">SkColorTable</a><li>locX() -: <a class="el" href="classSkView.html#a17">SkView</a><li>locY() -: <a class="el" href="classSkView.html#a18">SkView</a></ul> -<h3><a class="anchor" name="index_m">- m -</a></h3><ul> -<li>measureText() -: <a class="el" href="classSkPaint.html#a61">SkPaint</a><li>measureText16() -: <a class="el" href="classSkPaint.html#a58">SkPaint</a><li>moveTo() -: <a class="el" href="classSkPath.html#a13">SkPath</a></ul> -<h3><a class="anchor" name="index_o">- o -</a></h3><ul> -<li>offset() -: <a class="el" href="classSkView.html#a23">SkView</a>, <a class="el" href="classSkPath.html#a33">SkPath</a><li>onClick() -: <a class="el" href="classSkView.html#a49">SkView</a><li>onDecode() -: <a class="el" href="classSkImageDecoder.html#b1">SkImageDecoder</a><li>onEvent() -: <a class="el" href="classSkEventSink.html#b0">SkEventSink</a><li>onFindClickHandler() -: <a class="el" href="classSkView.html#a48">SkView</a><li>onInflate() -: <a class="el" href="classSkView.html#a50">SkView</a><li>onIRect() -: <a class="el" href="classSkBounder.html#b0">SkBounder</a><li>onPostInflate() -: <a class="el" href="classSkView.html#a51">SkView</a><li>operator=() -: <a class="el" href="classSkBitmap.html#a3">SkBitmap</a><li>operator[]() -: <a class="el" href="classSkColorTable.html#a5">SkColorTable</a><li>orPaintSetClearBits() -: <a class="el" href="classSkCanvas.html#a40">SkCanvas</a></ul> -<h3><a class="anchor" name="index_p">- p -</a></h3><ul> -<li>post() -: <a class="el" href="classSkEvent.html#a37">SkEvent</a><li>postEvent() -: <a class="el" href="classSkView.html#a32">SkView</a><li>postInflate() -: <a class="el" href="classSkView.html#a46">SkView</a><li>PostTime() -: <a class="el" href="classSkEvent.html#e0">SkEvent</a><li>postToListeners() -: <a class="el" href="classSkEventSink.html#a9">SkEventSink</a><li>ProcessEvent() -: <a class="el" href="classSkEvent.html#e3">SkEvent</a><li>PurgeCacheAll() -: <a class="el" href="classSkBitmapRef.html#e4">SkBitmapRef</a><li>PurgeCacheOne() -: <a class="el" href="classSkBitmapRef.html#e5">SkBitmapRef</a></ul> -<h3><a class="anchor" name="index_q">- q -</a></h3><ul> -<li>quadTo() -: <a class="el" href="classSkPath.html#a17">SkPath</a><li>quickReject() -: <a class="el" href="classSkCanvas.html#a19">SkCanvas</a></ul> -<h3><a class="anchor" name="index_r">- r -</a></h3><ul> -<li>rCubicTo() -: <a class="el" href="classSkPath.html#a20">SkPath</a><li>ref() -: <a class="el" href="classSkRefCnt.html#a3">SkRefCnt</a><li>removeListenerID() -: <a class="el" href="classSkEventSink.html#a7">SkEventSink</a><li>reset() -: <a class="el" href="classSkPath.html#a6">SkPath</a>, <a class="el" href="classSkPaint.html#a4">SkPaint</a>, <a class="el" href="classSkBitmap.html#a13">SkBitmap</a>, <a class="el" href="classSkAnimator.html#a42">SkAnimator</a><li>restore() -: <a class="el" href="classSkCanvas.html#a6">SkCanvas</a><li>restoreToCount() -: <a class="el" href="classSkCanvas.html#a8">SkCanvas</a><li>rLineTo() -: <a class="el" href="classSkPath.html#a16">SkPath</a><li>rMoveTo() -: <a class="el" href="classSkPath.html#a14">SkPath</a><li>rotate() -: <a class="el" href="classSkCanvas.html#a11">SkCanvas</a><li>rowBytes() -: <a class="el" href="classSkBitmap.html#a8">SkBitmap</a><li>rQuadTo() -: <a class="el" href="classSkPath.html#a18">SkPath</a></ul> -<h3><a class="anchor" name="index_s">- s -</a></h3><ul> -<li>safeRef() -: <a class="el" href="classSkRefCnt.html#a5">SkRefCnt</a><li>safeUnref() -: <a class="el" href="classSkRefCnt.html#a6">SkRefCnt</a><li>save() -: <a class="el" href="classSkCanvas.html#a5">SkCanvas</a><li>scale() -: <a class="el" href="classSkCanvas.html#a10">SkCanvas</a><li>sendEventToParents() -: <a class="el" href="classSkView.html#a31">SkView</a><li>ServiceQueueTimer() -: <a class="el" href="classSkEvent.html#e4">SkEvent</a><li>setAlpha() -: <a class="el" href="classSkPaint.html#a24">SkPaint</a><li>setAntiAliasOn() -: <a class="el" href="classSkPaint.html#a8">SkPaint</a><li>setARGB() -: <a class="el" href="classSkPaint.html#a25">SkPaint</a><li>setArtist() -: <a class="el" href="classSkView.html#a41">SkView</a><li>setBounder() -: <a class="el" href="classSkCanvas.html#a43">SkCanvas</a><li>setColor() -: <a class="el" href="classSkPaint.html#a23">SkPaint</a><li>setColors() -: <a class="el" href="classSkColorTable.html#a6">SkColorTable</a><li>setColorTable() -: <a class="el" href="classSkBitmap.html#a20">SkBitmap</a><li>setConfig() -: <a class="el" href="classSkBitmap.html#a14">SkBitmap</a><li>setContext() -: <a class="el" href="classSkShader.html#a5">SkShader</a>, <a class="el" href="classSkLightShader.html#a4">SkLightShader</a><li>SetDeviceConfig() -: <a class="el" href="classSkImageDecoder.html#e5">SkImageDecoder</a><li>setFakeBoldTextOn() -: <a class="el" href="classSkPaint.html#a16">SkPaint</a><li>setFast32() -: <a class="el" href="classSkEvent.html#a11">SkEvent</a><li>setFillType() -: <a class="el" href="classSkPath.html#a5">SkPath</a><li>setFilterType() -: <a class="el" href="classSkPaint.html#a35">SkPaint</a><li>setFlags() -: <a class="el" href="classSkView.html#a3">SkView</a>, <a class="el" href="classSkColorTable.html#a3">SkColorTable</a><li>setHostEventSinkID() -: <a class="el" href="classSkAnimator.html#a51">SkAnimator</a><li>setInt() -: <a class="el" href="classSkAnimator.html#a44">SkAnimator</a><li>setIsOpaque() -: <a class="el" href="classSkBitmap.html#a12">SkBitmap</a><li>setLastPt() -: <a class="el" href="classSkPath.html#a37">SkPath</a><li>setLayout() -: <a class="el" href="classSkView.html#a43">SkView</a><li>setLinearTextOn() -: <a class="el" href="classSkPaint.html#a10">SkPaint</a><li>setLoc() -: <a class="el" href="classSkView.html#a19">SkView</a><li>setLocalMatrix() -: <a class="el" href="classSkShader.html#a3">SkShader</a><li>setMaskFilter() -: <a class="el" href="classSkPaint.html#a44">SkPaint</a><li>setOwnsPixels() -: <a class="el" href="classSkBitmap.html#a18">SkBitmap</a><li>setPaintSetClearBits() -: <a class="el" href="classSkCanvas.html#a39">SkCanvas</a><li>setPathEffect() -: <a class="el" href="classSkPaint.html#a42">SkPaint</a><li>setPixels() -: <a class="el" href="classSkCanvas.html#a4">SkCanvas</a>, <a class="el" href="classSkBitmap.html#a15">SkBitmap</a><li>setPtr() -: <a class="el" href="classSkEvent.html#a28">SkEvent</a><li>setS32() -: <a class="el" href="classSkEvent.html#a23">SkEvent</a><li>setScalar() -: <a class="el" href="classSkEvent.html#a24">SkEvent</a>, <a class="el" href="classSkAnimator.html#a46">SkAnimator</a><li>setScalars() -: <a class="el" href="classSkEvent.html#a25">SkEvent</a><li>setShader() -: <a class="el" href="classSkPaint.html#a37">SkPaint</a><li>setSize() -: <a class="el" href="classSkView.html#a12">SkView</a><li>setStrikeThruTextOn() -: <a class="el" href="classSkPaint.html#a14">SkPaint</a><li>setString() -: <a class="el" href="classSkEvent.html#a27">SkEvent</a>, <a class="el" href="classSkAnimator.html#a48">SkAnimator</a><li>setStrokeCap() -: <a class="el" href="classSkPaint.html#a31">SkPaint</a><li>setStrokeJoin() -: <a class="el" href="classSkPaint.html#a33">SkPaint</a><li>setStrokeMiter() -: <a class="el" href="classSkPaint.html#a29">SkPaint</a><li>setStrokeWidth() -: <a class="el" href="classSkPaint.html#a27">SkPaint</a><li>setStyle() -: <a class="el" href="classSkPaint.html#a18">SkPaint</a><li>setTextAlign() -: <a class="el" href="classSkPaint.html#a48">SkPaint</a><li>setTextScaleX() -: <a class="el" href="classSkPaint.html#a52">SkPaint</a><li>setTextSize() -: <a class="el" href="classSkPaint.html#a50">SkPaint</a><li>setTextSkewX() -: <a class="el" href="classSkPaint.html#a54">SkPaint</a><li>setTextTracking() -: <a class="el" href="classSkPaint.html#a56">SkPaint</a><li>setTimeline() -: <a class="el" href="classSkAnimator.html#a49">SkAnimator</a><li>setType() -: <a class="el" href="classSkEvent.html#a9">SkEvent</a><li>setTypeface() -: <a class="el" href="classSkPaint.html#a46">SkPaint</a><li>setUnderlineTextOn() -: <a class="el" href="classSkPaint.html#a12">SkPaint</a><li>setURIBase() -: <a class="el" href="classSkAnimator.html#a50">SkAnimator</a><li>setVisibleP() -: <a class="el" href="classSkView.html#a7">SkView</a><li>setXfermode() -: <a class="el" href="classSkPaint.html#a39">SkPaint</a><li>shadeSpan() -: <a class="el" href="classSkShader.html#a6">SkShader</a>, <a class="el" href="classSkLightShader.html#a5">SkLightShader</a><li>shadeSpanAlpha() -: <a class="el" href="classSkShader.html#a8">SkShader</a><li>shadeSpanOpaque16() -: <a class="el" href="classSkShader.html#a7">SkShader</a><li>SignalNonEmptyQueue() -: <a class="el" href="classSkEvent.html#e5">SkEvent</a><li>SignalQueueTimer() -: <a class="el" href="classSkEvent.html#e6">SkEvent</a><li>SkBitmap() -: <a class="el" href="classSkBitmap.html#a1">SkBitmap</a><li>SkBitmapRef() -: <a class="el" href="classSkBitmapRef.html#a0">SkBitmapRef</a><li>SkBufferStream() -: <a class="el" href="classSkBufferStream.html#a1">SkBufferStream</a><li>SkColorTable() -: <a class="el" href="classSkColorTable.html#a0">SkColorTable</a><li>SkComposePathEffect() -: <a class="el" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a><li>SkCornerPathEffect() -: <a class="el" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a><li>SkDashPathEffect() -: <a class="el" href="classSkDashPathEffect.html#a0">SkDashPathEffect</a><li>SkDEBUGCODE() -: <a class="el" href="classSkEvent.html#a36">SkEvent</a><li>SkEvent() -: <a class="el" href="classSkEvent.html#a3">SkEvent</a><li>skew() -: <a class="el" href="classSkCanvas.html#a12">SkCanvas</a><li>SkLightShader() -: <a class="el" href="classSkLightShader.html#a1">SkLightShader</a><li>SkRefCnt() -: <a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a><li>SkSumPathEffect() -: <a class="el" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a><li>Style -: <a class="el" href="classSkPaint.html#w35">SkPaint</a><li>subdivide() -: <a class="el" href="classSkPath.html#a41">SkPath</a><li>swap() -: <a class="el" href="classSkString.html#a45">SkString</a>, <a class="el" href="classSkPath.html#a10">SkPath</a>, <a class="el" href="classSkBitmap.html#a4">SkBitmap</a></ul> -<h3><a class="anchor" name="index_t">- t -</a></h3><ul> -<li>Term() -: <a class="el" href="classSkEvent.html#e2">SkEvent</a><li>TileMode -: <a class="el" href="classSkShader.html#w8">SkShader</a><li>transform() -: <a class="el" href="classSkPath.html#a35">SkPath</a><li>translate() -: <a class="el" href="classSkCanvas.html#a9">SkCanvas</a></ul> -<h3><a class="anchor" name="index_u">- u -</a></h3><ul> -<li>unlock16BitCache() -: <a class="el" href="classSkColorTable.html#a11">SkColorTable</a><li>unlockColors() -: <a class="el" href="classSkColorTable.html#a9">SkColorTable</a><li>unref() -: <a class="el" href="classSkRefCnt.html#a4">SkRefCnt</a></ul> -<h3><a class="anchor" name="index_v">- v -</a></h3><ul> -<li>Verb -: <a class="el" href="classSkPath.html#w15">SkPath</a></ul> -<h3><a class="anchor" name="index_w">- w -</a></h3><ul> -<li>width() -: <a class="el" href="classSkView.html#a10">SkView</a>, <a class="el" href="classSkBitmap.html#a6">SkBitmap</a></ul> -<h3><a class="anchor" name="index_~">- ~ -</a></h3><ul> -<li>~SkBitmap() -: <a class="el" href="classSkBitmap.html#a2">SkBitmap</a><li>~SkRefCnt() -: <a class="el" href="classSkRefCnt.html#a1">SkRefCnt</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/functions_enum.html b/sgl_doxygen/html/functions_enum.html deleted file mode 100644 index 4852d4d..0000000 --- a/sgl_doxygen/html/functions_enum.html +++ /dev/null @@ -1,34 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Class Members - Enumerations</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindexHL" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindex" href="functions.html">All</a> | <a class="qindex" href="functions_func.html">Functions</a> | <a class="qindexHL" href="functions_enum.html">Enumerations</a> | <a class="qindex" href="functions_eval.html">Enumeration values</a></div> - -<p> -<ul> -<li>BoundsType -: <a class="el" href="classSkPath.html#w13">SkPath</a><li>Cap -: <a class="el" href="classSkPaint.html#w36">SkPaint</a><li>Config -: <a class="el" href="classSkBitmap.html#w7">SkBitmap</a><li>DifferenceType -: <a class="el" href="classSkAnimator.html#w4">SkAnimator</a><li>Direction -: <a class="el" href="classSkPath.html#w14">SkPath</a><li>EventResult -: <a class="el" href="classSkEventSink.html#w3">SkEventSink</a><li>FillType -: <a class="el" href="classSkPath.html#w12">SkPath</a><li>FilterType -: <a class="el" href="classSkPaint.html#w38">SkPaint</a><li>Flag_Mask -: <a class="el" href="classSkView.html#w16">SkView</a><li>FlagMask -: <a class="el" href="classSkPaint.html#w34">SkPaint</a><li>Flags -: <a class="el" href="classSkShader.html#w9">SkShader</a>, <a class="el" href="classSkColorTable.html#w1">SkColorTable</a><li>FlagShift -: <a class="el" href="classSkPaint.html#w33">SkPaint</a><li>Format -: <a class="el" href="structSkMask.html#w3">SkMask</a><li>Join -: <a class="el" href="classSkPaint.html#w37">SkPaint</a><li>Style -: <a class="el" href="classSkPaint.html#w35">SkPaint</a><li>TileMode -: <a class="el" href="classSkShader.html#w8">SkShader</a><li>Verb -: <a class="el" href="classSkPath.html#w15">SkPath</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/functions_eval.html b/sgl_doxygen/html/functions_eval.html deleted file mode 100644 index ccb6c87..0000000 --- a/sgl_doxygen/html/functions_eval.html +++ /dev/null @@ -1,76 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Class Members - Enumeration values</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindexHL" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindex" href="functions.html">All</a> | <a class="qindex" href="functions_func.html">Functions</a> | <a class="qindex" href="functions_enum.html">Enumerations</a> | <a class="qindexHL" href="functions_eval.html">Enumeration values</a></div> -<div class="qindex"><a class="qindex" href="#index_k">k</a></div> - -<p> - -<p> -<h3><a class="anchor" name="index_k">- k -</a></h3><ul> -<li>k3D_Format -: <a class="el" href="structSkMask.html#w3w2">SkMask</a><li>kA1_Config -: <a class="el" href="classSkBitmap.html#w7w1">SkBitmap</a><li>kA8_Config -: <a class="el" href="classSkBitmap.html#w7w2">SkBitmap</a><li>kA8_Format -: <a class="el" href="structSkMask.html#w3w1">SkMask</a><li>kAntiAlias_Mask -: <a class="el" href="classSkPaint.html#w34w6">SkPaint</a><li>kAntiAlias_Shift -: <a class="el" href="classSkPaint.html#w33w0">SkPaint</a><li>kARGB_8888_Config -: <a class="el" href="classSkBitmap.html#w7w5">SkBitmap</a><li>kBevel_Join -: <a class="el" href="classSkPaint.html#w37w23">SkPaint</a><li>kBilinear_FilterType -: <a class="el" href="classSkPaint.html#w38w27">SkPaint</a><li>kButt_Cap -: <a class="el" href="classSkPaint.html#w36w16">SkPaint</a><li>kBW_Format -: <a class="el" href="structSkMask.html#w3w0">SkMask</a><li>kCCW_Direction -: <a class="el" href="classSkPath.html#w14w5">SkPath</a><li>kClamp_TileMode -: <a class="el" href="classSkShader.html#w8w0">SkShader</a><li>kClose_Verb -: <a class="el" href="classSkPath.html#w15w10">SkPath</a><li>kColorsAreOpaque_Flag -: <a class="el" href="classSkColorTable.html#w1w0">SkColorTable</a><li>kConstAlpha_Flag -: <a class="el" href="classSkShader.html#w9w5">SkShader</a><li>kCubic_Verb -: <a class="el" href="classSkPath.html#w15w9">SkPath</a><li>kCW_Direction -: <a class="el" href="classSkPath.html#w14w4">SkPath</a><li>kDone_Verb -: <a class="el" href="classSkPath.html#w15w11">SkPath</a><li>kEnabled_Mask -: <a class="el" href="classSkView.html#w16w7">SkView</a><li>kEvenOdd_FillType -: <a class="el" href="classSkPath.html#w12w1">SkPath</a><li>kExact_BoundsType -: <a class="el" href="classSkPath.html#w13w3">SkPath</a><li>kFakeBoldText_Mask -: <a class="el" href="classSkPaint.html#w34w10">SkPaint</a><li>kFakeBoldText_Shift -: <a class="el" href="classSkPaint.html#w33w4">SkPaint</a><li>kFast_BoundsType -: <a class="el" href="classSkPath.html#w13w2">SkPath</a><li>kFill_Style -: <a class="el" href="classSkPaint.html#w35w12">SkPaint</a><li>kFlexH_Mask -: <a class="el" href="classSkView.html#w16w9">SkView</a><li>kFlexV_Mask -: <a class="el" href="classSkView.html#w16w10">SkView</a><li>kFocusable_Mask -: <a class="el" href="classSkView.html#w16w8">SkView</a><li>kHandled_EventResult -: <a class="el" href="classSkEventSink.html#w3w0">SkEventSink</a><li>kHasSpan16_Flag -: <a class="el" href="classSkShader.html#w9w6">SkShader</a><li>kIndex8_Config -: <a class="el" href="classSkBitmap.html#w7w3">SkBitmap</a><li>kLine_Verb -: <a class="el" href="classSkPath.html#w15w7">SkPath</a><li>kLinearText_Mask -: <a class="el" href="classSkPaint.html#w34w7">SkPaint</a><li>kLinearText_Shift -: <a class="el" href="classSkPaint.html#w33w1">SkPaint</a><li>kMirror_TileMode -: <a class="el" href="classSkShader.html#w8w2">SkShader</a><li>kMiter_Join -: <a class="el" href="classSkPaint.html#w37w21">SkPaint</a><li>kMove_Verb -: <a class="el" href="classSkPath.html#w15w6">SkPath</a><li>kNo_FilterType -: <a class="el" href="classSkPaint.html#w38w26">SkPaint</a><li>kNotHandled_EventResult -: <a class="el" href="classSkEventSink.html#w3w1">SkEventSink</a><li>kOpaqueAlpha_Flag -: <a class="el" href="classSkShader.html#w9w4">SkShader</a><li>kQuad_Verb -: <a class="el" href="classSkPath.html#w15w8">SkPath</a><li>kRepeat_TileMode -: <a class="el" href="classSkShader.html#w8w1">SkShader</a><li>kRGB_565_Config -: <a class="el" href="classSkBitmap.html#w7w4">SkBitmap</a><li>kRound_Cap -: <a class="el" href="classSkPaint.html#w36w17">SkPaint</a><li>kRound_Join -: <a class="el" href="classSkPaint.html#w37w22">SkPaint</a><li>kSinkNotFound_EventResult -: <a class="el" href="classSkEventSink.html#w3w2">SkEventSink</a><li>kSquare_Cap -: <a class="el" href="classSkPaint.html#w36w18">SkPaint</a><li>kStrikeThruText_Mask -: <a class="el" href="classSkPaint.html#w34w9">SkPaint</a><li>kStrikeThruText_Shift -: <a class="el" href="classSkPaint.html#w33w3">SkPaint</a><li>kStroke_Style -: <a class="el" href="classSkPaint.html#w35w13">SkPaint</a><li>kStrokeAndFill_Style -: <a class="el" href="classSkPaint.html#w35w14">SkPaint</a><li>kUnderlineText_Mask -: <a class="el" href="classSkPaint.html#w34w8">SkPaint</a><li>kUnderlineText_Shift -: <a class="el" href="classSkPaint.html#w33w2">SkPaint</a><li>kVisible_Mask -: <a class="el" href="classSkView.html#w16w6">SkView</a><li>kWinding_FillType -: <a class="el" href="classSkPath.html#w12w0">SkPath</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/functions_func.html b/sgl_doxygen/html/functions_func.html deleted file mode 100644 index 2cc41d5..0000000 --- a/sgl_doxygen/html/functions_func.html +++ /dev/null @@ -1,356 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Class Members - Functions</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindexHL" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindex" href="functions.html">All</a> | <a class="qindexHL" href="functions_func.html">Functions</a> | <a class="qindex" href="functions_enum.html">Enumerations</a> | <a class="qindex" href="functions_eval.html">Enumeration values</a></div> -<div class="qindex"><a class="qindex" href="#index_a">a</a> | <a class="qindex" href="#index_c">c</a> | <a class="qindex" href="#index_d">d</a> | <a class="qindex" href="#index_e">e</a> | <a class="qindex" href="#index_f">f</a> | <a class="qindex" href="#index_g">g</a> | <a class="qindex" href="#index_h">h</a> | <a class="qindex" href="#index_i">i</a> | <a class="qindex" href="#index_l">l</a> | <a class="qindex" href="#index_m">m</a> | <a class="qindex" href="#index_o">o</a> | <a class="qindex" href="#index_p">p</a> | <a class="qindex" href="#index_q">q</a> | <a class="qindex" href="#index_r">r</a> | <a class="qindex" href="#index_s">s</a> | <a class="qindex" href="#index_t">t</a> | <a class="qindex" href="#index_u">u</a> | <a class="qindex" href="#index_w">w</a> | <a class="qindex" href="#index_~">~</a></div> - -<p> - -<p> -<h3><a class="anchor" name="index_a">- a -</a></h3><ul> -<li>addCircle() -: <a class="el" href="classSkPath.html#a28">SkPath</a><li>addExtras() -: <a class="el" href="classSkAnimator.html#a2">SkAnimator</a><li>addListenerID() -: <a class="el" href="classSkEventSink.html#a5">SkEventSink</a><li>addOval() -: <a class="el" href="classSkPath.html#a27">SkPath</a><li>addPath() -: <a class="el" href="classSkPath.html#a32">SkPath</a><li>addRect() -: <a class="el" href="classSkPath.html#a26">SkPath</a><li>addRoundRect() -: <a class="el" href="classSkPath.html#a29">SkPath</a><li>allocPixels() -: <a class="el" href="classSkBitmap.html#a16">SkBitmap</a><li>appendStream() -: <a class="el" href="classSkAnimator.html#a3">SkAnimator</a><li>applyGamma() -: <a class="el" href="classSkBitmap.html#a29">SkBitmap</a><li>ascent() -: <a class="el" href="classSkPaint.html#a59">SkPaint</a><li>attachChildToBack() -: <a class="el" href="classSkView.html#a35">SkView</a></ul> -<h3><a class="anchor" name="index_c">- c -</a></h3><ul> -<li>canCallShadeSpanOpaque16() -: <a class="el" href="classSkShader.html#a9">SkShader</a><li>CanCallShadeSpanOpaque16() -: <a class="el" href="classSkShader.html#e0">SkShader</a><li>clipDeviceRgn() -: <a class="el" href="classSkCanvas.html#a41">SkCanvas</a><li>clipPath() -: <a class="el" href="classSkCanvas.html#a16">SkCanvas</a><li>clipRect() -: <a class="el" href="classSkCanvas.html#a15">SkCanvas</a><li>close() -: <a class="el" href="classSkPath.html#a21">SkPath</a><li>commit() -: <a class="el" href="classSkBounder.html#b1">SkBounder</a><li>computeBounds() -: <a class="el" href="classSkPath.html#a11">SkPath</a><li>computeImageSize() -: <a class="el" href="structSkMask.html#a0">SkMask</a><li>computeTotalImageSize() -: <a class="el" href="structSkMask.html#a1">SkMask</a><li>concat() -: <a class="el" href="classSkCanvas.html#a13">SkCanvas</a><li>copyListeners() -: <a class="el" href="classSkEventSink.html#a6">SkEventSink</a><li>count() -: <a class="el" href="classSkColorTable.html#a4">SkColorTable</a><li>CreateBitmapShader() -: <a class="el" href="classSkShader.html#e1">SkShader</a><li>CreateLinear() -: <a class="el" href="classSkGradientShader.html#e0">SkGradientShader</a><li>CreateRadial() -: <a class="el" href="classSkGradientShader.html#e1">SkGradientShader</a><li>CreateScalarContext() -: <a class="el" href="classSkFontHost.html#e2">SkFontHost</a><li>CreateTypeface() -: <a class="el" href="classSkFontHost.html#e0">SkFontHost</a><li>cubicTo() -: <a class="el" href="classSkPath.html#a19">SkPath</a></ul> -<h3><a class="anchor" name="index_d">- d -</a></h3><ul> -<li>decodeDOM() -: <a class="el" href="classSkAnimator.html#a6">SkAnimator</a><li>DecodeFile() -: <a class="el" href="classSkImageDecoder.html#e0">SkImageDecoder</a><li>decodeMemory() -: <a class="el" href="classSkAnimator.html#a4">SkAnimator</a><li>DecodeMemory() -: <a class="el" href="classSkImageDecoder.html#e1">SkImageDecoder</a><li>decodeStream() -: <a class="el" href="classSkAnimator.html#a5">SkAnimator</a><li>DecodeStream() -: <a class="el" href="classSkImageDecoder.html#e2">SkImageDecoder</a><li>decodeURI() -: <a class="el" href="classSkAnimator.html#a7">SkAnimator</a><li>DecodeURL() -: <a class="el" href="classSkImageDecoder.html#e3">SkImageDecoder</a><li>detachAllChildren() -: <a class="el" href="classSkView.html#a37">SkView</a><li>detachFromParent() -: <a class="el" href="classSkView.html#a36">SkView</a><li>doCharEvent() -: <a class="el" href="classSkAnimator.html#a8">SkAnimator</a><li>doClickEvent() -: <a class="el" href="classSkAnimator.html#a9">SkAnimator</a><li>doEvent() -: <a class="el" href="classSkEventSink.html#a3">SkEventSink</a><li>DoEvent() -: <a class="el" href="classSkEventSink.html#e0">SkEventSink</a><li>doKeyEvent() -: <a class="el" href="classSkAnimator.html#a10">SkAnimator</a><li>doQuery() -: <a class="el" href="classSkEventSink.html#a4">SkEventSink</a><li>doUserEvent() -: <a class="el" href="classSkAnimator.html#a12">SkAnimator</a><li>draw() -: <a class="el" href="classSkView.html#a24">SkView</a>, <a class="el" href="classSkAnimator.html#a14">SkAnimator</a><li>drawARGB() -: <a class="el" href="classSkCanvas.html#a21">SkCanvas</a><li>drawBitmap() -: <a class="el" href="classSkCanvas.html#a32">SkCanvas</a><li>drawCircle() -: <a class="el" href="classSkCanvas.html#a28">SkCanvas</a><li>drawColor() -: <a class="el" href="classSkCanvas.html#a22">SkCanvas</a><li>drawLine() -: <a class="el" href="classSkCanvas.html#a25">SkCanvas</a><li>drawOval() -: <a class="el" href="classSkCanvas.html#a27">SkCanvas</a><li>drawPaint() -: <a class="el" href="classSkCanvas.html#a23">SkCanvas</a><li>drawPath() -: <a class="el" href="classSkCanvas.html#a30">SkCanvas</a><li>drawRect() -: <a class="el" href="classSkCanvas.html#a26">SkCanvas</a><li>drawRGB() -: <a class="el" href="classSkCanvas.html#a20">SkCanvas</a><li>drawRoundRect() -: <a class="el" href="classSkCanvas.html#a29">SkCanvas</a><li>drawText() -: <a class="el" href="classSkCanvas.html#a33">SkCanvas</a><li>drawText16() -: <a class="el" href="classSkCanvas.html#a34">SkCanvas</a><li>drawText16OnPath() -: <a class="el" href="classSkCanvas.html#a36">SkCanvas</a><li>drawTextOnPath() -: <a class="el" href="classSkCanvas.html#a35">SkCanvas</a></ul> -<h3><a class="anchor" name="index_e">- e -</a></h3><ul> -<li>eraseARGB() -: <a class="el" href="classSkBitmap.html#a21">SkBitmap</a><li>eraseColor() -: <a class="el" href="classSkBitmap.html#a23">SkBitmap</a><li>eraseRGB() -: <a class="el" href="classSkBitmap.html#a22">SkBitmap</a></ul> -<h3><a class="anchor" name="index_f">- f -</a></h3><ul> -<li>filterMask() -: <a class="el" href="classSkMaskFilter.html#a1">SkMaskFilter</a><li>filterPath() -: <a class="el" href="classSkSumPathEffect.html#a1">SkSumPathEffect</a>, <a class="el" href="classSkComposePathEffect.html#a1">SkComposePathEffect</a>, <a class="el" href="classSkPathEffect.html#a1">SkPathEffect</a>, <a class="el" href="classSkMaskFilter.html#a2">SkMaskFilter</a>, <a class="el" href="classSkDashPathEffect.html#a2">SkDashPathEffect</a>, <a class="el" href="classSkCornerPathEffect.html#a2">SkCornerPathEffect</a><li>findClickEvent() -: <a class="el" href="classSkAnimator.html#a15">SkAnimator</a><li>findPtr() -: <a class="el" href="classSkEvent.html#a16">SkEvent</a><li>findS32() -: <a class="el" href="classSkEvent.html#a12">SkEvent</a><li>findScalar() -: <a class="el" href="classSkEvent.html#a13">SkEvent</a><li>findScalars() -: <a class="el" href="classSkEvent.html#a14">SkEvent</a><li>FindSink() -: <a class="el" href="classSkEventSink.html#e1">SkEventSink</a><li>findString() -: <a class="el" href="classSkEvent.html#a15">SkEvent</a><li>flatten() -: <a class="el" href="classSkPath.html#a39">SkPath</a><li>FlattenTypeface() -: <a class="el" href="classSkFontHost.html#e1">SkFontHost</a></ul> -<h3><a class="anchor" name="index_g">- g -</a></h3><ul> -<li>getAddr() -: <a class="el" href="structSkMask.html#a3">SkMask</a><li>getAddr1() -: <a class="el" href="structSkMask.html#a2">SkMask</a>, <a class="el" href="classSkBitmap.html#a28">SkBitmap</a><li>getAddr16() -: <a class="el" href="classSkBitmap.html#a25">SkBitmap</a><li>getAddr32() -: <a class="el" href="classSkBitmap.html#a24">SkBitmap</a><li>getAddr8() -: <a class="el" href="classSkBitmap.html#a26">SkBitmap</a><li>getAlpha() -: <a class="el" href="classSkPaint.html#a22">SkPaint</a><li>getAnimator() -: <a class="el" href="classSkAnimator.html#a16">SkAnimator</a><li>getArrayInt() -: <a class="el" href="classSkAnimator.html#a18">SkAnimator</a><li>getArrayScalar() -: <a class="el" href="classSkAnimator.html#a20">SkAnimator</a><li>getArrayString() -: <a class="el" href="classSkAnimator.html#a22">SkAnimator</a><li>getArtist() -: <a class="el" href="classSkView.html#a40">SkView</a><li>getBounder() -: <a class="el" href="classSkCanvas.html#a42">SkCanvas</a><li>getColor() -: <a class="el" href="classSkPaint.html#a21">SkPaint</a><li>getColorTable() -: <a class="el" href="classSkBitmap.html#a19">SkBitmap</a><li>getConfig() -: <a class="el" href="classSkBitmap.html#a5">SkBitmap</a><li>GetDeviceConfig() -: <a class="el" href="classSkImageDecoder.html#e4">SkImageDecoder</a><li>getElement() -: <a class="el" href="classSkAnimator.html#a23">SkAnimator</a><li>getElementType() -: <a class="el" href="classSkAnimator.html#a25">SkAnimator</a><li>getFactory() -: <a class="el" href="classSkSumPathEffect.html#a2">SkSumPathEffect</a>, <a class="el" href="classSkComposePathEffect.html#a2">SkComposePathEffect</a>, <a class="el" href="classSkPathEffect.html#a2">SkPathEffect</a>, <a class="el" href="classSkDashPathEffect.html#a3">SkDashPathEffect</a>, <a class="el" href="classSkCornerPathEffect.html#a3">SkCornerPathEffect</a><li>getFast32() -: <a class="el" href="classSkEvent.html#a10">SkEvent</a><li>getField() -: <a class="el" href="classSkAnimator.html#a27">SkAnimator</a><li>getFieldType() -: <a class="el" href="classSkAnimator.html#a29">SkAnimator</a><li>getFillType() -: <a class="el" href="classSkPath.html#a4">SkPath</a><li>getFilterType() -: <a class="el" href="classSkPaint.html#a34">SkPaint</a><li>getFlags() -: <a class="el" href="classSkView.html#a2">SkView</a>, <a class="el" href="classSkShader.html#a4">SkShader</a>, <a class="el" href="classSkLightShader.html#a3">SkLightShader</a>, <a class="el" href="classSkColorTable.html#a2">SkColorTable</a><li>getFormat() -: <a class="el" href="classSkMaskFilter.html#a0">SkMaskFilter</a><li>getIndex8Color() -: <a class="el" href="classSkBitmap.html#a27">SkBitmap</a><li>getInt() -: <a class="el" href="classSkAnimator.html#a35">SkAnimator</a><li>getInterval() -: <a class="el" href="classSkAnimator.html#a30">SkAnimator</a><li>getInvalBounds() -: <a class="el" href="classSkAnimator.html#a31">SkAnimator</a><li>getLastPt() -: <a class="el" href="classSkPath.html#a36">SkPath</a><li>getLayout() -: <a class="el" href="classSkView.html#a42">SkView</a><li>getLocalBounds() -: <a class="el" href="classSkView.html#a16">SkView</a><li>getLocalMatrix() -: <a class="el" href="classSkShader.html#a2">SkShader</a><li>getMaskFilter() -: <a class="el" href="classSkPaint.html#a43">SkPaint</a><li>getMetaData() -: <a class="el" href="classSkEvent.html#a31">SkEvent</a><li>getMSecs() -: <a class="el" href="classSkAnimator_1_1Timeline.html#a0">SkAnimator::Timeline</a><li>getOwnsPixels() -: <a class="el" href="classSkBitmap.html#a17">SkBitmap</a><li>getPaintClearBits() -: <a class="el" href="classSkCanvas.html#a38">SkCanvas</a><li>getPaintSetBits() -: <a class="el" href="classSkCanvas.html#a37">SkCanvas</a><li>getParent() -: <a class="el" href="classSkView.html#a33">SkView</a><li>getParserError() -: <a class="el" href="classSkAnimator.html#a32">SkAnimator</a><li>getParserErrorString() -: <a class="el" href="classSkAnimator.html#a33">SkAnimator</a><li>getPathEffect() -: <a class="el" href="classSkPaint.html#a41">SkPaint</a><li>getPixels() -: <a class="el" href="classSkCanvas.html#a3">SkCanvas</a>, <a class="el" href="classSkBitmap.html#a9">SkBitmap</a><li>getPoints() -: <a class="el" href="classSkPath.html#a9">SkPath</a><li>getRefCnt() -: <a class="el" href="classSkRefCnt.html#a2">SkRefCnt</a><li>getSaveCount() -: <a class="el" href="classSkCanvas.html#a7">SkCanvas</a><li>getScalar() -: <a class="el" href="classSkAnimator.html#a37">SkAnimator</a><li>getShader() -: <a class="el" href="classSkPaint.html#a36">SkPaint</a><li>getSinkID() -: <a class="el" href="classSkEventSink.html#a2">SkEventSink</a><li>getSize() -: <a class="el" href="classSkBitmap.html#a10">SkBitmap</a><li>getString() -: <a class="el" href="classSkAnimator.html#a39">SkAnimator</a><li>getStrokeCap() -: <a class="el" href="classSkPaint.html#a30">SkPaint</a><li>getStrokeJoin() -: <a class="el" href="classSkPaint.html#a32">SkPaint</a><li>getStrokeMiter() -: <a class="el" href="classSkPaint.html#a28">SkPaint</a><li>getStrokeWidth() -: <a class="el" href="classSkPaint.html#a26">SkPaint</a><li>getStyle() -: <a class="el" href="classSkPaint.html#a17">SkPaint</a><li>getText16Path() -: <a class="el" href="classSkPaint.html#a64">SkPaint</a><li>getTextAlign() -: <a class="el" href="classSkPaint.html#a47">SkPaint</a><li>getTextPath() -: <a class="el" href="classSkPaint.html#a63">SkPaint</a><li>getTextScaleX() -: <a class="el" href="classSkPaint.html#a51">SkPaint</a><li>getTextSize() -: <a class="el" href="classSkPaint.html#a49">SkPaint</a><li>getTextSkewX() -: <a class="el" href="classSkPaint.html#a53">SkPaint</a><li>getTextTracking() -: <a class="el" href="classSkPaint.html#a55">SkPaint</a><li>getType() -: <a class="el" href="classSkEvent.html#a5">SkEvent</a><li>getTypeface() -: <a class="el" href="classSkPaint.html#a45">SkPaint</a><li>getURIBase() -: <a class="el" href="classSkAnimator.html#a40">SkAnimator</a><li>getXfermode() -: <a class="el" href="classSkPaint.html#a38">SkPaint</a><li>globalToLocal() -: <a class="el" href="classSkView.html#a39">SkView</a></ul> -<h3><a class="anchor" name="index_h">- h -</a></h3><ul> -<li>handleInval() -: <a class="el" href="classSkView.html#a47">SkView</a><li>hasListeners() -: <a class="el" href="classSkEventSink.html#a8">SkEventSink</a><li>hasPtr() -: <a class="el" href="classSkEvent.html#a21">SkEvent</a><li>hasS32() -: <a class="el" href="classSkEvent.html#a18">SkEvent</a><li>hasScalar() -: <a class="el" href="classSkEvent.html#a19">SkEvent</a><li>hasString() -: <a class="el" href="classSkEvent.html#a20">SkEvent</a><li>height() -: <a class="el" href="classSkView.html#a11">SkView</a>, <a class="el" href="classSkBitmap.html#a7">SkBitmap</a></ul> -<h3><a class="anchor" name="index_i">- i -</a></h3><ul> -<li>inflate() -: <a class="el" href="classSkView.html#a45">SkView</a>, <a class="el" href="classSkEvent.html#a35">SkEvent</a><li>Init() -: <a class="el" href="classSkEvent.html#e1">SkEvent</a><li>initialize() -: <a class="el" href="classSkAnimator.html#a41">SkAnimator</a><li>inval() -: <a class="el" href="classSkView.html#a25">SkView</a><li>invokeLayout() -: <a class="el" href="classSkView.html#a44">SkView</a><li>isAntiAliasOn() -: <a class="el" href="classSkPaint.html#a7">SkPaint</a><li>isCloseLine() -: <a class="el" href="classSkPath_1_1Iter.html#a4">SkPath::Iter</a><li>isEmpty() -: <a class="el" href="classSkPath.html#a7">SkPath</a><li>isFakeBoldTextOn() -: <a class="el" href="classSkPaint.html#a15">SkPaint</a><li>isLinearTextOn() -: <a class="el" href="classSkPaint.html#a9">SkPaint</a><li>isOpaque() -: <a class="el" href="classSkBitmap.html#a11">SkBitmap</a><li>isRect() -: <a class="el" href="classSkPath.html#a8">SkPath</a><li>isStrikeThruTextOn() -: <a class="el" href="classSkPaint.html#a13">SkPaint</a><li>isType() -: <a class="el" href="classSkEvent.html#a7">SkEvent</a><li>isUnderlineTextOn() -: <a class="el" href="classSkPaint.html#a11">SkPaint</a><li>isVisible() -: <a class="el" href="classSkView.html#a4">SkView</a></ul> -<h3><a class="anchor" name="index_l">- l -</a></h3><ul> -<li>lineTo() -: <a class="el" href="classSkPath.html#a15">SkPath</a><li>lock16BitCache() -: <a class="el" href="classSkColorTable.html#a10">SkColorTable</a><li>lockColors() -: <a class="el" href="classSkColorTable.html#a8">SkColorTable</a><li>locX() -: <a class="el" href="classSkView.html#a17">SkView</a><li>locY() -: <a class="el" href="classSkView.html#a18">SkView</a></ul> -<h3><a class="anchor" name="index_m">- m -</a></h3><ul> -<li>measureText() -: <a class="el" href="classSkPaint.html#a61">SkPaint</a><li>measureText16() -: <a class="el" href="classSkPaint.html#a58">SkPaint</a><li>moveTo() -: <a class="el" href="classSkPath.html#a13">SkPath</a></ul> -<h3><a class="anchor" name="index_o">- o -</a></h3><ul> -<li>offset() -: <a class="el" href="classSkView.html#a23">SkView</a>, <a class="el" href="classSkPath.html#a33">SkPath</a><li>onClick() -: <a class="el" href="classSkView.html#a49">SkView</a><li>onDecode() -: <a class="el" href="classSkImageDecoder.html#b1">SkImageDecoder</a><li>onEvent() -: <a class="el" href="classSkEventSink.html#b0">SkEventSink</a><li>onFindClickHandler() -: <a class="el" href="classSkView.html#a48">SkView</a><li>onInflate() -: <a class="el" href="classSkView.html#a50">SkView</a><li>onIRect() -: <a class="el" href="classSkBounder.html#b0">SkBounder</a><li>onPostInflate() -: <a class="el" href="classSkView.html#a51">SkView</a><li>operator=() -: <a class="el" href="classSkBitmap.html#a3">SkBitmap</a><li>operator[]() -: <a class="el" href="classSkColorTable.html#a5">SkColorTable</a><li>orPaintSetClearBits() -: <a class="el" href="classSkCanvas.html#a40">SkCanvas</a></ul> -<h3><a class="anchor" name="index_p">- p -</a></h3><ul> -<li>post() -: <a class="el" href="classSkEvent.html#a37">SkEvent</a><li>postEvent() -: <a class="el" href="classSkView.html#a32">SkView</a><li>postInflate() -: <a class="el" href="classSkView.html#a46">SkView</a><li>PostTime() -: <a class="el" href="classSkEvent.html#e0">SkEvent</a><li>postToListeners() -: <a class="el" href="classSkEventSink.html#a9">SkEventSink</a><li>ProcessEvent() -: <a class="el" href="classSkEvent.html#e3">SkEvent</a><li>PurgeCacheAll() -: <a class="el" href="classSkBitmapRef.html#e4">SkBitmapRef</a><li>PurgeCacheOne() -: <a class="el" href="classSkBitmapRef.html#e5">SkBitmapRef</a></ul> -<h3><a class="anchor" name="index_q">- q -</a></h3><ul> -<li>quadTo() -: <a class="el" href="classSkPath.html#a17">SkPath</a><li>quickReject() -: <a class="el" href="classSkCanvas.html#a19">SkCanvas</a></ul> -<h3><a class="anchor" name="index_r">- r -</a></h3><ul> -<li>rCubicTo() -: <a class="el" href="classSkPath.html#a20">SkPath</a><li>ref() -: <a class="el" href="classSkRefCnt.html#a3">SkRefCnt</a><li>removeListenerID() -: <a class="el" href="classSkEventSink.html#a7">SkEventSink</a><li>reset() -: <a class="el" href="classSkPath.html#a6">SkPath</a>, <a class="el" href="classSkPaint.html#a4">SkPaint</a>, <a class="el" href="classSkBitmap.html#a13">SkBitmap</a>, <a class="el" href="classSkAnimator.html#a42">SkAnimator</a><li>restore() -: <a class="el" href="classSkCanvas.html#a6">SkCanvas</a><li>restoreToCount() -: <a class="el" href="classSkCanvas.html#a8">SkCanvas</a><li>rLineTo() -: <a class="el" href="classSkPath.html#a16">SkPath</a><li>rMoveTo() -: <a class="el" href="classSkPath.html#a14">SkPath</a><li>rotate() -: <a class="el" href="classSkCanvas.html#a11">SkCanvas</a><li>rowBytes() -: <a class="el" href="classSkBitmap.html#a8">SkBitmap</a><li>rQuadTo() -: <a class="el" href="classSkPath.html#a18">SkPath</a></ul> -<h3><a class="anchor" name="index_s">- s -</a></h3><ul> -<li>safeRef() -: <a class="el" href="classSkRefCnt.html#a5">SkRefCnt</a><li>safeUnref() -: <a class="el" href="classSkRefCnt.html#a6">SkRefCnt</a><li>save() -: <a class="el" href="classSkCanvas.html#a5">SkCanvas</a><li>scale() -: <a class="el" href="classSkCanvas.html#a10">SkCanvas</a><li>sendEventToParents() -: <a class="el" href="classSkView.html#a31">SkView</a><li>ServiceQueueTimer() -: <a class="el" href="classSkEvent.html#e4">SkEvent</a><li>setAlpha() -: <a class="el" href="classSkPaint.html#a24">SkPaint</a><li>setAntiAliasOn() -: <a class="el" href="classSkPaint.html#a8">SkPaint</a><li>setARGB() -: <a class="el" href="classSkPaint.html#a25">SkPaint</a><li>setArtist() -: <a class="el" href="classSkView.html#a41">SkView</a><li>setBounder() -: <a class="el" href="classSkCanvas.html#a43">SkCanvas</a><li>setColor() -: <a class="el" href="classSkPaint.html#a23">SkPaint</a><li>setColors() -: <a class="el" href="classSkColorTable.html#a6">SkColorTable</a><li>setColorTable() -: <a class="el" href="classSkBitmap.html#a20">SkBitmap</a><li>setConfig() -: <a class="el" href="classSkBitmap.html#a14">SkBitmap</a><li>setContext() -: <a class="el" href="classSkShader.html#a5">SkShader</a>, <a class="el" href="classSkLightShader.html#a4">SkLightShader</a><li>SetDeviceConfig() -: <a class="el" href="classSkImageDecoder.html#e5">SkImageDecoder</a><li>setFakeBoldTextOn() -: <a class="el" href="classSkPaint.html#a16">SkPaint</a><li>setFast32() -: <a class="el" href="classSkEvent.html#a11">SkEvent</a><li>setFillType() -: <a class="el" href="classSkPath.html#a5">SkPath</a><li>setFilterType() -: <a class="el" href="classSkPaint.html#a35">SkPaint</a><li>setFlags() -: <a class="el" href="classSkView.html#a3">SkView</a>, <a class="el" href="classSkColorTable.html#a3">SkColorTable</a><li>setHostEventSinkID() -: <a class="el" href="classSkAnimator.html#a51">SkAnimator</a><li>setInt() -: <a class="el" href="classSkAnimator.html#a44">SkAnimator</a><li>setIsOpaque() -: <a class="el" href="classSkBitmap.html#a12">SkBitmap</a><li>setLastPt() -: <a class="el" href="classSkPath.html#a37">SkPath</a><li>setLayout() -: <a class="el" href="classSkView.html#a43">SkView</a><li>setLinearTextOn() -: <a class="el" href="classSkPaint.html#a10">SkPaint</a><li>setLoc() -: <a class="el" href="classSkView.html#a19">SkView</a><li>setLocalMatrix() -: <a class="el" href="classSkShader.html#a3">SkShader</a><li>setMaskFilter() -: <a class="el" href="classSkPaint.html#a44">SkPaint</a><li>setOwnsPixels() -: <a class="el" href="classSkBitmap.html#a18">SkBitmap</a><li>setPaintSetClearBits() -: <a class="el" href="classSkCanvas.html#a39">SkCanvas</a><li>setPathEffect() -: <a class="el" href="classSkPaint.html#a42">SkPaint</a><li>setPixels() -: <a class="el" href="classSkCanvas.html#a4">SkCanvas</a>, <a class="el" href="classSkBitmap.html#a15">SkBitmap</a><li>setPtr() -: <a class="el" href="classSkEvent.html#a28">SkEvent</a><li>setS32() -: <a class="el" href="classSkEvent.html#a23">SkEvent</a><li>setScalar() -: <a class="el" href="classSkEvent.html#a24">SkEvent</a>, <a class="el" href="classSkAnimator.html#a46">SkAnimator</a><li>setScalars() -: <a class="el" href="classSkEvent.html#a25">SkEvent</a><li>setShader() -: <a class="el" href="classSkPaint.html#a37">SkPaint</a><li>setSize() -: <a class="el" href="classSkView.html#a12">SkView</a><li>setStrikeThruTextOn() -: <a class="el" href="classSkPaint.html#a14">SkPaint</a><li>setString() -: <a class="el" href="classSkEvent.html#a27">SkEvent</a>, <a class="el" href="classSkAnimator.html#a48">SkAnimator</a><li>setStrokeCap() -: <a class="el" href="classSkPaint.html#a31">SkPaint</a><li>setStrokeJoin() -: <a class="el" href="classSkPaint.html#a33">SkPaint</a><li>setStrokeMiter() -: <a class="el" href="classSkPaint.html#a29">SkPaint</a><li>setStrokeWidth() -: <a class="el" href="classSkPaint.html#a27">SkPaint</a><li>setStyle() -: <a class="el" href="classSkPaint.html#a18">SkPaint</a><li>setTextAlign() -: <a class="el" href="classSkPaint.html#a48">SkPaint</a><li>setTextScaleX() -: <a class="el" href="classSkPaint.html#a52">SkPaint</a><li>setTextSize() -: <a class="el" href="classSkPaint.html#a50">SkPaint</a><li>setTextSkewX() -: <a class="el" href="classSkPaint.html#a54">SkPaint</a><li>setTextTracking() -: <a class="el" href="classSkPaint.html#a56">SkPaint</a><li>setTimeline() -: <a class="el" href="classSkAnimator.html#a49">SkAnimator</a><li>setType() -: <a class="el" href="classSkEvent.html#a9">SkEvent</a><li>setTypeface() -: <a class="el" href="classSkPaint.html#a46">SkPaint</a><li>setUnderlineTextOn() -: <a class="el" href="classSkPaint.html#a12">SkPaint</a><li>setURIBase() -: <a class="el" href="classSkAnimator.html#a50">SkAnimator</a><li>setVisibleP() -: <a class="el" href="classSkView.html#a7">SkView</a><li>setXfermode() -: <a class="el" href="classSkPaint.html#a39">SkPaint</a><li>shadeSpan() -: <a class="el" href="classSkShader.html#a6">SkShader</a>, <a class="el" href="classSkLightShader.html#a5">SkLightShader</a><li>shadeSpanAlpha() -: <a class="el" href="classSkShader.html#a8">SkShader</a><li>shadeSpanOpaque16() -: <a class="el" href="classSkShader.html#a7">SkShader</a><li>SignalNonEmptyQueue() -: <a class="el" href="classSkEvent.html#e5">SkEvent</a><li>SignalQueueTimer() -: <a class="el" href="classSkEvent.html#e6">SkEvent</a><li>SkBitmap() -: <a class="el" href="classSkBitmap.html#a1">SkBitmap</a><li>SkBitmapRef() -: <a class="el" href="classSkBitmapRef.html#a0">SkBitmapRef</a><li>SkBufferStream() -: <a class="el" href="classSkBufferStream.html#a1">SkBufferStream</a><li>SkColorTable() -: <a class="el" href="classSkColorTable.html#a0">SkColorTable</a><li>SkComposePathEffect() -: <a class="el" href="classSkComposePathEffect.html#a0">SkComposePathEffect</a><li>SkCornerPathEffect() -: <a class="el" href="classSkCornerPathEffect.html#a0">SkCornerPathEffect</a><li>SkDashPathEffect() -: <a class="el" href="classSkDashPathEffect.html#a0">SkDashPathEffect</a><li>SkDEBUGCODE() -: <a class="el" href="classSkEvent.html#a36">SkEvent</a><li>SkEvent() -: <a class="el" href="classSkEvent.html#a3">SkEvent</a><li>skew() -: <a class="el" href="classSkCanvas.html#a12">SkCanvas</a><li>SkLightShader() -: <a class="el" href="classSkLightShader.html#a1">SkLightShader</a><li>SkRefCnt() -: <a class="el" href="classSkRefCnt.html#a0">SkRefCnt</a><li>SkSumPathEffect() -: <a class="el" href="classSkSumPathEffect.html#a0">SkSumPathEffect</a><li>subdivide() -: <a class="el" href="classSkPath.html#a41">SkPath</a><li>swap() -: <a class="el" href="classSkString.html#a45">SkString</a>, <a class="el" href="classSkPath.html#a10">SkPath</a>, <a class="el" href="classSkBitmap.html#a4">SkBitmap</a></ul> -<h3><a class="anchor" name="index_t">- t -</a></h3><ul> -<li>Term() -: <a class="el" href="classSkEvent.html#e2">SkEvent</a><li>transform() -: <a class="el" href="classSkPath.html#a35">SkPath</a><li>translate() -: <a class="el" href="classSkCanvas.html#a9">SkCanvas</a></ul> -<h3><a class="anchor" name="index_u">- u -</a></h3><ul> -<li>unlock16BitCache() -: <a class="el" href="classSkColorTable.html#a11">SkColorTable</a><li>unlockColors() -: <a class="el" href="classSkColorTable.html#a9">SkColorTable</a><li>unref() -: <a class="el" href="classSkRefCnt.html#a4">SkRefCnt</a></ul> -<h3><a class="anchor" name="index_w">- w -</a></h3><ul> -<li>width() -: <a class="el" href="classSkView.html#a10">SkView</a>, <a class="el" href="classSkBitmap.html#a6">SkBitmap</a></ul> -<h3><a class="anchor" name="index_~">- ~ -</a></h3><ul> -<li>~SkBitmap() -: <a class="el" href="classSkBitmap.html#a2">SkBitmap</a><li>~SkRefCnt() -: <a class="el" href="classSkRefCnt.html#a1">SkRefCnt</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/globals.html b/sgl_doxygen/html/globals.html deleted file mode 100644 index 34f95bb..0000000 --- a/sgl_doxygen/html/globals.html +++ /dev/null @@ -1,39 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: File Members</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindexHL" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindexHL" href="globals.html">All</a> | <a class="qindex" href="globals_func.html">Functions</a> | <a class="qindex" href="globals_type.html">Typedefs</a> | <a class="qindex" href="globals_defs.html">Defines</a></div> - -<p> -Here is a list of all documented file members with links to the documentation:<ul> -<li>SK_ColorBLACK -: <a class="el" href="SkColor_8h.html#a5">SkColor.h</a><li>SK_ColorBLUE -: <a class="el" href="SkColor_8h.html#a12">SkColor.h</a><li>SK_ColorCYAN -: <a class="el" href="SkColor_8h.html#a14">SkColor.h</a><li>SK_ColorDKGRAY -: <a class="el" href="SkColor_8h.html#a6">SkColor.h</a><li>SK_ColorGRAY -: <a class="el" href="SkColor_8h.html#a7">SkColor.h</a><li>SK_ColorGREEN -: <a class="el" href="SkColor_8h.html#a11">SkColor.h</a><li>SK_ColorLTGRAY -: <a class="el" href="SkColor_8h.html#a8">SkColor.h</a><li>SK_ColorMAGENTA -: <a class="el" href="SkColor_8h.html#a15">SkColor.h</a><li>SK_ColorRED -: <a class="el" href="SkColor_8h.html#a10">SkColor.h</a><li>SK_ColorWHITE -: <a class="el" href="SkColor_8h.html#a9">SkColor.h</a><li>SK_ColorYELLOW -: <a class="el" href="SkColor_8h.html#a13">SkColor.h</a><li>SkAlpha -: <a class="el" href="SkColor_8h.html#a16">SkColor.h</a><li>SkColor -: <a class="el" href="SkColor_8h.html#a17">SkColor.h</a><li>SkColorGetA -: <a class="el" href="SkColor_8h.html#a1">SkColor.h</a><li>SkColorGetB -: <a class="el" href="SkColor_8h.html#a4">SkColor.h</a><li>SkColorGetG -: <a class="el" href="SkColor_8h.html#a3">SkColor.h</a><li>SkColorGetR -: <a class="el" href="SkColor_8h.html#a2">SkColor.h</a><li>SkColorSetARGB() -: <a class="el" href="SkColor_8h.html#a19">SkColor.h</a><li>SkColorSetRGB -: <a class="el" href="SkColor_8h.html#a0">SkColor.h</a><li>SkPMColor -: <a class="el" href="SkColor_8h.html#a18">SkColor.h</a><li>SkPreMultiplyARGB() -: <a class="el" href="SkColor_8h.html#a20">SkColor.h</a><li>SkPreMultiplyColor() -: <a class="el" href="SkColor_8h.html#a21">SkColor.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/globals_defs.html b/sgl_doxygen/html/globals_defs.html deleted file mode 100644 index 8b989fc..0000000 --- a/sgl_doxygen/html/globals_defs.html +++ /dev/null @@ -1,33 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: File Members - Defines</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindexHL" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindex" href="globals.html">All</a> | <a class="qindex" href="globals_func.html">Functions</a> | <a class="qindex" href="globals_type.html">Typedefs</a> | <a class="qindexHL" href="globals_defs.html">Defines</a></div> - -<p> -<ul> -<li>SK_ColorBLACK -: <a class="el" href="SkColor_8h.html#a5">SkColor.h</a><li>SK_ColorBLUE -: <a class="el" href="SkColor_8h.html#a12">SkColor.h</a><li>SK_ColorCYAN -: <a class="el" href="SkColor_8h.html#a14">SkColor.h</a><li>SK_ColorDKGRAY -: <a class="el" href="SkColor_8h.html#a6">SkColor.h</a><li>SK_ColorGRAY -: <a class="el" href="SkColor_8h.html#a7">SkColor.h</a><li>SK_ColorGREEN -: <a class="el" href="SkColor_8h.html#a11">SkColor.h</a><li>SK_ColorLTGRAY -: <a class="el" href="SkColor_8h.html#a8">SkColor.h</a><li>SK_ColorMAGENTA -: <a class="el" href="SkColor_8h.html#a15">SkColor.h</a><li>SK_ColorRED -: <a class="el" href="SkColor_8h.html#a10">SkColor.h</a><li>SK_ColorWHITE -: <a class="el" href="SkColor_8h.html#a9">SkColor.h</a><li>SK_ColorYELLOW -: <a class="el" href="SkColor_8h.html#a13">SkColor.h</a><li>SkColorGetA -: <a class="el" href="SkColor_8h.html#a1">SkColor.h</a><li>SkColorGetB -: <a class="el" href="SkColor_8h.html#a4">SkColor.h</a><li>SkColorGetG -: <a class="el" href="SkColor_8h.html#a3">SkColor.h</a><li>SkColorGetR -: <a class="el" href="SkColor_8h.html#a2">SkColor.h</a><li>SkColorSetRGB -: <a class="el" href="SkColor_8h.html#a0">SkColor.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/globals_func.html b/sgl_doxygen/html/globals_func.html deleted file mode 100644 index 0fd7203..0000000 --- a/sgl_doxygen/html/globals_func.html +++ /dev/null @@ -1,20 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: File Members - Functions</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindexHL" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindex" href="globals.html">All</a> | <a class="qindexHL" href="globals_func.html">Functions</a> | <a class="qindex" href="globals_type.html">Typedefs</a> | <a class="qindex" href="globals_defs.html">Defines</a></div> - -<p> -<ul> -<li>SkColorSetARGB() -: <a class="el" href="SkColor_8h.html#a19">SkColor.h</a><li>SkPreMultiplyARGB() -: <a class="el" href="SkColor_8h.html#a20">SkColor.h</a><li>SkPreMultiplyColor() -: <a class="el" href="SkColor_8h.html#a21">SkColor.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/globals_type.html b/sgl_doxygen/html/globals_type.html deleted file mode 100644 index bfd67f7..0000000 --- a/sgl_doxygen/html/globals_type.html +++ /dev/null @@ -1,20 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: File Members - Typedefs</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindexHL" href="globals.html">File Members</a></div> -<div class="qindex"><a class="qindex" href="globals.html">All</a> | <a class="qindex" href="globals_func.html">Functions</a> | <a class="qindexHL" href="globals_type.html">Typedefs</a> | <a class="qindex" href="globals_defs.html">Defines</a></div> - -<p> -<ul> -<li>SkAlpha -: <a class="el" href="SkColor_8h.html#a16">SkColor.h</a><li>SkColor -: <a class="el" href="SkColor_8h.html#a17">SkColor.h</a><li>SkPMColor -: <a class="el" href="SkColor_8h.html#a18">SkColor.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:24 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/hierarchy.html b/sgl_doxygen/html/hierarchy.html deleted file mode 100644 index a3bc222..0000000 --- a/sgl_doxygen/html/hierarchy.html +++ /dev/null @@ -1,81 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Hierarchical Index</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindexHL" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SGL Class Hierarchy</h1>This inheritance list is sorted roughly, but not completely, alphabetically:<ul> -<li><b>BML_WXMLParser</b><li><b>BML_XMLParser</b><li><b>sk_trait_trivial_assign< T ></b><li><b>sk_trait_trivial_constructor< T ></b><li><b>sk_trait_trivial_copy< T ></b><li><b>sk_trait_trivial_destructor< T ></b><li><b>sk_traits< T ></b><li><a class="el" href="classSkAnimator_1_1Timeline.html">SkAnimator::Timeline</a> -<li><b>SkAutoBitmapRef</b><li><a class="el" href="classSkAutoCanvasRestore.html">SkAutoCanvasRestore</a> -<li><a class="el" href="classSkAutoMaskImage.html">SkAutoMaskImage</a> -<li><b>SkAutoRestorePaintFlags</b><li><b>SkAutoUCS2</b><li><a class="el" href="classSkAutoUnref.html">SkAutoUnref</a> -<li><a class="el" href="classSkBitmap.html">SkBitmap</a> -<li><b>SkBorderView</b><li><a class="el" href="classSkBufferStream.html">SkBufferStream</a> -<li><b>SkButtonView</b><li><b>SkButtonWidget</b><li><b>SkCamera3D</b><li><a class="el" href="classSkCanvas.html">SkCanvas</a> -<li><b>SkCanvas::MCRec</b><li><b>SkCheckBoxView</b><li><b>SkCheckBoxWidget</b><li><b>SkCheckButtonView</b><li><b>SkComposeShader</b><li><b>SkDebugWStream</b><li><b>SkDeque</b><li><b>SkDeque::Iter</b><li><b>SkDescriptor</b><li><b>SkDescriptor::Entry</b><li><a class="el" href="classSkDiscreteMapper.html">SkDiscreteMapper</a> -<li><b>SkDOM</b><li><b>SkDOM::AttrIter</b><li><b>SkEmbossMaskFilter::Light</b><li><a class="el" href="classSkEvent.html">SkEvent</a> -<li><b>SkFILEStream</b><li><b>SkFILEWStream</b><li><a class="el" href="classSkFlipCosineMapper.html">SkFlipCosineMapper</a> -<li><b>SkFontCodec</b><li><a class="el" href="classSkFontHost.html">SkFontHost</a> -<li><b>SkGlobals</b><li><b>SkGlobals::BootStrap</b><li><b>SkGlobals::Rec</b><li><b>SkGlyph</b><li><b>SkGraphics</b><li><b>SkGridView</b><li><b>SkHasLabelWidget</b><li><a class="el" href="classSkImageDecoder.html">SkImageDecoder</a> -<ul> -<li><b>SkGIFImageDecoder</b><li><b>SkJPEGImageDecoder</b><li><b>SkPNGImageDecoder</b></ul> -<li><b>SkInterpolator</b><li><b>SkInterpolatorBase</b><li><b>SkInterpolatorBase::SkTimeCode</b><li><b>SkJS</b><li><b>SkListView</b><li><a class="el" href="structSkMask.html">SkMask</a> -<li><b>SkMemoryStream</b><li><b>SkMemoryWStream</b><li><b>SkMetaData</b><li><b>SkMetaData::Iter</b><li><b>SkMetaData::Rec</b><li><b>SkOSFile</b><li><b>SkOSFile::Iter</b><li><b>SkOSMenu</b><li><b>SkOSSound</b><li><b>SkOSWindow</b><li><a class="el" href="classSkPaint.html">SkPaint</a> -<li><b>SkParse</b><li><b>SkPatch3D</b><li><a class="el" href="classSkPath.html">SkPath</a> -<li><a class="el" href="classSkPath_1_1Iter.html">SkPath::Iter</a> -<li><b>SkPathMeasure</b><li><b>SkPoint3D</b><li><b>SkPorterDuff</b><li><b>SkProgressBarView</b><li><b>SkPushButtonView</b><li><b>SkPushButtonWidget</b><li><a class="el" href="classSkRefCnt.html">SkRefCnt</a> -<ul> -<li><a class="el" href="classSkBitmapRef.html">SkBitmapRef</a> -<li><a class="el" href="classSkBounder.html">SkBounder</a> -<li><a class="el" href="classSkColorTable.html">SkColorTable</a> -<li><a class="el" href="classSkEventSink.html">SkEventSink</a> -<ul> -<li><a class="el" href="classSkAnimator.html">SkAnimator</a> -<li><b>SkListSource</b><li><a class="el" href="classSkView.html">SkView</a> -<ul> -<li><b>SkAnimatorView</b><li><b>SkBitmapView</b><li><b>SkHasLabelView</b><li><b>SkImageView</b><li><b>SkProgressView</b><li><b>SkStaticTextView</b><li><b>SkStaticTextView</b><li><b>SkTextView</b><li><b>SkWidget</b><li><b>SkWidgetView</b><li><b>SkWidgetView</b><li><b>SkWindow</b></ul> -</ul> -<li><a class="el" href="classSkFlattenable.html">SkFlattenable</a> -<ul> -<li><a class="el" href="classSkMaskFilter.html">SkMaskFilter</a> -<ul> -<li><b>SkBlurMaskFilter</b><li><b>SkEmbossMaskFilter</b><li><b>SkLayersMaskFilter</b></ul> -<li><a class="el" href="classSkPathEffect.html">SkPathEffect</a> -<ul> -<li><b>Sk1DPathEffect</b><li><b>Sk2DPathEffect</b><li><a class="el" href="classSkCornerPathEffect.html">SkCornerPathEffect</a> -<li><a class="el" href="classSkDashPathEffect.html">SkDashPathEffect</a> -<li><b>SkDiscretePathEffect</b><li><a class="el" href="classSkPairPathEffect.html">SkPairPathEffect</a> -<ul> -<li><a class="el" href="classSkComposePathEffect.html">SkComposePathEffect</a> -<li><a class="el" href="classSkSumPathEffect.html">SkSumPathEffect</a> -</ul> -<li><b>SkStrokePathEffect</b></ul> -</ul> -<li><b>SkListSource</b><li><a class="el" href="classSkShader.html">SkShader</a> -<ul> -<li><a class="el" href="classSkGradientShader.html">SkGradientShader</a> -<li><a class="el" href="classSkLightShader.html">SkLightShader</a> -<li><b>SkPairShader</b><li><b>SkTransparentShader</b></ul> -<li><b>SkTypeface</b><li><b>SkUnitMapper</b><li><a class="el" href="classSkView_1_1Artist.html">SkView::Artist</a> -<ul> -<li><b>SkBGViewArtist</b></ul> -<li><a class="el" href="classSkView_1_1Layout.html">SkView::Layout</a> -<ul> -<li><b>SkFillViewLayout</b><li><b>SkStackViewLayout</b></ul> -<li><a class="el" href="classSkXfermode.html">SkXfermode</a> -<ul> -<li><b>SkProcXfermode</b></ul> -</ul> -<li><b>SkScalerContext</b><li><b>SkScalerContext::Rec</b><li><b>SkScrollBarView</b><li><b>SkSliderView</b><li><b>SkSTDeque< COUNT, T ></b><li><b>SkStream</b><li><a class="el" href="classSkString.html">SkString</a> -<li><a class="el" href="classSkStroke.html">SkStroke</a> -<li><b>SkSumShader</b><li><b>SkSVGAttribute</b><li><b>SkSVGBase</b><li><b>SkSVGPaint</b><li><b>SkSVGParser</b><li><b>SkTDArray< T ></b><li><b>SkTDeque< T ></b><li><b>SkTDeque< T >::Iter</b><li><b>SkTDict< T ></b><li><b>SkTDict< T >::Iter</b><li><b>SkTDict< T >::Pair</b><li><b>SkTDStack< T ></b><li><a class="el" href="classSkTextBox.html">SkTextBox</a> -<li><b>SkTextLineBreaker</b><li><a class="el" href="classSkTime.html">SkTime</a> -<li><b>SkTime::DateTime</b><li><b>SkUnit3D</b><li><b>SkUnixWindow</b><li><b>SkUTF16_Str</b><li><b>SkUtils</b><li><a class="el" href="classSkView_1_1B2FIter.html">SkView::B2FIter</a> -<li><b>SkView::Click</b><li><a class="el" href="classSkView_1_1F2BIter.html">SkView::F2BIter</a> -<li><b>SkViewInflate</b><li><b>SkWStream</b><li><b>SkXMLParser</b><li><b>SkXMLParserError</b><li><b>SkXMLParserWriter</b><li><b>SkXMLStreamWriter</b><li><b>SkXMLWriter</b><li><b>SkXMLWriter::Elem</b></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/index.html b/sgl_doxygen/html/index.html deleted file mode 100644 index f9df1ac..0000000 --- a/sgl_doxygen/html/index.html +++ /dev/null @@ -1,14 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Main Page</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindexHL" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SGL Documentation</h1> -<p> -<h3 align="center">1.0 </h3><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/structSkMask-members.html b/sgl_doxygen/html/structSkMask-members.html deleted file mode 100644 index a9235aa..0000000 --- a/sgl_doxygen/html/structSkMask-members.html +++ /dev/null @@ -1,27 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: Member List</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkMask Member List</h1>This is the complete list of members for <a class="el" href="structSkMask.html">SkMask</a>, including all inherited members.<p><table> - <tr bgcolor="#f0f0f0"><td><b>AllocImage</b>(size_t bytes) (defined in <a class="el" href="structSkMask.html">SkMask</a>)</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td><code> [static]</code></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#a0">computeImageSize</a>() const </td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#a1">computeTotalImageSize</a>() const </td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fBounds</b> (defined in <a class="el" href="structSkMask.html">SkMask</a>)</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fFormat</b> (defined in <a class="el" href="structSkMask.html">SkMask</a>)</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fImage</b> (defined in <a class="el" href="structSkMask.html">SkMask</a>)</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#w3">Format</a> enum name</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr bgcolor="#f0f0f0"><td><b>FreeImage</b>(U8 *image) (defined in <a class="el" href="structSkMask.html">SkMask</a>)</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td><code> [static]</code></td></tr> - <tr bgcolor="#f0f0f0"><td><b>fRowBytes</b> (defined in <a class="el" href="structSkMask.html">SkMask</a>)</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#a3">getAddr</a>(int x, int y) const </td><td><a class="el" href="structSkMask.html">SkMask</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#a2">getAddr1</a>(int x, int y) const </td><td><a class="el" href="structSkMask.html">SkMask</a></td><td><code> [inline]</code></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#w3w2">k3D_Format</a> enum value</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#w3w1">kA8_Format</a> enum value</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> - <tr class="memlist"><td><a class="el" href="structSkMask.html#w3w0">kBW_Format</a> enum value</td><td><a class="el" href="structSkMask.html">SkMask</a></td><td></td></tr> -</table><hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/sgl_doxygen/html/structSkMask.html b/sgl_doxygen/html/structSkMask.html deleted file mode 100644 index 1e5ecf6..0000000 --- a/sgl_doxygen/html/structSkMask.html +++ /dev/null @@ -1,220 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> -<html><head><meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1"> -<title>SGL: SkMask Struct Reference</title> -<link href="doxygen.css" rel="stylesheet" type="text/css"> -</head><body> -<!-- Generated by Doxygen 1.4.0 --> -<div class="qindex"><a class="qindex" href="index.html">Main Page</a> | <a class="qindex" href="hierarchy.html">Class Hierarchy</a> | <a class="qindex" href="annotated.html">Class List</a> | <a class="qindex" href="dirs.html">Directories</a> | <a class="qindex" href="files.html">File List</a> | <a class="qindex" href="functions.html">Class Members</a> | <a class="qindex" href="globals.html">File Members</a></div> -<h1>SkMask Struct Reference</h1><code>#include <<a class="el" href="SkMask_8h-source.html">SkMask.h</a>></code> -<p> -<a href="structSkMask-members.html">List of all members.</a><table border="0" cellpadding="0" cellspacing="0"> -<tr><td></td></tr> -<tr><td colspan="2"><br><h2>Public Types</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">enum </td><td class="memItemRight" valign="bottom"><a class="el" href="structSkMask.html#w3">Format</a> { <a class="el" href="structSkMask.html#w3w0">kBW_Format</a>, -<a class="el" href="structSkMask.html#w3w1">kA8_Format</a>, -<a class="el" href="structSkMask.html#w3w2">k3D_Format</a> - }</td></tr> - -<tr><td colspan="2"><br><h2>Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top">size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structSkMask.html#a0">computeImageSize</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">size_t </td><td class="memItemRight" valign="bottom"><a class="el" href="structSkMask.html#a1">computeTotalImageSize</a> () const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U8 * </td><td class="memItemRight" valign="bottom"><a class="el" href="structSkMask.html#a2">getAddr1</a> (int x, int y) const </td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top">U8 * </td><td class="memItemRight" valign="bottom"><a class="el" href="structSkMask.html#a3">getAddr</a> (int x, int y) const </td></tr> - -<tr><td colspan="2"><br><h2>Static Public Member Functions</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e0" doxytag="SkMask::AllocImage"></a> -static U8 * </td><td class="memItemRight" valign="bottom"><b>AllocImage</b> (size_t bytes)</td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="e1" doxytag="SkMask::FreeImage"></a> -static void </td><td class="memItemRight" valign="bottom"><b>FreeImage</b> (U8 *image)</td></tr> - -<tr><td colspan="2"><br><h2>Public Attributes</h2></td></tr> -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="o0" doxytag="SkMask::fImage"></a> -U8 * </td><td class="memItemRight" valign="bottom"><b>fImage</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="o1" doxytag="SkMask::fBounds"></a> -SkRect16 </td><td class="memItemRight" valign="bottom"><b>fBounds</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="o2" doxytag="SkMask::fRowBytes"></a> -U16 </td><td class="memItemRight" valign="bottom"><b>fRowBytes</b></td></tr> - -<tr><td class="memItemLeft" nowrap align="right" valign="top"><a class="anchor" name="o3" doxytag="SkMask::fFormat"></a> -U8 </td><td class="memItemRight" valign="bottom"><b>fFormat</b></td></tr> - -</table> -<hr><a name="_details"></a><h2>Detailed Description</h2> -SkMask is used to describe alpha bitmaps, either 1bit, 8bit, or the 3-channel 3D format. These are passed to <a class="el" href="classSkMaskFilter.html">SkMaskFilter</a> objects. -<p> -<hr><h2>Member Enumeration Documentation</h2> -<a class="anchor" name="w3" doxytag="SkMask::Format"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">enum <a class="el" href="structSkMask.html#w3">SkMask::Format</a> </td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -<dl compact><dt><b>Enumeration values: </b></dt><dd> -<table border="0" cellspacing="2" cellpadding="0"> -<tr><td valign="top"><em><a class="anchor" name="w3w0" doxytag="kBW_Format"></a>kBW_Format</em> </td><td> -1bit per pixel mask (e.g. monochrome) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w3w1" doxytag="kA8_Format"></a>kA8_Format</em> </td><td> -8bits per pixel mask (e.g. antialiasing) </td></tr> -<tr><td valign="top"><em><a class="anchor" name="w3w2" doxytag="k3D_Format"></a>k3D_Format</em> </td><td> -3 8bit per pixl planes: alpha, mul, add </td></tr> -</table> -</dl> - </td> - </tr> -</table> -<hr><h2>Member Function Documentation</h2> -<a class="anchor" name="a0" doxytag="SkMask::computeImageSize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">size_t SkMask::computeImageSize </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the byte size of the mask, assuming only 1 plane. Does not account for k3D_Format. For that, use computeFormatImageSize() </td> - </tr> -</table> -<a class="anchor" name="a1" doxytag="SkMask::computeTotalImageSize"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">size_t SkMask::computeTotalImageSize </td> - <td class="md" valign="top">( </td> - <td class="mdname1" valign="top" nowrap> </td> - <td class="md" valign="top"> ) </td> - <td class="md" nowrap> const</td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Return the byte size of the mask, taking into account any extra planes (e.g. k3D_Format). </td> - </tr> -</table> -<a class="anchor" name="a3" doxytag="SkMask::getAddr"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U8* SkMask::getAddr </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the address of the specified byte. Asserts that the mask is kA8_Format, and that x,y are in range. x,y are in the same coordiate space as fBounds. </td> - </tr> -</table> -<a class="anchor" name="a2" doxytag="SkMask::getAddr1"></a><p> -<table class="mdTable" cellpadding="2" cellspacing="0"> - <tr> - <td class="mdRow"> - <table cellpadding="0" cellspacing="0" border="0"> - <tr> - <td class="md" nowrap valign="top">U8* SkMask::getAddr1 </td> - <td class="md" valign="top">( </td> - <td class="md" nowrap valign="top">int </td> - <td class="mdname" nowrap> <em>x</em>, </td> - </tr> - <tr> - <td class="md" nowrap align="right"></td> - <td class="md"></td> - <td class="md" nowrap>int </td> - <td class="mdname" nowrap> <em>y</em></td> - </tr> - <tr> - <td class="md"></td> - <td class="md">) </td> - <td class="md" colspan="2"> const<code> [inline]</code></td> - </tr> - </table> - </td> - </tr> -</table> -<table cellspacing="5" cellpadding="0" border="0"> - <tr> - <td> - - </td> - <td> - -<p> -Returns the address of the byte that holds the specified bit. Asserts that the mask is kBW_Format, and that x,y are in range. x,y are in the same coordiate space as fBounds. </td> - </tr> -</table> -<hr>The documentation for this struct was generated from the following file:<ul> -<li><a class="el" href="SkMask_8h-source.html">SkMask.h</a></ul> -<hr size="1"><address style="align: right;"><small>Generated on Tue May 9 14:35:23 2006 for SGL by -<a href="http://www.doxygen.org/index.html"> -<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.0 </small></address> -</body> -</html> diff --git a/test/SkSetPoly3To3.cpp b/test/SkSetPoly3To3.cpp new file mode 100644 index 0000000..1420eba --- /dev/null +++ b/test/SkSetPoly3To3.cpp @@ -0,0 +1,60 @@ +#include "SkMatrix.h" + +static void computeOuterProduct(SkScalar op[4], + const SkPoint pts0[3], const SkPoint& ave0, + const SkPoint pts1[3], const SkPoint& ave1) { + bzero(op, 4 * sizeof(op[0])); + for (int i = 0; i < 3; i++) { + SkScalar x0 = pts0[i].fX - ave0.fX; + SkScalar y0 = pts0[i].fY - ave0.fY; + SkScalar x1 = pts1[i].fX - ave1.fX; + SkScalar y1 = pts1[i].fY - ave1.fY; + op[0] += SkScalarMul(x0, x1); + op[1] += SkScalarMul(x0, y1); + op[2] += SkScalarMul(y0, x1); + op[3] += SkScalarMul(y0, y1); + } +} + +static SkScalar dot(SkScalar ax, SkScalar ay, SkScalar bx, SkScalar by) { + return SkScalarMul(ax, bx) + SkScalarMul(ay, by); +} + +bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]) { + const SkPoint& srcAve = src[0]; + const SkPoint& dstAve = dst[0]; + + SkScalar srcOP[4], dstOP[4]; + + computeOuterProduct(srcOP, src, srcAve, src, srcAve); + computeOuterProduct(dstOP, src, srcAve, dst, dstAve); + + SkScalar det = SkScalarMul(srcOP[0], srcOP[3]) - SkScalarMul(srcOP[1], srcOP[2]); + + // need SkScalarNearlyZeroSquared for this (to match Chrome's fix) + if (SkScalarNearlyZero(det)) { + return false; + } + + SkScalar invDet = SkScalarInvert(det); + + // now compute invDet * [srcOP]T * [dstOP] + + // scale and transpose + const SkScalar srcOP0 = SkScalarMul( srcOP[3], invDet); + const SkScalar srcOP1 = SkScalarMul(-srcOP[1], invDet); + const SkScalar srcOP2 = SkScalarMul(-srcOP[2], invDet); + const SkScalar srcOP3 = SkScalarMul( srcOP[0], invDet); + + matrix->reset(); + matrix->setScaleX(dot(srcOP0, srcOP1, dstOP[0], dstOP[2])); + matrix->setSkewX( dot(srcOP2, srcOP3, dstOP[0], dstOP[2])); + matrix->setSkewY (dot(srcOP0, srcOP1, dstOP[1], dstOP[3])); + matrix->setScaleY(dot(srcOP2, srcOP3, dstOP[1], dstOP[3])); + matrix->setTranslateX(dstAve.fX - dot(srcAve.fX, srcAve.fY, + matrix->getScaleX(), matrix->getSkewX())); + matrix->setTranslateY(dstAve.fY - dot(srcAve.fX, srcAve.fY, + matrix->getSkewY(), matrix->getScaleY())); + return true; +} + diff --git a/test/SkSetPoly3To3_A.cpp b/test/SkSetPoly3To3_A.cpp new file mode 100644 index 0000000..cc953f5 --- /dev/null +++ b/test/SkSetPoly3To3_A.cpp @@ -0,0 +1,90 @@ +#include "SkMatrix.h" + +#ifdef SK_SCALAR_IS_FIXED + typedef int64_t SkDScalar; + + static SkScalar SkDScalar_toScalar(SkDScalar value) { + SkDScalar result = (value + (1 << 15)) >> 16; + int top = result >> 31; + SkASSERT(top == 0 || top == -1); + return (SkScalar)result; + } + static SkScalar div(SkDScalar numer, SkDScalar denom) { + denom >>= 16; + return numer / denom; + } +#else + typedef double SkDScalar; + + static SkScalar SkDScalar_toScalar(SkDScalar value) { + return static_cast<float>(value); + } + static SkScalar div(SkDScalar numer, SkDScalar denom) { + return static_cast<float>(numer / denom); + } +#endif + +static SkDScalar SkDScalar_setMul(SkScalar a, SkScalar b) { + return (SkDScalar)a * b; +} + +static void computeOuterProduct(SkScalar op[4], + const SkPoint pts0[3], const SkPoint& ave0, + const SkPoint pts1[3], const SkPoint& ave1) { + bzero(op, 4 * sizeof(op[0])); + for (int i = 0; i < 3; i++) { + SkScalar x0 = pts0[i].fX - ave0.fX; + SkScalar y0 = pts0[i].fY - ave0.fY; + SkScalar x1 = pts1[i].fX - ave1.fX; + SkScalar y1 = pts1[i].fY - ave1.fY; + op[0] += SkScalarMul(x0, x1); + op[1] += SkScalarMul(x0, y1); + op[2] += SkScalarMul(y0, x1); + op[3] += SkScalarMul(y0, y1); + } +} + +static SkDScalar ddot(SkScalar ax, SkScalar ay, SkScalar bx, SkScalar by) { + return SkDScalar_setMul(ax, bx) + SkDScalar_setMul(ay, by); +} + +static SkScalar dot(SkScalar ax, SkScalar ay, SkScalar bx, SkScalar by) { + return SkDScalar_toScalar(ddot(ax, ay, bx, by)); +} + +bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]) { + const SkPoint& srcAve = src[0]; + const SkPoint& dstAve = dst[0]; + + SkScalar srcOP[4], dstOP[4]; + + computeOuterProduct(srcOP, src, srcAve, src, srcAve); + computeOuterProduct(dstOP, src, srcAve, dst, dstAve); + + SkDScalar det = SkDScalar_setMul(srcOP[0], srcOP[3]) - + SkDScalar_setMul(srcOP[1], srcOP[2]); + + SkDScalar M[4]; + + const SkScalar srcOP0 = srcOP[3]; + const SkScalar srcOP1 = -srcOP[1]; + const SkScalar srcOP2 = -srcOP[2]; + const SkScalar srcOP3 = srcOP[0]; + + M[0] = ddot(srcOP0, srcOP1, dstOP[0], dstOP[2]); + M[1] = ddot(srcOP2, srcOP3, dstOP[0], dstOP[2]); + M[2] = ddot(srcOP0, srcOP1, dstOP[1], dstOP[3]); + M[3] = ddot(srcOP2, srcOP3, dstOP[1], dstOP[3]); + + matrix->reset(); + matrix->setScaleX(div(M[0], det)); + matrix->setSkewX( div(M[1], det)); + matrix->setSkewY (div(M[2], det)); + matrix->setScaleY(div(M[3], det)); + matrix->setTranslateX(dstAve.fX - dot(srcAve.fX, srcAve.fY, + matrix->getScaleX(), matrix->getSkewX())); + matrix->setTranslateY(dstAve.fY - dot(srcAve.fX, srcAve.fY, + matrix->getSkewY(), matrix->getScaleY())); + return true; +} + diff --git a/test/SkSetPoly3To3_D.cpp b/test/SkSetPoly3To3_D.cpp new file mode 100644 index 0000000..72ee9b1 --- /dev/null +++ b/test/SkSetPoly3To3_D.cpp @@ -0,0 +1,65 @@ +#include "SkMatrix.h" + +typedef int64_t SkDScalar; + +static SkScalar SkDScalar_toScalar(SkDScalar value) { + SkDScalar result = (value + (1 << 15)) >> 16; + int top = result >> 31; + SkASSERT(top == 0 || top == -1); + return (SkScalar)result; +} + +static SkDScalar SkDScalar_setMul(SkScalar a, SkScalar b) { + return (SkDScalar)a * b; +} + +static void computeOuterProduct(SkMatrix* matrix, + const SkPoint pts0[3], const SkPoint& ave0, + const SkPoint pts1[3], const SkPoint& ave1) { + SkDScalar tmp[4]; + bzero(tmp, sizeof(tmp)); + + for (int i = 0; i < 3; i++) { + SkScalar x0 = pts0[i].fX - ave0.fX; + SkScalar y0 = pts0[i].fY - ave0.fY; + SkScalar x1 = pts1[i].fX - ave1.fX; + SkScalar y1 = pts1[i].fY - ave1.fY; + tmp[0] += SkDScalar_setMul(x0, x1); + tmp[1] += SkDScalar_setMul(x0, y1); + tmp[2] += SkDScalar_setMul(y0, x1); + tmp[3] += SkDScalar_setMul(y0, y1); + } + matrix->reset(); + matrix->setScaleX(SkDScalar_toScalar(tmp[0])); + matrix->setSkewY( SkDScalar_toScalar(tmp[1])); + matrix->setSkewX( SkDScalar_toScalar(tmp[2])); + matrix->setScaleY(SkDScalar_toScalar(tmp[3])); +} + +static SkScalar dot(SkScalar ax, SkScalar ay, SkScalar bx, SkScalar by) { + return SkDScalar_toScalar(SkDScalar_setMul(ax, bx) + + SkDScalar_setMul(ay, by)); +} + +bool SkSetPoly3To3(SkMatrix* matrix, const SkPoint src[3], const SkPoint dst[3]) { + const SkPoint& srcAve = src[0]; + const SkPoint& dstAve = dst[0]; + + SkMatrix srcOP, dstOP; + + computeOuterProduct(&srcOP, src, srcAve, src, srcAve); + + if (!srcOP.invert(&srcOP)) { + return false; + } + + computeOuterProduct(&dstOP, src, srcAve, dst, dstAve); + + matrix->setConcat(dstOP, srcOP); + matrix->setTranslateX(dstAve.fX - dot(srcAve.fX, srcAve.fY, + matrix->getScaleX(), matrix->getSkewX())); + matrix->setTranslateY(dstAve.fY - dot(srcAve.fX, srcAve.fY, + matrix->getSkewY(), matrix->getScaleY())); + return true; +} + diff --git a/test/test.cpp b/test/test.cpp new file mode 100644 index 0000000..8d2e1f2 --- /dev/null +++ b/test/test.cpp @@ -0,0 +1,42 @@ +#include "test.h" + +namespace skia { + +#define MAX_REC_COUNT 1000 + +struct Rec { + Test::Factory fFact; + void* fData; +}; +static Rec gRecs[MAX_REC_COUNT]; +static int gRecCount; + +void Test::Register(Factory fact, void* data) { + SkASSERT(gRecCount < MAX_REC_COUNT); + + gRecs[gRecCount].fFact = fact; + gRecs[gRecCount].fData = data; + gRecCount++; +} + +Test::Registrar::Registrar(Factory fact, void* data) { + Test::Register(fact, data); +} + +Test::Init::Init(void (*proc)()) { + proc(); +} + +Test* Test::Iter::next() { + if (fIndex < gRecCount) { + Test* test = gRecs[fIndex].fFact(gRecs[fIndex].fData); + fIndex++; + return test; + } + return NULL; +} + +int Test::Iter::Count() { return gRecCount; } + +} // namespace + diff --git a/test/test.h b/test/test.h new file mode 100644 index 0000000..114638d --- /dev/null +++ b/test/test.h @@ -0,0 +1,56 @@ +#ifndef SkiaTest_DEFINED +#define SkiaTest_DEFINED + +#include "SkCanvas.h" +#include "SkPoint.h" +#include "SkString.h" + +namespace skia { + + class Test { + public: + virtual ~Test() {} + + enum StringType { + kTitle, + kDescription + }; + + virtual void getSize(SkIPoint* size) = 0; + virtual void draw(SkCanvas*) = 0; + virtual bool getString(StringType, SkString*) = 0; + + /////////////////////////////////////////////////////////////////////// + + class Iter { + public: + Iter() : fIndex(0) {} + + void reset() { fIndex = 0; } + Test* next(); + + static int Count(); + private: + int fIndex; + }; + + /////////////////////////////////////////////////////////////////////// + + typedef Test* (*Factory)(void*); + static void Register(Factory, void*); + + class Registrar { + public: + Registrar(Factory, void*); + }; + + class Init { + public: + Init(void (*)()); + }; + }; + +} + +#endif + diff --git a/test/test_drawcolor.cpp b/test/test_drawcolor.cpp new file mode 100644 index 0000000..6b6b254 --- /dev/null +++ b/test/test_drawcolor.cpp @@ -0,0 +1,53 @@ +#include "test.h" + +namespace skia { + +class draw_color_test : public Test { +public: + enum { kSizeX = 32, kSizeY = 32 }; + + draw_color_test(SkColor color) : fColor(color) {} + + virtual void getSize(SkIPoint* size) { + size->set(kSizeX, kSizeY); + } + + virtual void draw(SkCanvas* canvas) { + canvas->drawColor(fColor); + } + + virtual bool getString(StringType st, SkString* str) { + switch (st) { + case kTitle: + str->printf("DrawColor %X", fColor); + return true; + case kDescription: + str->printf("Call drawColor(%X) on the entire canvas", fColor); + return true; + default: + return false; + } + } + +private: + SkColor fColor; +}; + +static Test* factory(void* color) { + return new draw_color_test(reinterpret_cast<SkColor>(color)); +} + +static void init() { + static const SkColor gColors[] = { + SK_ColorBLACK, SK_ColorWHITE, + SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, + SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW + }; + for (size_t i = 0; i < SK_ARRAY_COUNT(gColors); i++) { + Test::Register(factory, reinterpret_cast<void*>(gColors[i])); + } +} +static Test::Init i(init); + +} // namespace + diff --git a/test/test_drawrect.cpp b/test/test_drawrect.cpp new file mode 100644 index 0000000..35daad1 --- /dev/null +++ b/test/test_drawrect.cpp @@ -0,0 +1,74 @@ +#include "test.h" + +namespace skia { + +class drawrect_test : public Test { +public: + enum { kSizeX = 510, kSizeY = 510 }; + + drawrect_test() {} + + virtual void getSize(SkIPoint* size) { + size->set(kSizeX, kSizeY); + } + + virtual void draw(SkCanvas* canvas) { + SkRect r; + SkPaint p; + + p.setAntiAlias(true); + r.set(SkIntToScalar(10), SkIntToScalar(10), + SkIntToScalar(10+80), SkIntToScalar(10+80)); + + static const SkPaint::Style gStyles[] = { + SkPaint::kStroke_Style, + SkPaint::kStrokeAndFill_Style + }; + static const SkScalar gWidths[] = { 0, SkIntToScalar(9) }; + static const SkPaint::Join gJoins[] = { + SkPaint::kMiter_Join, + SkPaint::kRound_Join, + SkPaint::kBevel_Join + }; + + const SkScalar dx = r.width() + SkIntToScalar(20); + const SkScalar dy = r.height() + SkIntToScalar(10); + + canvas->drawRect(r, p); + for (size_t k = 0; k < SK_ARRAY_COUNT(gJoins); k++) { + p.setStrokeJoin(gJoins[k]); + canvas->translate(0, dy); + canvas->save(SkCanvas::kMatrix_SaveFlag); + for (size_t i = 0; i < SK_ARRAY_COUNT(gStyles); i++) { + p.setStyle(gStyles[i]); + for (size_t j = 0; j < SK_ARRAY_COUNT(gWidths); j++) { + p.setStrokeWidth(gWidths[j]); + canvas->drawRect(r, p); + canvas->translate(dx, 0); + } + } + canvas->restore(); + } + } + + virtual bool getString(StringType st, SkString* str) { + switch (st) { + case kTitle: + str->set("drawRect"); + return true; + case kDescription: + str->set("Call drawRect with different stroke widths and joins"); + return true; + default: + return false; + } + } +}; + +static Test* factory(void*) { + return new drawrect_test; +} +static Test::Registrar reg(factory, 0); + +} + diff --git a/xcode/GL.xcodeproj/project.pbxproj b/xcode/GL.xcodeproj/project.pbxproj new file mode 100644 index 0000000..2d60cf8 --- /dev/null +++ b/xcode/GL.xcodeproj/project.pbxproj @@ -0,0 +1,267 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 44; + objects = { + +/* Begin PBXBuildFile section */ + 00B7DCF60EDCA0BD00F77EA2 /* SkGL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCE90EDCA0BD00F77EA2 /* SkGL.cpp */; }; + 00B7DCF70EDCA0BD00F77EA2 /* SkGL.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCEA0EDCA0BD00F77EA2 /* SkGL.h */; }; + 00B7DCF80EDCA0BD00F77EA2 /* SkGLCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCEB0EDCA0BD00F77EA2 /* SkGLCanvas.cpp */; }; + 00B7DCF90EDCA0BD00F77EA2 /* SkGLDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCEC0EDCA0BD00F77EA2 /* SkGLDevice.cpp */; }; + 00B7DCFA0EDCA0BD00F77EA2 /* SkGLDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCED0EDCA0BD00F77EA2 /* SkGLDevice.h */; }; + 00B7DCFB0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCEE0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp */; }; + 00B7DCFC0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCEF0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h */; }; + 00B7DCFD0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCF00EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp */; }; + 00B7DCFE0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCF10EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h */; }; + 00B7DCFF0EDCA0BD00F77EA2 /* SkGLTextCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCF20EDCA0BD00F77EA2 /* SkGLTextCache.cpp */; }; + 00B7DD000EDCA0BD00F77EA2 /* SkGLTextCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCF30EDCA0BD00F77EA2 /* SkGLTextCache.h */; }; + 00B7DD010EDCA0BD00F77EA2 /* SkTextureCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCF40EDCA0BD00F77EA2 /* SkTextureCache.cpp */; }; + 00B7DD020EDCA0BD00F77EA2 /* SkTextureCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DCF50EDCA0BD00F77EA2 /* SkTextureCache.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7DCE90EDCA0BD00F77EA2 /* SkGL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGL.cpp; path = ../libsgl/gl/SkGL.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCEA0EDCA0BD00F77EA2 /* SkGL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGL.h; path = ../libsgl/gl/SkGL.h; sourceTree = SOURCE_ROOT; }; + 00B7DCEB0EDCA0BD00F77EA2 /* SkGLCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLCanvas.cpp; path = ../libsgl/gl/SkGLCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCEC0EDCA0BD00F77EA2 /* SkGLDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice.cpp; path = ../libsgl/gl/SkGLDevice.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCED0EDCA0BD00F77EA2 /* SkGLDevice.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice.h; path = ../libsgl/gl/SkGLDevice.h; sourceTree = SOURCE_ROOT; }; + 00B7DCEE0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_FBO.cpp; path = ../libsgl/gl/SkGLDevice_FBO.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCEF0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_FBO.h; path = ../libsgl/gl/SkGLDevice_FBO.h; sourceTree = SOURCE_ROOT; }; + 00B7DCF00EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_SWLayer.cpp; path = ../libsgl/gl/SkGLDevice_SWLayer.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCF10EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_SWLayer.h; path = ../libsgl/gl/SkGLDevice_SWLayer.h; sourceTree = SOURCE_ROOT; }; + 00B7DCF20EDCA0BD00F77EA2 /* SkGLTextCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLTextCache.cpp; path = ../libsgl/gl/SkGLTextCache.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCF30EDCA0BD00F77EA2 /* SkGLTextCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLTextCache.h; path = ../libsgl/gl/SkGLTextCache.h; sourceTree = SOURCE_ROOT; }; + 00B7DCF40EDCA0BD00F77EA2 /* SkTextureCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextureCache.cpp; path = ../libsgl/gl/SkTextureCache.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCF50EDCA0BD00F77EA2 /* SkTextureCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextureCache.h; path = ../libsgl/gl/SkTextureCache.h; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libGL.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libGL.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* GL */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = GL; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7DCE90EDCA0BD00F77EA2 /* SkGL.cpp */, + 00B7DCEA0EDCA0BD00F77EA2 /* SkGL.h */, + 00B7DCEB0EDCA0BD00F77EA2 /* SkGLCanvas.cpp */, + 00B7DCEC0EDCA0BD00F77EA2 /* SkGLDevice.cpp */, + 00B7DCED0EDCA0BD00F77EA2 /* SkGLDevice.h */, + 00B7DCEE0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp */, + 00B7DCEF0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h */, + 00B7DCF00EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp */, + 00B7DCF10EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h */, + 00B7DCF20EDCA0BD00F77EA2 /* SkGLTextCache.cpp */, + 00B7DCF30EDCA0BD00F77EA2 /* SkGLTextCache.h */, + 00B7DCF40EDCA0BD00F77EA2 /* SkTextureCache.cpp */, + 00B7DCF50EDCA0BD00F77EA2 /* SkTextureCache.h */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libGL.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DCF70EDCA0BD00F77EA2 /* SkGL.h in Headers */, + 00B7DCFA0EDCA0BD00F77EA2 /* SkGLDevice.h in Headers */, + 00B7DCFC0EDCA0BD00F77EA2 /* SkGLDevice_FBO.h in Headers */, + 00B7DCFE0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.h in Headers */, + 00B7DD000EDCA0BD00F77EA2 /* SkGLTextCache.h in Headers */, + 00B7DD020EDCA0BD00F77EA2 /* SkTextureCache.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* GL */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "GL" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = GL; + productName = GL; + productReference = D2AAC046055464E500DB518D /* libGL.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "GL" */; + compatibilityVersion = "Xcode 3.0"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* GL */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + D2AAC045055464E500DB518D /* GL */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DCF60EDCA0BD00F77EA2 /* SkGL.cpp in Sources */, + 00B7DCF80EDCA0BD00F77EA2 /* SkGLCanvas.cpp in Sources */, + 00B7DCF90EDCA0BD00F77EA2 /* SkGLDevice.cpp in Sources */, + 00B7DCFB0EDCA0BD00F77EA2 /* SkGLDevice_FBO.cpp in Sources */, + 00B7DCFD0EDCA0BD00F77EA2 /* SkGLDevice_SWLayer.cpp in Sources */, + 00B7DCFF0EDCA0BD00F77EA2 /* SkGLTextCache.cpp in Sources */, + 00B7DD010EDCA0BD00F77EA2 /* SkTextureCache.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = GL; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = GL; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_DEBUG, + SK_BUILD_FOR_MAC, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk"; + USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/corecg ../include/graphics"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS = YES; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_MISSING_NEWLINE = YES; + GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk"; + USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/corecg ../include/graphics"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "GL" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "GL" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/SampleCode/English.lproj/InfoPlist.strings b/xcode/SampleCode/English.lproj/InfoPlist.strings new file mode 100644 index 0000000..e842e19 --- /dev/null +++ b/xcode/SampleCode/English.lproj/InfoPlist.strings @@ -0,0 +1,3 @@ +/* Localized versions of Info.plist keys */ + +NSHumanReadableCopyright = "© __MyCompanyName__, 2008"; diff --git a/xcode/SampleCode/English.lproj/main.nib/classes.nib b/xcode/SampleCode/English.lproj/main.nib/classes.nib new file mode 100644 index 0000000..c4b887e --- /dev/null +++ b/xcode/SampleCode/English.lproj/main.nib/classes.nib @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>IBVersion</key> + <string>1</string> +</dict> +</plist> diff --git a/xcode/SampleCode/English.lproj/main.nib/info.nib b/xcode/SampleCode/English.lproj/main.nib/info.nib new file mode 100644 index 0000000..2af896b --- /dev/null +++ b/xcode/SampleCode/English.lproj/main.nib/info.nib @@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>IBFramework Version</key> + <string>629</string> + <key>IBLastKnownRelativeProjectPath</key> + <string>../../SampleCode.xcodeproj</string> + <key>IBOldestOS</key> + <integer>5</integer> + <key>IBOpenObjects</key> + <array/> + <key>IBSystem Version</key> + <string>9B18</string> + <key>targetFramework</key> + <string>IBCarbonFramework</string> +</dict> +</plist> diff --git a/xcode/SampleCode/English.lproj/main.nib/objects.xib b/xcode/SampleCode/English.lproj/main.nib/objects.xib new file mode 100644 index 0000000..a9e438e --- /dev/null +++ b/xcode/SampleCode/English.lproj/main.nib/objects.xib @@ -0,0 +1,269 @@ +<?xml version="1.0" standalone="yes"?> +<object class="NSIBObjectData"> + <object name="rootObject" class="NSCustomObject" id="1"> + </object> + <array count="38" name="allObjects"> + <object class="IBCarbonMenuItem" id="193"> + <string name="title">Arrange in Front</string> + <boolean name="dynamic">TRUE</boolean> + <int name="keyEquivalentModifier">1572864</int> + <ostype name="command">frnt</ostype> + </object> + <object class="IBCarbonMenuItem" id="148"> + <string name="title">Select All</string> + <string name="keyEquivalent">a</string> + <ostype name="command">sall</ostype> + </object> + <object class="IBCarbonMenuItem" id="152"> + <string name="title">Edit</string> + <object name="submenu" class="IBCarbonMenu" id="147"> + <string name="title">Edit</string> + <array count="10" name="items"> + <object class="IBCarbonMenuItem" id="141"> + <string name="title">Undo</string> + <string name="keyEquivalent">z</string> + <ostype name="command">undo</ostype> + </object> + <object class="IBCarbonMenuItem" id="146"> + <string name="title">Redo</string> + <string name="keyEquivalent">Z</string> + <ostype name="command">redo</ostype> + </object> + <object class="IBCarbonMenuItem" id="142"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="143"> + <string name="title">Cut</string> + <string name="keyEquivalent">x</string> + <ostype name="command">cut </ostype> + </object> + <object class="IBCarbonMenuItem" id="149"> + <string name="title">Copy</string> + <string name="keyEquivalent">c</string> + <ostype name="command">copy</ostype> + </object> + <object class="IBCarbonMenuItem" id="144"> + <string name="title">Paste</string> + <string name="keyEquivalent">v</string> + <ostype name="command">past</ostype> + </object> + <object class="IBCarbonMenuItem" id="151"> + <string name="title">Delete</string> + <ostype name="command">clea</ostype> + </object> + <reference idRef="148"/> + <object class="IBCarbonMenuItem" id="199"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="198"> + <string name="title">Special Characters…</string> + <ostype name="command">chrp</ostype> + </object> + </array> + </object> + </object> + <object class="IBCarbonRootControl" id="167"> + <string name="bounds">0 0 360 480 </string> + </object> + <object class="IBCarbonMenuItem" id="139"> + <string name="title">New</string> + <string name="keyEquivalent">n</string> + <ostype name="command">new </ostype> + </object> + <object class="IBCarbonMenuItem" id="192"> + <string name="title">Window</string> + <object name="submenu" class="IBCarbonMenu" id="195"> + <string name="title">Window</string> + <string name="name">_NSWindowsMenu</string> + <array count="6" name="items"> + <object class="IBCarbonMenuItem" id="190"> + <string name="title">Minimize</string> + <string name="keyEquivalent">m</string> + <boolean name="dynamic">TRUE</boolean> + <ostype name="command">mini</ostype> + </object> + <object class="IBCarbonMenuItem" id="191"> + <string name="title">Minimize All</string> + <string name="keyEquivalent">m</string> + <boolean name="dynamic">TRUE</boolean> + <int name="keyEquivalentModifier">1572864</int> + <ostype name="command">mina</ostype> + </object> + <object class="IBCarbonMenuItem" id="197"> + <string name="title">Zoom</string> + <ostype name="command">zoom</ostype> + </object> + <object class="IBCarbonMenuItem" id="194"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="196"> + <string name="title">Bring All to Front</string> + <boolean name="dynamic">TRUE</boolean> + <ostype name="command">bfrt</ostype> + </object> + <reference idRef="193"/> + </array> + </object> + </object> + <object class="IBCarbonMenuItem" id="132"> + <string name="title">Revert</string> + <string name="keyEquivalent">r</string> + <ostype name="command">rvrt</ostype> + </object> + <object class="IBCarbonMenuItem" id="187"> + <string name="title">About Foo</string> + <int name="keyEquivalentModifier">0</int> + <ostype name="command">abou</ostype> + </object> + <object class="IBCarbonMenuItem" id="138"> + <string name="title">Save</string> + <string name="keyEquivalent">s</string> + <ostype name="command">save</ostype> + </object> + <object class="IBCarbonMenuItem" id="137"> + <string name="title">Save As…</string> + <string name="keyEquivalent">S</string> + <ostype name="command">svas</ostype> + </object> + <object class="IBCarbonMenuItem" id="136"> + <string name="title">Print…</string> + <string name="keyEquivalent">p</string> + <ostype name="command">prnt</ostype> + </object> + <reference idRef="146"/> + <reference idRef="142"/> + <reference idRef="143"/> + <object class="IBCarbonWindow" id="166"> + <boolean name="liveResize">TRUE</boolean> + <int name="scalingMode">1048576</int> + <string name="title">Window</string> + <reference name="rootControl" idRef="167"/> + <string name="windowRect">1001 727 1361 1207 </string> + <string name="ScreenRectAtEncodeTime">0 0 768 1024 </string> + </object> + <reference idRef="199"/> + <object class="IBCarbonMenuItem" id="135"> + <string name="title">Page Setup…</string> + <string name="keyEquivalent">P</string> + <ostype name="command">page</ostype> + </object> + <reference idRef="144"/> + <object class="IBCarbonMenuItem" id="134"> + <string name="title">Open…</string> + <string name="keyEquivalent">o</string> + <ostype name="command">open</ostype> + </object> + <object class="IBCarbonMenu" id="131"> + <string name="title">File</string> + <array count="10" name="items"> + <reference idRef="139"/> + <reference idRef="134"/> + <object class="IBCarbonMenuItem" id="133"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="130"> + <string name="title">Close</string> + <string name="keyEquivalent">w</string> + <ostype name="command">clos</ostype> + </object> + <reference idRef="138"/> + <reference idRef="137"/> + <reference idRef="132"/> + <object class="IBCarbonMenuItem" id="128"> + <boolean name="separator">TRUE</boolean> + </object> + <reference idRef="135"/> + <reference idRef="136"/> + </array> + </object> + <reference idRef="128"/> + <reference idRef="141"/> + <reference idRef="198"/> + <object class="IBCarbonMenu" id="29"> + <string name="title">main</string> + <string name="name">_NSMainMenu</string> + <array count="4" name="items"> + <object class="IBCarbonMenuItem" id="185"> + <string name="title">Foo</string> + <object name="submenu" class="IBCarbonMenu" id="184"> + <string name="title">Foo</string> + <string name="name">_NSAppleMenu</string> + <array count="1" name="items"> + <reference idRef="187"/> + </array> + </object> + </object> + <object class="IBCarbonMenuItem" id="127"> + <string name="title">File</string> + <reference name="submenu" idRef="131"/> + </object> + <reference idRef="152"/> + <reference idRef="192"/> + </array> + </object> + <reference idRef="184"/> + <reference idRef="194"/> + <reference idRef="195"/> + <reference idRef="127"/> + <reference idRef="147"/> + <reference idRef="133"/> + <reference idRef="149"/> + <reference idRef="151"/> + <reference idRef="190"/> + <reference idRef="185"/> + <reference idRef="197"/> + <reference idRef="130"/> + <reference idRef="191"/> + <reference idRef="196"/> + </array> + <array count="38" name="allParents"> + <reference idRef="195"/> + <reference idRef="147"/> + <reference idRef="29"/> + <reference idRef="166"/> + <reference idRef="131"/> + <reference idRef="29"/> + <reference idRef="131"/> + <reference idRef="184"/> + <reference idRef="131"/> + <reference idRef="131"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="1"/> + <reference idRef="147"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="131"/> + <reference idRef="127"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="1"/> + <reference idRef="185"/> + <reference idRef="195"/> + <reference idRef="192"/> + <reference idRef="29"/> + <reference idRef="152"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="195"/> + <reference idRef="29"/> + <reference idRef="195"/> + <reference idRef="131"/> + <reference idRef="195"/> + <reference idRef="195"/> + </array> + <dictionary count="3" name="nameTable"> + <string>File's Owner</string> + <reference idRef="1"/> + <string>MainWindow</string> + <reference idRef="166"/> + <string>MenuBar</string> + <reference idRef="29"/> + </dictionary> + <string name="targetFramework">IBCarbonFramework</string> + <unsigned_int name="nextObjectID">200</unsigned_int> +</object> diff --git a/xcode/SampleCode/Info.plist b/xcode/SampleCode/Info.plist new file mode 100644 index 0000000..e12ff9b --- /dev/null +++ b/xcode/SampleCode/Info.plist @@ -0,0 +1,26 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> + <string>English</string> + <key>CFBundleExecutable</key> + <string>${EXECUTABLE_NAME}</string> + <key>CFBundleIconFile</key> + <string></string> + <key>CFBundleIdentifier</key> + <string>com.yourcompany.SampleCode</string> + <key>CFBundleInfoDictionaryVersion</key> + <string>6.0</string> + <key>CFBundleName</key> + <string>${PRODUCT_NAME}</string> + <key>CFBundlePackageType</key> + <string>APPL</string> + <key>CFBundleSignature</key> + <string>????</string> + <key>CFBundleVersion</key> + <string>1.0</string> + <key>CSResourcesFileMapped</key> + <true/> +</dict> +</plist> diff --git a/xcode/SampleCode/SampleCode.xcodeproj/project.pbxproj b/xcode/SampleCode/SampleCode.xcodeproj/project.pbxproj new file mode 100644 index 0000000..685aea4 --- /dev/null +++ b/xcode/SampleCode/SampleCode.xcodeproj/project.pbxproj @@ -0,0 +1,1067 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 0008AEE10DABF08F00477EFB /* libgiflib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0008AEDE0DABF01400477EFB /* libgiflib.a */; }; + 00152A800EE71EB60068F9B2 /* SkDumpCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00152A7F0EE71EB60068F9B2 /* SkDumpCanvas.cpp */; }; + 0017F2CF0D6F3933008D9B31 /* libgraphics.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C440D3E999300651393 /* libgraphics.a */; }; + 0017F2D00D6F393F008D9B31 /* libcorecg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C2C0D3E999300651393 /* libcorecg.a */; }; + 0017F2D60D6F3949008D9B31 /* libviews.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C5E0D3E999300651393 /* libviews.a */; }; + 006860100D8A1C8B00CD71AA /* OpenGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0068600F0D8A1C8A00CD71AA /* OpenGL.framework */; }; + 006860290D8A1DFB00CD71AA /* AGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 006860280D8A1DFB00CD71AA /* AGL.framework */; }; + 0081D7800EE45EF100AB0A0A /* SampleRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F60EDCAF2000F77EA2 /* SampleRegion.cpp */; }; + 0082BE7C0EE414DE00DEE451 /* SkSetPoly3To3.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0082BE790EE414DE00DEE451 /* SkSetPoly3To3.cpp */; }; + 009A74250DA11C5D00876C03 /* libGL.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 009A740E0DA11B1F00876C03 /* libGL.a */; }; + 00B7E3030EDCAF2000F77EA2 /* SampleAll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2D70EDCAF2000F77EA2 /* SampleAll.cpp */; }; + 00B7E3040EDCAF2000F77EA2 /* SampleApp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2D80EDCAF2000F77EA2 /* SampleApp.cpp */; }; + 00B7E3050EDCAF2000F77EA2 /* SampleArc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2D90EDCAF2000F77EA2 /* SampleArc.cpp */; }; + 00B7E3060EDCAF2000F77EA2 /* SampleBitmapRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DA0EDCAF2000F77EA2 /* SampleBitmapRect.cpp */; }; + 00B7E3070EDCAF2000F77EA2 /* SampleCamera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DB0EDCAF2000F77EA2 /* SampleCamera.cpp */; }; + 00B7E3080EDCAF2000F77EA2 /* SampleCircle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DC0EDCAF2000F77EA2 /* SampleCircle.cpp */; }; + 00B7E3090EDCAF2000F77EA2 /* SampleCull.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DE0EDCAF2000F77EA2 /* SampleCull.cpp */; }; + 00B7E30A0EDCAF2000F77EA2 /* SampleDither.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2DF0EDCAF2000F77EA2 /* SampleDither.cpp */; }; + 00B7E30B0EDCAF2000F77EA2 /* SampleDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E00EDCAF2000F77EA2 /* SampleDrawLooper.cpp */; }; + 00B7E30C0EDCAF2000F77EA2 /* SampleEmboss.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E10EDCAF2000F77EA2 /* SampleEmboss.cpp */; }; + 00B7E30D0EDCAF2000F77EA2 /* SampleEncode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E20EDCAF2000F77EA2 /* SampleEncode.cpp */; }; + 00B7E30F0EDCAF2000F77EA2 /* SampleFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E40EDCAF2000F77EA2 /* SampleFilter.cpp */; }; + 00B7E3100EDCAF2000F77EA2 /* SampleFilter2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E50EDCAF2000F77EA2 /* SampleFilter2.cpp */; }; + 00B7E3110EDCAF2000F77EA2 /* SampleFontCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E60EDCAF2000F77EA2 /* SampleFontCache.cpp */; }; + 00B7E3130EDCAF2000F77EA2 /* SampleImage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E80EDCAF2000F77EA2 /* SampleImage.cpp */; }; + 00B7E3140EDCAF2000F77EA2 /* SampleImageDir.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2E90EDCAF2000F77EA2 /* SampleImageDir.cpp */; }; + 00B7E3150EDCAF2000F77EA2 /* SampleLayers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EA0EDCAF2000F77EA2 /* SampleLayers.cpp */; }; + 00B7E3160EDCAF2000F77EA2 /* SampleLines.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EB0EDCAF2000F77EA2 /* SampleLines.cpp */; }; + 00B7E3170EDCAF2000F77EA2 /* SampleMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EC0EDCAF2000F77EA2 /* SampleMeasure.cpp */; }; + 00B7E3180EDCAF2000F77EA2 /* SampleNinePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2ED0EDCAF2000F77EA2 /* SampleNinePatch.cpp */; }; + 00B7E3190EDCAF2000F77EA2 /* SampleOverflow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EE0EDCAF2000F77EA2 /* SampleOverflow.cpp */; }; + 00B7E31A0EDCAF2000F77EA2 /* SamplePageFlip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2EF0EDCAF2000F77EA2 /* SamplePageFlip.cpp */; }; + 00B7E31B0EDCAF2000F77EA2 /* SamplePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F00EDCAF2000F77EA2 /* SamplePatch.cpp */; }; + 00B7E31C0EDCAF2000F77EA2 /* SamplePath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F10EDCAF2000F77EA2 /* SamplePath.cpp */; }; + 00B7E31D0EDCAF2000F77EA2 /* SamplePathEffects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F20EDCAF2000F77EA2 /* SamplePathEffects.cpp */; }; + 00B7E31E0EDCAF2000F77EA2 /* SamplePicture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F30EDCAF2000F77EA2 /* SamplePicture.cpp */; }; + 00B7E31F0EDCAF2000F77EA2 /* SamplePoints.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F40EDCAF2000F77EA2 /* SamplePoints.cpp */; }; + 00B7E3200EDCAF2000F77EA2 /* SamplePolyToPoly.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F50EDCAF2000F77EA2 /* SamplePolyToPoly.cpp */; }; + 00B7E3220EDCAF2000F77EA2 /* SampleShaders.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F70EDCAF2000F77EA2 /* SampleShaders.cpp */; }; + 00B7E3230EDCAF2000F77EA2 /* SampleStrokeText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F80EDCAF2000F77EA2 /* SampleStrokeText.cpp */; }; + 00B7E3240EDCAF2000F77EA2 /* SampleTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2F90EDCAF2000F77EA2 /* SampleTests.cpp */; }; + 00B7E3250EDCAF2000F77EA2 /* SampleText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FA0EDCAF2000F77EA2 /* SampleText.cpp */; }; + 00B7E3260EDCAF2000F77EA2 /* SampleTextAlpha.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FB0EDCAF2000F77EA2 /* SampleTextAlpha.cpp */; }; + 00B7E3270EDCAF2000F77EA2 /* SampleTextEffects.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FC0EDCAF2000F77EA2 /* SampleTextEffects.cpp */; }; + 00B7E3280EDCAF2000F77EA2 /* SampleTextOnPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FD0EDCAF2000F77EA2 /* SampleTextOnPath.cpp */; }; + 00B7E3290EDCAF2000F77EA2 /* SampleTiling.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FE0EDCAF2000F77EA2 /* SampleTiling.cpp */; }; + 00B7E32A0EDCAF2000F77EA2 /* SampleTypeface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2FF0EDCAF2000F77EA2 /* SampleTypeface.cpp */; }; + 00B7E32B0EDCAF2000F77EA2 /* SampleVertices.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3000EDCAF2000F77EA2 /* SampleVertices.cpp */; }; + 00B7E32C0EDCAF2000F77EA2 /* SampleXfermodes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3010EDCAF2000F77EA2 /* SampleXfermodes.cpp */; }; + 00B7E32D0EDCAF2000F77EA2 /* vertexdump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3020EDCAF2000F77EA2 /* vertexdump.cpp */; }; + 00B7E3560EDCB03600F77EA2 /* test.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3520EDCB03600F77EA2 /* test.cpp */; }; + 00B7E3570EDCB03600F77EA2 /* test_drawcolor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3540EDCB03600F77EA2 /* test_drawcolor.cpp */; }; + 00B7E3580EDCB03600F77EA2 /* test_drawrect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3550EDCB03600F77EA2 /* test_drawrect.cpp */; }; + 00D12E4D0DAD3D0A003918C5 /* libanimator.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0013C7920D94043200B41703 /* libanimator.a */; }; + 00ED8CD70D3E9FD900651393 /* libexpat.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C320D3E999300651393 /* libexpat.a */; }; + 00ED8CD80D3E9FDB00651393 /* libfreetype.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C380D3E999300651393 /* libfreetype.a */; }; + 00ED8CDB0D3E9FE300651393 /* libjpeg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C480D3E999300651393 /* libjpeg.a */; }; + 00ED8CDC0D3E9FE500651393 /* liblibpng.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C4C0D3E999300651393 /* liblibpng.a */; }; + 00ED8CDD0D3E9FE700651393 /* libports-mac.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C520D3E999300651393 /* libports-mac.a */; }; + 00ED8CDE0D3E9FEA00651393 /* libports.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C580D3E999300651393 /* libports.a */; }; + 00ED8CE00D3E9FEF00651393 /* libzlib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00ED8C620D3E999300651393 /* libzlib.a */; }; + 8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; }; + 8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; }; + 8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 0008AEDD0DABF01400477EFB /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 0008AED90DABF01300477EFB /* giflib.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = giflib; + }; + 0008AF0F0DABF9BD00477EFB /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 0008AED90DABF01300477EFB /* giflib.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = giflib; + }; + 0013C7910D94043200B41703 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 0013C78A0D94043200B41703 /* animator.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = animator; + }; + 0013C7940D94044800B41703 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 0013C78A0D94043200B41703 /* animator.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = animator; + }; + 009A740D0DA11B1F00876C03 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 009A74060DA11B1F00876C03 /* GL.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = GL; + }; + 009A741C0DA11BAE00876C03 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 009A74060DA11B1F00876C03 /* GL.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = GL; + }; + 00ED8C2B0D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C060D3E999300651393 /* corecg.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = corecg; + }; + 00ED8C310D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C090D3E999300651393 /* expat.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = expat; + }; + 00ED8C370D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = freetype; + }; + 00ED8C430D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C120D3E999300651393 /* graphics.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC06F0554671400DB518D; + remoteInfo = graphics; + }; + 00ED8C470D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C150D3E999300651393 /* jpeg.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = jpeg; + }; + 00ED8C4B0D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C180D3E999300651393 /* libpng.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = libpng; + }; + 00ED8C510D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = "ports-mac"; + }; + 00ED8C570D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C1E0D3E999300651393 /* ports.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = ports; + }; + 00ED8C5D0D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C210D3E999300651393 /* views.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = views; + }; + 00ED8C610D3E999300651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C240D3E999300651393 /* zlib.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = zlib; + }; + 00ED8C9D0D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = "ports-mac"; + }; + 00ED8C9F0D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C1E0D3E999300651393 /* ports.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = ports; + }; + 00ED8CA10D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C150D3E999300651393 /* jpeg.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = jpeg; + }; + 00ED8CA30D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C120D3E999300651393 /* graphics.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC06E0554671400DB518D; + remoteInfo = graphics; + }; + 00ED8CA70D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C090D3E999300651393 /* expat.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = expat; + }; + 00ED8CA90D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C210D3E999300651393 /* views.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = views; + }; + 00ED8CAB0D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C060D3E999300651393 /* corecg.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = corecg; + }; + 00ED8CAD0D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C240D3E999300651393 /* zlib.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = zlib; + }; + 00ED8CAF0D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = freetype; + }; + 00ED8CB10D3E9AFA00651393 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00ED8C180D3E999300651393 /* libpng.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = libpng; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 0008AED90DABF01300477EFB /* giflib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = giflib.xcodeproj; path = ../giflib.xcodeproj; sourceTree = SOURCE_ROOT; }; + 0013C78A0D94043200B41703 /* animator.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = animator.xcodeproj; path = ../animator.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00152A7F0EE71EB60068F9B2 /* SkDumpCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDumpCanvas.cpp; path = ../../libsgl/effects/SkDumpCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00152A810EE71EEC0068F9B2 /* SkDumpCanvas.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDumpCanvas.h; path = ../../include/graphics/SkDumpCanvas.h; sourceTree = SOURCE_ROOT; }; + 0068600F0D8A1C8A00CD71AA /* OpenGL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenGL.framework; path = SDKs/MacOSX10.5.sdk/System/Library/Frameworks/OpenGL.framework; sourceTree = SYSTEM_DEVELOPER_DIR; }; + 006860280D8A1DFB00CD71AA /* AGL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AGL.framework; path = SDKs/MacOSX10.5.sdk/System/Library/Frameworks/AGL.framework; sourceTree = SYSTEM_DEVELOPER_DIR; }; + 0082BE790EE414DE00DEE451 /* SkSetPoly3To3.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSetPoly3To3.cpp; path = ../../test/SkSetPoly3To3.cpp; sourceTree = SOURCE_ROOT; }; + 0082BE7A0EE414DE00DEE451 /* SkSetPoly3To3_A.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSetPoly3To3_A.cpp; path = ../../test/SkSetPoly3To3_A.cpp; sourceTree = SOURCE_ROOT; }; + 0082BE7B0EE414DE00DEE451 /* SkSetPoly3To3_D.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSetPoly3To3_D.cpp; path = ../../test/SkSetPoly3To3_D.cpp; sourceTree = SOURCE_ROOT; }; + 009A74060DA11B1F00876C03 /* GL.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = GL.xcodeproj; path = ../GL.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00B7E2D70EDCAF2000F77EA2 /* SampleAll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleAll.cpp; path = ../../Samples/SampleAll.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2D80EDCAF2000F77EA2 /* SampleApp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleApp.cpp; path = ../../Samples/SampleApp.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2D90EDCAF2000F77EA2 /* SampleArc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleArc.cpp; path = ../../Samples/SampleArc.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2DA0EDCAF2000F77EA2 /* SampleBitmapRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleBitmapRect.cpp; path = ../../Samples/SampleBitmapRect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2DB0EDCAF2000F77EA2 /* SampleCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleCamera.cpp; path = ../../Samples/SampleCamera.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2DC0EDCAF2000F77EA2 /* SampleCircle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleCircle.cpp; path = ../../Samples/SampleCircle.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2DD0EDCAF2000F77EA2 /* SampleCode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SampleCode.h; path = ../../Samples/SampleCode.h; sourceTree = SOURCE_ROOT; }; + 00B7E2DE0EDCAF2000F77EA2 /* SampleCull.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleCull.cpp; path = ../../Samples/SampleCull.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2DF0EDCAF2000F77EA2 /* SampleDither.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleDither.cpp; path = ../../Samples/SampleDither.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E00EDCAF2000F77EA2 /* SampleDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleDrawLooper.cpp; path = ../../Samples/SampleDrawLooper.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E10EDCAF2000F77EA2 /* SampleEmboss.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleEmboss.cpp; path = ../../Samples/SampleEmboss.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E20EDCAF2000F77EA2 /* SampleEncode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleEncode.cpp; path = ../../Samples/SampleEncode.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E30EDCAF2000F77EA2 /* SampleFillType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFillType.cpp; path = ../../Samples/SampleFillType.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E40EDCAF2000F77EA2 /* SampleFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFilter.cpp; path = ../../Samples/SampleFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E50EDCAF2000F77EA2 /* SampleFilter2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFilter2.cpp; path = ../../Samples/SampleFilter2.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E60EDCAF2000F77EA2 /* SampleFontCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleFontCache.cpp; path = ../../Samples/SampleFontCache.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E70EDCAF2000F77EA2 /* SampleGL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleGL.cpp; path = ../../Samples/SampleGL.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E80EDCAF2000F77EA2 /* SampleImage.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleImage.cpp; path = ../../Samples/SampleImage.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2E90EDCAF2000F77EA2 /* SampleImageDir.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleImageDir.cpp; path = ../../Samples/SampleImageDir.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2EA0EDCAF2000F77EA2 /* SampleLayers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleLayers.cpp; path = ../../Samples/SampleLayers.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2EB0EDCAF2000F77EA2 /* SampleLines.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleLines.cpp; path = ../../Samples/SampleLines.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2EC0EDCAF2000F77EA2 /* SampleMeasure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleMeasure.cpp; path = ../../Samples/SampleMeasure.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2ED0EDCAF2000F77EA2 /* SampleNinePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleNinePatch.cpp; path = ../../Samples/SampleNinePatch.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2EE0EDCAF2000F77EA2 /* SampleOverflow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleOverflow.cpp; path = ../../Samples/SampleOverflow.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2EF0EDCAF2000F77EA2 /* SamplePageFlip.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePageFlip.cpp; path = ../../Samples/SamplePageFlip.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F00EDCAF2000F77EA2 /* SamplePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePatch.cpp; path = ../../Samples/SamplePatch.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F10EDCAF2000F77EA2 /* SamplePath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePath.cpp; path = ../../Samples/SamplePath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F20EDCAF2000F77EA2 /* SamplePathEffects.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePathEffects.cpp; path = ../../Samples/SamplePathEffects.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F30EDCAF2000F77EA2 /* SamplePicture.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePicture.cpp; path = ../../Samples/SamplePicture.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F40EDCAF2000F77EA2 /* SamplePoints.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePoints.cpp; path = ../../Samples/SamplePoints.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F50EDCAF2000F77EA2 /* SamplePolyToPoly.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplePolyToPoly.cpp; path = ../../Samples/SamplePolyToPoly.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F60EDCAF2000F77EA2 /* SampleRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleRegion.cpp; path = ../../Samples/SampleRegion.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F70EDCAF2000F77EA2 /* SampleShaders.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleShaders.cpp; path = ../../Samples/SampleShaders.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F80EDCAF2000F77EA2 /* SampleStrokeText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleStrokeText.cpp; path = ../../Samples/SampleStrokeText.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2F90EDCAF2000F77EA2 /* SampleTests.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTests.cpp; path = ../../Samples/SampleTests.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2FA0EDCAF2000F77EA2 /* SampleText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleText.cpp; path = ../../Samples/SampleText.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2FB0EDCAF2000F77EA2 /* SampleTextAlpha.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTextAlpha.cpp; path = ../../Samples/SampleTextAlpha.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2FC0EDCAF2000F77EA2 /* SampleTextEffects.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTextEffects.cpp; path = ../../Samples/SampleTextEffects.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2FD0EDCAF2000F77EA2 /* SampleTextOnPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTextOnPath.cpp; path = ../../Samples/SampleTextOnPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2FE0EDCAF2000F77EA2 /* SampleTiling.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTiling.cpp; path = ../../Samples/SampleTiling.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E2FF0EDCAF2000F77EA2 /* SampleTypeface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleTypeface.cpp; path = ../../Samples/SampleTypeface.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3000EDCAF2000F77EA2 /* SampleVertices.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleVertices.cpp; path = ../../Samples/SampleVertices.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3010EDCAF2000F77EA2 /* SampleXfermodes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SampleXfermodes.cpp; path = ../../Samples/SampleXfermodes.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3020EDCAF2000F77EA2 /* vertexdump.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = vertexdump.cpp; path = ../../Samples/vertexdump.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3430EDCAFA600F77EA2 /* SkGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGeometry.h; path = ../../libsgl/sgl/SkGeometry.h; sourceTree = SOURCE_ROOT; }; + 00B7E3520EDCB03600F77EA2 /* test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test.cpp; path = ../../test/test.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3530EDCB03600F77EA2 /* test.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = test.h; path = ../../test/test.h; sourceTree = SOURCE_ROOT; }; + 00B7E3540EDCB03600F77EA2 /* test_drawcolor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test_drawcolor.cpp; path = ../../test/test_drawcolor.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3550EDCB03600F77EA2 /* test_drawrect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test_drawrect.cpp; path = ../../test/test_drawrect.cpp; sourceTree = SOURCE_ROOT; }; + 00ED8C060D3E999300651393 /* corecg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = corecg.xcodeproj; path = ../corecg.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C090D3E999300651393 /* expat.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = expat.xcodeproj; path = ../expat.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = freetype2.xcodeproj; path = ../freetype2.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C120D3E999300651393 /* graphics.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = graphics.xcodeproj; path = ../graphics.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C150D3E999300651393 /* jpeg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = jpeg.xcodeproj; path = ../jpeg.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C180D3E999300651393 /* libpng.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = libpng.xcodeproj; path = ../libpng.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = "ports-mac.xcodeproj"; path = "../ports-mac.xcodeproj"; sourceTree = SOURCE_ROOT; }; + 00ED8C1E0D3E999300651393 /* ports.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = ports.xcodeproj; path = ../ports.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C210D3E999300651393 /* views.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = views.xcodeproj; path = ../views.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00ED8C240D3E999300651393 /* zlib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = zlib.xcodeproj; path = ../zlib.xcodeproj; sourceTree = SOURCE_ROOT; }; + 0867D6ABFE840B52C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 1870340FFE93FCAF11CA0CD7 /* English */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; name = English; path = English.lproj/main.nib; sourceTree = "<group>"; }; + 20286C33FDCF999611CA2CEA /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; }; + 8D0C4E960486CD37000505A6 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; }; + 8D0C4E970486CD37000505A6 /* SampleCode.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = SampleCode.app; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8D0C4E910486CD37000505A6 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 00ED8CD70D3E9FD900651393 /* libexpat.a in Frameworks */, + 00ED8CD80D3E9FDB00651393 /* libfreetype.a in Frameworks */, + 00ED8CDB0D3E9FE300651393 /* libjpeg.a in Frameworks */, + 00ED8CDC0D3E9FE500651393 /* liblibpng.a in Frameworks */, + 00ED8CDD0D3E9FE700651393 /* libports-mac.a in Frameworks */, + 00ED8CDE0D3E9FEA00651393 /* libports.a in Frameworks */, + 00ED8CE00D3E9FEF00651393 /* libzlib.a in Frameworks */, + 8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */, + 0017F2CF0D6F3933008D9B31 /* libgraphics.a in Frameworks */, + 0017F2D00D6F393F008D9B31 /* libcorecg.a in Frameworks */, + 0017F2D60D6F3949008D9B31 /* libviews.a in Frameworks */, + 006860100D8A1C8B00CD71AA /* OpenGL.framework in Frameworks */, + 006860290D8A1DFB00CD71AA /* AGL.framework in Frameworks */, + 009A74250DA11C5D00876C03 /* libGL.a in Frameworks */, + 0008AEE10DABF08F00477EFB /* libgiflib.a in Frameworks */, + 00D12E4D0DAD3D0A003918C5 /* libanimator.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 0008AEDA0DABF01300477EFB /* Products */ = { + isa = PBXGroup; + children = ( + 0008AEDE0DABF01400477EFB /* libgiflib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 0013C78B0D94043200B41703 /* Products */ = { + isa = PBXGroup; + children = ( + 0013C7920D94043200B41703 /* libanimator.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 009A74070DA11B1F00876C03 /* Products */ = { + isa = PBXGroup; + children = ( + 009A740E0DA11B1F00876C03 /* libGL.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00B7E2D60EDCAF0E00F77EA2 /* Samples */ = { + isa = PBXGroup; + children = ( + 00B7E3430EDCAFA600F77EA2 /* SkGeometry.h */, + 00B7E2D70EDCAF2000F77EA2 /* SampleAll.cpp */, + 00B7E2D80EDCAF2000F77EA2 /* SampleApp.cpp */, + 00B7E2D90EDCAF2000F77EA2 /* SampleArc.cpp */, + 00B7E2DA0EDCAF2000F77EA2 /* SampleBitmapRect.cpp */, + 00B7E2DB0EDCAF2000F77EA2 /* SampleCamera.cpp */, + 00B7E2DC0EDCAF2000F77EA2 /* SampleCircle.cpp */, + 00B7E2DD0EDCAF2000F77EA2 /* SampleCode.h */, + 00B7E2DE0EDCAF2000F77EA2 /* SampleCull.cpp */, + 00B7E2DF0EDCAF2000F77EA2 /* SampleDither.cpp */, + 00B7E2E00EDCAF2000F77EA2 /* SampleDrawLooper.cpp */, + 00B7E2E10EDCAF2000F77EA2 /* SampleEmboss.cpp */, + 00B7E2E20EDCAF2000F77EA2 /* SampleEncode.cpp */, + 00B7E2E30EDCAF2000F77EA2 /* SampleFillType.cpp */, + 00B7E2E40EDCAF2000F77EA2 /* SampleFilter.cpp */, + 00B7E2E50EDCAF2000F77EA2 /* SampleFilter2.cpp */, + 00B7E2E60EDCAF2000F77EA2 /* SampleFontCache.cpp */, + 00B7E2E70EDCAF2000F77EA2 /* SampleGL.cpp */, + 00B7E2E80EDCAF2000F77EA2 /* SampleImage.cpp */, + 00B7E2E90EDCAF2000F77EA2 /* SampleImageDir.cpp */, + 00B7E2EA0EDCAF2000F77EA2 /* SampleLayers.cpp */, + 00B7E2EB0EDCAF2000F77EA2 /* SampleLines.cpp */, + 00B7E2EC0EDCAF2000F77EA2 /* SampleMeasure.cpp */, + 00B7E2ED0EDCAF2000F77EA2 /* SampleNinePatch.cpp */, + 00B7E2EE0EDCAF2000F77EA2 /* SampleOverflow.cpp */, + 00B7E2EF0EDCAF2000F77EA2 /* SamplePageFlip.cpp */, + 00B7E2F00EDCAF2000F77EA2 /* SamplePatch.cpp */, + 00B7E2F10EDCAF2000F77EA2 /* SamplePath.cpp */, + 00B7E2F20EDCAF2000F77EA2 /* SamplePathEffects.cpp */, + 00B7E2F30EDCAF2000F77EA2 /* SamplePicture.cpp */, + 00B7E2F40EDCAF2000F77EA2 /* SamplePoints.cpp */, + 00B7E2F50EDCAF2000F77EA2 /* SamplePolyToPoly.cpp */, + 00B7E2F60EDCAF2000F77EA2 /* SampleRegion.cpp */, + 00B7E2F70EDCAF2000F77EA2 /* SampleShaders.cpp */, + 00B7E2F80EDCAF2000F77EA2 /* SampleStrokeText.cpp */, + 00B7E2F90EDCAF2000F77EA2 /* SampleTests.cpp */, + 00B7E2FA0EDCAF2000F77EA2 /* SampleText.cpp */, + 00B7E2FB0EDCAF2000F77EA2 /* SampleTextAlpha.cpp */, + 00B7E2FC0EDCAF2000F77EA2 /* SampleTextEffects.cpp */, + 00B7E2FD0EDCAF2000F77EA2 /* SampleTextOnPath.cpp */, + 00B7E2FE0EDCAF2000F77EA2 /* SampleTiling.cpp */, + 00B7E2FF0EDCAF2000F77EA2 /* SampleTypeface.cpp */, + 00B7E3000EDCAF2000F77EA2 /* SampleVertices.cpp */, + 00B7E3010EDCAF2000F77EA2 /* SampleXfermodes.cpp */, + 00B7E3020EDCAF2000F77EA2 /* vertexdump.cpp */, + ); + name = Samples; + sourceTree = "<group>"; + }; + 00B7E3510EDCB02800F77EA2 /* tests */ = { + isa = PBXGroup; + children = ( + 00152A810EE71EEC0068F9B2 /* SkDumpCanvas.h */, + 00152A7F0EE71EB60068F9B2 /* SkDumpCanvas.cpp */, + 0082BE790EE414DE00DEE451 /* SkSetPoly3To3.cpp */, + 0082BE7A0EE414DE00DEE451 /* SkSetPoly3To3_A.cpp */, + 0082BE7B0EE414DE00DEE451 /* SkSetPoly3To3_D.cpp */, + 00B7E3520EDCB03600F77EA2 /* test.cpp */, + 00B7E3530EDCB03600F77EA2 /* test.h */, + 00B7E3540EDCB03600F77EA2 /* test_drawcolor.cpp */, + 00B7E3550EDCB03600F77EA2 /* test_drawrect.cpp */, + ); + name = tests; + sourceTree = "<group>"; + }; + 00ED8C070D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C2C0D3E999300651393 /* libcorecg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C0A0D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C320D3E999300651393 /* libexpat.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C0D0D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C380D3E999300651393 /* libfreetype.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C130D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C440D3E999300651393 /* libgraphics.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C160D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C480D3E999300651393 /* libjpeg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C190D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C4C0D3E999300651393 /* liblibpng.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C1C0D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C520D3E999300651393 /* libports-mac.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C1F0D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C580D3E999300651393 /* libports.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C220D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C5E0D3E999300651393 /* libviews.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00ED8C250D3E999300651393 /* Products */ = { + isa = PBXGroup; + children = ( + 00ED8C620D3E999300651393 /* libzlib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 195DF8CFFE9D517E11CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 8D0C4E970486CD37000505A6 /* SampleCode.app */, + ); + name = Products; + sourceTree = "<group>"; + }; + 20286C29FDCF999611CA2CEA /* SampleCode */ = { + isa = PBXGroup; + children = ( + 00B7E3510EDCB02800F77EA2 /* tests */, + 00B7E2D60EDCAF0E00F77EA2 /* Samples */, + 0008AED90DABF01300477EFB /* giflib.xcodeproj */, + 009A74060DA11B1F00876C03 /* GL.xcodeproj */, + 0013C78A0D94043200B41703 /* animator.xcodeproj */, + 00ED8C060D3E999300651393 /* corecg.xcodeproj */, + 00ED8C090D3E999300651393 /* expat.xcodeproj */, + 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */, + 00ED8C120D3E999300651393 /* graphics.xcodeproj */, + 00ED8C150D3E999300651393 /* jpeg.xcodeproj */, + 00ED8C180D3E999300651393 /* libpng.xcodeproj */, + 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */, + 00ED8C1E0D3E999300651393 /* ports.xcodeproj */, + 00ED8C210D3E999300651393 /* views.xcodeproj */, + 00ED8C240D3E999300651393 /* zlib.xcodeproj */, + 20286C2CFDCF999611CA2CEA /* Resources */, + 20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */, + 195DF8CFFE9D517E11CA2CBB /* Products */, + ); + name = SampleCode; + sourceTree = "<group>"; + }; + 20286C2CFDCF999611CA2CEA /* Resources */ = { + isa = PBXGroup; + children = ( + 8D0C4E960486CD37000505A6 /* Info.plist */, + 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */, + 02345980000FD03B11CA0E72 /* main.nib */, + ); + name = Resources; + sourceTree = "<group>"; + }; + 20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */ = { + isa = PBXGroup; + children = ( + 006860280D8A1DFB00CD71AA /* AGL.framework */, + 0068600F0D8A1C8A00CD71AA /* OpenGL.framework */, + 20286C33FDCF999611CA2CEA /* Carbon.framework */, + ); + name = "External Frameworks and Libraries"; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 8D0C4E890486CD37000505A6 /* SampleCode */ = { + isa = PBXNativeTarget; + buildConfigurationList = C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "SampleCode" */; + buildPhases = ( + 8D0C4E8C0486CD37000505A6 /* Resources */, + 8D0C4E8F0486CD37000505A6 /* Sources */, + 8D0C4E910486CD37000505A6 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 00ED8C9E0D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CA00D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CA20D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CA40D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CA80D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CAA0D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CAC0D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CAE0D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CB00D3E9AFA00651393 /* PBXTargetDependency */, + 00ED8CB20D3E9AFA00651393 /* PBXTargetDependency */, + 0013C7950D94044800B41703 /* PBXTargetDependency */, + 009A741D0DA11BAE00876C03 /* PBXTargetDependency */, + 0008AF100DABF9BD00477EFB /* PBXTargetDependency */, + ); + name = SampleCode; + productInstallPath = "$(HOME)/Applications"; + productName = SampleCode; + productReference = 8D0C4E970486CD37000505A6 /* SampleCode.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 20286C28FDCF999611CA2CEA /* Project object */ = { + isa = PBXProject; + buildConfigurationList = C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "SampleCode" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 20286C29FDCF999611CA2CEA /* SampleCode */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 0013C78B0D94043200B41703 /* Products */; + ProjectRef = 0013C78A0D94043200B41703 /* animator.xcodeproj */; + }, + { + ProductGroup = 00ED8C070D3E999300651393 /* Products */; + ProjectRef = 00ED8C060D3E999300651393 /* corecg.xcodeproj */; + }, + { + ProductGroup = 00ED8C0A0D3E999300651393 /* Products */; + ProjectRef = 00ED8C090D3E999300651393 /* expat.xcodeproj */; + }, + { + ProductGroup = 00ED8C0D0D3E999300651393 /* Products */; + ProjectRef = 00ED8C0C0D3E999300651393 /* freetype2.xcodeproj */; + }, + { + ProductGroup = 0008AEDA0DABF01300477EFB /* Products */; + ProjectRef = 0008AED90DABF01300477EFB /* giflib.xcodeproj */; + }, + { + ProductGroup = 009A74070DA11B1F00876C03 /* Products */; + ProjectRef = 009A74060DA11B1F00876C03 /* GL.xcodeproj */; + }, + { + ProductGroup = 00ED8C130D3E999300651393 /* Products */; + ProjectRef = 00ED8C120D3E999300651393 /* graphics.xcodeproj */; + }, + { + ProductGroup = 00ED8C160D3E999300651393 /* Products */; + ProjectRef = 00ED8C150D3E999300651393 /* jpeg.xcodeproj */; + }, + { + ProductGroup = 00ED8C190D3E999300651393 /* Products */; + ProjectRef = 00ED8C180D3E999300651393 /* libpng.xcodeproj */; + }, + { + ProductGroup = 00ED8C1C0D3E999300651393 /* Products */; + ProjectRef = 00ED8C1B0D3E999300651393 /* ports-mac.xcodeproj */; + }, + { + ProductGroup = 00ED8C1F0D3E999300651393 /* Products */; + ProjectRef = 00ED8C1E0D3E999300651393 /* ports.xcodeproj */; + }, + { + ProductGroup = 00ED8C220D3E999300651393 /* Products */; + ProjectRef = 00ED8C210D3E999300651393 /* views.xcodeproj */; + }, + { + ProductGroup = 00ED8C250D3E999300651393 /* Products */; + ProjectRef = 00ED8C240D3E999300651393 /* zlib.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 8D0C4E890486CD37000505A6 /* SampleCode */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 0008AEDE0DABF01400477EFB /* libgiflib.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libgiflib.a; + remoteRef = 0008AEDD0DABF01400477EFB /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 0013C7920D94043200B41703 /* libanimator.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libanimator.a; + remoteRef = 0013C7910D94043200B41703 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 009A740E0DA11B1F00876C03 /* libGL.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libGL.a; + remoteRef = 009A740D0DA11B1F00876C03 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C2C0D3E999300651393 /* libcorecg.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libcorecg.a; + remoteRef = 00ED8C2B0D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C320D3E999300651393 /* libexpat.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libexpat.a; + remoteRef = 00ED8C310D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C380D3E999300651393 /* libfreetype.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libfreetype.a; + remoteRef = 00ED8C370D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C440D3E999300651393 /* libgraphics.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libgraphics.a; + remoteRef = 00ED8C430D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C480D3E999300651393 /* libjpeg.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libjpeg.a; + remoteRef = 00ED8C470D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C4C0D3E999300651393 /* liblibpng.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = liblibpng.a; + remoteRef = 00ED8C4B0D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C520D3E999300651393 /* libports-mac.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libports-mac.a"; + remoteRef = 00ED8C510D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C580D3E999300651393 /* libports.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libports.a; + remoteRef = 00ED8C570D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C5E0D3E999300651393 /* libviews.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libviews.a; + remoteRef = 00ED8C5D0D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00ED8C620D3E999300651393 /* libzlib.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libzlib.a; + remoteRef = 00ED8C610D3E999300651393 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXResourcesBuildPhase section */ + 8D0C4E8C0486CD37000505A6 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */, + 8D0C4E8E0486CD37000505A6 /* main.nib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 8D0C4E8F0486CD37000505A6 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E3030EDCAF2000F77EA2 /* SampleAll.cpp in Sources */, + 00B7E3040EDCAF2000F77EA2 /* SampleApp.cpp in Sources */, + 00B7E3060EDCAF2000F77EA2 /* SampleBitmapRect.cpp in Sources */, + 00B7E3070EDCAF2000F77EA2 /* SampleCamera.cpp in Sources */, + 00B7E3090EDCAF2000F77EA2 /* SampleCull.cpp in Sources */, + 00B7E30B0EDCAF2000F77EA2 /* SampleDrawLooper.cpp in Sources */, + 00B7E30C0EDCAF2000F77EA2 /* SampleEmboss.cpp in Sources */, + 00B7E30D0EDCAF2000F77EA2 /* SampleEncode.cpp in Sources */, + 00B7E30F0EDCAF2000F77EA2 /* SampleFilter.cpp in Sources */, + 00B7E3100EDCAF2000F77EA2 /* SampleFilter2.cpp in Sources */, + 00B7E3110EDCAF2000F77EA2 /* SampleFontCache.cpp in Sources */, + 00B7E3130EDCAF2000F77EA2 /* SampleImage.cpp in Sources */, + 00B7E3140EDCAF2000F77EA2 /* SampleImageDir.cpp in Sources */, + 00B7E3150EDCAF2000F77EA2 /* SampleLayers.cpp in Sources */, + 00B7E3160EDCAF2000F77EA2 /* SampleLines.cpp in Sources */, + 00B7E3170EDCAF2000F77EA2 /* SampleMeasure.cpp in Sources */, + 00B7E3180EDCAF2000F77EA2 /* SampleNinePatch.cpp in Sources */, + 00B7E3190EDCAF2000F77EA2 /* SampleOverflow.cpp in Sources */, + 00B7E31A0EDCAF2000F77EA2 /* SamplePageFlip.cpp in Sources */, + 00B7E31B0EDCAF2000F77EA2 /* SamplePatch.cpp in Sources */, + 00B7E31C0EDCAF2000F77EA2 /* SamplePath.cpp in Sources */, + 00B7E31D0EDCAF2000F77EA2 /* SamplePathEffects.cpp in Sources */, + 00B7E31E0EDCAF2000F77EA2 /* SamplePicture.cpp in Sources */, + 00B7E31F0EDCAF2000F77EA2 /* SamplePoints.cpp in Sources */, + 00B7E3200EDCAF2000F77EA2 /* SamplePolyToPoly.cpp in Sources */, + 00B7E3220EDCAF2000F77EA2 /* SampleShaders.cpp in Sources */, + 00B7E3230EDCAF2000F77EA2 /* SampleStrokeText.cpp in Sources */, + 00B7E3240EDCAF2000F77EA2 /* SampleTests.cpp in Sources */, + 00B7E3250EDCAF2000F77EA2 /* SampleText.cpp in Sources */, + 00B7E3260EDCAF2000F77EA2 /* SampleTextAlpha.cpp in Sources */, + 00B7E3270EDCAF2000F77EA2 /* SampleTextEffects.cpp in Sources */, + 00B7E3280EDCAF2000F77EA2 /* SampleTextOnPath.cpp in Sources */, + 00B7E3290EDCAF2000F77EA2 /* SampleTiling.cpp in Sources */, + 00B7E32A0EDCAF2000F77EA2 /* SampleTypeface.cpp in Sources */, + 00B7E32B0EDCAF2000F77EA2 /* SampleVertices.cpp in Sources */, + 00B7E32C0EDCAF2000F77EA2 /* SampleXfermodes.cpp in Sources */, + 00B7E32D0EDCAF2000F77EA2 /* vertexdump.cpp in Sources */, + 00B7E3560EDCB03600F77EA2 /* test.cpp in Sources */, + 00B7E3570EDCB03600F77EA2 /* test_drawcolor.cpp in Sources */, + 00B7E3580EDCB03600F77EA2 /* test_drawrect.cpp in Sources */, + 0082BE7C0EE414DE00DEE451 /* SkSetPoly3To3.cpp in Sources */, + 0081D7800EE45EF100AB0A0A /* SampleRegion.cpp in Sources */, + 00152A800EE71EB60068F9B2 /* SkDumpCanvas.cpp in Sources */, + 00B7E3080EDCAF2000F77EA2 /* SampleCircle.cpp in Sources */, + 00B7E3050EDCAF2000F77EA2 /* SampleArc.cpp in Sources */, + 00B7E30A0EDCAF2000F77EA2 /* SampleDither.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 0008AF100DABF9BD00477EFB /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = giflib; + targetProxy = 0008AF0F0DABF9BD00477EFB /* PBXContainerItemProxy */; + }; + 0013C7950D94044800B41703 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = animator; + targetProxy = 0013C7940D94044800B41703 /* PBXContainerItemProxy */; + }; + 009A741D0DA11BAE00876C03 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = GL; + targetProxy = 009A741C0DA11BAE00876C03 /* PBXContainerItemProxy */; + }; + 00ED8C9E0D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = "ports-mac"; + targetProxy = 00ED8C9D0D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CA00D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = ports; + targetProxy = 00ED8C9F0D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CA20D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = jpeg; + targetProxy = 00ED8CA10D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CA40D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = graphics; + targetProxy = 00ED8CA30D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CA80D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = expat; + targetProxy = 00ED8CA70D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CAA0D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = views; + targetProxy = 00ED8CA90D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CAC0D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = corecg; + targetProxy = 00ED8CAB0D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CAE0D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = zlib; + targetProxy = 00ED8CAD0D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CB00D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = freetype; + targetProxy = 00ED8CAF0D3E9AFA00651393 /* PBXContainerItemProxy */; + }; + 00ED8CB20D3E9AFA00651393 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = libpng; + targetProxy = 00ED8CB10D3E9AFA00651393 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 02345980000FD03B11CA0E72 /* main.nib */ = { + isa = PBXVariantGroup; + children = ( + 1870340FFE93FCAF11CA0CD7 /* English */, + ); + name = main.nib; + sourceTree = "<group>"; + }; + 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 0867D6ABFE840B52C02AAC07 /* English */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 006B85250EED8C4400938119 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_CW_ASM_SYNTAX = NO; + GCC_DEBUGGING_SYMBOLS = full; + GCC_ENABLE_ASM_KEYWORD = NO; + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_OPTIMIZATION_LEVEL = 2; + GCC_PREFIX_HEADER = " "; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_RELEASE, + SK_BUILD_FOR_MAC, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + USER_HEADER_SEARCH_PATHS = "../../include/**"; + }; + name = Release; + }; + 006B85260EED8C4400938119 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)", + ); + FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(DEVELOPER_DIR)/SDKs/MacOSX10.5.sdk/System/Library/Frameworks\""; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PRECOMPILE_PREFIX_HEADER = NO; + GCC_PREFIX_HEADER = SampleCode_Prefix.pch; + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = "$(HOME)/Applications"; + PRODUCT_NAME = SampleCode; + WRAPPER_EXTENSION = app; + ZERO_LINK = YES; + }; + name = Release; + }; + C0E91AC608A95435008D54AB /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + FRAMEWORK_SEARCH_PATHS = ( + "$(inherited)", + "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)", + ); + FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(DEVELOPER_DIR)/SDKs/MacOSX10.5.sdk/System/Library/Frameworks\""; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PRECOMPILE_PREFIX_HEADER = NO; + GCC_PREFIX_HEADER = SampleCode_Prefix.pch; + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = "$(HOME)/Applications"; + PRODUCT_NAME = SampleCode; + WRAPPER_EXTENSION = app; + ZERO_LINK = YES; + }; + name = Debug; + }; + C0E91ACA08A95435008D54AB /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_CW_ASM_SYNTAX = NO; + GCC_DEBUGGING_SYMBOLS = full; + GCC_ENABLE_ASM_KEYWORD = NO; + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREFIX_HEADER = " "; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_DEBUG, + SK_BUILD_FOR_MAC, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + USER_HEADER_SEARCH_PATHS = "../../include/**"; + }; + name = Debug; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "SampleCode" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C0E91AC608A95435008D54AB /* Debug */, + 006B85260EED8C4400938119 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "SampleCode" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C0E91ACA08A95435008D54AB /* Debug */, + 006B85250EED8C4400938119 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = 20286C28FDCF999611CA2CEA /* Project object */; +} diff --git a/xcode/SampleCode/SampleCode_Prefix.pch b/xcode/SampleCode/SampleCode_Prefix.pch new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/xcode/SampleCode/SampleCode_Prefix.pch diff --git a/xcode/Simple/English.lproj/InfoPlist.strings b/xcode/Simple/English.lproj/InfoPlist.strings Binary files differnew file mode 100644 index 0000000..26bf880 --- /dev/null +++ b/xcode/Simple/English.lproj/InfoPlist.strings diff --git a/xcode/Simple/English.lproj/main.nib/classes.nib b/xcode/Simple/English.lproj/main.nib/classes.nib new file mode 100644 index 0000000..c4b887e --- /dev/null +++ b/xcode/Simple/English.lproj/main.nib/classes.nib @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>IBVersion</key> + <string>1</string> +</dict> +</plist> diff --git a/xcode/Simple/English.lproj/main.nib/info.nib b/xcode/Simple/English.lproj/main.nib/info.nib new file mode 100644 index 0000000..2af896b --- /dev/null +++ b/xcode/Simple/English.lproj/main.nib/info.nib @@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>IBFramework Version</key> + <string>629</string> + <key>IBLastKnownRelativeProjectPath</key> + <string>../../SampleCode.xcodeproj</string> + <key>IBOldestOS</key> + <integer>5</integer> + <key>IBOpenObjects</key> + <array/> + <key>IBSystem Version</key> + <string>9B18</string> + <key>targetFramework</key> + <string>IBCarbonFramework</string> +</dict> +</plist> diff --git a/xcode/Simple/English.lproj/main.nib/objects.xib b/xcode/Simple/English.lproj/main.nib/objects.xib new file mode 100644 index 0000000..a9e438e --- /dev/null +++ b/xcode/Simple/English.lproj/main.nib/objects.xib @@ -0,0 +1,269 @@ +<?xml version="1.0" standalone="yes"?> +<object class="NSIBObjectData"> + <object name="rootObject" class="NSCustomObject" id="1"> + </object> + <array count="38" name="allObjects"> + <object class="IBCarbonMenuItem" id="193"> + <string name="title">Arrange in Front</string> + <boolean name="dynamic">TRUE</boolean> + <int name="keyEquivalentModifier">1572864</int> + <ostype name="command">frnt</ostype> + </object> + <object class="IBCarbonMenuItem" id="148"> + <string name="title">Select All</string> + <string name="keyEquivalent">a</string> + <ostype name="command">sall</ostype> + </object> + <object class="IBCarbonMenuItem" id="152"> + <string name="title">Edit</string> + <object name="submenu" class="IBCarbonMenu" id="147"> + <string name="title">Edit</string> + <array count="10" name="items"> + <object class="IBCarbonMenuItem" id="141"> + <string name="title">Undo</string> + <string name="keyEquivalent">z</string> + <ostype name="command">undo</ostype> + </object> + <object class="IBCarbonMenuItem" id="146"> + <string name="title">Redo</string> + <string name="keyEquivalent">Z</string> + <ostype name="command">redo</ostype> + </object> + <object class="IBCarbonMenuItem" id="142"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="143"> + <string name="title">Cut</string> + <string name="keyEquivalent">x</string> + <ostype name="command">cut </ostype> + </object> + <object class="IBCarbonMenuItem" id="149"> + <string name="title">Copy</string> + <string name="keyEquivalent">c</string> + <ostype name="command">copy</ostype> + </object> + <object class="IBCarbonMenuItem" id="144"> + <string name="title">Paste</string> + <string name="keyEquivalent">v</string> + <ostype name="command">past</ostype> + </object> + <object class="IBCarbonMenuItem" id="151"> + <string name="title">Delete</string> + <ostype name="command">clea</ostype> + </object> + <reference idRef="148"/> + <object class="IBCarbonMenuItem" id="199"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="198"> + <string name="title">Special Characters…</string> + <ostype name="command">chrp</ostype> + </object> + </array> + </object> + </object> + <object class="IBCarbonRootControl" id="167"> + <string name="bounds">0 0 360 480 </string> + </object> + <object class="IBCarbonMenuItem" id="139"> + <string name="title">New</string> + <string name="keyEquivalent">n</string> + <ostype name="command">new </ostype> + </object> + <object class="IBCarbonMenuItem" id="192"> + <string name="title">Window</string> + <object name="submenu" class="IBCarbonMenu" id="195"> + <string name="title">Window</string> + <string name="name">_NSWindowsMenu</string> + <array count="6" name="items"> + <object class="IBCarbonMenuItem" id="190"> + <string name="title">Minimize</string> + <string name="keyEquivalent">m</string> + <boolean name="dynamic">TRUE</boolean> + <ostype name="command">mini</ostype> + </object> + <object class="IBCarbonMenuItem" id="191"> + <string name="title">Minimize All</string> + <string name="keyEquivalent">m</string> + <boolean name="dynamic">TRUE</boolean> + <int name="keyEquivalentModifier">1572864</int> + <ostype name="command">mina</ostype> + </object> + <object class="IBCarbonMenuItem" id="197"> + <string name="title">Zoom</string> + <ostype name="command">zoom</ostype> + </object> + <object class="IBCarbonMenuItem" id="194"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="196"> + <string name="title">Bring All to Front</string> + <boolean name="dynamic">TRUE</boolean> + <ostype name="command">bfrt</ostype> + </object> + <reference idRef="193"/> + </array> + </object> + </object> + <object class="IBCarbonMenuItem" id="132"> + <string name="title">Revert</string> + <string name="keyEquivalent">r</string> + <ostype name="command">rvrt</ostype> + </object> + <object class="IBCarbonMenuItem" id="187"> + <string name="title">About Foo</string> + <int name="keyEquivalentModifier">0</int> + <ostype name="command">abou</ostype> + </object> + <object class="IBCarbonMenuItem" id="138"> + <string name="title">Save</string> + <string name="keyEquivalent">s</string> + <ostype name="command">save</ostype> + </object> + <object class="IBCarbonMenuItem" id="137"> + <string name="title">Save As…</string> + <string name="keyEquivalent">S</string> + <ostype name="command">svas</ostype> + </object> + <object class="IBCarbonMenuItem" id="136"> + <string name="title">Print…</string> + <string name="keyEquivalent">p</string> + <ostype name="command">prnt</ostype> + </object> + <reference idRef="146"/> + <reference idRef="142"/> + <reference idRef="143"/> + <object class="IBCarbonWindow" id="166"> + <boolean name="liveResize">TRUE</boolean> + <int name="scalingMode">1048576</int> + <string name="title">Window</string> + <reference name="rootControl" idRef="167"/> + <string name="windowRect">1001 727 1361 1207 </string> + <string name="ScreenRectAtEncodeTime">0 0 768 1024 </string> + </object> + <reference idRef="199"/> + <object class="IBCarbonMenuItem" id="135"> + <string name="title">Page Setup…</string> + <string name="keyEquivalent">P</string> + <ostype name="command">page</ostype> + </object> + <reference idRef="144"/> + <object class="IBCarbonMenuItem" id="134"> + <string name="title">Open…</string> + <string name="keyEquivalent">o</string> + <ostype name="command">open</ostype> + </object> + <object class="IBCarbonMenu" id="131"> + <string name="title">File</string> + <array count="10" name="items"> + <reference idRef="139"/> + <reference idRef="134"/> + <object class="IBCarbonMenuItem" id="133"> + <boolean name="separator">TRUE</boolean> + </object> + <object class="IBCarbonMenuItem" id="130"> + <string name="title">Close</string> + <string name="keyEquivalent">w</string> + <ostype name="command">clos</ostype> + </object> + <reference idRef="138"/> + <reference idRef="137"/> + <reference idRef="132"/> + <object class="IBCarbonMenuItem" id="128"> + <boolean name="separator">TRUE</boolean> + </object> + <reference idRef="135"/> + <reference idRef="136"/> + </array> + </object> + <reference idRef="128"/> + <reference idRef="141"/> + <reference idRef="198"/> + <object class="IBCarbonMenu" id="29"> + <string name="title">main</string> + <string name="name">_NSMainMenu</string> + <array count="4" name="items"> + <object class="IBCarbonMenuItem" id="185"> + <string name="title">Foo</string> + <object name="submenu" class="IBCarbonMenu" id="184"> + <string name="title">Foo</string> + <string name="name">_NSAppleMenu</string> + <array count="1" name="items"> + <reference idRef="187"/> + </array> + </object> + </object> + <object class="IBCarbonMenuItem" id="127"> + <string name="title">File</string> + <reference name="submenu" idRef="131"/> + </object> + <reference idRef="152"/> + <reference idRef="192"/> + </array> + </object> + <reference idRef="184"/> + <reference idRef="194"/> + <reference idRef="195"/> + <reference idRef="127"/> + <reference idRef="147"/> + <reference idRef="133"/> + <reference idRef="149"/> + <reference idRef="151"/> + <reference idRef="190"/> + <reference idRef="185"/> + <reference idRef="197"/> + <reference idRef="130"/> + <reference idRef="191"/> + <reference idRef="196"/> + </array> + <array count="38" name="allParents"> + <reference idRef="195"/> + <reference idRef="147"/> + <reference idRef="29"/> + <reference idRef="166"/> + <reference idRef="131"/> + <reference idRef="29"/> + <reference idRef="131"/> + <reference idRef="184"/> + <reference idRef="131"/> + <reference idRef="131"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="1"/> + <reference idRef="147"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="131"/> + <reference idRef="127"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="1"/> + <reference idRef="185"/> + <reference idRef="195"/> + <reference idRef="192"/> + <reference idRef="29"/> + <reference idRef="152"/> + <reference idRef="131"/> + <reference idRef="147"/> + <reference idRef="147"/> + <reference idRef="195"/> + <reference idRef="29"/> + <reference idRef="195"/> + <reference idRef="131"/> + <reference idRef="195"/> + <reference idRef="195"/> + </array> + <dictionary count="3" name="nameTable"> + <string>File's Owner</string> + <reference idRef="1"/> + <string>MainWindow</string> + <reference idRef="166"/> + <string>MenuBar</string> + <reference idRef="29"/> + </dictionary> + <string name="targetFramework">IBCarbonFramework</string> + <unsigned_int name="nextObjectID">200</unsigned_int> +</object> diff --git a/xcode/Simple/Info.plist b/xcode/Simple/Info.plist new file mode 100644 index 0000000..d70d738 --- /dev/null +++ b/xcode/Simple/Info.plist @@ -0,0 +1,26 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> + <string>English</string> + <key>CFBundleExecutable</key> + <string>$(EXECUTABLE_NAME)</string> + <key>CFBundleIconFile</key> + <string></string> + <key>CFBundleIdentifier</key> + <string>com.yourcompany.Simple</string> + <key>CFBundleInfoDictionaryVersion</key> + <string>6.0</string> + <key>CFBundleName</key> + <string>$(PRODUCT_NAME)</string> + <key>CFBundlePackageType</key> + <string>APPL</string> + <key>CFBundleSignature</key> + <string>????</string> + <key>CFBundleVersion</key> + <string>1.0</string> + <key>CSResourcesFileMapped</key> + <true/> +</dict> +</plist> diff --git a/xcode/Simple/Simple.xcodeproj/project.pbxproj b/xcode/Simple/Simple.xcodeproj/project.pbxproj new file mode 100644 index 0000000..d24c9e9 --- /dev/null +++ b/xcode/Simple/Simple.xcodeproj/project.pbxproj @@ -0,0 +1,335 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 0099A4CA0EF176A5004F1DA4 /* SimpleApp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0099A4C90EF176A5004F1DA4 /* SimpleApp.cpp */; }; + 00AFCD5B0EF1667600BD2FF1 /* libskia2.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00AFCD4D0EF165CE00BD2FF1 /* libskia2.a */; }; + 00AFCD750EF1679700BD2FF1 /* skia_mac.cp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD730EF1679700BD2FF1 /* skia_mac.cp */; }; + 8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; }; + 8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; }; + 8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 00AFCD4C0EF165CE00BD2FF1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = skia2; + }; + 00AFCD510EF165E500BD2FF1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = skia2; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 0099A4C90EF176A5004F1DA4 /* SimpleApp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleApp.cpp; sourceTree = "<group>"; }; + 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = skia2.xcodeproj; path = ../skia2.xcodeproj; sourceTree = SOURCE_ROOT; }; + 00AFCD730EF1679700BD2FF1 /* skia_mac.cp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = skia_mac.cp; path = ../ports/skia_mac.cp; sourceTree = SOURCE_ROOT; }; + 0867D6ABFE840B52C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 1870340FFE93FCAF11CA0CD7 /* English */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; name = English; path = English.lproj/main.nib; sourceTree = "<group>"; }; + 20286C33FDCF999611CA2CEA /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; }; + 5048396D09E3307300765E4B /* SimpleProj.xcconfig */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text.xcconfig; path = SimpleProj.xcconfig; sourceTree = "<group>"; }; + 5048396E09E3307300765E4B /* SimpleTarget.xcconfig */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text.xcconfig; path = SimpleTarget.xcconfig; sourceTree = "<group>"; }; + 508344B209E5C41E0093A071 /* Simple.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Simple.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 8D0C4E960486CD37000505A6 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8D0C4E910486CD37000505A6 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */, + 00AFCD5B0EF1667600BD2FF1 /* libskia2.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 00AFCD310EF165CE00BD2FF1 /* Products */ = { + isa = PBXGroup; + children = ( + 00AFCD4D0EF165CE00BD2FF1 /* libskia2.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 195DF8CFFE9D517E11CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 508344B209E5C41E0093A071 /* Simple.app */, + ); + name = Products; + sourceTree = "<group>"; + }; + 20286C29FDCF999611CA2CEA /* Simple */ = { + isa = PBXGroup; + children = ( + 5048396909E3304600765E4B /* Configuration Files */, + 20286C2AFDCF999611CA2CEA /* Sources */, + 20286C2CFDCF999611CA2CEA /* Resources */, + 20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */, + 195DF8CFFE9D517E11CA2CBB /* Products */, + 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */, + ); + name = Simple; + sourceTree = "<group>"; + }; + 20286C2AFDCF999611CA2CEA /* Sources */ = { + isa = PBXGroup; + children = ( + 0099A4C90EF176A5004F1DA4 /* SimpleApp.cpp */, + 00AFCD730EF1679700BD2FF1 /* skia_mac.cp */, + ); + name = Sources; + sourceTree = "<group>"; + }; + 20286C2CFDCF999611CA2CEA /* Resources */ = { + isa = PBXGroup; + children = ( + 8D0C4E960486CD37000505A6 /* Info.plist */, + 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */, + 02345980000FD03B11CA0E72 /* main.nib */, + ); + name = Resources; + sourceTree = "<group>"; + }; + 20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */ = { + isa = PBXGroup; + children = ( + 20286C33FDCF999611CA2CEA /* Carbon.framework */, + ); + name = "External Frameworks and Libraries"; + sourceTree = "<group>"; + }; + 5048396909E3304600765E4B /* Configuration Files */ = { + isa = PBXGroup; + children = ( + 5048396D09E3307300765E4B /* SimpleProj.xcconfig */, + 5048396E09E3307300765E4B /* SimpleTarget.xcconfig */, + ); + name = "Configuration Files"; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 8D0C4E890486CD37000505A6 /* Simple */ = { + isa = PBXNativeTarget; + buildConfigurationList = C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "Simple" */; + buildPhases = ( + 8D0C4E8C0486CD37000505A6 /* Resources */, + 8D0C4E8F0486CD37000505A6 /* Sources */, + 8D0C4E910486CD37000505A6 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 00AFCD520EF165E500BD2FF1 /* PBXTargetDependency */, + ); + name = Simple; + productInstallPath = "$(HOME)/Applications"; + productName = Simple; + productReference = 508344B209E5C41E0093A071 /* Simple.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 20286C28FDCF999611CA2CEA /* Project object */ = { + isa = PBXProject; + buildConfigurationList = C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "Simple" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 20286C29FDCF999611CA2CEA /* Simple */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 00AFCD310EF165CE00BD2FF1 /* Products */; + ProjectRef = 00AFCD300EF165CE00BD2FF1 /* skia2.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 8D0C4E890486CD37000505A6 /* Simple */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 00AFCD4D0EF165CE00BD2FF1 /* libskia2.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libskia2.a; + remoteRef = 00AFCD4C0EF165CE00BD2FF1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXResourcesBuildPhase section */ + 8D0C4E8C0486CD37000505A6 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */, + 8D0C4E8E0486CD37000505A6 /* main.nib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 8D0C4E8F0486CD37000505A6 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00AFCD750EF1679700BD2FF1 /* skia_mac.cp in Sources */, + 0099A4CA0EF176A5004F1DA4 /* SimpleApp.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 00AFCD520EF165E500BD2FF1 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = skia2; + targetProxy = 00AFCD510EF165E500BD2FF1 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 02345980000FD03B11CA0E72 /* main.nib */ = { + isa = PBXVariantGroup; + children = ( + 1870340FFE93FCAF11CA0CD7 /* English */, + ); + name = main.nib; + sourceTree = "<group>"; + }; + 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 0867D6ABFE840B52C02AAC07 /* English */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + C0E91AC608A95435008D54AB /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 5048396E09E3307300765E4B /* SimpleTarget.xcconfig */; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_PREFIX_HEADER = Simple_Prefix.pch; + GCC_PREPROCESSOR_DEFINITIONS = ( + "_GLIBCXX_DEBUG=1", + "_GLIBCXX_DEBUG_PEDANTIC=1", + ); + }; + name = Debug; + }; + C0E91AC708A95435008D54AB /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 5048396E09E3307300765E4B /* SimpleTarget.xcconfig */; + buildSettings = { + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_PREFIX_HEADER = Simple_Prefix.pch; + INSTALL_PATH = "$(HOME)/Applications"; + PRESERVE_DEAD_CODE_INITS_AND_TERMS = YES; + }; + name = Release; + }; + C0E91ACA08A95435008D54AB /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 5048396D09E3307300765E4B /* SimpleProj.xcconfig */; + buildSettings = { + ARCHS = ( + i386, + ppc, + ); + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_INCREASE_PRECOMPILED_HEADER_SHARING = NO; + GCC_MODEL_TUNING = ""; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_DEBUG, + SK_BUILD_FOR_MAC, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + USER_HEADER_SEARCH_PATHS = "../../include/**"; + VALID_ARCHS = "i386 x86_64"; + ZERO_LINK = YES; + }; + name = Debug; + }; + C0E91ACB08A95435008D54AB /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 5048396D09E3307300765E4B /* SimpleProj.xcconfig */; + buildSettings = { + ARCHS = ( + i386, + ppc, + ); + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_INCREASE_PRECOMPILED_HEADER_SHARING = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_RELEASE, + SK_BUILD_FOR_MAC, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + SEPARATE_STRIP = YES; + USER_HEADER_SEARCH_PATHS = "../../include/**"; + VALID_ARCHS = "i386 x86_64"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "Simple" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C0E91AC608A95435008D54AB /* Debug */, + C0E91AC708A95435008D54AB /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "Simple" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C0E91ACA08A95435008D54AB /* Debug */, + C0E91ACB08A95435008D54AB /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 20286C28FDCF999611CA2CEA /* Project object */; +} diff --git a/xcode/Simple/SimpleApp.cpp b/xcode/Simple/SimpleApp.cpp new file mode 100644 index 0000000..7e7e282 --- /dev/null +++ b/xcode/Simple/SimpleApp.cpp @@ -0,0 +1,102 @@ +#include "SkCanvas.h" +#include "SkDevice.h" +#include "SkGraphics.h" +#include "SkPaint.h" +#include "SkPicture.h" +#include "SkStream.h" +#include "SkWindow.h" + +////////////////////////////////////////////////////////////////////////////// + +class SimpleWindow : public SkOSWindow { +public: + SimpleWindow(void* hwnd); + +protected: + virtual void onDraw(SkCanvas* canvas); + virtual bool onHandleKey(SkKey key); + virtual bool onHandleChar(SkUnichar); + virtual void onSizeChange(); + + virtual SkCanvas* beforeChildren(SkCanvas*); + virtual void afterChildren(SkCanvas*); + + virtual bool onEvent(const SkEvent& evt); + +private: + typedef SkOSWindow INHERITED; +}; + +SimpleWindow::SimpleWindow(void* hwnd) : INHERITED(hwnd) { +// this->setConfig(SkBitmap::kRGB_565_Config); + this->setConfig(SkBitmap::kARGB_8888_Config); + this->setVisibleP(true); + this->setTitle("Simple"); +} + +void SimpleWindow::onDraw(SkCanvas* canvas) { + canvas->drawColor(SK_ColorWHITE); + + const SkScalar w = this->width(); + const SkScalar h = this->height(); + + SkPaint paint; + paint.setAntiAlias(true); + paint.setTextSize(SkIntToScalar(40)); + paint.setTextAlign(SkPaint::kCenter_Align); + + canvas->drawText("Hello world", 11, w/2, h/2, paint); +} + +SkCanvas* SimpleWindow::beforeChildren(SkCanvas* canvas) { + // can wack the canvas here, which will affect child views + // and can be "undone" in afterChildren() + // + // e.g. return a picture-canvas, or wack the clip or matrix, etc. + + return canvas; +} + +void SimpleWindow::afterChildren(SkCanvas* orig) { +} + +bool SimpleWindow::onEvent(const SkEvent& evt) { + return this->INHERITED::onEvent(evt); +} + +bool SimpleWindow::onHandleChar(SkUnichar uni) { + return this->INHERITED::onHandleChar(uni); +} + +bool SimpleWindow::onHandleKey(SkKey key) { + return this->INHERITED::onHandleKey(key); +} + +void SimpleWindow::onSizeChange() { + this->INHERITED::onSizeChange(); +} + +/////////////////////////////////////////////////////////////////////////////// + +SkOSWindow* create_sk_window(void* hwnd) { + return new SimpleWindow(hwnd); +} + +void get_preferred_size(int* x, int* y, int* width, int* height) { + *x = 10; + *y = 50; + *width = 640; + *height = 480; +} + +void application_init() { +// setenv("ANDROID_ROOT", "../../../data", 0); + setenv("ANDROID_ROOT", "/android/device/data", 0); + SkGraphics::Init(true); + SkEvent::Init(); +} + +void application_term() { + SkEvent::Term(); + SkGraphics::Term(); +} diff --git a/xcode/Simple/SimpleProj.xcconfig b/xcode/Simple/SimpleProj.xcconfig new file mode 100644 index 0000000..73543b8 --- /dev/null +++ b/xcode/Simple/SimpleProj.xcconfig @@ -0,0 +1,8 @@ + GCC_ENABLE_CPP_EXCEPTIONS = YES; + GCC_ENABLE_CPP_RTTI = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + GCC_INCREASE_PRECOMPILED_HEADER_SHARING = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + PREBINDING = NO; + INFOPLIST_EXPAND_BUILD_SETTINGS = YES;
\ No newline at end of file diff --git a/xcode/Simple/SimpleTarget.xcconfig b/xcode/Simple/SimpleTarget.xcconfig new file mode 100644 index 0000000..1d47d33 --- /dev/null +++ b/xcode/Simple/SimpleTarget.xcconfig @@ -0,0 +1,7 @@ + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = Simple_Prefix.pch; + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = $(HOME)/Applications; + PRODUCT_NAME = Simple; + STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = Dynamic; + GCC_SYMBOLS_PRIVATE_EXTERN = YES; diff --git a/xcode/Simple/Simple_Prefix.pch b/xcode/Simple/Simple_Prefix.pch new file mode 100644 index 0000000..ffcb61e --- /dev/null +++ b/xcode/Simple/Simple_Prefix.pch @@ -0,0 +1,4 @@ +// +// Prefix header for all source files of the 'Simple' target in the 'Simple' project. +// + diff --git a/xcode/animator.xcodeproj/project.pbxproj b/xcode/animator.xcodeproj/project.pbxproj new file mode 100644 index 0000000..ea401fd --- /dev/null +++ b/xcode/animator.xcodeproj/project.pbxproj @@ -0,0 +1,833 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7DDB80EDCA15800F77EA2 /* SkAnimate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD170EDCA15800F77EA2 /* SkAnimate.h */; }; + 00B7DDB90EDCA15800F77EA2 /* SkAnimateActive.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1A0EDCA15800F77EA2 /* SkAnimateActive.cpp */; }; + 00B7DDBA0EDCA15800F77EA2 /* SkAnimateActive.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD1B0EDCA15800F77EA2 /* SkAnimateActive.h */; }; + 00B7DDBB0EDCA15800F77EA2 /* SkAnimateBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1C0EDCA15800F77EA2 /* SkAnimateBase.cpp */; }; + 00B7DDBC0EDCA15800F77EA2 /* SkAnimateBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD1D0EDCA15800F77EA2 /* SkAnimateBase.h */; }; + 00B7DDBD0EDCA15800F77EA2 /* SkAnimateField.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1E0EDCA15800F77EA2 /* SkAnimateField.cpp */; }; + 00B7DDBE0EDCA15800F77EA2 /* SkAnimateMaker.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD1F0EDCA15800F77EA2 /* SkAnimateMaker.cpp */; }; + 00B7DDBF0EDCA15800F77EA2 /* SkAnimateMaker.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD200EDCA15800F77EA2 /* SkAnimateMaker.h */; }; + 00B7DDC00EDCA15800F77EA2 /* SkAnimateProperties.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD210EDCA15800F77EA2 /* SkAnimateProperties.h */; }; + 00B7DDC10EDCA15800F77EA2 /* SkAnimateSet.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD240EDCA15800F77EA2 /* SkAnimateSet.cpp */; }; + 00B7DDC20EDCA15800F77EA2 /* SkAnimateSet.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD250EDCA15800F77EA2 /* SkAnimateSet.h */; }; + 00B7DDC30EDCA15800F77EA2 /* SkAnimator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD260EDCA15800F77EA2 /* SkAnimator.cpp */; }; + 00B7DDC40EDCA15800F77EA2 /* SkAnimatorScript.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD270EDCA15800F77EA2 /* SkAnimatorScript.cpp */; }; + 00B7DDC50EDCA15800F77EA2 /* SkAnimatorScript.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD280EDCA15800F77EA2 /* SkAnimatorScript.h */; }; + 00B7DDC60EDCA15800F77EA2 /* SkAnimatorScript2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD290EDCA15800F77EA2 /* SkAnimatorScript2.cpp */; }; + 00B7DDC70EDCA15800F77EA2 /* SkAnimatorScript2.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD2A0EDCA15800F77EA2 /* SkAnimatorScript2.h */; }; + 00B7DDC80EDCA15800F77EA2 /* SkBase64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD2B0EDCA15800F77EA2 /* SkBase64.cpp */; }; + 00B7DDC90EDCA15800F77EA2 /* SkBase64.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD2C0EDCA15800F77EA2 /* SkBase64.h */; }; + 00B7DDCA0EDCA15800F77EA2 /* SkBoundable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD2D0EDCA15800F77EA2 /* SkBoundable.cpp */; }; + 00B7DDCB0EDCA15800F77EA2 /* SkBoundable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD2E0EDCA15800F77EA2 /* SkBoundable.h */; }; + 00B7DDCF0EDCA15800F77EA2 /* SkDisplayable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD320EDCA15800F77EA2 /* SkDisplayable.cpp */; }; + 00B7DDD00EDCA15800F77EA2 /* SkDisplayable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD330EDCA15800F77EA2 /* SkDisplayable.h */; }; + 00B7DDD10EDCA15800F77EA2 /* SkDisplayAdd.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD340EDCA15800F77EA2 /* SkDisplayAdd.cpp */; }; + 00B7DDD20EDCA15800F77EA2 /* SkDisplayAdd.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD350EDCA15800F77EA2 /* SkDisplayAdd.h */; }; + 00B7DDD30EDCA15800F77EA2 /* SkDisplayApply.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD360EDCA15800F77EA2 /* SkDisplayApply.cpp */; }; + 00B7DDD40EDCA15800F77EA2 /* SkDisplayApply.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD370EDCA15800F77EA2 /* SkDisplayApply.h */; }; + 00B7DDD50EDCA15800F77EA2 /* SkDisplayBounds.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD380EDCA15800F77EA2 /* SkDisplayBounds.cpp */; }; + 00B7DDD60EDCA15800F77EA2 /* SkDisplayBounds.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD390EDCA15800F77EA2 /* SkDisplayBounds.h */; }; + 00B7DDD70EDCA15800F77EA2 /* SkDisplayEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD3A0EDCA15800F77EA2 /* SkDisplayEvent.cpp */; }; + 00B7DDD80EDCA15800F77EA2 /* SkDisplayEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD3B0EDCA15800F77EA2 /* SkDisplayEvent.h */; }; + 00B7DDD90EDCA15800F77EA2 /* SkDisplayEvents.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD3C0EDCA15800F77EA2 /* SkDisplayEvents.cpp */; }; + 00B7DDDA0EDCA15800F77EA2 /* SkDisplayEvents.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD3D0EDCA15800F77EA2 /* SkDisplayEvents.h */; }; + 00B7DDDB0EDCA15800F77EA2 /* SkDisplayInclude.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD3E0EDCA15800F77EA2 /* SkDisplayInclude.cpp */; }; + 00B7DDDC0EDCA15800F77EA2 /* SkDisplayInclude.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD3F0EDCA15800F77EA2 /* SkDisplayInclude.h */; }; + 00B7DDDD0EDCA15800F77EA2 /* SkDisplayInput.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD400EDCA15800F77EA2 /* SkDisplayInput.cpp */; }; + 00B7DDDE0EDCA15800F77EA2 /* SkDisplayInput.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD410EDCA15800F77EA2 /* SkDisplayInput.h */; }; + 00B7DDDF0EDCA15800F77EA2 /* SkDisplayList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD420EDCA15800F77EA2 /* SkDisplayList.cpp */; }; + 00B7DDE00EDCA15800F77EA2 /* SkDisplayList.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD430EDCA15800F77EA2 /* SkDisplayList.h */; }; + 00B7DDE10EDCA15800F77EA2 /* SkDisplayMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD440EDCA15800F77EA2 /* SkDisplayMath.cpp */; }; + 00B7DDE20EDCA15800F77EA2 /* SkDisplayMath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD450EDCA15800F77EA2 /* SkDisplayMath.h */; }; + 00B7DDE30EDCA15800F77EA2 /* SkDisplayMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD460EDCA15800F77EA2 /* SkDisplayMovie.cpp */; }; + 00B7DDE40EDCA15800F77EA2 /* SkDisplayMovie.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD470EDCA15800F77EA2 /* SkDisplayMovie.h */; }; + 00B7DDE50EDCA15800F77EA2 /* SkDisplayNumber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD480EDCA15800F77EA2 /* SkDisplayNumber.cpp */; }; + 00B7DDE60EDCA15800F77EA2 /* SkDisplayNumber.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD490EDCA15800F77EA2 /* SkDisplayNumber.h */; }; + 00B7DDE70EDCA15800F77EA2 /* SkDisplayPost.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD4A0EDCA15800F77EA2 /* SkDisplayPost.cpp */; }; + 00B7DDE80EDCA15800F77EA2 /* SkDisplayPost.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD4B0EDCA15800F77EA2 /* SkDisplayPost.h */; }; + 00B7DDE90EDCA15800F77EA2 /* SkDisplayRandom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD4C0EDCA15800F77EA2 /* SkDisplayRandom.cpp */; }; + 00B7DDEA0EDCA15800F77EA2 /* SkDisplayRandom.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD4D0EDCA15800F77EA2 /* SkDisplayRandom.h */; }; + 00B7DDEB0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD4E0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp */; }; + 00B7DDEC0EDCA15800F77EA2 /* SkDisplayScreenplay.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD4F0EDCA15800F77EA2 /* SkDisplayScreenplay.h */; }; + 00B7DDED0EDCA15800F77EA2 /* SkDisplayType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD500EDCA15800F77EA2 /* SkDisplayType.cpp */; }; + 00B7DDEE0EDCA15800F77EA2 /* SkDisplayType.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD510EDCA15800F77EA2 /* SkDisplayType.h */; }; + 00B7DDEF0EDCA15800F77EA2 /* SkDisplayTypes.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD520EDCA15800F77EA2 /* SkDisplayTypes.cpp */; }; + 00B7DDF00EDCA15800F77EA2 /* SkDisplayTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD530EDCA15800F77EA2 /* SkDisplayTypes.h */; }; + 00B7DDF10EDCA15800F77EA2 /* SkDisplayXMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD540EDCA15800F77EA2 /* SkDisplayXMLParser.cpp */; }; + 00B7DDF20EDCA15800F77EA2 /* SkDisplayXMLParser.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD550EDCA15800F77EA2 /* SkDisplayXMLParser.h */; }; + 00B7DDF30EDCA15800F77EA2 /* SkDraw3D.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD560EDCA15800F77EA2 /* SkDraw3D.cpp */; }; + 00B7DDF40EDCA15800F77EA2 /* SkDraw3D.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD570EDCA15800F77EA2 /* SkDraw3D.h */; }; + 00B7DDF50EDCA15800F77EA2 /* SkDrawable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD580EDCA15800F77EA2 /* SkDrawable.cpp */; }; + 00B7DDF60EDCA15800F77EA2 /* SkDrawable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD590EDCA15800F77EA2 /* SkDrawable.h */; }; + 00B7DDF70EDCA15800F77EA2 /* SkDrawBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD5A0EDCA15800F77EA2 /* SkDrawBitmap.cpp */; }; + 00B7DDF80EDCA15800F77EA2 /* SkDrawBitmap.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD5B0EDCA15800F77EA2 /* SkDrawBitmap.h */; }; + 00B7DDF90EDCA15800F77EA2 /* SkDrawBlur.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD5C0EDCA15800F77EA2 /* SkDrawBlur.cpp */; }; + 00B7DDFA0EDCA15800F77EA2 /* SkDrawBlur.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD5D0EDCA15800F77EA2 /* SkDrawBlur.h */; }; + 00B7DDFB0EDCA15800F77EA2 /* SkDrawClip.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD5E0EDCA15800F77EA2 /* SkDrawClip.cpp */; }; + 00B7DDFC0EDCA15800F77EA2 /* SkDrawClip.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD5F0EDCA15800F77EA2 /* SkDrawClip.h */; }; + 00B7DDFD0EDCA15800F77EA2 /* SkDrawColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD600EDCA15800F77EA2 /* SkDrawColor.cpp */; }; + 00B7DDFE0EDCA15800F77EA2 /* SkDrawColor.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD610EDCA15800F77EA2 /* SkDrawColor.h */; }; + 00B7DDFF0EDCA15800F77EA2 /* SkDrawDash.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD620EDCA15800F77EA2 /* SkDrawDash.cpp */; }; + 00B7DE000EDCA15800F77EA2 /* SkDrawDash.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD630EDCA15800F77EA2 /* SkDrawDash.h */; }; + 00B7DE010EDCA15800F77EA2 /* SkDrawDiscrete.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD640EDCA15800F77EA2 /* SkDrawDiscrete.cpp */; }; + 00B7DE020EDCA15800F77EA2 /* SkDrawDiscrete.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD650EDCA15800F77EA2 /* SkDrawDiscrete.h */; }; + 00B7DE030EDCA15800F77EA2 /* SkDrawEmboss.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD660EDCA15800F77EA2 /* SkDrawEmboss.cpp */; }; + 00B7DE040EDCA15800F77EA2 /* SkDrawEmboss.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD670EDCA15800F77EA2 /* SkDrawEmboss.h */; }; + 00B7DE050EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD680EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp */; }; + 00B7DE060EDCA15800F77EA2 /* SkDrawFull.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD690EDCA15800F77EA2 /* SkDrawFull.cpp */; }; + 00B7DE070EDCA15800F77EA2 /* SkDrawFull.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD6A0EDCA15800F77EA2 /* SkDrawFull.h */; }; + 00B7DE080EDCA15800F77EA2 /* SkDrawGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD6B0EDCA15800F77EA2 /* SkDrawGradient.cpp */; }; + 00B7DE090EDCA15800F77EA2 /* SkDrawGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD6C0EDCA15800F77EA2 /* SkDrawGradient.h */; }; + 00B7DE0A0EDCA15800F77EA2 /* SkDrawGroup.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD6D0EDCA15800F77EA2 /* SkDrawGroup.cpp */; }; + 00B7DE0B0EDCA15800F77EA2 /* SkDrawGroup.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD6E0EDCA15800F77EA2 /* SkDrawGroup.h */; }; + 00B7DE0C0EDCA15800F77EA2 /* SkDrawLine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD6F0EDCA15800F77EA2 /* SkDrawLine.cpp */; }; + 00B7DE0D0EDCA15800F77EA2 /* SkDrawLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD700EDCA15800F77EA2 /* SkDrawLine.h */; }; + 00B7DE0E0EDCA15800F77EA2 /* SkDrawMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD710EDCA15800F77EA2 /* SkDrawMatrix.cpp */; }; + 00B7DE0F0EDCA15800F77EA2 /* SkDrawMatrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD720EDCA15800F77EA2 /* SkDrawMatrix.h */; }; + 00B7DE100EDCA15800F77EA2 /* SkDrawOval.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD730EDCA15800F77EA2 /* SkDrawOval.cpp */; }; + 00B7DE110EDCA15800F77EA2 /* SkDrawOval.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD740EDCA15800F77EA2 /* SkDrawOval.h */; }; + 00B7DE120EDCA15800F77EA2 /* SkDrawPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD750EDCA15800F77EA2 /* SkDrawPaint.cpp */; }; + 00B7DE130EDCA15800F77EA2 /* SkDrawPaint.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD760EDCA15800F77EA2 /* SkDrawPaint.h */; }; + 00B7DE140EDCA15800F77EA2 /* SkDrawPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD770EDCA15800F77EA2 /* SkDrawPath.cpp */; }; + 00B7DE150EDCA15800F77EA2 /* SkDrawPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD780EDCA15800F77EA2 /* SkDrawPath.h */; }; + 00B7DE160EDCA15800F77EA2 /* SkDrawPoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD790EDCA15800F77EA2 /* SkDrawPoint.cpp */; }; + 00B7DE170EDCA15800F77EA2 /* SkDrawPoint.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD7A0EDCA15800F77EA2 /* SkDrawPoint.h */; }; + 00B7DE180EDCA15800F77EA2 /* SkDrawRectangle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD7B0EDCA15800F77EA2 /* SkDrawRectangle.cpp */; }; + 00B7DE190EDCA15800F77EA2 /* SkDrawRectangle.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD7C0EDCA15800F77EA2 /* SkDrawRectangle.h */; }; + 00B7DE1A0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD7D0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp */; }; + 00B7DE1B0EDCA15800F77EA2 /* SkDrawSaveLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD7E0EDCA15800F77EA2 /* SkDrawSaveLayer.h */; }; + 00B7DE1C0EDCA15800F77EA2 /* SkDrawShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD7F0EDCA15800F77EA2 /* SkDrawShader.cpp */; }; + 00B7DE1D0EDCA15800F77EA2 /* SkDrawShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD800EDCA15800F77EA2 /* SkDrawShader.h */; }; + 00B7DE1E0EDCA15800F77EA2 /* SkDrawText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD810EDCA15800F77EA2 /* SkDrawText.cpp */; }; + 00B7DE1F0EDCA15800F77EA2 /* SkDrawText.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD820EDCA15800F77EA2 /* SkDrawText.h */; }; + 00B7DE200EDCA15800F77EA2 /* SkDrawTextBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD830EDCA15800F77EA2 /* SkDrawTextBox.cpp */; }; + 00B7DE210EDCA15800F77EA2 /* SkDrawTextBox.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD840EDCA15800F77EA2 /* SkDrawTextBox.h */; }; + 00B7DE220EDCA15800F77EA2 /* SkDrawTo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD850EDCA15800F77EA2 /* SkDrawTo.cpp */; }; + 00B7DE230EDCA15800F77EA2 /* SkDrawTo.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD860EDCA15800F77EA2 /* SkDrawTo.h */; }; + 00B7DE240EDCA15800F77EA2 /* SkDrawTransparentShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD870EDCA15800F77EA2 /* SkDrawTransparentShader.cpp */; }; + 00B7DE250EDCA15800F77EA2 /* SkDrawTransparentShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD880EDCA15800F77EA2 /* SkDrawTransparentShader.h */; }; + 00B7DE260EDCA15800F77EA2 /* SkDump.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD890EDCA15800F77EA2 /* SkDump.cpp */; }; + 00B7DE270EDCA15800F77EA2 /* SkDump.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD8A0EDCA15800F77EA2 /* SkDump.h */; }; + 00B7DE280EDCA15800F77EA2 /* SkExtras.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD8C0EDCA15800F77EA2 /* SkExtras.h */; }; + 00B7DE290EDCA15800F77EA2 /* SkGetCondensedInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD8D0EDCA15800F77EA2 /* SkGetCondensedInfo.cpp */; }; + 00B7DE2A0EDCA15800F77EA2 /* SkHitClear.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD8E0EDCA15800F77EA2 /* SkHitClear.cpp */; }; + 00B7DE2B0EDCA15800F77EA2 /* SkHitClear.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD8F0EDCA15800F77EA2 /* SkHitClear.h */; }; + 00B7DE2C0EDCA15800F77EA2 /* SkHitTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD900EDCA15800F77EA2 /* SkHitTest.cpp */; }; + 00B7DE2D0EDCA15800F77EA2 /* SkHitTest.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD910EDCA15800F77EA2 /* SkHitTest.h */; }; + 00B7DE2E0EDCA15800F77EA2 /* SkIntArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD920EDCA15800F77EA2 /* SkIntArray.h */; }; + 00B7DE2F0EDCA15800F77EA2 /* SkMatrixParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD930EDCA15800F77EA2 /* SkMatrixParts.cpp */; }; + 00B7DE300EDCA15800F77EA2 /* SkMatrixParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD940EDCA15800F77EA2 /* SkMatrixParts.h */; }; + 00B7DE310EDCA15800F77EA2 /* SkMemberInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD950EDCA15800F77EA2 /* SkMemberInfo.cpp */; }; + 00B7DE320EDCA15800F77EA2 /* SkMemberInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD960EDCA15800F77EA2 /* SkMemberInfo.h */; }; + 00B7DE330EDCA15800F77EA2 /* SkOpArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD970EDCA15800F77EA2 /* SkOpArray.cpp */; }; + 00B7DE340EDCA15800F77EA2 /* SkOpArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD980EDCA15800F77EA2 /* SkOpArray.h */; }; + 00B7DE350EDCA15800F77EA2 /* SkOperand.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD990EDCA15800F77EA2 /* SkOperand.h */; }; + 00B7DE360EDCA15800F77EA2 /* SkOperand2.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD9A0EDCA15800F77EA2 /* SkOperand2.h */; }; + 00B7DE370EDCA15800F77EA2 /* SkOperandInterpolator.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD9B0EDCA15800F77EA2 /* SkOperandInterpolator.h */; }; + 00B7DE380EDCA15800F77EA2 /* SkOperandIterpolator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD9C0EDCA15800F77EA2 /* SkOperandIterpolator.cpp */; }; + 00B7DE390EDCA15800F77EA2 /* SkPaintParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD9D0EDCA15800F77EA2 /* SkPaintParts.cpp */; }; + 00B7DE3A0EDCA15800F77EA2 /* SkPaintParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DD9E0EDCA15800F77EA2 /* SkPaintParts.h */; }; + 00B7DE3B0EDCA15800F77EA2 /* SkPathParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DD9F0EDCA15800F77EA2 /* SkPathParts.cpp */; }; + 00B7DE3C0EDCA15800F77EA2 /* SkPathParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA00EDCA15800F77EA2 /* SkPathParts.h */; }; + 00B7DE3D0EDCA15800F77EA2 /* SkPostParts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA10EDCA15800F77EA2 /* SkPostParts.cpp */; }; + 00B7DE3E0EDCA15800F77EA2 /* SkPostParts.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA20EDCA15800F77EA2 /* SkPostParts.h */; }; + 00B7DE3F0EDCA15800F77EA2 /* SkScript.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA30EDCA15800F77EA2 /* SkScript.cpp */; }; + 00B7DE400EDCA15800F77EA2 /* SkScript.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA40EDCA15800F77EA2 /* SkScript.h */; }; + 00B7DE410EDCA15800F77EA2 /* SkScript2.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA50EDCA15800F77EA2 /* SkScript2.h */; }; + 00B7DE420EDCA15800F77EA2 /* SkScriptCallBack.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA60EDCA15800F77EA2 /* SkScriptCallBack.h */; }; + 00B7DE430EDCA15800F77EA2 /* SkScriptDecompile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA70EDCA15800F77EA2 /* SkScriptDecompile.cpp */; }; + 00B7DE440EDCA15800F77EA2 /* SkScriptRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDA80EDCA15800F77EA2 /* SkScriptRuntime.cpp */; }; + 00B7DE450EDCA15800F77EA2 /* SkScriptRuntime.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDA90EDCA15800F77EA2 /* SkScriptRuntime.h */; }; + 00B7DE460EDCA15800F77EA2 /* SkScriptTokenizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAA0EDCA15800F77EA2 /* SkScriptTokenizer.cpp */; }; + 00B7DE470EDCA15800F77EA2 /* SkSnapshot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAB0EDCA15800F77EA2 /* SkSnapshot.cpp */; }; + 00B7DE480EDCA15800F77EA2 /* SkSnapshot.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDAC0EDCA15800F77EA2 /* SkSnapshot.h */; }; + 00B7DE490EDCA15800F77EA2 /* SkSVGPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAD0EDCA15800F77EA2 /* SkSVGPath.cpp */; }; + 00B7DE4A0EDCA15800F77EA2 /* SkTDArray_Experimental.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDAE0EDCA15800F77EA2 /* SkTDArray_Experimental.h */; }; + 00B7DE4B0EDCA15800F77EA2 /* SkTextOnPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDAF0EDCA15800F77EA2 /* SkTextOnPath.cpp */; }; + 00B7DE4C0EDCA15800F77EA2 /* SkTextOnPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB00EDCA15800F77EA2 /* SkTextOnPath.h */; }; + 00B7DE4D0EDCA15800F77EA2 /* SkTextToPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB10EDCA15800F77EA2 /* SkTextToPath.cpp */; }; + 00B7DE4E0EDCA15800F77EA2 /* SkTextToPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB20EDCA15800F77EA2 /* SkTextToPath.h */; }; + 00B7DE4F0EDCA15800F77EA2 /* SkTime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB30EDCA15800F77EA2 /* SkTime.cpp */; }; + 00B7DE500EDCA15800F77EA2 /* SkTypedArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB40EDCA15800F77EA2 /* SkTypedArray.cpp */; }; + 00B7DE510EDCA15800F77EA2 /* SkTypedArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB50EDCA15800F77EA2 /* SkTypedArray.h */; }; + 00B7DE520EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DDB60EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp */; }; + 00B7DE530EDCA15800F77EA2 /* SkXMLAnimatorWriter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DDB70EDCA15800F77EA2 /* SkXMLAnimatorWriter.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7DD170EDCA15800F77EA2 /* SkAnimate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimate.h; path = ../libsgl/animator/SkAnimate.h; sourceTree = SOURCE_ROOT; }; + 00B7DD1A0EDCA15800F77EA2 /* SkAnimateActive.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateActive.cpp; path = ../libsgl/animator/SkAnimateActive.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD1B0EDCA15800F77EA2 /* SkAnimateActive.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateActive.h; path = ../libsgl/animator/SkAnimateActive.h; sourceTree = SOURCE_ROOT; }; + 00B7DD1C0EDCA15800F77EA2 /* SkAnimateBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateBase.cpp; path = ../libsgl/animator/SkAnimateBase.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD1D0EDCA15800F77EA2 /* SkAnimateBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateBase.h; path = ../libsgl/animator/SkAnimateBase.h; sourceTree = SOURCE_ROOT; }; + 00B7DD1E0EDCA15800F77EA2 /* SkAnimateField.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateField.cpp; path = ../libsgl/animator/SkAnimateField.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD1F0EDCA15800F77EA2 /* SkAnimateMaker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateMaker.cpp; path = ../libsgl/animator/SkAnimateMaker.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD200EDCA15800F77EA2 /* SkAnimateMaker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateMaker.h; path = ../libsgl/animator/SkAnimateMaker.h; sourceTree = SOURCE_ROOT; }; + 00B7DD210EDCA15800F77EA2 /* SkAnimateProperties.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateProperties.h; path = ../libsgl/animator/SkAnimateProperties.h; sourceTree = SOURCE_ROOT; }; + 00B7DD240EDCA15800F77EA2 /* SkAnimateSet.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimateSet.cpp; path = ../libsgl/animator/SkAnimateSet.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD250EDCA15800F77EA2 /* SkAnimateSet.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimateSet.h; path = ../libsgl/animator/SkAnimateSet.h; sourceTree = SOURCE_ROOT; }; + 00B7DD260EDCA15800F77EA2 /* SkAnimator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimator.cpp; path = ../libsgl/animator/SkAnimator.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD270EDCA15800F77EA2 /* SkAnimatorScript.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimatorScript.cpp; path = ../libsgl/animator/SkAnimatorScript.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD280EDCA15800F77EA2 /* SkAnimatorScript.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimatorScript.h; path = ../libsgl/animator/SkAnimatorScript.h; sourceTree = SOURCE_ROOT; }; + 00B7DD290EDCA15800F77EA2 /* SkAnimatorScript2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAnimatorScript2.cpp; path = ../libsgl/animator/SkAnimatorScript2.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD2A0EDCA15800F77EA2 /* SkAnimatorScript2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAnimatorScript2.h; path = ../libsgl/animator/SkAnimatorScript2.h; sourceTree = SOURCE_ROOT; }; + 00B7DD2B0EDCA15800F77EA2 /* SkBase64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBase64.cpp; path = ../libsgl/animator/SkBase64.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD2C0EDCA15800F77EA2 /* SkBase64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBase64.h; path = ../libsgl/animator/SkBase64.h; sourceTree = SOURCE_ROOT; }; + 00B7DD2D0EDCA15800F77EA2 /* SkBoundable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBoundable.cpp; path = ../libsgl/animator/SkBoundable.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD2E0EDCA15800F77EA2 /* SkBoundable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBoundable.h; path = ../libsgl/animator/SkBoundable.h; sourceTree = SOURCE_ROOT; }; + 00B7DD320EDCA15800F77EA2 /* SkDisplayable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayable.cpp; path = ../libsgl/animator/SkDisplayable.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD330EDCA15800F77EA2 /* SkDisplayable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayable.h; path = ../libsgl/animator/SkDisplayable.h; sourceTree = SOURCE_ROOT; }; + 00B7DD340EDCA15800F77EA2 /* SkDisplayAdd.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayAdd.cpp; path = ../libsgl/animator/SkDisplayAdd.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD350EDCA15800F77EA2 /* SkDisplayAdd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayAdd.h; path = ../libsgl/animator/SkDisplayAdd.h; sourceTree = SOURCE_ROOT; }; + 00B7DD360EDCA15800F77EA2 /* SkDisplayApply.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayApply.cpp; path = ../libsgl/animator/SkDisplayApply.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD370EDCA15800F77EA2 /* SkDisplayApply.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayApply.h; path = ../libsgl/animator/SkDisplayApply.h; sourceTree = SOURCE_ROOT; }; + 00B7DD380EDCA15800F77EA2 /* SkDisplayBounds.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayBounds.cpp; path = ../libsgl/animator/SkDisplayBounds.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD390EDCA15800F77EA2 /* SkDisplayBounds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayBounds.h; path = ../libsgl/animator/SkDisplayBounds.h; sourceTree = SOURCE_ROOT; }; + 00B7DD3A0EDCA15800F77EA2 /* SkDisplayEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayEvent.cpp; path = ../libsgl/animator/SkDisplayEvent.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD3B0EDCA15800F77EA2 /* SkDisplayEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayEvent.h; path = ../libsgl/animator/SkDisplayEvent.h; sourceTree = SOURCE_ROOT; }; + 00B7DD3C0EDCA15800F77EA2 /* SkDisplayEvents.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayEvents.cpp; path = ../libsgl/animator/SkDisplayEvents.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD3D0EDCA15800F77EA2 /* SkDisplayEvents.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayEvents.h; path = ../libsgl/animator/SkDisplayEvents.h; sourceTree = SOURCE_ROOT; }; + 00B7DD3E0EDCA15800F77EA2 /* SkDisplayInclude.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayInclude.cpp; path = ../libsgl/animator/SkDisplayInclude.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD3F0EDCA15800F77EA2 /* SkDisplayInclude.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayInclude.h; path = ../libsgl/animator/SkDisplayInclude.h; sourceTree = SOURCE_ROOT; }; + 00B7DD400EDCA15800F77EA2 /* SkDisplayInput.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayInput.cpp; path = ../libsgl/animator/SkDisplayInput.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD410EDCA15800F77EA2 /* SkDisplayInput.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayInput.h; path = ../libsgl/animator/SkDisplayInput.h; sourceTree = SOURCE_ROOT; }; + 00B7DD420EDCA15800F77EA2 /* SkDisplayList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayList.cpp; path = ../libsgl/animator/SkDisplayList.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD430EDCA15800F77EA2 /* SkDisplayList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayList.h; path = ../libsgl/animator/SkDisplayList.h; sourceTree = SOURCE_ROOT; }; + 00B7DD440EDCA15800F77EA2 /* SkDisplayMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayMath.cpp; path = ../libsgl/animator/SkDisplayMath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD450EDCA15800F77EA2 /* SkDisplayMath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayMath.h; path = ../libsgl/animator/SkDisplayMath.h; sourceTree = SOURCE_ROOT; }; + 00B7DD460EDCA15800F77EA2 /* SkDisplayMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayMovie.cpp; path = ../libsgl/animator/SkDisplayMovie.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD470EDCA15800F77EA2 /* SkDisplayMovie.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayMovie.h; path = ../libsgl/animator/SkDisplayMovie.h; sourceTree = SOURCE_ROOT; }; + 00B7DD480EDCA15800F77EA2 /* SkDisplayNumber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayNumber.cpp; path = ../libsgl/animator/SkDisplayNumber.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD490EDCA15800F77EA2 /* SkDisplayNumber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayNumber.h; path = ../libsgl/animator/SkDisplayNumber.h; sourceTree = SOURCE_ROOT; }; + 00B7DD4A0EDCA15800F77EA2 /* SkDisplayPost.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayPost.cpp; path = ../libsgl/animator/SkDisplayPost.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD4B0EDCA15800F77EA2 /* SkDisplayPost.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayPost.h; path = ../libsgl/animator/SkDisplayPost.h; sourceTree = SOURCE_ROOT; }; + 00B7DD4C0EDCA15800F77EA2 /* SkDisplayRandom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayRandom.cpp; path = ../libsgl/animator/SkDisplayRandom.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD4D0EDCA15800F77EA2 /* SkDisplayRandom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayRandom.h; path = ../libsgl/animator/SkDisplayRandom.h; sourceTree = SOURCE_ROOT; }; + 00B7DD4E0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayScreenplay.cpp; path = ../libsgl/animator/SkDisplayScreenplay.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD4F0EDCA15800F77EA2 /* SkDisplayScreenplay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayScreenplay.h; path = ../libsgl/animator/SkDisplayScreenplay.h; sourceTree = SOURCE_ROOT; }; + 00B7DD500EDCA15800F77EA2 /* SkDisplayType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayType.cpp; path = ../libsgl/animator/SkDisplayType.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD510EDCA15800F77EA2 /* SkDisplayType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayType.h; path = ../libsgl/animator/SkDisplayType.h; sourceTree = SOURCE_ROOT; }; + 00B7DD520EDCA15800F77EA2 /* SkDisplayTypes.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayTypes.cpp; path = ../libsgl/animator/SkDisplayTypes.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD530EDCA15800F77EA2 /* SkDisplayTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayTypes.h; path = ../libsgl/animator/SkDisplayTypes.h; sourceTree = SOURCE_ROOT; }; + 00B7DD540EDCA15800F77EA2 /* SkDisplayXMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDisplayXMLParser.cpp; path = ../libsgl/animator/SkDisplayXMLParser.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD550EDCA15800F77EA2 /* SkDisplayXMLParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDisplayXMLParser.h; path = ../libsgl/animator/SkDisplayXMLParser.h; sourceTree = SOURCE_ROOT; }; + 00B7DD560EDCA15800F77EA2 /* SkDraw3D.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDraw3D.cpp; path = ../libsgl/animator/SkDraw3D.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD570EDCA15800F77EA2 /* SkDraw3D.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDraw3D.h; path = ../libsgl/animator/SkDraw3D.h; sourceTree = SOURCE_ROOT; }; + 00B7DD580EDCA15800F77EA2 /* SkDrawable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawable.cpp; path = ../libsgl/animator/SkDrawable.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD590EDCA15800F77EA2 /* SkDrawable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawable.h; path = ../libsgl/animator/SkDrawable.h; sourceTree = SOURCE_ROOT; }; + 00B7DD5A0EDCA15800F77EA2 /* SkDrawBitmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawBitmap.cpp; path = ../libsgl/animator/SkDrawBitmap.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD5B0EDCA15800F77EA2 /* SkDrawBitmap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawBitmap.h; path = ../libsgl/animator/SkDrawBitmap.h; sourceTree = SOURCE_ROOT; }; + 00B7DD5C0EDCA15800F77EA2 /* SkDrawBlur.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawBlur.cpp; path = ../libsgl/animator/SkDrawBlur.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD5D0EDCA15800F77EA2 /* SkDrawBlur.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawBlur.h; path = ../libsgl/animator/SkDrawBlur.h; sourceTree = SOURCE_ROOT; }; + 00B7DD5E0EDCA15800F77EA2 /* SkDrawClip.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawClip.cpp; path = ../libsgl/animator/SkDrawClip.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD5F0EDCA15800F77EA2 /* SkDrawClip.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawClip.h; path = ../libsgl/animator/SkDrawClip.h; sourceTree = SOURCE_ROOT; }; + 00B7DD600EDCA15800F77EA2 /* SkDrawColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawColor.cpp; path = ../libsgl/animator/SkDrawColor.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD610EDCA15800F77EA2 /* SkDrawColor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawColor.h; path = ../libsgl/animator/SkDrawColor.h; sourceTree = SOURCE_ROOT; }; + 00B7DD620EDCA15800F77EA2 /* SkDrawDash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawDash.cpp; path = ../libsgl/animator/SkDrawDash.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD630EDCA15800F77EA2 /* SkDrawDash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawDash.h; path = ../libsgl/animator/SkDrawDash.h; sourceTree = SOURCE_ROOT; }; + 00B7DD640EDCA15800F77EA2 /* SkDrawDiscrete.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawDiscrete.cpp; path = ../libsgl/animator/SkDrawDiscrete.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD650EDCA15800F77EA2 /* SkDrawDiscrete.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawDiscrete.h; path = ../libsgl/animator/SkDrawDiscrete.h; sourceTree = SOURCE_ROOT; }; + 00B7DD660EDCA15800F77EA2 /* SkDrawEmboss.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawEmboss.cpp; path = ../libsgl/animator/SkDrawEmboss.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD670EDCA15800F77EA2 /* SkDrawEmboss.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawEmboss.h; path = ../libsgl/animator/SkDrawEmboss.h; sourceTree = SOURCE_ROOT; }; + 00B7DD680EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawExtraPathEffect.cpp; path = ../libsgl/animator/SkDrawExtraPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD690EDCA15800F77EA2 /* SkDrawFull.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawFull.cpp; path = ../libsgl/animator/SkDrawFull.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD6A0EDCA15800F77EA2 /* SkDrawFull.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawFull.h; path = ../libsgl/animator/SkDrawFull.h; sourceTree = SOURCE_ROOT; }; + 00B7DD6B0EDCA15800F77EA2 /* SkDrawGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawGradient.cpp; path = ../libsgl/animator/SkDrawGradient.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD6C0EDCA15800F77EA2 /* SkDrawGradient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawGradient.h; path = ../libsgl/animator/SkDrawGradient.h; sourceTree = SOURCE_ROOT; }; + 00B7DD6D0EDCA15800F77EA2 /* SkDrawGroup.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawGroup.cpp; path = ../libsgl/animator/SkDrawGroup.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD6E0EDCA15800F77EA2 /* SkDrawGroup.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawGroup.h; path = ../libsgl/animator/SkDrawGroup.h; sourceTree = SOURCE_ROOT; }; + 00B7DD6F0EDCA15800F77EA2 /* SkDrawLine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawLine.cpp; path = ../libsgl/animator/SkDrawLine.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD700EDCA15800F77EA2 /* SkDrawLine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawLine.h; path = ../libsgl/animator/SkDrawLine.h; sourceTree = SOURCE_ROOT; }; + 00B7DD710EDCA15800F77EA2 /* SkDrawMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawMatrix.cpp; path = ../libsgl/animator/SkDrawMatrix.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD720EDCA15800F77EA2 /* SkDrawMatrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawMatrix.h; path = ../libsgl/animator/SkDrawMatrix.h; sourceTree = SOURCE_ROOT; }; + 00B7DD730EDCA15800F77EA2 /* SkDrawOval.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawOval.cpp; path = ../libsgl/animator/SkDrawOval.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD740EDCA15800F77EA2 /* SkDrawOval.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawOval.h; path = ../libsgl/animator/SkDrawOval.h; sourceTree = SOURCE_ROOT; }; + 00B7DD750EDCA15800F77EA2 /* SkDrawPaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawPaint.cpp; path = ../libsgl/animator/SkDrawPaint.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD760EDCA15800F77EA2 /* SkDrawPaint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawPaint.h; path = ../libsgl/animator/SkDrawPaint.h; sourceTree = SOURCE_ROOT; }; + 00B7DD770EDCA15800F77EA2 /* SkDrawPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawPath.cpp; path = ../libsgl/animator/SkDrawPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD780EDCA15800F77EA2 /* SkDrawPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawPath.h; path = ../libsgl/animator/SkDrawPath.h; sourceTree = SOURCE_ROOT; }; + 00B7DD790EDCA15800F77EA2 /* SkDrawPoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawPoint.cpp; path = ../libsgl/animator/SkDrawPoint.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD7A0EDCA15800F77EA2 /* SkDrawPoint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawPoint.h; path = ../libsgl/animator/SkDrawPoint.h; sourceTree = SOURCE_ROOT; }; + 00B7DD7B0EDCA15800F77EA2 /* SkDrawRectangle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawRectangle.cpp; path = ../libsgl/animator/SkDrawRectangle.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD7C0EDCA15800F77EA2 /* SkDrawRectangle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawRectangle.h; path = ../libsgl/animator/SkDrawRectangle.h; sourceTree = SOURCE_ROOT; }; + 00B7DD7D0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawSaveLayer.cpp; path = ../libsgl/animator/SkDrawSaveLayer.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD7E0EDCA15800F77EA2 /* SkDrawSaveLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawSaveLayer.h; path = ../libsgl/animator/SkDrawSaveLayer.h; sourceTree = SOURCE_ROOT; }; + 00B7DD7F0EDCA15800F77EA2 /* SkDrawShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawShader.cpp; path = ../libsgl/animator/SkDrawShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD800EDCA15800F77EA2 /* SkDrawShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawShader.h; path = ../libsgl/animator/SkDrawShader.h; sourceTree = SOURCE_ROOT; }; + 00B7DD810EDCA15800F77EA2 /* SkDrawText.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawText.cpp; path = ../libsgl/animator/SkDrawText.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD820EDCA15800F77EA2 /* SkDrawText.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawText.h; path = ../libsgl/animator/SkDrawText.h; sourceTree = SOURCE_ROOT; }; + 00B7DD830EDCA15800F77EA2 /* SkDrawTextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawTextBox.cpp; path = ../libsgl/animator/SkDrawTextBox.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD840EDCA15800F77EA2 /* SkDrawTextBox.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawTextBox.h; path = ../libsgl/animator/SkDrawTextBox.h; sourceTree = SOURCE_ROOT; }; + 00B7DD850EDCA15800F77EA2 /* SkDrawTo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawTo.cpp; path = ../libsgl/animator/SkDrawTo.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD860EDCA15800F77EA2 /* SkDrawTo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawTo.h; path = ../libsgl/animator/SkDrawTo.h; sourceTree = SOURCE_ROOT; }; + 00B7DD870EDCA15800F77EA2 /* SkDrawTransparentShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDrawTransparentShader.cpp; path = ../libsgl/animator/SkDrawTransparentShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD880EDCA15800F77EA2 /* SkDrawTransparentShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawTransparentShader.h; path = ../libsgl/animator/SkDrawTransparentShader.h; sourceTree = SOURCE_ROOT; }; + 00B7DD890EDCA15800F77EA2 /* SkDump.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDump.cpp; path = ../libsgl/animator/SkDump.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD8A0EDCA15800F77EA2 /* SkDump.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDump.h; path = ../libsgl/animator/SkDump.h; sourceTree = SOURCE_ROOT; }; + 00B7DD8C0EDCA15800F77EA2 /* SkExtras.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkExtras.h; path = ../libsgl/animator/SkExtras.h; sourceTree = SOURCE_ROOT; }; + 00B7DD8D0EDCA15800F77EA2 /* SkGetCondensedInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGetCondensedInfo.cpp; path = ../libsgl/animator/SkGetCondensedInfo.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD8E0EDCA15800F77EA2 /* SkHitClear.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkHitClear.cpp; path = ../libsgl/animator/SkHitClear.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD8F0EDCA15800F77EA2 /* SkHitClear.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkHitClear.h; path = ../libsgl/animator/SkHitClear.h; sourceTree = SOURCE_ROOT; }; + 00B7DD900EDCA15800F77EA2 /* SkHitTest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkHitTest.cpp; path = ../libsgl/animator/SkHitTest.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD910EDCA15800F77EA2 /* SkHitTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkHitTest.h; path = ../libsgl/animator/SkHitTest.h; sourceTree = SOURCE_ROOT; }; + 00B7DD920EDCA15800F77EA2 /* SkIntArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkIntArray.h; path = ../libsgl/animator/SkIntArray.h; sourceTree = SOURCE_ROOT; }; + 00B7DD930EDCA15800F77EA2 /* SkMatrixParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMatrixParts.cpp; path = ../libsgl/animator/SkMatrixParts.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD940EDCA15800F77EA2 /* SkMatrixParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkMatrixParts.h; path = ../libsgl/animator/SkMatrixParts.h; sourceTree = SOURCE_ROOT; }; + 00B7DD950EDCA15800F77EA2 /* SkMemberInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMemberInfo.cpp; path = ../libsgl/animator/SkMemberInfo.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD960EDCA15800F77EA2 /* SkMemberInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkMemberInfo.h; path = ../libsgl/animator/SkMemberInfo.h; sourceTree = SOURCE_ROOT; }; + 00B7DD970EDCA15800F77EA2 /* SkOpArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOpArray.cpp; path = ../libsgl/animator/SkOpArray.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD980EDCA15800F77EA2 /* SkOpArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOpArray.h; path = ../libsgl/animator/SkOpArray.h; sourceTree = SOURCE_ROOT; }; + 00B7DD990EDCA15800F77EA2 /* SkOperand.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOperand.h; path = ../libsgl/animator/SkOperand.h; sourceTree = SOURCE_ROOT; }; + 00B7DD9A0EDCA15800F77EA2 /* SkOperand2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOperand2.h; path = ../libsgl/animator/SkOperand2.h; sourceTree = SOURCE_ROOT; }; + 00B7DD9B0EDCA15800F77EA2 /* SkOperandInterpolator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkOperandInterpolator.h; path = ../libsgl/animator/SkOperandInterpolator.h; sourceTree = SOURCE_ROOT; }; + 00B7DD9C0EDCA15800F77EA2 /* SkOperandIterpolator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOperandIterpolator.cpp; path = ../libsgl/animator/SkOperandIterpolator.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD9D0EDCA15800F77EA2 /* SkPaintParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaintParts.cpp; path = ../libsgl/animator/SkPaintParts.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DD9E0EDCA15800F77EA2 /* SkPaintParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPaintParts.h; path = ../libsgl/animator/SkPaintParts.h; sourceTree = SOURCE_ROOT; }; + 00B7DD9F0EDCA15800F77EA2 /* SkPathParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathParts.cpp; path = ../libsgl/animator/SkPathParts.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDA00EDCA15800F77EA2 /* SkPathParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPathParts.h; path = ../libsgl/animator/SkPathParts.h; sourceTree = SOURCE_ROOT; }; + 00B7DDA10EDCA15800F77EA2 /* SkPostParts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPostParts.cpp; path = ../libsgl/animator/SkPostParts.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDA20EDCA15800F77EA2 /* SkPostParts.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPostParts.h; path = ../libsgl/animator/SkPostParts.h; sourceTree = SOURCE_ROOT; }; + 00B7DDA30EDCA15800F77EA2 /* SkScript.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScript.cpp; path = ../libsgl/animator/SkScript.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDA40EDCA15800F77EA2 /* SkScript.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScript.h; path = ../libsgl/animator/SkScript.h; sourceTree = SOURCE_ROOT; }; + 00B7DDA50EDCA15800F77EA2 /* SkScript2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScript2.h; path = ../libsgl/animator/SkScript2.h; sourceTree = SOURCE_ROOT; }; + 00B7DDA60EDCA15800F77EA2 /* SkScriptCallBack.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScriptCallBack.h; path = ../libsgl/animator/SkScriptCallBack.h; sourceTree = SOURCE_ROOT; }; + 00B7DDA70EDCA15800F77EA2 /* SkScriptDecompile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScriptDecompile.cpp; path = ../libsgl/animator/SkScriptDecompile.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDA80EDCA15800F77EA2 /* SkScriptRuntime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScriptRuntime.cpp; path = ../libsgl/animator/SkScriptRuntime.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDA90EDCA15800F77EA2 /* SkScriptRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScriptRuntime.h; path = ../libsgl/animator/SkScriptRuntime.h; sourceTree = SOURCE_ROOT; }; + 00B7DDAA0EDCA15800F77EA2 /* SkScriptTokenizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScriptTokenizer.cpp; path = ../libsgl/animator/SkScriptTokenizer.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDAB0EDCA15800F77EA2 /* SkSnapshot.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSnapshot.cpp; path = ../libsgl/animator/SkSnapshot.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDAC0EDCA15800F77EA2 /* SkSnapshot.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSnapshot.h; path = ../libsgl/animator/SkSnapshot.h; sourceTree = SOURCE_ROOT; }; + 00B7DDAD0EDCA15800F77EA2 /* SkSVGPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSVGPath.cpp; path = ../libsgl/animator/SkSVGPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDAE0EDCA15800F77EA2 /* SkTDArray_Experimental.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTDArray_Experimental.h; path = ../libsgl/animator/SkTDArray_Experimental.h; sourceTree = SOURCE_ROOT; }; + 00B7DDAF0EDCA15800F77EA2 /* SkTextOnPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextOnPath.cpp; path = ../libsgl/animator/SkTextOnPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDB00EDCA15800F77EA2 /* SkTextOnPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextOnPath.h; path = ../libsgl/animator/SkTextOnPath.h; sourceTree = SOURCE_ROOT; }; + 00B7DDB10EDCA15800F77EA2 /* SkTextToPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextToPath.cpp; path = ../libsgl/animator/SkTextToPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDB20EDCA15800F77EA2 /* SkTextToPath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextToPath.h; path = ../libsgl/animator/SkTextToPath.h; sourceTree = SOURCE_ROOT; }; + 00B7DDB30EDCA15800F77EA2 /* SkTime.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTime.cpp; path = ../libsgl/animator/SkTime.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDB40EDCA15800F77EA2 /* SkTypedArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTypedArray.cpp; path = ../libsgl/animator/SkTypedArray.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDB50EDCA15800F77EA2 /* SkTypedArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTypedArray.h; path = ../libsgl/animator/SkTypedArray.h; sourceTree = SOURCE_ROOT; }; + 00B7DDB60EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLAnimatorWriter.cpp; path = ../libsgl/animator/SkXMLAnimatorWriter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DDB70EDCA15800F77EA2 /* SkXMLAnimatorWriter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkXMLAnimatorWriter.h; path = ../libsgl/animator/SkXMLAnimatorWriter.h; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libanimator.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libanimator.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* animator */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = animator; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7DD170EDCA15800F77EA2 /* SkAnimate.h */, + 00B7DD1A0EDCA15800F77EA2 /* SkAnimateActive.cpp */, + 00B7DD1B0EDCA15800F77EA2 /* SkAnimateActive.h */, + 00B7DD1C0EDCA15800F77EA2 /* SkAnimateBase.cpp */, + 00B7DD1D0EDCA15800F77EA2 /* SkAnimateBase.h */, + 00B7DD1E0EDCA15800F77EA2 /* SkAnimateField.cpp */, + 00B7DD1F0EDCA15800F77EA2 /* SkAnimateMaker.cpp */, + 00B7DD200EDCA15800F77EA2 /* SkAnimateMaker.h */, + 00B7DD210EDCA15800F77EA2 /* SkAnimateProperties.h */, + 00B7DD240EDCA15800F77EA2 /* SkAnimateSet.cpp */, + 00B7DD250EDCA15800F77EA2 /* SkAnimateSet.h */, + 00B7DD260EDCA15800F77EA2 /* SkAnimator.cpp */, + 00B7DD270EDCA15800F77EA2 /* SkAnimatorScript.cpp */, + 00B7DD280EDCA15800F77EA2 /* SkAnimatorScript.h */, + 00B7DD290EDCA15800F77EA2 /* SkAnimatorScript2.cpp */, + 00B7DD2A0EDCA15800F77EA2 /* SkAnimatorScript2.h */, + 00B7DD2B0EDCA15800F77EA2 /* SkBase64.cpp */, + 00B7DD2C0EDCA15800F77EA2 /* SkBase64.h */, + 00B7DD2D0EDCA15800F77EA2 /* SkBoundable.cpp */, + 00B7DD2E0EDCA15800F77EA2 /* SkBoundable.h */, + 00B7DD320EDCA15800F77EA2 /* SkDisplayable.cpp */, + 00B7DD330EDCA15800F77EA2 /* SkDisplayable.h */, + 00B7DD340EDCA15800F77EA2 /* SkDisplayAdd.cpp */, + 00B7DD350EDCA15800F77EA2 /* SkDisplayAdd.h */, + 00B7DD360EDCA15800F77EA2 /* SkDisplayApply.cpp */, + 00B7DD370EDCA15800F77EA2 /* SkDisplayApply.h */, + 00B7DD380EDCA15800F77EA2 /* SkDisplayBounds.cpp */, + 00B7DD390EDCA15800F77EA2 /* SkDisplayBounds.h */, + 00B7DD3A0EDCA15800F77EA2 /* SkDisplayEvent.cpp */, + 00B7DD3B0EDCA15800F77EA2 /* SkDisplayEvent.h */, + 00B7DD3C0EDCA15800F77EA2 /* SkDisplayEvents.cpp */, + 00B7DD3D0EDCA15800F77EA2 /* SkDisplayEvents.h */, + 00B7DD3E0EDCA15800F77EA2 /* SkDisplayInclude.cpp */, + 00B7DD3F0EDCA15800F77EA2 /* SkDisplayInclude.h */, + 00B7DD400EDCA15800F77EA2 /* SkDisplayInput.cpp */, + 00B7DD410EDCA15800F77EA2 /* SkDisplayInput.h */, + 00B7DD420EDCA15800F77EA2 /* SkDisplayList.cpp */, + 00B7DD430EDCA15800F77EA2 /* SkDisplayList.h */, + 00B7DD440EDCA15800F77EA2 /* SkDisplayMath.cpp */, + 00B7DD450EDCA15800F77EA2 /* SkDisplayMath.h */, + 00B7DD460EDCA15800F77EA2 /* SkDisplayMovie.cpp */, + 00B7DD470EDCA15800F77EA2 /* SkDisplayMovie.h */, + 00B7DD480EDCA15800F77EA2 /* SkDisplayNumber.cpp */, + 00B7DD490EDCA15800F77EA2 /* SkDisplayNumber.h */, + 00B7DD4A0EDCA15800F77EA2 /* SkDisplayPost.cpp */, + 00B7DD4B0EDCA15800F77EA2 /* SkDisplayPost.h */, + 00B7DD4C0EDCA15800F77EA2 /* SkDisplayRandom.cpp */, + 00B7DD4D0EDCA15800F77EA2 /* SkDisplayRandom.h */, + 00B7DD4E0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp */, + 00B7DD4F0EDCA15800F77EA2 /* SkDisplayScreenplay.h */, + 00B7DD500EDCA15800F77EA2 /* SkDisplayType.cpp */, + 00B7DD510EDCA15800F77EA2 /* SkDisplayType.h */, + 00B7DD520EDCA15800F77EA2 /* SkDisplayTypes.cpp */, + 00B7DD530EDCA15800F77EA2 /* SkDisplayTypes.h */, + 00B7DD540EDCA15800F77EA2 /* SkDisplayXMLParser.cpp */, + 00B7DD550EDCA15800F77EA2 /* SkDisplayXMLParser.h */, + 00B7DD560EDCA15800F77EA2 /* SkDraw3D.cpp */, + 00B7DD570EDCA15800F77EA2 /* SkDraw3D.h */, + 00B7DD580EDCA15800F77EA2 /* SkDrawable.cpp */, + 00B7DD590EDCA15800F77EA2 /* SkDrawable.h */, + 00B7DD5A0EDCA15800F77EA2 /* SkDrawBitmap.cpp */, + 00B7DD5B0EDCA15800F77EA2 /* SkDrawBitmap.h */, + 00B7DD5C0EDCA15800F77EA2 /* SkDrawBlur.cpp */, + 00B7DD5D0EDCA15800F77EA2 /* SkDrawBlur.h */, + 00B7DD5E0EDCA15800F77EA2 /* SkDrawClip.cpp */, + 00B7DD5F0EDCA15800F77EA2 /* SkDrawClip.h */, + 00B7DD600EDCA15800F77EA2 /* SkDrawColor.cpp */, + 00B7DD610EDCA15800F77EA2 /* SkDrawColor.h */, + 00B7DD620EDCA15800F77EA2 /* SkDrawDash.cpp */, + 00B7DD630EDCA15800F77EA2 /* SkDrawDash.h */, + 00B7DD640EDCA15800F77EA2 /* SkDrawDiscrete.cpp */, + 00B7DD650EDCA15800F77EA2 /* SkDrawDiscrete.h */, + 00B7DD660EDCA15800F77EA2 /* SkDrawEmboss.cpp */, + 00B7DD670EDCA15800F77EA2 /* SkDrawEmboss.h */, + 00B7DD680EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp */, + 00B7DD690EDCA15800F77EA2 /* SkDrawFull.cpp */, + 00B7DD6A0EDCA15800F77EA2 /* SkDrawFull.h */, + 00B7DD6B0EDCA15800F77EA2 /* SkDrawGradient.cpp */, + 00B7DD6C0EDCA15800F77EA2 /* SkDrawGradient.h */, + 00B7DD6D0EDCA15800F77EA2 /* SkDrawGroup.cpp */, + 00B7DD6E0EDCA15800F77EA2 /* SkDrawGroup.h */, + 00B7DD6F0EDCA15800F77EA2 /* SkDrawLine.cpp */, + 00B7DD700EDCA15800F77EA2 /* SkDrawLine.h */, + 00B7DD710EDCA15800F77EA2 /* SkDrawMatrix.cpp */, + 00B7DD720EDCA15800F77EA2 /* SkDrawMatrix.h */, + 00B7DD730EDCA15800F77EA2 /* SkDrawOval.cpp */, + 00B7DD740EDCA15800F77EA2 /* SkDrawOval.h */, + 00B7DD750EDCA15800F77EA2 /* SkDrawPaint.cpp */, + 00B7DD760EDCA15800F77EA2 /* SkDrawPaint.h */, + 00B7DD770EDCA15800F77EA2 /* SkDrawPath.cpp */, + 00B7DD780EDCA15800F77EA2 /* SkDrawPath.h */, + 00B7DD790EDCA15800F77EA2 /* SkDrawPoint.cpp */, + 00B7DD7A0EDCA15800F77EA2 /* SkDrawPoint.h */, + 00B7DD7B0EDCA15800F77EA2 /* SkDrawRectangle.cpp */, + 00B7DD7C0EDCA15800F77EA2 /* SkDrawRectangle.h */, + 00B7DD7D0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp */, + 00B7DD7E0EDCA15800F77EA2 /* SkDrawSaveLayer.h */, + 00B7DD7F0EDCA15800F77EA2 /* SkDrawShader.cpp */, + 00B7DD800EDCA15800F77EA2 /* SkDrawShader.h */, + 00B7DD810EDCA15800F77EA2 /* SkDrawText.cpp */, + 00B7DD820EDCA15800F77EA2 /* SkDrawText.h */, + 00B7DD830EDCA15800F77EA2 /* SkDrawTextBox.cpp */, + 00B7DD840EDCA15800F77EA2 /* SkDrawTextBox.h */, + 00B7DD850EDCA15800F77EA2 /* SkDrawTo.cpp */, + 00B7DD860EDCA15800F77EA2 /* SkDrawTo.h */, + 00B7DD870EDCA15800F77EA2 /* SkDrawTransparentShader.cpp */, + 00B7DD880EDCA15800F77EA2 /* SkDrawTransparentShader.h */, + 00B7DD890EDCA15800F77EA2 /* SkDump.cpp */, + 00B7DD8A0EDCA15800F77EA2 /* SkDump.h */, + 00B7DD8C0EDCA15800F77EA2 /* SkExtras.h */, + 00B7DD8D0EDCA15800F77EA2 /* SkGetCondensedInfo.cpp */, + 00B7DD8E0EDCA15800F77EA2 /* SkHitClear.cpp */, + 00B7DD8F0EDCA15800F77EA2 /* SkHitClear.h */, + 00B7DD900EDCA15800F77EA2 /* SkHitTest.cpp */, + 00B7DD910EDCA15800F77EA2 /* SkHitTest.h */, + 00B7DD920EDCA15800F77EA2 /* SkIntArray.h */, + 00B7DD930EDCA15800F77EA2 /* SkMatrixParts.cpp */, + 00B7DD940EDCA15800F77EA2 /* SkMatrixParts.h */, + 00B7DD950EDCA15800F77EA2 /* SkMemberInfo.cpp */, + 00B7DD960EDCA15800F77EA2 /* SkMemberInfo.h */, + 00B7DD970EDCA15800F77EA2 /* SkOpArray.cpp */, + 00B7DD980EDCA15800F77EA2 /* SkOpArray.h */, + 00B7DD990EDCA15800F77EA2 /* SkOperand.h */, + 00B7DD9A0EDCA15800F77EA2 /* SkOperand2.h */, + 00B7DD9B0EDCA15800F77EA2 /* SkOperandInterpolator.h */, + 00B7DD9C0EDCA15800F77EA2 /* SkOperandIterpolator.cpp */, + 00B7DD9D0EDCA15800F77EA2 /* SkPaintParts.cpp */, + 00B7DD9E0EDCA15800F77EA2 /* SkPaintParts.h */, + 00B7DD9F0EDCA15800F77EA2 /* SkPathParts.cpp */, + 00B7DDA00EDCA15800F77EA2 /* SkPathParts.h */, + 00B7DDA10EDCA15800F77EA2 /* SkPostParts.cpp */, + 00B7DDA20EDCA15800F77EA2 /* SkPostParts.h */, + 00B7DDA30EDCA15800F77EA2 /* SkScript.cpp */, + 00B7DDA40EDCA15800F77EA2 /* SkScript.h */, + 00B7DDA50EDCA15800F77EA2 /* SkScript2.h */, + 00B7DDA60EDCA15800F77EA2 /* SkScriptCallBack.h */, + 00B7DDA70EDCA15800F77EA2 /* SkScriptDecompile.cpp */, + 00B7DDA80EDCA15800F77EA2 /* SkScriptRuntime.cpp */, + 00B7DDA90EDCA15800F77EA2 /* SkScriptRuntime.h */, + 00B7DDAA0EDCA15800F77EA2 /* SkScriptTokenizer.cpp */, + 00B7DDAB0EDCA15800F77EA2 /* SkSnapshot.cpp */, + 00B7DDAC0EDCA15800F77EA2 /* SkSnapshot.h */, + 00B7DDAD0EDCA15800F77EA2 /* SkSVGPath.cpp */, + 00B7DDAE0EDCA15800F77EA2 /* SkTDArray_Experimental.h */, + 00B7DDAF0EDCA15800F77EA2 /* SkTextOnPath.cpp */, + 00B7DDB00EDCA15800F77EA2 /* SkTextOnPath.h */, + 00B7DDB10EDCA15800F77EA2 /* SkTextToPath.cpp */, + 00B7DDB20EDCA15800F77EA2 /* SkTextToPath.h */, + 00B7DDB30EDCA15800F77EA2 /* SkTime.cpp */, + 00B7DDB40EDCA15800F77EA2 /* SkTypedArray.cpp */, + 00B7DDB50EDCA15800F77EA2 /* SkTypedArray.h */, + 00B7DDB60EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp */, + 00B7DDB70EDCA15800F77EA2 /* SkXMLAnimatorWriter.h */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libanimator.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DDB80EDCA15800F77EA2 /* SkAnimate.h in Headers */, + 00B7DDBA0EDCA15800F77EA2 /* SkAnimateActive.h in Headers */, + 00B7DDBC0EDCA15800F77EA2 /* SkAnimateBase.h in Headers */, + 00B7DDBF0EDCA15800F77EA2 /* SkAnimateMaker.h in Headers */, + 00B7DDC00EDCA15800F77EA2 /* SkAnimateProperties.h in Headers */, + 00B7DDC20EDCA15800F77EA2 /* SkAnimateSet.h in Headers */, + 00B7DDC50EDCA15800F77EA2 /* SkAnimatorScript.h in Headers */, + 00B7DDC70EDCA15800F77EA2 /* SkAnimatorScript2.h in Headers */, + 00B7DDC90EDCA15800F77EA2 /* SkBase64.h in Headers */, + 00B7DDCB0EDCA15800F77EA2 /* SkBoundable.h in Headers */, + 00B7DDD00EDCA15800F77EA2 /* SkDisplayable.h in Headers */, + 00B7DDD20EDCA15800F77EA2 /* SkDisplayAdd.h in Headers */, + 00B7DDD40EDCA15800F77EA2 /* SkDisplayApply.h in Headers */, + 00B7DDD60EDCA15800F77EA2 /* SkDisplayBounds.h in Headers */, + 00B7DDD80EDCA15800F77EA2 /* SkDisplayEvent.h in Headers */, + 00B7DDDA0EDCA15800F77EA2 /* SkDisplayEvents.h in Headers */, + 00B7DDDC0EDCA15800F77EA2 /* SkDisplayInclude.h in Headers */, + 00B7DDDE0EDCA15800F77EA2 /* SkDisplayInput.h in Headers */, + 00B7DDE00EDCA15800F77EA2 /* SkDisplayList.h in Headers */, + 00B7DDE20EDCA15800F77EA2 /* SkDisplayMath.h in Headers */, + 00B7DDE40EDCA15800F77EA2 /* SkDisplayMovie.h in Headers */, + 00B7DDE60EDCA15800F77EA2 /* SkDisplayNumber.h in Headers */, + 00B7DDE80EDCA15800F77EA2 /* SkDisplayPost.h in Headers */, + 00B7DDEA0EDCA15800F77EA2 /* SkDisplayRandom.h in Headers */, + 00B7DDEC0EDCA15800F77EA2 /* SkDisplayScreenplay.h in Headers */, + 00B7DDEE0EDCA15800F77EA2 /* SkDisplayType.h in Headers */, + 00B7DDF00EDCA15800F77EA2 /* SkDisplayTypes.h in Headers */, + 00B7DDF20EDCA15800F77EA2 /* SkDisplayXMLParser.h in Headers */, + 00B7DDF40EDCA15800F77EA2 /* SkDraw3D.h in Headers */, + 00B7DDF60EDCA15800F77EA2 /* SkDrawable.h in Headers */, + 00B7DDF80EDCA15800F77EA2 /* SkDrawBitmap.h in Headers */, + 00B7DDFA0EDCA15800F77EA2 /* SkDrawBlur.h in Headers */, + 00B7DDFC0EDCA15800F77EA2 /* SkDrawClip.h in Headers */, + 00B7DDFE0EDCA15800F77EA2 /* SkDrawColor.h in Headers */, + 00B7DE000EDCA15800F77EA2 /* SkDrawDash.h in Headers */, + 00B7DE020EDCA15800F77EA2 /* SkDrawDiscrete.h in Headers */, + 00B7DE040EDCA15800F77EA2 /* SkDrawEmboss.h in Headers */, + 00B7DE070EDCA15800F77EA2 /* SkDrawFull.h in Headers */, + 00B7DE090EDCA15800F77EA2 /* SkDrawGradient.h in Headers */, + 00B7DE0B0EDCA15800F77EA2 /* SkDrawGroup.h in Headers */, + 00B7DE0D0EDCA15800F77EA2 /* SkDrawLine.h in Headers */, + 00B7DE0F0EDCA15800F77EA2 /* SkDrawMatrix.h in Headers */, + 00B7DE110EDCA15800F77EA2 /* SkDrawOval.h in Headers */, + 00B7DE130EDCA15800F77EA2 /* SkDrawPaint.h in Headers */, + 00B7DE150EDCA15800F77EA2 /* SkDrawPath.h in Headers */, + 00B7DE170EDCA15800F77EA2 /* SkDrawPoint.h in Headers */, + 00B7DE190EDCA15800F77EA2 /* SkDrawRectangle.h in Headers */, + 00B7DE1B0EDCA15800F77EA2 /* SkDrawSaveLayer.h in Headers */, + 00B7DE1D0EDCA15800F77EA2 /* SkDrawShader.h in Headers */, + 00B7DE1F0EDCA15800F77EA2 /* SkDrawText.h in Headers */, + 00B7DE210EDCA15800F77EA2 /* SkDrawTextBox.h in Headers */, + 00B7DE230EDCA15800F77EA2 /* SkDrawTo.h in Headers */, + 00B7DE250EDCA15800F77EA2 /* SkDrawTransparentShader.h in Headers */, + 00B7DE270EDCA15800F77EA2 /* SkDump.h in Headers */, + 00B7DE280EDCA15800F77EA2 /* SkExtras.h in Headers */, + 00B7DE2B0EDCA15800F77EA2 /* SkHitClear.h in Headers */, + 00B7DE2D0EDCA15800F77EA2 /* SkHitTest.h in Headers */, + 00B7DE2E0EDCA15800F77EA2 /* SkIntArray.h in Headers */, + 00B7DE300EDCA15800F77EA2 /* SkMatrixParts.h in Headers */, + 00B7DE320EDCA15800F77EA2 /* SkMemberInfo.h in Headers */, + 00B7DE340EDCA15800F77EA2 /* SkOpArray.h in Headers */, + 00B7DE350EDCA15800F77EA2 /* SkOperand.h in Headers */, + 00B7DE360EDCA15800F77EA2 /* SkOperand2.h in Headers */, + 00B7DE370EDCA15800F77EA2 /* SkOperandInterpolator.h in Headers */, + 00B7DE3A0EDCA15800F77EA2 /* SkPaintParts.h in Headers */, + 00B7DE3C0EDCA15800F77EA2 /* SkPathParts.h in Headers */, + 00B7DE3E0EDCA15800F77EA2 /* SkPostParts.h in Headers */, + 00B7DE400EDCA15800F77EA2 /* SkScript.h in Headers */, + 00B7DE410EDCA15800F77EA2 /* SkScript2.h in Headers */, + 00B7DE420EDCA15800F77EA2 /* SkScriptCallBack.h in Headers */, + 00B7DE450EDCA15800F77EA2 /* SkScriptRuntime.h in Headers */, + 00B7DE480EDCA15800F77EA2 /* SkSnapshot.h in Headers */, + 00B7DE4A0EDCA15800F77EA2 /* SkTDArray_Experimental.h in Headers */, + 00B7DE4C0EDCA15800F77EA2 /* SkTextOnPath.h in Headers */, + 00B7DE4E0EDCA15800F77EA2 /* SkTextToPath.h in Headers */, + 00B7DE510EDCA15800F77EA2 /* SkTypedArray.h in Headers */, + 00B7DE530EDCA15800F77EA2 /* SkXMLAnimatorWriter.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* animator */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "animator" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = animator; + productName = animator; + productReference = D2AAC046055464E500DB518D /* libanimator.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "animator" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* animator */; + projectDirPath = ""; + projectRoot = ..; + targets = ( + D2AAC045055464E500DB518D /* animator */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DDB90EDCA15800F77EA2 /* SkAnimateActive.cpp in Sources */, + 00B7DDBB0EDCA15800F77EA2 /* SkAnimateBase.cpp in Sources */, + 00B7DDBD0EDCA15800F77EA2 /* SkAnimateField.cpp in Sources */, + 00B7DDBE0EDCA15800F77EA2 /* SkAnimateMaker.cpp in Sources */, + 00B7DDC10EDCA15800F77EA2 /* SkAnimateSet.cpp in Sources */, + 00B7DDC30EDCA15800F77EA2 /* SkAnimator.cpp in Sources */, + 00B7DDC40EDCA15800F77EA2 /* SkAnimatorScript.cpp in Sources */, + 00B7DDC60EDCA15800F77EA2 /* SkAnimatorScript2.cpp in Sources */, + 00B7DDC80EDCA15800F77EA2 /* SkBase64.cpp in Sources */, + 00B7DDCA0EDCA15800F77EA2 /* SkBoundable.cpp in Sources */, + 00B7DDCF0EDCA15800F77EA2 /* SkDisplayable.cpp in Sources */, + 00B7DDD10EDCA15800F77EA2 /* SkDisplayAdd.cpp in Sources */, + 00B7DDD30EDCA15800F77EA2 /* SkDisplayApply.cpp in Sources */, + 00B7DDD50EDCA15800F77EA2 /* SkDisplayBounds.cpp in Sources */, + 00B7DDD70EDCA15800F77EA2 /* SkDisplayEvent.cpp in Sources */, + 00B7DDD90EDCA15800F77EA2 /* SkDisplayEvents.cpp in Sources */, + 00B7DDDB0EDCA15800F77EA2 /* SkDisplayInclude.cpp in Sources */, + 00B7DDDD0EDCA15800F77EA2 /* SkDisplayInput.cpp in Sources */, + 00B7DDDF0EDCA15800F77EA2 /* SkDisplayList.cpp in Sources */, + 00B7DDE10EDCA15800F77EA2 /* SkDisplayMath.cpp in Sources */, + 00B7DDE30EDCA15800F77EA2 /* SkDisplayMovie.cpp in Sources */, + 00B7DDE50EDCA15800F77EA2 /* SkDisplayNumber.cpp in Sources */, + 00B7DDE70EDCA15800F77EA2 /* SkDisplayPost.cpp in Sources */, + 00B7DDE90EDCA15800F77EA2 /* SkDisplayRandom.cpp in Sources */, + 00B7DDEB0EDCA15800F77EA2 /* SkDisplayScreenplay.cpp in Sources */, + 00B7DDED0EDCA15800F77EA2 /* SkDisplayType.cpp in Sources */, + 00B7DDEF0EDCA15800F77EA2 /* SkDisplayTypes.cpp in Sources */, + 00B7DDF10EDCA15800F77EA2 /* SkDisplayXMLParser.cpp in Sources */, + 00B7DDF30EDCA15800F77EA2 /* SkDraw3D.cpp in Sources */, + 00B7DDF50EDCA15800F77EA2 /* SkDrawable.cpp in Sources */, + 00B7DDF70EDCA15800F77EA2 /* SkDrawBitmap.cpp in Sources */, + 00B7DDF90EDCA15800F77EA2 /* SkDrawBlur.cpp in Sources */, + 00B7DDFB0EDCA15800F77EA2 /* SkDrawClip.cpp in Sources */, + 00B7DDFD0EDCA15800F77EA2 /* SkDrawColor.cpp in Sources */, + 00B7DDFF0EDCA15800F77EA2 /* SkDrawDash.cpp in Sources */, + 00B7DE010EDCA15800F77EA2 /* SkDrawDiscrete.cpp in Sources */, + 00B7DE030EDCA15800F77EA2 /* SkDrawEmboss.cpp in Sources */, + 00B7DE050EDCA15800F77EA2 /* SkDrawExtraPathEffect.cpp in Sources */, + 00B7DE060EDCA15800F77EA2 /* SkDrawFull.cpp in Sources */, + 00B7DE080EDCA15800F77EA2 /* SkDrawGradient.cpp in Sources */, + 00B7DE0A0EDCA15800F77EA2 /* SkDrawGroup.cpp in Sources */, + 00B7DE0C0EDCA15800F77EA2 /* SkDrawLine.cpp in Sources */, + 00B7DE0E0EDCA15800F77EA2 /* SkDrawMatrix.cpp in Sources */, + 00B7DE100EDCA15800F77EA2 /* SkDrawOval.cpp in Sources */, + 00B7DE120EDCA15800F77EA2 /* SkDrawPaint.cpp in Sources */, + 00B7DE140EDCA15800F77EA2 /* SkDrawPath.cpp in Sources */, + 00B7DE160EDCA15800F77EA2 /* SkDrawPoint.cpp in Sources */, + 00B7DE180EDCA15800F77EA2 /* SkDrawRectangle.cpp in Sources */, + 00B7DE1A0EDCA15800F77EA2 /* SkDrawSaveLayer.cpp in Sources */, + 00B7DE1C0EDCA15800F77EA2 /* SkDrawShader.cpp in Sources */, + 00B7DE1E0EDCA15800F77EA2 /* SkDrawText.cpp in Sources */, + 00B7DE200EDCA15800F77EA2 /* SkDrawTextBox.cpp in Sources */, + 00B7DE220EDCA15800F77EA2 /* SkDrawTo.cpp in Sources */, + 00B7DE240EDCA15800F77EA2 /* SkDrawTransparentShader.cpp in Sources */, + 00B7DE260EDCA15800F77EA2 /* SkDump.cpp in Sources */, + 00B7DE290EDCA15800F77EA2 /* SkGetCondensedInfo.cpp in Sources */, + 00B7DE2A0EDCA15800F77EA2 /* SkHitClear.cpp in Sources */, + 00B7DE2C0EDCA15800F77EA2 /* SkHitTest.cpp in Sources */, + 00B7DE2F0EDCA15800F77EA2 /* SkMatrixParts.cpp in Sources */, + 00B7DE310EDCA15800F77EA2 /* SkMemberInfo.cpp in Sources */, + 00B7DE330EDCA15800F77EA2 /* SkOpArray.cpp in Sources */, + 00B7DE380EDCA15800F77EA2 /* SkOperandIterpolator.cpp in Sources */, + 00B7DE390EDCA15800F77EA2 /* SkPaintParts.cpp in Sources */, + 00B7DE3B0EDCA15800F77EA2 /* SkPathParts.cpp in Sources */, + 00B7DE3D0EDCA15800F77EA2 /* SkPostParts.cpp in Sources */, + 00B7DE3F0EDCA15800F77EA2 /* SkScript.cpp in Sources */, + 00B7DE430EDCA15800F77EA2 /* SkScriptDecompile.cpp in Sources */, + 00B7DE440EDCA15800F77EA2 /* SkScriptRuntime.cpp in Sources */, + 00B7DE460EDCA15800F77EA2 /* SkScriptTokenizer.cpp in Sources */, + 00B7DE470EDCA15800F77EA2 /* SkSnapshot.cpp in Sources */, + 00B7DE490EDCA15800F77EA2 /* SkSVGPath.cpp in Sources */, + 00B7DE4B0EDCA15800F77EA2 /* SkTextOnPath.cpp in Sources */, + 00B7DE4D0EDCA15800F77EA2 /* SkTextToPath.cpp in Sources */, + 00B7DE4F0EDCA15800F77EA2 /* SkTime.cpp in Sources */, + 00B7DE500EDCA15800F77EA2 /* SkTypedArray.cpp in Sources */, + 00B7DE520EDCA15800F77EA2 /* SkXMLAnimatorWriter.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = animator; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = animator; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "animator" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "animator" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/animatorTest/animatorTest.xcodeproj/project.pbxproj b/xcode/animatorTest/animatorTest.xcodeproj/project.pbxproj new file mode 100644 index 0000000..26004dc --- /dev/null +++ b/xcode/animatorTest/animatorTest.xcodeproj/project.pbxproj @@ -0,0 +1,1112 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */; }; + 8D0C4E8E0486CD37000505A6 /* main.nib in Resources */ = {isa = PBXBuildFile; fileRef = 02345980000FD03B11CA0E72 /* main.nib */; }; + 8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 20286C33FDCF999611CA2CEA /* Carbon.framework */; }; + FE33CA3A094E2D2500C4A640 /* libgraphics.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA1F094E2CC900C4A640 /* libgraphics.a */; }; + FE33CA3B094E2D2E00C4A640 /* libfreetype.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA19094E2CC900C4A640 /* libfreetype.a */; }; + FE33CA49094E2D3A00C4A640 /* libports.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA1C094E2CC900C4A640 /* libports.a */; }; + FE33CA4A094E2D4600C4A640 /* libports-mac.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA01094E2CC900C4A640 /* libports-mac.a */; }; + FE33CA4B094E2D4D00C4A640 /* libgif.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA0A094E2CC900C4A640 /* libgif.a */; }; + FE33CA4C094E2D5400C4A640 /* libjpeg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA0D094E2CC900C4A640 /* libjpeg.a */; }; + FE33CA4D094E2D5B00C4A640 /* liblibpng.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA10094E2CC900C4A640 /* liblibpng.a */; }; + FE33CA4E094E2D6600C4A640 /* libzlib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA13094E2CC900C4A640 /* libzlib.a */; }; + FE33CA4F094E2D7000C4A640 /* libviews.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA16094E2CC900C4A640 /* libviews.a */; }; + FE33CA50094E2D7600C4A640 /* libanimator.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA07094E2CC900C4A640 /* libanimator.a */; }; + FE3485990950D204003F0C3F /* libsvg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE3485980950D1EE003F0C3F /* libsvg.a */; }; + FE61323709B616EA004BB4B8 /* libcorecg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE61323609B616A5004BB4B8 /* libcorecg.a */; }; + FEBB00B00D7DD8D70027C5D6 /* CacheBuilder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEBB00A20D7DD8D70027C5D6 /* CacheBuilder.cpp */; }; + FEBB00B10D7DD8D70027C5D6 /* CachedFrame.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEBB00A50D7DD8D70027C5D6 /* CachedFrame.cpp */; }; + FEBB00B20D7DD8D70027C5D6 /* CachedHistory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEBB00A70D7DD8D70027C5D6 /* CachedHistory.cpp */; }; + FEBB00B30D7DD8D70027C5D6 /* CachedNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEBB00A90D7DD8D70027C5D6 /* CachedNode.cpp */; }; + FEBB00B40D7DD8D70027C5D6 /* CachedRoot.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEBB00AD0D7DD8D70027C5D6 /* CachedRoot.cpp */; }; + FEBB00B90D7DD8F20027C5D6 /* BrowserDebug.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEBB00B70D7DD8F20027C5D6 /* BrowserDebug.cpp */; }; + FEBB00C60D7DDA4A0027C5D6 /* animatorTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE33CAC4094F301100C4A640 /* animatorTest.cpp */; }; + FEF4C9AA09574C4600F2B941 /* libexpat.a in Frameworks */ = {isa = PBXBuildFile; fileRef = FE33CA04094E2CC900C4A640 /* libexpat.a */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + FE33CA00094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9DE094E2CC900C4A640 /* ports-mac.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = "ports-mac"; + }; + FE33CA03094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9E1094E2CC900C4A640 /* expat.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = expat; + }; + FE33CA06094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9E4094E2CC900C4A640 /* animator.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = animator; + }; + FE33CA09094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9E7094E2CC900C4A640 /* gif.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = gif; + }; + FE33CA0C094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9EA094E2CC900C4A640 /* jpeg.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = jpeg; + }; + FE33CA0F094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9ED094E2CC900C4A640 /* libpng.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = libpng; + }; + FE33CA12094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F0094E2CC900C4A640 /* zlib.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = zlib; + }; + FE33CA15094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F3094E2CC900C4A640 /* views.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = views; + }; + FE33CA18094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F6094E2CC900C4A640 /* freetype2.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = freetype; + }; + FE33CA1B094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F9094E2CC900C4A640 /* ports.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = ports; + }; + FE33CA1E094E2CC900C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9FC094E2CC900C4A640 /* graphics.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC06F0554671400DB518D; + remoteInfo = graphics; + }; + FE33CA20094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F9094E2CC900C4A640 /* ports.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = ports; + }; + FE33CA22094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F3094E2CC900C4A640 /* views.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = views; + }; + FE33CA24094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9ED094E2CC900C4A640 /* libpng.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = libpng; + }; + FE33CA26094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9E7094E2CC900C4A640 /* gif.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = gif; + }; + FE33CA28094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9E4094E2CC900C4A640 /* animator.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = animator; + }; + FE33CA2A094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9DE094E2CC900C4A640 /* ports-mac.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = "ports-mac"; + }; + FE33CA2C094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9FC094E2CC900C4A640 /* graphics.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC06E0554671400DB518D; + remoteInfo = graphics; + }; + FE33CA2E094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F6094E2CC900C4A640 /* freetype2.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = freetype; + }; + FE33CA30094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9F0094E2CC900C4A640 /* zlib.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = zlib; + }; + FE33CA32094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9EA094E2CC900C4A640 /* jpeg.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = jpeg; + }; + FE33CA34094E2CFD00C4A640 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE33C9E1094E2CC900C4A640 /* expat.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = expat; + }; + FE3485970950D1EE003F0C3F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE3485930950D1EE003F0C3F /* svg.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = svg; + }; + FE34859A0950D21C003F0C3F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE3485930950D1EE003F0C3F /* svg.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = svg; + }; + FE61323509B616A5004BB4B8 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE61323009B616A5004BB4B8 /* corecg.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = corecg; + }; + FE61324709B6191D004BB4B8 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = FE61323009B616A5004BB4B8 /* corecg.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = corecg; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 000419F90B4AD2C1002A456B /* SkFontHost_FONTPATH.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_FONTPATH.cpp; path = ../../../libs/graphics/ports/SkFontHost_FONTPATH.cpp; sourceTree = SOURCE_ROOT; }; + 000419FA0B4AD2C1002A456B /* SkFontHost_none.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_none.cpp; path = ../../../libs/graphics/ports/SkFontHost_none.cpp; sourceTree = SOURCE_ROOT; }; + 0009590E0A27775D001F29C8 /* pathTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = pathTest.cpp; path = ../../../tests/skia/animatorTest/pathTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3EE0C88591F00CC4316 /* cameraTest3.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = cameraTest3.cpp; path = ../../../tests/skia/animatorTest/cameraTest3.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3EF0C88591F00CC4316 /* ditherTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = ditherTest.cpp; path = ../../../tests/skia/animatorTest/ditherTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F00C88591F00CC4316 /* imageditherTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = imageditherTest.cpp; path = ../../../tests/skia/animatorTest/imageditherTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F10C88591F00CC4316 /* layerTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = layerTest.cpp; path = ../../../tests/skia/animatorTest/layerTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F20C88591F00CC4316 /* maskTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = maskTest.cpp; path = ../../../tests/skia/animatorTest/maskTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F30C88591F00CC4316 /* mipmapTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = mipmapTest.cpp; path = ../../../tests/skia/animatorTest/mipmapTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F40C88591F00CC4316 /* pathEffectTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = pathEffectTest.cpp; path = ../../../tests/skia/animatorTest/pathEffectTest.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F50C88591F00CC4316 /* regionToPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = regionToPath.cpp; path = ../../../tests/skia/animatorTest/regionToPath.cpp; sourceTree = SOURCE_ROOT; }; + 000BB3F60C88591F00CC4316 /* testImage.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = testImage.cpp; path = ../../../tests/skia/animatorTest/testImage.cpp; sourceTree = SOURCE_ROOT; }; + 000F5ED00B77BB82007BC854 /* shaderTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = shaderTest.cpp; path = ../../../tests/skia/animatorTest/shaderTest.cpp; sourceTree = SOURCE_ROOT; }; + 001164400CE0CC3400050E37 /* SampleAll.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleAll.cpp; sourceTree = "<group>"; }; + 0011644A0CE119B800050E37 /* SampleEncode.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleEncode.cpp; sourceTree = "<group>"; }; + 002136F80CFF35C80017CD78 /* SampleCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleCamera.cpp; sourceTree = "<group>"; }; + 002A08F90CE9F563009DE5DB /* SamplePath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SamplePath.cpp; sourceTree = "<group>"; }; + 0031B9800CC3A97D00366339 /* SkPackBits.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkPackBits.cpp; path = ../../../libs/graphics/sgl/SkPackBits.cpp; sourceTree = SOURCE_ROOT; }; + 004F37A90D1B73EB00FCE06A /* SampleFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleFilter.cpp; sourceTree = "<group>"; }; + 00540DFD09D04C9B00307DCB /* regionTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = regionTest.cpp; path = ../../../tests/skia/animatorTest/regionTest.cpp; sourceTree = SOURCE_ROOT; }; + 00625C700CB32B70003DB915 /* SampleImage.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleImage.cpp; sourceTree = "<group>"; }; + 006EEFA50AA611910064EC7C /* ninepatchTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = ninepatchTest.cpp; path = ../../../tests/skia/animatorTest/ninepatchTest.cpp; sourceTree = SOURCE_ROOT; }; + 00731B110C8F4DC900AF4FB6 /* SampleCull.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleCull.cpp; sourceTree = "<group>"; }; + 00731B120C8F4DC900AF4FB6 /* SampleLayers.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleLayers.cpp; sourceTree = "<group>"; }; + 0077DCA50B2087C000ED5E84 /* textOnPathTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = textOnPathTest.cpp; path = ../../../tests/skia/animatorTest/textOnPathTest.cpp; sourceTree = SOURCE_ROOT; }; + 0092A3610AD6EC13000FECBC /* cameraTest2.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = cameraTest2.cpp; path = ../../../tests/skia/animatorTest/cameraTest2.cpp; sourceTree = SOURCE_ROOT; }; + 00A1F4C60C90383200BCF1B6 /* SamplePoints.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SamplePoints.cpp; sourceTree = "<group>"; }; + 00A1F4C70C90383200BCF1B6 /* SampleText.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleText.cpp; sourceTree = "<group>"; }; + 00A1F4C80C90383200BCF1B6 /* SampleTiling.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleTiling.cpp; sourceTree = "<group>"; }; + 00A1F4ED0C903D1600BCF1B6 /* SampleTextOnPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleTextOnPath.cpp; sourceTree = "<group>"; }; + 00AAB9FE0A0A6DEF009B65B1 /* textTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = textTest.cpp; path = ../../../tests/skia/animatorTest/textTest.cpp; sourceTree = SOURCE_ROOT; }; + 00AB5FFF0A8267AE0038DE0A /* tilingTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = tilingTest.cpp; path = ../../../tests/skia/animatorTest/tilingTest.cpp; sourceTree = SOURCE_ROOT; }; + 00B1596D0AA37F6100B118AB /* testcull.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = testcull.cpp; path = ../../../tests/skia/animatorTest/testcull.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BA70CD01F7600BFAB53 /* jpgdec_api.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = jpgdec_api.h; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_api.h; sourceTree = SOURCE_ROOT; }; + 00BF1BA80CD01F7600BFAB53 /* jpgdec_bitstream.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_bitstream.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_bitstream.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BA90CD01F7600BFAB53 /* jpgdec_cint.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_cint.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_cint.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BAA0CD01F7600BFAB53 /* jpgdec_colorconv.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_colorconv.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_colorconv.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BAB0CD01F7600BFAB53 /* jpgdec_config.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = jpgdec_config.h; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_config.h; sourceTree = SOURCE_ROOT; }; + 00BF1BAC0CD01F7600BFAB53 /* jpgdec_ct.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_ct.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_ct.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BAD0CD01F7600BFAB53 /* jpgdec_decoder.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_decoder.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_decoder.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BAE0CD01F7600BFAB53 /* jpgdec_error.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = jpgdec_error.h; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_error.h; sourceTree = SOURCE_ROOT; }; + 00BF1BAF0CD01F7600BFAB53 /* jpgdec_header.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_header.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_header.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB00CD01F7600BFAB53 /* jpgdec_huffman.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_huffman.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_huffman.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB10CD01F7600BFAB53 /* jpgdec_idctp.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_idctp.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_idctp.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB20CD01F7600BFAB53 /* jpgdec_idcts.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_idcts.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_idcts.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB30CD01F7600BFAB53 /* jpgdec_prototype.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = jpgdec_prototype.h; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_prototype.h; sourceTree = SOURCE_ROOT; }; + 00BF1BB40CD01F7600BFAB53 /* jpgdec_scan.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_scan.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_scan.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB50CD01F7600BFAB53 /* jpgdec_table.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_table.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_table.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB60CD01F7600BFAB53 /* jpgdec_table.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = jpgdec_table.h; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_table.h; sourceTree = SOURCE_ROOT; }; + 00BF1BB70CD01F7600BFAB53 /* jpgdec_utils.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_utils.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_utils.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB80CD01F7600BFAB53 /* pvjpgdecoder_factory.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = pvjpgdecoder_factory.cpp; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/pvjpgdecoder_factory.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1BB90CD01F7600BFAB53 /* pvjpgdecoder.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = pvjpgdecoder.h; path = ../../../extlibs/pv/codecs_v2/image/jpeg/dec/src/pvjpgdecoder.h; sourceTree = SOURCE_ROOT; }; + 00BF1E950CD0274100BFAB53 /* SkImageDecoder_libpvjpeg.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libpvjpeg.cpp; path = ../../../libs/graphics/images/SkImageDecoder_libpvjpeg.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F240CD0E40D00BFAB53 /* oscl_assert.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_assert.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_assert.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F250CD0E40E00BFAB53 /* oscl_base.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_base.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_base.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F260CD0E40E00BFAB53 /* oscl_byte_order.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_byte_order.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_byte_order.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F270CD0E40E00BFAB53 /* oscl_int64_utils.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_int64_utils.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_int64_utils.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F280CD0E40E00BFAB53 /* oscl_int64.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_int64.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_int64.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F290CD0E40E00BFAB53 /* oscl_mem_basic_functions.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_mem_basic_functions.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_mem_basic_functions.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F2A0CD0E40E00BFAB53 /* oscl_singleton.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_singleton.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_singleton.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F2B0CD0E40E00BFAB53 /* oscl_stdstring.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_stdstring.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_stdstring.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F2C0CD0E40E00BFAB53 /* oscl_string_utils.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_string_utils.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_string_utils.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F2D0CD0E40E00BFAB53 /* oscl_tagtree.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_tagtree.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_tagtree.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F2E0CD0E40E00BFAB53 /* oscl_tree.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_tree.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_tree.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F2F0CD0E40E00BFAB53 /* oscl_uint64.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_uint64.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_uint64.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F520CD0E4A700BFAB53 /* oscl_tls.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_tls.cpp; path = ../../../extlibs/pv/oscl/oscl/osclbase/src/oscl_tls.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F5D0CD0E52300BFAB53 /* oscl_errno.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_errno.cpp; path = ../../../extlibs/pv/oscl/oscl/osclerror/src/oscl_errno.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F5E0CD0E52300BFAB53 /* oscl_error_imp_jumps.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_error_imp_jumps.cpp; path = ../../../extlibs/pv/oscl/oscl/osclerror/src/oscl_error_imp_jumps.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F5F0CD0E52300BFAB53 /* oscl_error_trapcleanup.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_error_trapcleanup.cpp; path = ../../../extlibs/pv/oscl/oscl/osclerror/src/oscl_error_trapcleanup.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F600CD0E52300BFAB53 /* oscl_heapbase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_heapbase.cpp; path = ../../../extlibs/pv/oscl/oscl/osclerror/src/oscl_heapbase.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F610CD0E52300BFAB53 /* oscl_mempool_allocator.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_mempool_allocator.cpp; path = ../../../extlibs/pv/oscl/oscl/osclerror/src/oscl_mempool_allocator.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F6E0CD0E56A00BFAB53 /* oscl_error.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_error.cpp; path = ../../../extlibs/pv/oscl/oscl/osclerror/src/oscl_error.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F790CD0E5BB00BFAB53 /* oscl_mem_audit.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_mem_audit.cpp; path = ../../../extlibs/pv/oscl/oscl/osclmemory/src/oscl_mem_audit.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F7A0CD0E5BB00BFAB53 /* oscl_mem_imp.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_mem_imp.cpp; path = ../../../extlibs/pv/oscl/oscl/osclmemory/src/oscl_mem_imp.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F7B0CD0E5BB00BFAB53 /* oscl_mem_mempool.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_mem_mempool.cpp; path = ../../../extlibs/pv/oscl/oscl/osclmemory/src/oscl_mem_mempool.cpp; sourceTree = SOURCE_ROOT; }; + 00BF1F7C0CD0E5BB00BFAB53 /* oscl_mem.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = oscl_mem.cpp; path = ../../../extlibs/pv/oscl/oscl/osclmemory/src/oscl_mem.cpp; sourceTree = SOURCE_ROOT; }; + 00C7F00B0ADBDC6200202BAB /* cameraTest4.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = cameraTest4.cpp; path = ../../../tests/skia/animatorTest/cameraTest4.cpp; sourceTree = SOURCE_ROOT; }; + 00E6E1790CCCE62A00F102DB /* SampleImageDir.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleImageDir.cpp; sourceTree = "<group>"; }; + 00E6E2B90CCD122A00F102DB /* SampleFontCache.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleFontCache.cpp; sourceTree = "<group>"; }; + 00F0528D0AD2D26D00B085B7 /* testbitmaptile.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = testbitmaptile.cpp; path = ../../../tests/skia/animatorTest/testbitmaptile.cpp; sourceTree = SOURCE_ROOT; }; + 00F0DC640D1846C00089B0C1 /* SampleDither.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleDither.cpp; sourceTree = "<group>"; }; + 00F6F7C70C8F1C890064A10D /* SampleApp.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleApp.cpp; sourceTree = "<group>"; }; + 00F6F7C80C8F1C890064A10D /* SampleArc.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleArc.cpp; sourceTree = "<group>"; }; + 00F6F7C90C8F1C890064A10D /* SamplePathEffects.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SamplePathEffects.cpp; sourceTree = "<group>"; }; + 00F6F7CA0C8F1C890064A10D /* SampleRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleRegion.cpp; sourceTree = "<group>"; }; + 00F6F7CB0C8F1C890064A10D /* SampleShaders.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleShaders.cpp; sourceTree = "<group>"; }; + 00F6F7CC0C8F1C890064A10D /* SampleTextEffects.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SampleTextEffects.cpp; sourceTree = "<group>"; }; + 00F714FB0ACC056500453651 /* TextSpeedTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = TextSpeedTest.cpp; path = ../../../tests/skia/animatorTest/TextSpeedTest.cpp; sourceTree = SOURCE_ROOT; }; + 0867D6ABFE840B52C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; }; + 1870340FFE93FCAF11CA0CD7 /* English */ = {isa = PBXFileReference; lastKnownFileType = wrapper.nib; name = English; path = English.lproj/main.nib; sourceTree = "<group>"; }; + 20286C33FDCF999611CA2CEA /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; }; + 32DBCF6D0370B57F00C91783 /* animatorTest_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = animatorTest_Prefix.pch; sourceTree = "<group>"; }; + 4A9504C8FFE6A3BC11CA0CBA /* ApplicationServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = ApplicationServices.framework; path = /System/Library/Frameworks/ApplicationServices.framework; sourceTree = "<absolute>"; }; + 4A9504CAFFE6A41611CA0CBA /* CoreServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreServices.framework; path = /System/Library/Frameworks/CoreServices.framework; sourceTree = "<absolute>"; }; + 8D0C4E960486CD37000505A6 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; }; + 8D0C4E970486CD37000505A6 /* animatorTest.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = animatorTest.app; sourceTree = BUILT_PRODUCTS_DIR; }; + FE21C73309537F3800D016FB /* animatorTest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = animatorTest.h; path = ../../../tests/skia/animatorTest/animatorTest.h; sourceTree = SOURCE_ROOT; }; + FE33C9DE094E2CC900C4A640 /* ports-mac.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = "ports-mac.xcodeproj"; path = "../ports-mac.xcodeproj"; sourceTree = SOURCE_ROOT; }; + FE33C9E1094E2CC900C4A640 /* expat.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = expat.xcodeproj; path = ../expat.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9E4094E2CC900C4A640 /* animator.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = animator.xcodeproj; path = ../animator.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9E7094E2CC900C4A640 /* gif.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = gif.xcodeproj; path = ../gif.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9EA094E2CC900C4A640 /* jpeg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = jpeg.xcodeproj; path = ../jpeg.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9ED094E2CC900C4A640 /* libpng.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = libpng.xcodeproj; path = ../libpng.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9F0094E2CC900C4A640 /* zlib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = zlib.xcodeproj; path = ../zlib.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9F3094E2CC900C4A640 /* views.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = views.xcodeproj; path = ../views.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9F6094E2CC900C4A640 /* freetype2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = freetype2.xcodeproj; path = ../freetype2.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9F9094E2CC900C4A640 /* ports.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = ports.xcodeproj; path = ../ports.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33C9FC094E2CC900C4A640 /* graphics.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = graphics.xcodeproj; path = ../graphics.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE33CAC4094F301100C4A640 /* animatorTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = animatorTest.cpp; path = ../../../tests/skia/animatorTest/animatorTest.cpp; sourceTree = SOURCE_ROOT; }; + FE3485930950D1EE003F0C3F /* svg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = svg.xcodeproj; path = ../svg.xcodeproj; sourceTree = SOURCE_ROOT; }; + FE61323009B616A5004BB4B8 /* corecg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = corecg.xcodeproj; path = ../corecg.xcodeproj; sourceTree = SOURCE_ROOT; }; + FEACF22A09E4636400D0C2E2 /* animatorUnitTest.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = animatorUnitTest.cpp; path = ../../../tests/skia/animatorTest/animatorUnitTest.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00A20D7DD8D70027C5D6 /* CacheBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = CacheBuilder.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CacheBuilder.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00A30D7DD8D70027C5D6 /* CacheBuilder.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CacheBuilder.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CacheBuilder.h; sourceTree = SOURCE_ROOT; }; + FEBB00A40D7DD8D70027C5D6 /* CachedDebug.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedDebug.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedDebug.h; sourceTree = SOURCE_ROOT; }; + FEBB00A50D7DD8D70027C5D6 /* CachedFrame.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = CachedFrame.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedFrame.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00A60D7DD8D70027C5D6 /* CachedFrame.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedFrame.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedFrame.h; sourceTree = SOURCE_ROOT; }; + FEBB00A70D7DD8D70027C5D6 /* CachedHistory.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = CachedHistory.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedHistory.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00A80D7DD8D70027C5D6 /* CachedHistory.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedHistory.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedHistory.h; sourceTree = SOURCE_ROOT; }; + FEBB00A90D7DD8D70027C5D6 /* CachedNode.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = CachedNode.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedNode.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00AA0D7DD8D70027C5D6 /* CachedNode.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedNode.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedNode.h; sourceTree = SOURCE_ROOT; }; + FEBB00AB0D7DD8D70027C5D6 /* CachedNodeType.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedNodeType.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedNodeType.h; sourceTree = SOURCE_ROOT; }; + FEBB00AC0D7DD8D70027C5D6 /* CachedPrefix.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedPrefix.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedPrefix.h; sourceTree = SOURCE_ROOT; }; + FEBB00AD0D7DD8D70027C5D6 /* CachedRoot.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = CachedRoot.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedRoot.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00AE0D7DD8D70027C5D6 /* CachedRoot.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = CachedRoot.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/CachedRoot.h; sourceTree = SOURCE_ROOT; }; + FEBB00AF0D7DD8D70027C5D6 /* WebView.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = WebView.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/nav/WebView.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00B70D7DD8F20027C5D6 /* BrowserDebug.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = BrowserDebug.cpp; path = ../../../tests/browser/focusNavigation/BrowserDebug.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00B80D7DD8F20027C5D6 /* BrowserDebug.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = BrowserDebug.h; path = ../../../tests/browser/focusNavigation/BrowserDebug.h; sourceTree = SOURCE_ROOT; }; + FEBB00D20D7DE0710027C5D6 /* android_widget_htmlwidget.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = android_widget_htmlwidget.cpp; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/jni/android_widget_htmlwidget.cpp; sourceTree = SOURCE_ROOT; }; + FEBB00D30D7DE0710027C5D6 /* android_widget_htmlwidget.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = android_widget_htmlwidget.h; path = ../../../libs/WebKitLib/WebKit/WebCore/platform/android/jni/android_widget_htmlwidget.h; sourceTree = SOURCE_ROOT; }; + FEBB00D60D7DE0B50027C5D6 /* WebView.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; name = WebView.java; path = ../../../java/android/android/webkit/WebView.java; sourceTree = SOURCE_ROOT; }; + FEBB00D70D7DE0B50027C5D6 /* WebViewCore.java */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.java; name = WebViewCore.java; path = ../../../java/android/android/webkit/WebViewCore.java; sourceTree = SOURCE_ROOT; }; + FEDCDA7309B892550042D964 /* masterList.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = masterList.cpp; path = ../../../tests/skia/masterList/masterList.cpp; sourceTree = SOURCE_ROOT; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8D0C4E910486CD37000505A6 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + FE33CA50094E2D7600C4A640 /* libanimator.a in Frameworks */, + FE3485990950D204003F0C3F /* libsvg.a in Frameworks */, + FE33CA4F094E2D7000C4A640 /* libviews.a in Frameworks */, + FE33CA3A094E2D2500C4A640 /* libgraphics.a in Frameworks */, + FE61323709B616EA004BB4B8 /* libcorecg.a in Frameworks */, + FE33CA3B094E2D2E00C4A640 /* libfreetype.a in Frameworks */, + FEF4C9AA09574C4600F2B941 /* libexpat.a in Frameworks */, + FE33CA49094E2D3A00C4A640 /* libports.a in Frameworks */, + FE33CA4A094E2D4600C4A640 /* libports-mac.a in Frameworks */, + FE33CA4C094E2D5400C4A640 /* libjpeg.a in Frameworks */, + FE33CA4B094E2D4D00C4A640 /* libgif.a in Frameworks */, + FE33CA4D094E2D5B00C4A640 /* liblibpng.a in Frameworks */, + FE33CA4E094E2D6600C4A640 /* libzlib.a in Frameworks */, + 8D0C4E920486CD37000505A6 /* Carbon.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 00BF1BA60CD01F5200BFAB53 /* pv_decode */ = { + isa = PBXGroup; + children = ( + 00BF1F790CD0E5BB00BFAB53 /* oscl_mem_audit.cpp */, + 00BF1F7A0CD0E5BB00BFAB53 /* oscl_mem_imp.cpp */, + 00BF1F7B0CD0E5BB00BFAB53 /* oscl_mem_mempool.cpp */, + 00BF1F7C0CD0E5BB00BFAB53 /* oscl_mem.cpp */, + 00BF1F6E0CD0E56A00BFAB53 /* oscl_error.cpp */, + 00BF1F5D0CD0E52300BFAB53 /* oscl_errno.cpp */, + 00BF1F5E0CD0E52300BFAB53 /* oscl_error_imp_jumps.cpp */, + 00BF1F5F0CD0E52300BFAB53 /* oscl_error_trapcleanup.cpp */, + 00BF1F600CD0E52300BFAB53 /* oscl_heapbase.cpp */, + 00BF1F610CD0E52300BFAB53 /* oscl_mempool_allocator.cpp */, + 00BF1F520CD0E4A700BFAB53 /* oscl_tls.cpp */, + 00BF1F240CD0E40D00BFAB53 /* oscl_assert.cpp */, + 00BF1F250CD0E40E00BFAB53 /* oscl_base.cpp */, + 00BF1F260CD0E40E00BFAB53 /* oscl_byte_order.cpp */, + 00BF1F270CD0E40E00BFAB53 /* oscl_int64_utils.cpp */, + 00BF1F280CD0E40E00BFAB53 /* oscl_int64.cpp */, + 00BF1F290CD0E40E00BFAB53 /* oscl_mem_basic_functions.cpp */, + 00BF1F2A0CD0E40E00BFAB53 /* oscl_singleton.cpp */, + 00BF1F2B0CD0E40E00BFAB53 /* oscl_stdstring.cpp */, + 00BF1F2C0CD0E40E00BFAB53 /* oscl_string_utils.cpp */, + 00BF1F2D0CD0E40E00BFAB53 /* oscl_tagtree.cpp */, + 00BF1F2E0CD0E40E00BFAB53 /* oscl_tree.cpp */, + 00BF1F2F0CD0E40E00BFAB53 /* oscl_uint64.cpp */, + 00BF1BA70CD01F7600BFAB53 /* jpgdec_api.h */, + 00BF1BA80CD01F7600BFAB53 /* jpgdec_bitstream.cpp */, + 00BF1BA90CD01F7600BFAB53 /* jpgdec_cint.cpp */, + 00BF1BAA0CD01F7600BFAB53 /* jpgdec_colorconv.cpp */, + 00BF1BAB0CD01F7600BFAB53 /* jpgdec_config.h */, + 00BF1BAC0CD01F7600BFAB53 /* jpgdec_ct.cpp */, + 00BF1BAD0CD01F7600BFAB53 /* jpgdec_decoder.cpp */, + 00BF1BAE0CD01F7600BFAB53 /* jpgdec_error.h */, + 00BF1BAF0CD01F7600BFAB53 /* jpgdec_header.cpp */, + 00BF1BB00CD01F7600BFAB53 /* jpgdec_huffman.cpp */, + 00BF1BB10CD01F7600BFAB53 /* jpgdec_idctp.cpp */, + 00BF1BB20CD01F7600BFAB53 /* jpgdec_idcts.cpp */, + 00BF1BB30CD01F7600BFAB53 /* jpgdec_prototype.h */, + 00BF1BB40CD01F7600BFAB53 /* jpgdec_scan.cpp */, + 00BF1BB50CD01F7600BFAB53 /* jpgdec_table.cpp */, + 00BF1BB60CD01F7600BFAB53 /* jpgdec_table.h */, + 00BF1BB70CD01F7600BFAB53 /* jpgdec_utils.cpp */, + 00BF1BB80CD01F7600BFAB53 /* pvjpgdecoder_factory.cpp */, + 00BF1BB90CD01F7600BFAB53 /* pvjpgdecoder.h */, + ); + name = pv_decode; + sourceTree = "<group>"; + }; + 00F6F7C50C8F1C890064A10D /* SampleCode */ = { + isa = PBXGroup; + children = ( + 00F6F7C70C8F1C890064A10D /* SampleApp.cpp */, + 00F6F7C80C8F1C890064A10D /* SampleArc.cpp */, + 0011644A0CE119B800050E37 /* SampleEncode.cpp */, + 001164400CE0CC3400050E37 /* SampleAll.cpp */, + 00A1F4C60C90383200BCF1B6 /* SamplePoints.cpp */, + 00A1F4C70C90383200BCF1B6 /* SampleText.cpp */, + 00A1F4C80C90383200BCF1B6 /* SampleTiling.cpp */, + 00731B110C8F4DC900AF4FB6 /* SampleCull.cpp */, + 002136F80CFF35C80017CD78 /* SampleCamera.cpp */, + 00731B120C8F4DC900AF4FB6 /* SampleLayers.cpp */, + 00F0DC640D1846C00089B0C1 /* SampleDither.cpp */, + 004F37A90D1B73EB00FCE06A /* SampleFilter.cpp */, + 00F6F7C90C8F1C890064A10D /* SamplePathEffects.cpp */, + 00F6F7CA0C8F1C890064A10D /* SampleRegion.cpp */, + 00F6F7CB0C8F1C890064A10D /* SampleShaders.cpp */, + 00625C700CB32B70003DB915 /* SampleImage.cpp */, + 002A08F90CE9F563009DE5DB /* SamplePath.cpp */, + 00E6E1790CCCE62A00F102DB /* SampleImageDir.cpp */, + 00E6E2B90CCD122A00F102DB /* SampleFontCache.cpp */, + 00F6F7CC0C8F1C890064A10D /* SampleTextEffects.cpp */, + 00A1F4ED0C903D1600BCF1B6 /* SampleTextOnPath.cpp */, + ); + name = SampleCode; + path = ../../../tests/skia/SampleCode; + sourceTree = SOURCE_ROOT; + }; + 195DF8CFFE9D517E11CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 8D0C4E970486CD37000505A6 /* animatorTest.app */, + ); + name = Products; + sourceTree = "<group>"; + }; + 20286C29FDCF999611CA2CEA /* animatorTest */ = { + isa = PBXGroup; + children = ( + 00BF1BA60CD01F5200BFAB53 /* pv_decode */, + 00F6F7C50C8F1C890064A10D /* SampleCode */, + FE33C9E1094E2CC900C4A640 /* expat.xcodeproj */, + FE61323009B616A5004BB4B8 /* corecg.xcodeproj */, + FE3485930950D1EE003F0C3F /* svg.xcodeproj */, + FE33C9DE094E2CC900C4A640 /* ports-mac.xcodeproj */, + FE33C9E4094E2CC900C4A640 /* animator.xcodeproj */, + FE33C9E7094E2CC900C4A640 /* gif.xcodeproj */, + FE33C9EA094E2CC900C4A640 /* jpeg.xcodeproj */, + FE33C9ED094E2CC900C4A640 /* libpng.xcodeproj */, + FE33C9F0094E2CC900C4A640 /* zlib.xcodeproj */, + FE33C9F3094E2CC900C4A640 /* views.xcodeproj */, + FE33C9F6094E2CC900C4A640 /* freetype2.xcodeproj */, + FE33C9F9094E2CC900C4A640 /* ports.xcodeproj */, + FE33C9FC094E2CC900C4A640 /* graphics.xcodeproj */, + 20286C2AFDCF999611CA2CEA /* Sources */, + 20286C2CFDCF999611CA2CEA /* Resources */, + 20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */, + 195DF8CFFE9D517E11CA2CBB /* Products */, + 00BF1E950CD0274100BFAB53 /* SkImageDecoder_libpvjpeg.cpp */, + ); + name = animatorTest; + sourceTree = "<group>"; + }; + 20286C2AFDCF999611CA2CEA /* Sources */ = { + isa = PBXGroup; + children = ( + FEBB00D60D7DE0B50027C5D6 /* WebView.java */, + FEBB00D70D7DE0B50027C5D6 /* WebViewCore.java */, + FEBB00D20D7DE0710027C5D6 /* android_widget_htmlwidget.cpp */, + FEBB00D30D7DE0710027C5D6 /* android_widget_htmlwidget.h */, + FEBB00B70D7DD8F20027C5D6 /* BrowserDebug.cpp */, + FEBB00B80D7DD8F20027C5D6 /* BrowserDebug.h */, + FEBB00A20D7DD8D70027C5D6 /* CacheBuilder.cpp */, + FEBB00A30D7DD8D70027C5D6 /* CacheBuilder.h */, + FEBB00A40D7DD8D70027C5D6 /* CachedDebug.h */, + FEBB00A50D7DD8D70027C5D6 /* CachedFrame.cpp */, + FEBB00A60D7DD8D70027C5D6 /* CachedFrame.h */, + FEBB00A70D7DD8D70027C5D6 /* CachedHistory.cpp */, + FEBB00A80D7DD8D70027C5D6 /* CachedHistory.h */, + FEBB00A90D7DD8D70027C5D6 /* CachedNode.cpp */, + FEBB00AA0D7DD8D70027C5D6 /* CachedNode.h */, + FEBB00AB0D7DD8D70027C5D6 /* CachedNodeType.h */, + FEBB00AC0D7DD8D70027C5D6 /* CachedPrefix.h */, + FEBB00AD0D7DD8D70027C5D6 /* CachedRoot.cpp */, + FEBB00AE0D7DD8D70027C5D6 /* CachedRoot.h */, + FEBB00AF0D7DD8D70027C5D6 /* WebView.cpp */, + 0031B9800CC3A97D00366339 /* SkPackBits.cpp */, + 000BB3EE0C88591F00CC4316 /* cameraTest3.cpp */, + 000BB3EF0C88591F00CC4316 /* ditherTest.cpp */, + 000BB3F00C88591F00CC4316 /* imageditherTest.cpp */, + 000BB3F10C88591F00CC4316 /* layerTest.cpp */, + 000BB3F20C88591F00CC4316 /* maskTest.cpp */, + 000BB3F30C88591F00CC4316 /* mipmapTest.cpp */, + 000BB3F40C88591F00CC4316 /* pathEffectTest.cpp */, + 000BB3F50C88591F00CC4316 /* regionToPath.cpp */, + 000BB3F60C88591F00CC4316 /* testImage.cpp */, + 000419F90B4AD2C1002A456B /* SkFontHost_FONTPATH.cpp */, + 000419FA0B4AD2C1002A456B /* SkFontHost_none.cpp */, + 00C7F00B0ADBDC6200202BAB /* cameraTest4.cpp */, + 00F0528D0AD2D26D00B085B7 /* testbitmaptile.cpp */, + 00B1596D0AA37F6100B118AB /* testcull.cpp */, + FEACF22A09E4636400D0C2E2 /* animatorUnitTest.cpp */, + 0009590E0A27775D001F29C8 /* pathTest.cpp */, + 006EEFA50AA611910064EC7C /* ninepatchTest.cpp */, + 00540DFD09D04C9B00307DCB /* regionTest.cpp */, + 00AAB9FE0A0A6DEF009B65B1 /* textTest.cpp */, + 00F714FB0ACC056500453651 /* TextSpeedTest.cpp */, + 000F5ED00B77BB82007BC854 /* shaderTest.cpp */, + 0092A3610AD6EC13000FECBC /* cameraTest2.cpp */, + 0077DCA50B2087C000ED5E84 /* textOnPathTest.cpp */, + 00AB5FFF0A8267AE0038DE0A /* tilingTest.cpp */, + FEDCDA7309B892550042D964 /* masterList.cpp */, + FE21C73309537F3800D016FB /* animatorTest.h */, + FE33CAC4094F301100C4A640 /* animatorTest.cpp */, + 32DBCF6D0370B57F00C91783 /* animatorTest_Prefix.pch */, + ); + name = Sources; + sourceTree = "<group>"; + }; + 20286C2CFDCF999611CA2CEA /* Resources */ = { + isa = PBXGroup; + children = ( + 8D0C4E960486CD37000505A6 /* Info.plist */, + 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */, + 02345980000FD03B11CA0E72 /* main.nib */, + ); + name = Resources; + sourceTree = "<group>"; + }; + 20286C32FDCF999611CA2CEA /* External Frameworks and Libraries */ = { + isa = PBXGroup; + children = ( + 20286C33FDCF999611CA2CEA /* Carbon.framework */, + 4A9504CAFFE6A41611CA0CBA /* CoreServices.framework */, + 4A9504C8FFE6A3BC11CA0CBA /* ApplicationServices.framework */, + ); + name = "External Frameworks and Libraries"; + sourceTree = "<group>"; + }; + FE33C9DF094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA01094E2CC900C4A640 /* libports-mac.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9E2094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA04094E2CC900C4A640 /* libexpat.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9E5094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA07094E2CC900C4A640 /* libanimator.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9E8094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA0A094E2CC900C4A640 /* libgif.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9EB094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA0D094E2CC900C4A640 /* libjpeg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9EE094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA10094E2CC900C4A640 /* liblibpng.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9F1094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA13094E2CC900C4A640 /* libzlib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9F4094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA16094E2CC900C4A640 /* libviews.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9F7094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA19094E2CC900C4A640 /* libfreetype.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9FA094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA1C094E2CC900C4A640 /* libports.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE33C9FD094E2CC900C4A640 /* Products */ = { + isa = PBXGroup; + children = ( + FE33CA1F094E2CC900C4A640 /* libgraphics.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE3485940950D1EE003F0C3F /* Products */ = { + isa = PBXGroup; + children = ( + FE3485980950D1EE003F0C3F /* libsvg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + FE61323109B616A5004BB4B8 /* Products */ = { + isa = PBXGroup; + children = ( + FE61323609B616A5004BB4B8 /* libcorecg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 8D0C4E890486CD37000505A6 /* animatorTest */ = { + isa = PBXNativeTarget; + buildConfigurationList = C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "animatorTest" */; + buildPhases = ( + 8D0C4E8C0486CD37000505A6 /* Resources */, + 8D0C4E8F0486CD37000505A6 /* Sources */, + 8D0C4E910486CD37000505A6 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + FE33CA21094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA23094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA25094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA27094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA29094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA2B094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA2D094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA2F094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA31094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA33094E2CFD00C4A640 /* PBXTargetDependency */, + FE33CA35094E2CFD00C4A640 /* PBXTargetDependency */, + FE34859B0950D21C003F0C3F /* PBXTargetDependency */, + FE61324809B6191D004BB4B8 /* PBXTargetDependency */, + ); + name = animatorTest; + productInstallPath = "$(HOME)/Applications"; + productName = animatorTest; + productReference = 8D0C4E970486CD37000505A6 /* animatorTest.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 20286C28FDCF999611CA2CEA /* Project object */ = { + isa = PBXProject; + buildConfigurationList = C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "animatorTest" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 20286C29FDCF999611CA2CEA /* animatorTest */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = FE33C9E5094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9E4094E2CC900C4A640 /* animator.xcodeproj */; + }, + { + ProductGroup = FE61323109B616A5004BB4B8 /* Products */; + ProjectRef = FE61323009B616A5004BB4B8 /* corecg.xcodeproj */; + }, + { + ProductGroup = FE33C9E2094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9E1094E2CC900C4A640 /* expat.xcodeproj */; + }, + { + ProductGroup = FE33C9F7094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9F6094E2CC900C4A640 /* freetype2.xcodeproj */; + }, + { + ProductGroup = FE33C9E8094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9E7094E2CC900C4A640 /* gif.xcodeproj */; + }, + { + ProductGroup = FE33C9FD094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9FC094E2CC900C4A640 /* graphics.xcodeproj */; + }, + { + ProductGroup = FE33C9EB094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9EA094E2CC900C4A640 /* jpeg.xcodeproj */; + }, + { + ProductGroup = FE33C9EE094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9ED094E2CC900C4A640 /* libpng.xcodeproj */; + }, + { + ProductGroup = FE33C9DF094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9DE094E2CC900C4A640 /* ports-mac.xcodeproj */; + }, + { + ProductGroup = FE33C9FA094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9F9094E2CC900C4A640 /* ports.xcodeproj */; + }, + { + ProductGroup = FE3485940950D1EE003F0C3F /* Products */; + ProjectRef = FE3485930950D1EE003F0C3F /* svg.xcodeproj */; + }, + { + ProductGroup = FE33C9F4094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9F3094E2CC900C4A640 /* views.xcodeproj */; + }, + { + ProductGroup = FE33C9F1094E2CC900C4A640 /* Products */; + ProjectRef = FE33C9F0094E2CC900C4A640 /* zlib.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 8D0C4E890486CD37000505A6 /* animatorTest */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + FE33CA01094E2CC900C4A640 /* libports-mac.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = "libports-mac.a"; + remoteRef = FE33CA00094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA04094E2CC900C4A640 /* libexpat.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libexpat.a; + remoteRef = FE33CA03094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA07094E2CC900C4A640 /* libanimator.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libanimator.a; + remoteRef = FE33CA06094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA0A094E2CC900C4A640 /* libgif.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libgif.a; + remoteRef = FE33CA09094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA0D094E2CC900C4A640 /* libjpeg.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libjpeg.a; + remoteRef = FE33CA0C094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA10094E2CC900C4A640 /* liblibpng.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = liblibpng.a; + remoteRef = FE33CA0F094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA13094E2CC900C4A640 /* libzlib.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libzlib.a; + remoteRef = FE33CA12094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA16094E2CC900C4A640 /* libviews.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libviews.a; + remoteRef = FE33CA15094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA19094E2CC900C4A640 /* libfreetype.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libfreetype.a; + remoteRef = FE33CA18094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA1C094E2CC900C4A640 /* libports.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libports.a; + remoteRef = FE33CA1B094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE33CA1F094E2CC900C4A640 /* libgraphics.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libgraphics.a; + remoteRef = FE33CA1E094E2CC900C4A640 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE3485980950D1EE003F0C3F /* libsvg.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libsvg.a; + remoteRef = FE3485970950D1EE003F0C3F /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + FE61323609B616A5004BB4B8 /* libcorecg.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libcorecg.a; + remoteRef = FE61323509B616A5004BB4B8 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXResourcesBuildPhase section */ + 8D0C4E8C0486CD37000505A6 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8D0C4E8D0486CD37000505A6 /* InfoPlist.strings in Resources */, + 8D0C4E8E0486CD37000505A6 /* main.nib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 8D0C4E8F0486CD37000505A6 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + FEBB00B00D7DD8D70027C5D6 /* CacheBuilder.cpp in Sources */, + FEBB00B10D7DD8D70027C5D6 /* CachedFrame.cpp in Sources */, + FEBB00B20D7DD8D70027C5D6 /* CachedHistory.cpp in Sources */, + FEBB00B30D7DD8D70027C5D6 /* CachedNode.cpp in Sources */, + FEBB00B40D7DD8D70027C5D6 /* CachedRoot.cpp in Sources */, + FEBB00B90D7DD8F20027C5D6 /* BrowserDebug.cpp in Sources */, + FEBB00C60D7DDA4A0027C5D6 /* animatorTest.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + FE33CA21094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = ports; + targetProxy = FE33CA20094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA23094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = views; + targetProxy = FE33CA22094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA25094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = libpng; + targetProxy = FE33CA24094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA27094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = gif; + targetProxy = FE33CA26094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA29094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = animator; + targetProxy = FE33CA28094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA2B094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = "ports-mac"; + targetProxy = FE33CA2A094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA2D094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = graphics; + targetProxy = FE33CA2C094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA2F094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = freetype; + targetProxy = FE33CA2E094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA31094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = zlib; + targetProxy = FE33CA30094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA33094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = jpeg; + targetProxy = FE33CA32094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE33CA35094E2CFD00C4A640 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = expat; + targetProxy = FE33CA34094E2CFD00C4A640 /* PBXContainerItemProxy */; + }; + FE34859B0950D21C003F0C3F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = svg; + targetProxy = FE34859A0950D21C003F0C3F /* PBXContainerItemProxy */; + }; + FE61324809B6191D004BB4B8 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = corecg; + targetProxy = FE61324709B6191D004BB4B8 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 02345980000FD03B11CA0E72 /* main.nib */ = { + isa = PBXVariantGroup; + children = ( + 1870340FFE93FCAF11CA0CD7 /* English */, + ); + name = main.nib; + sourceTree = "<group>"; + }; + 0867D6AAFE840B52C02AAC07 /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 0867D6ABFE840B52C02AAC07 /* English */, + ); + name = InfoPlist.strings; + sourceTree = "<group>"; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + C0E91AC608A95435008D54AB /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = stabs; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_FAST_OBJC_DISPATCH = NO; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = animatorTest_Prefix.pch; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_DEBUG, + BROWSER_DEBUG, + DEBUG_NAV_UI, + ANDROID_CANVAS_IMPL, + ); + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = "$(HOME)/Applications"; + PRODUCT_NAME = animatorTest; + SCAN_ALL_SOURCE_FILES_FOR_INCLUDES = YES; + WRAPPER_EXTENSION = app; + ZERO_LINK = NO; + }; + name = Debug; + }; + C0E91AC708A95435008D54AB /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = animatorTest_Prefix.pch; + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = "$(HOME)/Applications"; + PRODUCT_NAME = animatorTest; + WRAPPER_EXTENSION = app; + ZERO_LINK = NO; + }; + name = Release; + }; + C0E91ACA08A95435008D54AB /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_DEBUG, + PV_PRODUCT_SERVER, + BUILD_OMX_DEC_NODE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LIBRARY_SEARCH_PATHS = ../build/Debug; + LINK_WITH_STANDARD_LIBRARIES = YES; + OTHER_LDFLAGS = ""; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + PRODUCT_NAME = animatorTest; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + STANDARD_C_PLUS_PLUS_LIBRARY_TYPE = dynamic; + USER_HEADER_SEARCH_PATHS = "../../../include/graphics ../../../include/corecg ../../../libs/WebKitLib/WebKit/JavaScriptCore ../../../libs/WebKitLib/WebKit/WebCore/platform/android ../../../libs/WebKitLib/WebKit/WebCore/platform/graphics ../../../libs/WebKitLib/WebKit/WebCore/platform/graphics/android ../../../tests/browser/focusNavigation"; + }; + name = Debug; + }; + C0E91ACB08A95435008D54AB /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LIBRARY_SEARCH_PATHS = ../build/Release; + OTHER_LDFLAGS = ""; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + PRODUCT_NAME = animatorTest; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + USER_HEADER_SEARCH_PATHS = "../../../include/graphics ../../../include/corecg ../../../libs/WebKitLib/WebKit/JavaScriptCore ../../../libs/WebKitLib/WebKit/WebCore/bridge/android ../../../libs/WebKitLib/WebKit/WebCore/platform/android ../../../libs/WebKitLib/WebKit/WebCore/platform/graphics ../../../libs/WebKitLib/WebKit/WebCore/rendering ../../../tests/browser/focusNavigation ../../../extlibs/pv/oscl/oscl/osclbase/src ../../../extlibs/pv/oscl/oscl/config/linux_nj ../../../extlibs/pv/oscl/oscl/config/shared ../../../extlibs/pv/codecs_v2/image/jpeg/dec/include ../../../extlibs/pv/oscl/oscl/osclmemory/src ../../../extlibs/pv/oscl/oscl/osclerror/src"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + C0E91AC508A95435008D54AB /* Build configuration list for PBXNativeTarget "animatorTest" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C0E91AC608A95435008D54AB /* Debug */, + C0E91AC708A95435008D54AB /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + C0E91AC908A95435008D54AB /* Build configuration list for PBXProject "animatorTest" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C0E91ACA08A95435008D54AB /* Debug */, + C0E91ACB08A95435008D54AB /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 20286C28FDCF999611CA2CEA /* Project object */; +} diff --git a/xcode/benchmarks/benchmarks.xcodeproj/project.pbxproj b/xcode/benchmarks/benchmarks.xcodeproj/project.pbxproj new file mode 100644 index 0000000..3c4ef47 --- /dev/null +++ b/xcode/benchmarks/benchmarks.xcodeproj/project.pbxproj @@ -0,0 +1,267 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00BE44C30EE9D4980008420F /* libskia2.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE44C10EE9D4880008420F /* libskia2.a */; }; + 8DD76F650486A84900D96B5E /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 08FB7796FE84155DC02AAC07 /* main.cpp */; settings = {ATTRIBUTES = (); }; }; + 8DD76F6A0486A84900D96B5E /* benchmarks.1 in CopyFiles */ = {isa = PBXBuildFile; fileRef = C6859E8B029090EE04C91782 /* benchmarks.1 */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 00BE44C00EE9D4880008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE44BC0EE9D4880008420F /* skia2.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = skia2; + }; + 00BE44E80EE9D6ED0008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE44BC0EE9D4880008420F /* skia2.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = skia2; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 8DD76F690486A84900D96B5E /* CopyFiles */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 8; + dstPath = /usr/share/man/man1/; + dstSubfolderSpec = 0; + files = ( + 8DD76F6A0486A84900D96B5E /* benchmarks.1 in CopyFiles */, + ); + runOnlyForDeploymentPostprocessing = 1; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 00BE44BC0EE9D4880008420F /* skia2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = skia2.xcodeproj; path = ../skia2.xcodeproj; sourceTree = SOURCE_ROOT; }; + 08FB7796FE84155DC02AAC07 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = main.cpp; sourceTree = "<group>"; }; + 8DD76F6C0486A84900D96B5E /* benchmarks */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = benchmarks; sourceTree = BUILT_PRODUCTS_DIR; }; + C6859E8B029090EE04C91782 /* benchmarks.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = benchmarks.1; sourceTree = "<group>"; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8DD76F660486A84900D96B5E /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 00BE44C30EE9D4980008420F /* libskia2.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 00BE44BD0EE9D4880008420F /* Products */ = { + isa = PBXGroup; + children = ( + 00BE44C10EE9D4880008420F /* libskia2.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 08FB7794FE84155DC02AAC07 /* benchmarks */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6859E8C029090F304C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + 00BE44BC0EE9D4880008420F /* skia2.xcodeproj */, + ); + name = benchmarks; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 08FB7796FE84155DC02AAC07 /* main.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 8DD76F6C0486A84900D96B5E /* benchmarks */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6859E8C029090F304C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + C6859E8B029090EE04C91782 /* benchmarks.1 */, + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 8DD76F620486A84900D96B5E /* benchmarks */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB923108733DC60010E9CD /* Build configuration list for PBXNativeTarget "benchmarks" */; + buildPhases = ( + 8DD76F640486A84900D96B5E /* Sources */, + 8DD76F660486A84900D96B5E /* Frameworks */, + 8DD76F690486A84900D96B5E /* CopyFiles */, + ); + buildRules = ( + ); + dependencies = ( + 00BE44E90EE9D6ED0008420F /* PBXTargetDependency */, + ); + name = benchmarks; + productInstallPath = "$(HOME)/bin"; + productName = benchmarks; + productReference = 8DD76F6C0486A84900D96B5E /* benchmarks */; + productType = "com.apple.product-type.tool"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "benchmarks" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* benchmarks */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 00BE44BD0EE9D4880008420F /* Products */; + ProjectRef = 00BE44BC0EE9D4880008420F /* skia2.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 8DD76F620486A84900D96B5E /* benchmarks */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 00BE44C10EE9D4880008420F /* libskia2.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libskia2.a; + remoteRef = 00BE44C00EE9D4880008420F /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXSourcesBuildPhase section */ + 8DD76F640486A84900D96B5E /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8DD76F650486A84900D96B5E /* main.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 00BE44E90EE9D6ED0008420F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = skia2; + targetProxy = 00BE44E80EE9D6ED0008420F /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + 1DEB923208733DC60010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "_GLIBCXX_DEBUG=1", + "_GLIBCXX_DEBUG_PEDANTIC=1", + ); + INSTALL_PATH = /usr/local/bin; + PRODUCT_NAME = benchmarks; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB923308733DC60010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/bin; + PRODUCT_NAME = benchmarks; + }; + name = Release; + }; + 1DEB923608733DC60010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_DEBUG, + ); + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + USER_HEADER_SEARCH_PATHS = "../../include/**"; + }; + name = Debug; + }; + 1DEB923708733DC60010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + USER_HEADER_SEARCH_PATHS = "../../include/**"; + VALID_ARCHS = "i386 x86_64"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB923108733DC60010E9CD /* Build configuration list for PBXNativeTarget "benchmarks" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB923208733DC60010E9CD /* Debug */, + 1DEB923308733DC60010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "benchmarks" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB923608733DC60010E9CD /* Debug */, + 1DEB923708733DC60010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/benchmarks/main.cpp b/xcode/benchmarks/main.cpp new file mode 100644 index 0000000..635ddfd --- /dev/null +++ b/xcode/benchmarks/main.cpp @@ -0,0 +1,33 @@ +#include <iostream> +#include "SkCanvas.h" +#include "SkBitmap.h" +#include "SkPaint.h" +#include "SkImageDecoder.h" + +int main (int argc, char * const argv[]) { + // insert code here... + std::cout << "Begin test\n"; + + const int W = 256; + const int H = 256; + const SkScalar w = SkIntToScalar(W); + const SkScalar h = SkIntToScalar(H); + + SkBitmap bm; + bm.setConfig(SkBitmap::kARGB_8888_Config, W, H); + bm.allocPixels(); + + SkCanvas canvas(bm); + + SkPaint paint; + paint.setAntiAlias(true); + + canvas.drawColor(SK_ColorWHITE); + canvas.drawCircle(w/2, h/2, w/3, paint); + + SkImageEncoder::EncodeFile("../../bench1.png", bm, + SkImageEncoder::kPNG_Type); + + std::cout << "End test\n"; + return 0; +} diff --git a/xcode/chipmunk.xcodeproj/project.pbxproj b/xcode/chipmunk.xcodeproj/project.pbxproj new file mode 100644 index 0000000..d30ddcd --- /dev/null +++ b/xcode/chipmunk.xcodeproj/project.pbxproj @@ -0,0 +1,258 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + FE16E1510CE26D84006BB7E0 /* chipmunk.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1270CE26C3D006BB7E0 /* chipmunk.c */; }; + FE16E1520CE26D86006BB7E0 /* cpArbiter.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E12A0CE26C3D006BB7E0 /* cpArbiter.c */; }; + FE16E1530CE26D87006BB7E0 /* cpArray.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E12C0CE26C3D006BB7E0 /* cpArray.c */; }; + FE16E1540CE26D88006BB7E0 /* cpBB.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E12E0CE26C3D006BB7E0 /* cpBB.c */; }; + FE16E1550CE26D8A006BB7E0 /* cpBody.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1300CE26C3D006BB7E0 /* cpBody.c */; }; + FE16E1560CE26D8B006BB7E0 /* cpCollision.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1320CE26C3D006BB7E0 /* cpCollision.c */; }; + FE16E1570CE26D8C006BB7E0 /* cpHashSet.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1340CE26C3D006BB7E0 /* cpHashSet.c */; }; + FE16E1580CE26D8F006BB7E0 /* cpJoint.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1360CE26C3D006BB7E0 /* cpJoint.c */; }; + FE16E1590CE26D91006BB7E0 /* cpPolyShape.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1380CE26C3D006BB7E0 /* cpPolyShape.c */; }; + FE16E15E0CE26D9E006BB7E0 /* cpShape.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E13A0CE26C3D006BB7E0 /* cpShape.c */; }; + FE16E15F0CE26D9F006BB7E0 /* cpSpace.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E13C0CE26C3D006BB7E0 /* cpSpace.c */; }; + FE16E1600CE26DA0006BB7E0 /* cpSpaceHash.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E13E0CE26C3D006BB7E0 /* cpSpaceHash.c */; }; + FE16E1610CE26DA1006BB7E0 /* cpVect.c in Sources */ = {isa = PBXBuildFile; fileRef = FE16E1400CE26C3D006BB7E0 /* cpVect.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + FE16E1270CE26C3D006BB7E0 /* chipmunk.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = chipmunk.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/chipmunk.c"; sourceTree = "<absolute>"; }; + FE16E1280CE26C3D006BB7E0 /* chipmunk.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = chipmunk.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/chipmunk.h"; sourceTree = "<absolute>"; }; + FE16E1290CE26C3D006BB7E0 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; name = CMakeLists.txt; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/CMakeLists.txt"; sourceTree = "<absolute>"; }; + FE16E12A0CE26C3D006BB7E0 /* cpArbiter.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpArbiter.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArbiter.c"; sourceTree = "<absolute>"; }; + FE16E12B0CE26C3D006BB7E0 /* cpArbiter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpArbiter.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArbiter.h"; sourceTree = "<absolute>"; }; + FE16E12C0CE26C3D006BB7E0 /* cpArray.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpArray.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArray.c"; sourceTree = "<absolute>"; }; + FE16E12D0CE26C3D006BB7E0 /* cpArray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpArray.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpArray.h"; sourceTree = "<absolute>"; }; + FE16E12E0CE26C3D006BB7E0 /* cpBB.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpBB.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBB.c"; sourceTree = "<absolute>"; }; + FE16E12F0CE26C3D006BB7E0 /* cpBB.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpBB.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBB.h"; sourceTree = "<absolute>"; }; + FE16E1300CE26C3D006BB7E0 /* cpBody.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpBody.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBody.c"; sourceTree = "<absolute>"; }; + FE16E1310CE26C3D006BB7E0 /* cpBody.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpBody.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpBody.h"; sourceTree = "<absolute>"; }; + FE16E1320CE26C3D006BB7E0 /* cpCollision.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpCollision.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpCollision.c"; sourceTree = "<absolute>"; }; + FE16E1330CE26C3D006BB7E0 /* cpCollision.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpCollision.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpCollision.h"; sourceTree = "<absolute>"; }; + FE16E1340CE26C3D006BB7E0 /* cpHashSet.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpHashSet.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpHashSet.c"; sourceTree = "<absolute>"; }; + FE16E1350CE26C3D006BB7E0 /* cpHashSet.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpHashSet.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpHashSet.h"; sourceTree = "<absolute>"; }; + FE16E1360CE26C3D006BB7E0 /* cpJoint.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpJoint.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpJoint.c"; sourceTree = "<absolute>"; }; + FE16E1370CE26C3D006BB7E0 /* cpJoint.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpJoint.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpJoint.h"; sourceTree = "<absolute>"; }; + FE16E1380CE26C3D006BB7E0 /* cpPolyShape.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpPolyShape.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpPolyShape.c"; sourceTree = "<absolute>"; }; + FE16E1390CE26C3D006BB7E0 /* cpPolyShape.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpPolyShape.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpPolyShape.h"; sourceTree = "<absolute>"; }; + FE16E13A0CE26C3D006BB7E0 /* cpShape.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpShape.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpShape.c"; sourceTree = "<absolute>"; }; + FE16E13B0CE26C3D006BB7E0 /* cpShape.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpShape.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpShape.h"; sourceTree = "<absolute>"; }; + FE16E13C0CE26C3D006BB7E0 /* cpSpace.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpSpace.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpace.c"; sourceTree = "<absolute>"; }; + FE16E13D0CE26C3D006BB7E0 /* cpSpace.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpSpace.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpace.h"; sourceTree = "<absolute>"; }; + FE16E13E0CE26C3D006BB7E0 /* cpSpaceHash.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpSpaceHash.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpaceHash.c"; sourceTree = "<absolute>"; }; + FE16E13F0CE26C3D006BB7E0 /* cpSpaceHash.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpSpaceHash.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpSpaceHash.h"; sourceTree = "<absolute>"; }; + FE16E1400CE26C3D006BB7E0 /* cpVect.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = cpVect.c; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpVect.c"; sourceTree = "<absolute>"; }; + FE16E1410CE26C3D006BB7E0 /* cpVect.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = cpVect.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/cpVect.h"; sourceTree = "<absolute>"; }; + FE16E1420CE26C3D006BB7E0 /* prime.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = prime.h; path = "/Users/caryclark/Desktop/Chipmunk-4.0.2/src/prime.h"; sourceTree = "<absolute>"; }; + FE16E14C0CE26D61006BB7E0 /* libchipmunk.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libchipmunk.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + FE16E14A0CE26D61006BB7E0 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + FE16E11A0CE26B5D006BB7E0 = { + isa = PBXGroup; + children = ( + FE16E1250CE26B6A006BB7E0 /* Sources */, + FE16E14D0CE26D61006BB7E0 /* Products */, + ); + sourceTree = "<group>"; + }; + FE16E1250CE26B6A006BB7E0 /* Sources */ = { + isa = PBXGroup; + children = ( + FE16E1270CE26C3D006BB7E0 /* chipmunk.c */, + FE16E1280CE26C3D006BB7E0 /* chipmunk.h */, + FE16E1290CE26C3D006BB7E0 /* CMakeLists.txt */, + FE16E12A0CE26C3D006BB7E0 /* cpArbiter.c */, + FE16E12B0CE26C3D006BB7E0 /* cpArbiter.h */, + FE16E12C0CE26C3D006BB7E0 /* cpArray.c */, + FE16E12D0CE26C3D006BB7E0 /* cpArray.h */, + FE16E12E0CE26C3D006BB7E0 /* cpBB.c */, + FE16E12F0CE26C3D006BB7E0 /* cpBB.h */, + FE16E1300CE26C3D006BB7E0 /* cpBody.c */, + FE16E1310CE26C3D006BB7E0 /* cpBody.h */, + FE16E1320CE26C3D006BB7E0 /* cpCollision.c */, + FE16E1330CE26C3D006BB7E0 /* cpCollision.h */, + FE16E1340CE26C3D006BB7E0 /* cpHashSet.c */, + FE16E1350CE26C3D006BB7E0 /* cpHashSet.h */, + FE16E1360CE26C3D006BB7E0 /* cpJoint.c */, + FE16E1370CE26C3D006BB7E0 /* cpJoint.h */, + FE16E1380CE26C3D006BB7E0 /* cpPolyShape.c */, + FE16E1390CE26C3D006BB7E0 /* cpPolyShape.h */, + FE16E13A0CE26C3D006BB7E0 /* cpShape.c */, + FE16E13B0CE26C3D006BB7E0 /* cpShape.h */, + FE16E13C0CE26C3D006BB7E0 /* cpSpace.c */, + FE16E13D0CE26C3D006BB7E0 /* cpSpace.h */, + FE16E13E0CE26C3D006BB7E0 /* cpSpaceHash.c */, + FE16E13F0CE26C3D006BB7E0 /* cpSpaceHash.h */, + FE16E1400CE26C3D006BB7E0 /* cpVect.c */, + FE16E1410CE26C3D006BB7E0 /* cpVect.h */, + FE16E1420CE26C3D006BB7E0 /* prime.h */, + ); + name = Sources; + sourceTree = "<group>"; + }; + FE16E14D0CE26D61006BB7E0 /* Products */ = { + isa = PBXGroup; + children = ( + FE16E14C0CE26D61006BB7E0 /* libchipmunk.a */, + ); + name = Products; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + FE16E1480CE26D61006BB7E0 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + FE16E14B0CE26D61006BB7E0 /* chipmunk */ = { + isa = PBXNativeTarget; + buildConfigurationList = FE16E14E0CE26D61006BB7E0 /* Build configuration list for PBXNativeTarget "chipmunk" */; + buildPhases = ( + FE16E1480CE26D61006BB7E0 /* Headers */, + FE16E1490CE26D61006BB7E0 /* Sources */, + FE16E14A0CE26D61006BB7E0 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = chipmunk; + productName = chipmunk; + productReference = FE16E14C0CE26D61006BB7E0 /* libchipmunk.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + FE16E11C0CE26B5D006BB7E0 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = FE16E11D0CE26B5D006BB7E0 /* Build configuration list for PBXProject "chipmunk" */; + hasScannedForEncodings = 0; + mainGroup = FE16E11A0CE26B5D006BB7E0; + productRefGroup = FE16E14D0CE26D61006BB7E0 /* Products */; + projectDirPath = ""; + targets = ( + FE16E14B0CE26D61006BB7E0 /* chipmunk */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + FE16E1490CE26D61006BB7E0 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + FE16E1510CE26D84006BB7E0 /* chipmunk.c in Sources */, + FE16E1520CE26D86006BB7E0 /* cpArbiter.c in Sources */, + FE16E1530CE26D87006BB7E0 /* cpArray.c in Sources */, + FE16E1540CE26D88006BB7E0 /* cpBB.c in Sources */, + FE16E1550CE26D8A006BB7E0 /* cpBody.c in Sources */, + FE16E1560CE26D8B006BB7E0 /* cpCollision.c in Sources */, + FE16E1570CE26D8C006BB7E0 /* cpHashSet.c in Sources */, + FE16E1580CE26D8F006BB7E0 /* cpJoint.c in Sources */, + FE16E1590CE26D91006BB7E0 /* cpPolyShape.c in Sources */, + FE16E15E0CE26D9E006BB7E0 /* cpShape.c in Sources */, + FE16E15F0CE26D9F006BB7E0 /* cpSpace.c in Sources */, + FE16E1600CE26DA0006BB7E0 /* cpSpaceHash.c in Sources */, + FE16E1610CE26DA1006BB7E0 /* cpVect.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + FE16E11E0CE26B5D006BB7E0 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + }; + name = Debug; + }; + FE16E11F0CE26B5D006BB7E0 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = YES; + }; + name = Release; + }; + FE16E14F0CE26D61006BB7E0 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PREBINDING = NO; + PRODUCT_NAME = chipmunk; + ZERO_LINK = YES; + }; + name = Debug; + }; + FE16E1500CE26D61006BB7E0 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PREBINDING = NO; + PRODUCT_NAME = chipmunk; + ZERO_LINK = NO; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + FE16E11D0CE26B5D006BB7E0 /* Build configuration list for PBXProject "chipmunk" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE16E11E0CE26B5D006BB7E0 /* Debug */, + FE16E11F0CE26B5D006BB7E0 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + FE16E14E0CE26D61006BB7E0 /* Build configuration list for PBXNativeTarget "chipmunk" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE16E14F0CE26D61006BB7E0 /* Debug */, + FE16E1500CE26D61006BB7E0 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = FE16E11C0CE26B5D006BB7E0 /* Project object */; +} diff --git a/xcode/corecg.xcodeproj/project.pbxproj b/xcode/corecg.xcodeproj/project.pbxproj new file mode 100644 index 0000000..1b01d4f --- /dev/null +++ b/xcode/corecg.xcodeproj/project.pbxproj @@ -0,0 +1,292 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7DE790EDCA1CE00F77EA2 /* Sk64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE640EDCA1CE00F77EA2 /* Sk64.cpp */; }; + 00B7DE7A0EDCA1CE00F77EA2 /* SkBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE650EDCA1CE00F77EA2 /* SkBuffer.cpp */; }; + 00B7DE7B0EDCA1CE00F77EA2 /* SkChunkAlloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE660EDCA1CE00F77EA2 /* SkChunkAlloc.cpp */; }; + 00B7DE7C0EDCA1CE00F77EA2 /* SkCordic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE670EDCA1CE00F77EA2 /* SkCordic.cpp */; }; + 00B7DE7D0EDCA1CE00F77EA2 /* SkCordic.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE680EDCA1CE00F77EA2 /* SkCordic.h */; }; + 00B7DE7E0EDCA1CE00F77EA2 /* SkDebug.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE690EDCA1CE00F77EA2 /* SkDebug.cpp */; }; + 00B7DE7F0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6A0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp */; }; + 00B7DE800EDCA1CE00F77EA2 /* SkFloat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6B0EDCA1CE00F77EA2 /* SkFloat.cpp */; }; + 00B7DE810EDCA1CE00F77EA2 /* SkFloat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE6C0EDCA1CE00F77EA2 /* SkFloat.h */; }; + 00B7DE820EDCA1CE00F77EA2 /* SkFloatBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6D0EDCA1CE00F77EA2 /* SkFloatBits.cpp */; }; + 00B7DE830EDCA1CE00F77EA2 /* SkInterpolator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6E0EDCA1CE00F77EA2 /* SkInterpolator.cpp */; }; + 00B7DE840EDCA1CE00F77EA2 /* SkMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE6F0EDCA1CE00F77EA2 /* SkMath.cpp */; }; + 00B7DE850EDCA1CE00F77EA2 /* SkMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE700EDCA1CE00F77EA2 /* SkMatrix.cpp */; }; + 00B7DE860EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE710EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp */; }; + 00B7DE870EDCA1CE00F77EA2 /* SkPageFlipper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE720EDCA1CE00F77EA2 /* SkPageFlipper.cpp */; }; + 00B7DE880EDCA1CE00F77EA2 /* SkPoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE730EDCA1CE00F77EA2 /* SkPoint.cpp */; }; + 00B7DE890EDCA1CE00F77EA2 /* SkRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE740EDCA1CE00F77EA2 /* SkRect.cpp */; }; + 00B7DE8A0EDCA1CE00F77EA2 /* SkRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE750EDCA1CE00F77EA2 /* SkRegion.cpp */; }; + 00B7DE8B0EDCA1CE00F77EA2 /* SkRegionPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE760EDCA1CE00F77EA2 /* SkRegionPriv.h */; }; + 00B7DE8C0EDCA1CE00F77EA2 /* SkSinTable.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE770EDCA1CE00F77EA2 /* SkSinTable.h */; }; + 00B7DE8D0EDCA1CE00F77EA2 /* SkTSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DE780EDCA1CE00F77EA2 /* SkTSort.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7DE640EDCA1CE00F77EA2 /* Sk64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk64.cpp; path = ../libcorecg/Sk64.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE650EDCA1CE00F77EA2 /* SkBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBuffer.cpp; path = ../libcorecg/SkBuffer.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE660EDCA1CE00F77EA2 /* SkChunkAlloc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkChunkAlloc.cpp; path = ../libcorecg/SkChunkAlloc.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE670EDCA1CE00F77EA2 /* SkCordic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCordic.cpp; path = ../libcorecg/SkCordic.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE680EDCA1CE00F77EA2 /* SkCordic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCordic.h; path = ../libcorecg/SkCordic.h; sourceTree = SOURCE_ROOT; }; + 00B7DE690EDCA1CE00F77EA2 /* SkDebug.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug.cpp; path = ../libcorecg/SkDebug.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE6A0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug_stdio.cpp; path = ../libcorecg/SkDebug_stdio.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE6B0EDCA1CE00F77EA2 /* SkFloat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloat.cpp; path = ../libcorecg/SkFloat.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE6C0EDCA1CE00F77EA2 /* SkFloat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFloat.h; path = ../libcorecg/SkFloat.h; sourceTree = SOURCE_ROOT; }; + 00B7DE6D0EDCA1CE00F77EA2 /* SkFloatBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloatBits.cpp; path = ../libcorecg/SkFloatBits.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE6E0EDCA1CE00F77EA2 /* SkInterpolator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkInterpolator.cpp; path = ../libcorecg/SkInterpolator.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE6F0EDCA1CE00F77EA2 /* SkMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMath.cpp; path = ../libcorecg/SkMath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE700EDCA1CE00F77EA2 /* SkMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMatrix.cpp; path = ../libcorecg/SkMatrix.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE710EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMemory_stdlib.cpp; path = ../libcorecg/SkMemory_stdlib.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE720EDCA1CE00F77EA2 /* SkPageFlipper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPageFlipper.cpp; path = ../libcorecg/SkPageFlipper.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE730EDCA1CE00F77EA2 /* SkPoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPoint.cpp; path = ../libcorecg/SkPoint.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE740EDCA1CE00F77EA2 /* SkRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRect.cpp; path = ../libcorecg/SkRect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE750EDCA1CE00F77EA2 /* SkRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion.cpp; path = ../libcorecg/SkRegion.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DE760EDCA1CE00F77EA2 /* SkRegionPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkRegionPriv.h; path = ../libcorecg/SkRegionPriv.h; sourceTree = SOURCE_ROOT; }; + 00B7DE770EDCA1CE00F77EA2 /* SkSinTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSinTable.h; path = ../libcorecg/SkSinTable.h; sourceTree = SOURCE_ROOT; }; + 00B7DE780EDCA1CE00F77EA2 /* SkTSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTSort.h; path = ../libcorecg/SkTSort.h; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libcorecg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libcorecg.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* corecg */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = corecg; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7DE640EDCA1CE00F77EA2 /* Sk64.cpp */, + 00B7DE650EDCA1CE00F77EA2 /* SkBuffer.cpp */, + 00B7DE660EDCA1CE00F77EA2 /* SkChunkAlloc.cpp */, + 00B7DE670EDCA1CE00F77EA2 /* SkCordic.cpp */, + 00B7DE680EDCA1CE00F77EA2 /* SkCordic.h */, + 00B7DE690EDCA1CE00F77EA2 /* SkDebug.cpp */, + 00B7DE6A0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp */, + 00B7DE6B0EDCA1CE00F77EA2 /* SkFloat.cpp */, + 00B7DE6C0EDCA1CE00F77EA2 /* SkFloat.h */, + 00B7DE6D0EDCA1CE00F77EA2 /* SkFloatBits.cpp */, + 00B7DE6E0EDCA1CE00F77EA2 /* SkInterpolator.cpp */, + 00B7DE6F0EDCA1CE00F77EA2 /* SkMath.cpp */, + 00B7DE700EDCA1CE00F77EA2 /* SkMatrix.cpp */, + 00B7DE710EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp */, + 00B7DE720EDCA1CE00F77EA2 /* SkPageFlipper.cpp */, + 00B7DE730EDCA1CE00F77EA2 /* SkPoint.cpp */, + 00B7DE740EDCA1CE00F77EA2 /* SkRect.cpp */, + 00B7DE750EDCA1CE00F77EA2 /* SkRegion.cpp */, + 00B7DE760EDCA1CE00F77EA2 /* SkRegionPriv.h */, + 00B7DE770EDCA1CE00F77EA2 /* SkSinTable.h */, + 00B7DE780EDCA1CE00F77EA2 /* SkTSort.h */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libcorecg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DE7D0EDCA1CE00F77EA2 /* SkCordic.h in Headers */, + 00B7DE810EDCA1CE00F77EA2 /* SkFloat.h in Headers */, + 00B7DE8B0EDCA1CE00F77EA2 /* SkRegionPriv.h in Headers */, + 00B7DE8C0EDCA1CE00F77EA2 /* SkSinTable.h in Headers */, + 00B7DE8D0EDCA1CE00F77EA2 /* SkTSort.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* corecg */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "corecg" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = corecg; + productName = corecg; + productReference = D2AAC046055464E500DB518D /* libcorecg.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "corecg" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* corecg */; + projectDirPath = ""; + projectRoot = ../..; + targets = ( + D2AAC045055464E500DB518D /* corecg */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DE790EDCA1CE00F77EA2 /* Sk64.cpp in Sources */, + 00B7DE7A0EDCA1CE00F77EA2 /* SkBuffer.cpp in Sources */, + 00B7DE7B0EDCA1CE00F77EA2 /* SkChunkAlloc.cpp in Sources */, + 00B7DE7C0EDCA1CE00F77EA2 /* SkCordic.cpp in Sources */, + 00B7DE7E0EDCA1CE00F77EA2 /* SkDebug.cpp in Sources */, + 00B7DE7F0EDCA1CE00F77EA2 /* SkDebug_stdio.cpp in Sources */, + 00B7DE800EDCA1CE00F77EA2 /* SkFloat.cpp in Sources */, + 00B7DE820EDCA1CE00F77EA2 /* SkFloatBits.cpp in Sources */, + 00B7DE830EDCA1CE00F77EA2 /* SkInterpolator.cpp in Sources */, + 00B7DE840EDCA1CE00F77EA2 /* SkMath.cpp in Sources */, + 00B7DE850EDCA1CE00F77EA2 /* SkMatrix.cpp in Sources */, + 00B7DE860EDCA1CE00F77EA2 /* SkMemory_stdlib.cpp in Sources */, + 00B7DE870EDCA1CE00F77EA2 /* SkPageFlipper.cpp in Sources */, + 00B7DE880EDCA1CE00F77EA2 /* SkPoint.cpp in Sources */, + 00B7DE890EDCA1CE00F77EA2 /* SkRect.cpp in Sources */, + 00B7DE8A0EDCA1CE00F77EA2 /* SkRegion.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = corecg; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = corecg; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = ../include/corecg; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = ../include/corecg; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "corecg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "corecg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/expat.xcodeproj/project.pbxproj b/xcode/expat.xcodeproj/project.pbxproj new file mode 100644 index 0000000..37a9b0f --- /dev/null +++ b/xcode/expat.xcodeproj/project.pbxproj @@ -0,0 +1,246 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7DE9E0EDCA22F00F77EA2 /* SkXMLPullParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DE9C0EDCA22F00F77EA2 /* SkXMLPullParser.cpp */; }; + 00B7DEA20EDCA25700F77EA2 /* SkXMLParser_expat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA10EDCA25700F77EA2 /* SkXMLParser_expat.cpp */; }; + 00B7DEA60EDCA27F00F77EA2 /* xmlparse.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA30EDCA27F00F77EA2 /* xmlparse.c */; }; + 00B7DEA70EDCA27F00F77EA2 /* xmlrole.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA40EDCA27F00F77EA2 /* xmlrole.c */; }; + 00B7DEA80EDCA27F00F77EA2 /* xmltok.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEA50EDCA27F00F77EA2 /* xmltok.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7DE9C0EDCA22F00F77EA2 /* SkXMLPullParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLPullParser.cpp; path = ../libsgl/xml/SkXMLPullParser.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DEA10EDCA25700F77EA2 /* SkXMLParser_expat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLParser_expat.cpp; path = ../libsgl/ports/SkXMLParser_expat.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DEA30EDCA27F00F77EA2 /* xmlparse.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xmlparse.c; path = ../../expat/lib/xmlparse.c; sourceTree = SOURCE_ROOT; }; + 00B7DEA40EDCA27F00F77EA2 /* xmlrole.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xmlrole.c; path = ../../expat/lib/xmlrole.c; sourceTree = SOURCE_ROOT; }; + 00B7DEA50EDCA27F00F77EA2 /* xmltok.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = xmltok.c; path = ../../expat/lib/xmltok.c; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libexpat.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libexpat.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* expat */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = expat; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7DEA30EDCA27F00F77EA2 /* xmlparse.c */, + 00B7DEA40EDCA27F00F77EA2 /* xmlrole.c */, + 00B7DEA50EDCA27F00F77EA2 /* xmltok.c */, + 00B7DEA10EDCA25700F77EA2 /* SkXMLParser_expat.cpp */, + 00B7DE9C0EDCA22F00F77EA2 /* SkXMLPullParser.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libexpat.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* expat */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "expat" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = expat; + productName = expat; + productReference = D2AAC046055464E500DB518D /* libexpat.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "expat" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* expat */; + projectDirPath = ""; + projectRoot = ..; + targets = ( + D2AAC045055464E500DB518D /* expat */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DE9E0EDCA22F00F77EA2 /* SkXMLPullParser.cpp in Sources */, + 00B7DEA20EDCA25700F77EA2 /* SkXMLParser_expat.cpp in Sources */, + 00B7DEA60EDCA27F00F77EA2 /* xmlparse.c in Sources */, + 00B7DEA70EDCA27F00F77EA2 /* xmlrole.c in Sources */, + 00B7DEA80EDCA27F00F77EA2 /* xmltok.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = expat; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_PREPROCESSOR_DEFINITIONS = ( + MACOS_CLASSIC, + XML_STATIC, + SK_RELEASE, + ); + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = expat; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + MACOS_CLASSIC, + XML_STATIC, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/** ../../expat/lib"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + MACOS_CLASSIC, + XML_STATIC, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/** ../../expat/lib"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "expat" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "expat" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/freetype2.xcodeproj/project.pbxproj b/xcode/freetype2.xcodeproj/project.pbxproj new file mode 100644 index 0000000..08c13a3 --- /dev/null +++ b/xcode/freetype2.xcodeproj/project.pbxproj @@ -0,0 +1,456 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7DEE20EDCA46500F77EA2 /* ftadvanc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEC70EDCA46500F77EA2 /* ftadvanc.c */; }; + 00B7DEE30EDCA46500F77EA2 /* ftapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEC80EDCA46500F77EA2 /* ftapi.c */; }; + 00B7DEE40EDCA46500F77EA2 /* ftbase.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEC90EDCA46500F77EA2 /* ftbase.c */; }; + 00B7DEE50EDCA46500F77EA2 /* ftbbox.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECA0EDCA46500F77EA2 /* ftbbox.c */; }; + 00B7DEE60EDCA46500F77EA2 /* ftbitmap.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECB0EDCA46500F77EA2 /* ftbitmap.c */; }; + 00B7DEE70EDCA46500F77EA2 /* ftcalc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECC0EDCA46500F77EA2 /* ftcalc.c */; }; + 00B7DEE80EDCA46500F77EA2 /* ftdbgmem.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECD0EDCA46500F77EA2 /* ftdbgmem.c */; }; + 00B7DEE90EDCA46500F77EA2 /* ftdebug.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECE0EDCA46500F77EA2 /* ftdebug.c */; }; + 00B7DEEA0EDCA46500F77EA2 /* ftgasp.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DECF0EDCA46500F77EA2 /* ftgasp.c */; }; + 00B7DEEB0EDCA46500F77EA2 /* ftgloadr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED00EDCA46500F77EA2 /* ftgloadr.c */; }; + 00B7DEEC0EDCA46500F77EA2 /* ftglyph.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED10EDCA46500F77EA2 /* ftglyph.c */; }; + 00B7DEED0EDCA46500F77EA2 /* ftinit.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED20EDCA46500F77EA2 /* ftinit.c */; }; + 00B7DEEE0EDCA46500F77EA2 /* ftlcdfil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED30EDCA46500F77EA2 /* ftlcdfil.c */; }; + 00B7DEEF0EDCA46500F77EA2 /* ftmm.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED40EDCA46500F77EA2 /* ftmm.c */; }; + 00B7DEF00EDCA46500F77EA2 /* ftnames.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED50EDCA46500F77EA2 /* ftnames.c */; }; + 00B7DEF10EDCA46500F77EA2 /* ftobjs.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED60EDCA46500F77EA2 /* ftobjs.c */; }; + 00B7DEF20EDCA46500F77EA2 /* ftoutln.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED70EDCA46500F77EA2 /* ftoutln.c */; }; + 00B7DEF30EDCA46500F77EA2 /* ftpatent.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED80EDCA46500F77EA2 /* ftpatent.c */; }; + 00B7DEF40EDCA46500F77EA2 /* ftrfork.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DED90EDCA46500F77EA2 /* ftrfork.c */; }; + 00B7DEF50EDCA46500F77EA2 /* ftstream.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDA0EDCA46500F77EA2 /* ftstream.c */; }; + 00B7DEF60EDCA46500F77EA2 /* ftstroke.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDB0EDCA46500F77EA2 /* ftstroke.c */; }; + 00B7DEF70EDCA46500F77EA2 /* ftsynth.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDC0EDCA46500F77EA2 /* ftsynth.c */; }; + 00B7DEF80EDCA46500F77EA2 /* ftsystem.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDD0EDCA46500F77EA2 /* ftsystem.c */; }; + 00B7DEF90EDCA46500F77EA2 /* fttrigon.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDE0EDCA46500F77EA2 /* fttrigon.c */; }; + 00B7DEFA0EDCA46500F77EA2 /* ftutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEDF0EDCA46500F77EA2 /* ftutil.c */; }; + 00B7DEFB0EDCA46500F77EA2 /* ftwinfnt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEE00EDCA46500F77EA2 /* ftwinfnt.c */; }; + 00B7DEFC0EDCA46500F77EA2 /* ftxf86.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEE10EDCA46500F77EA2 /* ftxf86.c */; }; + 00B7DEFE0EDCA47900F77EA2 /* raster.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEFD0EDCA47900F77EA2 /* raster.c */; }; + 00B7DF000EDCA48B00F77EA2 /* sfnt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DEFF0EDCA48B00F77EA2 /* sfnt.c */; }; + 00B7DF020EDCA49C00F77EA2 /* smooth.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF010EDCA49C00F77EA2 /* smooth.c */; }; + 00B7DF040EDCA4AF00F77EA2 /* autofit.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF030EDCA4AF00F77EA2 /* autofit.c */; }; + 00B7DF060EDCA4BE00F77EA2 /* truetype.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF050EDCA4BE00F77EA2 /* truetype.c */; }; + 00B7DF080EDCA4CE00F77EA2 /* cff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF070EDCA4CE00F77EA2 /* cff.c */; }; + 00B7DF0A0EDCA4DD00F77EA2 /* psaux.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF090EDCA4DD00F77EA2 /* psaux.c */; }; + 00B7DF0C0EDCA4ED00F77EA2 /* psnames.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF0B0EDCA4ED00F77EA2 /* psnames.c */; }; + 00B7DF100EDCA50100F77EA2 /* pshinter.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF0F0EDCA50100F77EA2 /* pshinter.c */; }; + 00B7DF120EDCA51600F77EA2 /* SkFontHost_FreeType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF110EDCA51600F77EA2 /* SkFontHost_FreeType.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7DEC70EDCA46500F77EA2 /* ftadvanc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftadvanc.c; path = ../../freetype/src/base/ftadvanc.c; sourceTree = SOURCE_ROOT; }; + 00B7DEC80EDCA46500F77EA2 /* ftapi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftapi.c; path = ../../freetype/src/base/ftapi.c; sourceTree = SOURCE_ROOT; }; + 00B7DEC90EDCA46500F77EA2 /* ftbase.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftbase.c; path = ../../freetype/src/base/ftbase.c; sourceTree = SOURCE_ROOT; }; + 00B7DECA0EDCA46500F77EA2 /* ftbbox.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftbbox.c; path = ../../freetype/src/base/ftbbox.c; sourceTree = SOURCE_ROOT; }; + 00B7DECB0EDCA46500F77EA2 /* ftbitmap.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftbitmap.c; path = ../../freetype/src/base/ftbitmap.c; sourceTree = SOURCE_ROOT; }; + 00B7DECC0EDCA46500F77EA2 /* ftcalc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftcalc.c; path = ../../freetype/src/base/ftcalc.c; sourceTree = SOURCE_ROOT; }; + 00B7DECD0EDCA46500F77EA2 /* ftdbgmem.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftdbgmem.c; path = ../../freetype/src/base/ftdbgmem.c; sourceTree = SOURCE_ROOT; }; + 00B7DECE0EDCA46500F77EA2 /* ftdebug.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftdebug.c; path = ../../freetype/src/base/ftdebug.c; sourceTree = SOURCE_ROOT; }; + 00B7DECF0EDCA46500F77EA2 /* ftgasp.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftgasp.c; path = ../../freetype/src/base/ftgasp.c; sourceTree = SOURCE_ROOT; }; + 00B7DED00EDCA46500F77EA2 /* ftgloadr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftgloadr.c; path = ../../freetype/src/base/ftgloadr.c; sourceTree = SOURCE_ROOT; }; + 00B7DED10EDCA46500F77EA2 /* ftglyph.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftglyph.c; path = ../../freetype/src/base/ftglyph.c; sourceTree = SOURCE_ROOT; }; + 00B7DED20EDCA46500F77EA2 /* ftinit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftinit.c; path = ../../freetype/src/base/ftinit.c; sourceTree = SOURCE_ROOT; }; + 00B7DED30EDCA46500F77EA2 /* ftlcdfil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftlcdfil.c; path = ../../freetype/src/base/ftlcdfil.c; sourceTree = SOURCE_ROOT; }; + 00B7DED40EDCA46500F77EA2 /* ftmm.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftmm.c; path = ../../freetype/src/base/ftmm.c; sourceTree = SOURCE_ROOT; }; + 00B7DED50EDCA46500F77EA2 /* ftnames.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftnames.c; path = ../../freetype/src/base/ftnames.c; sourceTree = SOURCE_ROOT; }; + 00B7DED60EDCA46500F77EA2 /* ftobjs.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftobjs.c; path = ../../freetype/src/base/ftobjs.c; sourceTree = SOURCE_ROOT; }; + 00B7DED70EDCA46500F77EA2 /* ftoutln.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftoutln.c; path = ../../freetype/src/base/ftoutln.c; sourceTree = SOURCE_ROOT; }; + 00B7DED80EDCA46500F77EA2 /* ftpatent.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftpatent.c; path = ../../freetype/src/base/ftpatent.c; sourceTree = SOURCE_ROOT; }; + 00B7DED90EDCA46500F77EA2 /* ftrfork.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftrfork.c; path = ../../freetype/src/base/ftrfork.c; sourceTree = SOURCE_ROOT; }; + 00B7DEDA0EDCA46500F77EA2 /* ftstream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftstream.c; path = ../../freetype/src/base/ftstream.c; sourceTree = SOURCE_ROOT; }; + 00B7DEDB0EDCA46500F77EA2 /* ftstroke.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftstroke.c; path = ../../freetype/src/base/ftstroke.c; sourceTree = SOURCE_ROOT; }; + 00B7DEDC0EDCA46500F77EA2 /* ftsynth.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftsynth.c; path = ../../freetype/src/base/ftsynth.c; sourceTree = SOURCE_ROOT; }; + 00B7DEDD0EDCA46500F77EA2 /* ftsystem.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftsystem.c; path = ../../freetype/src/base/ftsystem.c; sourceTree = SOURCE_ROOT; }; + 00B7DEDE0EDCA46500F77EA2 /* fttrigon.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = fttrigon.c; path = ../../freetype/src/base/fttrigon.c; sourceTree = SOURCE_ROOT; }; + 00B7DEDF0EDCA46500F77EA2 /* ftutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftutil.c; path = ../../freetype/src/base/ftutil.c; sourceTree = SOURCE_ROOT; }; + 00B7DEE00EDCA46500F77EA2 /* ftwinfnt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftwinfnt.c; path = ../../freetype/src/base/ftwinfnt.c; sourceTree = SOURCE_ROOT; }; + 00B7DEE10EDCA46500F77EA2 /* ftxf86.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = ftxf86.c; path = ../../freetype/src/base/ftxf86.c; sourceTree = SOURCE_ROOT; }; + 00B7DEFD0EDCA47900F77EA2 /* raster.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = raster.c; path = ../../freetype/src/raster/raster.c; sourceTree = SOURCE_ROOT; }; + 00B7DEFF0EDCA48B00F77EA2 /* sfnt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = sfnt.c; path = ../../freetype/src/sfnt/sfnt.c; sourceTree = SOURCE_ROOT; }; + 00B7DF010EDCA49C00F77EA2 /* smooth.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = smooth.c; path = ../../freetype/src/smooth/smooth.c; sourceTree = SOURCE_ROOT; }; + 00B7DF030EDCA4AF00F77EA2 /* autofit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = autofit.c; path = ../../freetype/src/autofit/autofit.c; sourceTree = SOURCE_ROOT; }; + 00B7DF050EDCA4BE00F77EA2 /* truetype.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = truetype.c; path = ../../freetype/src/truetype/truetype.c; sourceTree = SOURCE_ROOT; }; + 00B7DF070EDCA4CE00F77EA2 /* cff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = cff.c; path = ../../freetype/src/cff/cff.c; sourceTree = SOURCE_ROOT; }; + 00B7DF090EDCA4DD00F77EA2 /* psaux.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = psaux.c; path = ../../freetype/src/psaux/psaux.c; sourceTree = SOURCE_ROOT; }; + 00B7DF0B0EDCA4ED00F77EA2 /* psnames.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = psnames.c; path = ../../freetype/src/psnames/psnames.c; sourceTree = SOURCE_ROOT; }; + 00B7DF0F0EDCA50100F77EA2 /* pshinter.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pshinter.c; path = ../../freetype/src/pshinter/pshinter.c; sourceTree = SOURCE_ROOT; }; + 00B7DF110EDCA51600F77EA2 /* SkFontHost_FreeType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_FreeType.cpp; path = ../libsgl/ports/SkFontHost_FreeType.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libfreetype.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libfreetype.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* freetype */ = { + isa = PBXGroup; + children = ( + FE33C98F094E104700C4A640 /* base */, + FE33C990094E105100C4A640 /* raster */, + FE33C997094E109300C4A640 /* snft */, + FE33C998094E109D00C4A640 /* smooth */, + FE33C999094E10B000C4A640 /* autohint */, + FE33C99A094E10BD00C4A640 /* truetype */, + FE33C99B094E10C600C4A640 /* cff */, + FE33C99E094E10E100C4A640 /* psaux */, + FE33C99F094E10EB00C4A640 /* psnames */, + FE33C9A0094E10F400C4A640 /* pshinter */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = freetype; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7DF110EDCA51600F77EA2 /* SkFontHost_FreeType.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libfreetype.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; + FE33C98F094E104700C4A640 /* base */ = { + isa = PBXGroup; + children = ( + 00B7DEC70EDCA46500F77EA2 /* ftadvanc.c */, + 00B7DEC80EDCA46500F77EA2 /* ftapi.c */, + 00B7DEC90EDCA46500F77EA2 /* ftbase.c */, + 00B7DECA0EDCA46500F77EA2 /* ftbbox.c */, + 00B7DECB0EDCA46500F77EA2 /* ftbitmap.c */, + 00B7DECC0EDCA46500F77EA2 /* ftcalc.c */, + 00B7DECD0EDCA46500F77EA2 /* ftdbgmem.c */, + 00B7DECE0EDCA46500F77EA2 /* ftdebug.c */, + 00B7DECF0EDCA46500F77EA2 /* ftgasp.c */, + 00B7DED00EDCA46500F77EA2 /* ftgloadr.c */, + 00B7DED10EDCA46500F77EA2 /* ftglyph.c */, + 00B7DED20EDCA46500F77EA2 /* ftinit.c */, + 00B7DED30EDCA46500F77EA2 /* ftlcdfil.c */, + 00B7DED40EDCA46500F77EA2 /* ftmm.c */, + 00B7DED50EDCA46500F77EA2 /* ftnames.c */, + 00B7DED60EDCA46500F77EA2 /* ftobjs.c */, + 00B7DED70EDCA46500F77EA2 /* ftoutln.c */, + 00B7DED80EDCA46500F77EA2 /* ftpatent.c */, + 00B7DED90EDCA46500F77EA2 /* ftrfork.c */, + 00B7DEDA0EDCA46500F77EA2 /* ftstream.c */, + 00B7DEDB0EDCA46500F77EA2 /* ftstroke.c */, + 00B7DEDC0EDCA46500F77EA2 /* ftsynth.c */, + 00B7DEDD0EDCA46500F77EA2 /* ftsystem.c */, + 00B7DEDE0EDCA46500F77EA2 /* fttrigon.c */, + 00B7DEDF0EDCA46500F77EA2 /* ftutil.c */, + 00B7DEE00EDCA46500F77EA2 /* ftwinfnt.c */, + 00B7DEE10EDCA46500F77EA2 /* ftxf86.c */, + ); + name = base; + sourceTree = "<group>"; + }; + FE33C990094E105100C4A640 /* raster */ = { + isa = PBXGroup; + children = ( + 00B7DEFD0EDCA47900F77EA2 /* raster.c */, + ); + name = raster; + sourceTree = "<group>"; + }; + FE33C997094E109300C4A640 /* snft */ = { + isa = PBXGroup; + children = ( + 00B7DEFF0EDCA48B00F77EA2 /* sfnt.c */, + ); + name = snft; + sourceTree = "<group>"; + }; + FE33C998094E109D00C4A640 /* smooth */ = { + isa = PBXGroup; + children = ( + 00B7DF010EDCA49C00F77EA2 /* smooth.c */, + ); + name = smooth; + sourceTree = "<group>"; + }; + FE33C999094E10B000C4A640 /* autohint */ = { + isa = PBXGroup; + children = ( + 00B7DF030EDCA4AF00F77EA2 /* autofit.c */, + ); + name = autohint; + sourceTree = "<group>"; + }; + FE33C99A094E10BD00C4A640 /* truetype */ = { + isa = PBXGroup; + children = ( + 00B7DF050EDCA4BE00F77EA2 /* truetype.c */, + ); + name = truetype; + sourceTree = "<group>"; + }; + FE33C99B094E10C600C4A640 /* cff */ = { + isa = PBXGroup; + children = ( + 00B7DF070EDCA4CE00F77EA2 /* cff.c */, + ); + name = cff; + sourceTree = "<group>"; + }; + FE33C99E094E10E100C4A640 /* psaux */ = { + isa = PBXGroup; + children = ( + 00B7DF090EDCA4DD00F77EA2 /* psaux.c */, + ); + name = psaux; + sourceTree = "<group>"; + }; + FE33C99F094E10EB00C4A640 /* psnames */ = { + isa = PBXGroup; + children = ( + 00B7DF0B0EDCA4ED00F77EA2 /* psnames.c */, + ); + name = psnames; + sourceTree = "<group>"; + }; + FE33C9A0094E10F400C4A640 /* pshinter */ = { + isa = PBXGroup; + children = ( + 00B7DF0F0EDCA50100F77EA2 /* pshinter.c */, + ); + name = pshinter; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* freetype */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "freetype" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = freetype; + productName = freetype; + productReference = D2AAC046055464E500DB518D /* libfreetype.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "freetype2" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* freetype */; + projectDirPath = ""; + projectRoot = ../..; + targets = ( + D2AAC045055464E500DB518D /* freetype */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DEE20EDCA46500F77EA2 /* ftadvanc.c in Sources */, + 00B7DEE30EDCA46500F77EA2 /* ftapi.c in Sources */, + 00B7DEE40EDCA46500F77EA2 /* ftbase.c in Sources */, + 00B7DEE50EDCA46500F77EA2 /* ftbbox.c in Sources */, + 00B7DEE60EDCA46500F77EA2 /* ftbitmap.c in Sources */, + 00B7DEE70EDCA46500F77EA2 /* ftcalc.c in Sources */, + 00B7DEE80EDCA46500F77EA2 /* ftdbgmem.c in Sources */, + 00B7DEE90EDCA46500F77EA2 /* ftdebug.c in Sources */, + 00B7DEEA0EDCA46500F77EA2 /* ftgasp.c in Sources */, + 00B7DEEB0EDCA46500F77EA2 /* ftgloadr.c in Sources */, + 00B7DEEC0EDCA46500F77EA2 /* ftglyph.c in Sources */, + 00B7DEED0EDCA46500F77EA2 /* ftinit.c in Sources */, + 00B7DEEE0EDCA46500F77EA2 /* ftlcdfil.c in Sources */, + 00B7DEEF0EDCA46500F77EA2 /* ftmm.c in Sources */, + 00B7DEF00EDCA46500F77EA2 /* ftnames.c in Sources */, + 00B7DEF10EDCA46500F77EA2 /* ftobjs.c in Sources */, + 00B7DEF20EDCA46500F77EA2 /* ftoutln.c in Sources */, + 00B7DEF30EDCA46500F77EA2 /* ftpatent.c in Sources */, + 00B7DEF40EDCA46500F77EA2 /* ftrfork.c in Sources */, + 00B7DEF50EDCA46500F77EA2 /* ftstream.c in Sources */, + 00B7DEF60EDCA46500F77EA2 /* ftstroke.c in Sources */, + 00B7DEF70EDCA46500F77EA2 /* ftsynth.c in Sources */, + 00B7DEF80EDCA46500F77EA2 /* ftsystem.c in Sources */, + 00B7DEF90EDCA46500F77EA2 /* fttrigon.c in Sources */, + 00B7DEFA0EDCA46500F77EA2 /* ftutil.c in Sources */, + 00B7DEFB0EDCA46500F77EA2 /* ftwinfnt.c in Sources */, + 00B7DEFC0EDCA46500F77EA2 /* ftxf86.c in Sources */, + 00B7DEFE0EDCA47900F77EA2 /* raster.c in Sources */, + 00B7DF000EDCA48B00F77EA2 /* sfnt.c in Sources */, + 00B7DF020EDCA49C00F77EA2 /* smooth.c in Sources */, + 00B7DF040EDCA4AF00F77EA2 /* autofit.c in Sources */, + 00B7DF060EDCA4BE00F77EA2 /* truetype.c in Sources */, + 00B7DF080EDCA4CE00F77EA2 /* cff.c in Sources */, + 00B7DF0A0EDCA4DD00F77EA2 /* psaux.c in Sources */, + 00B7DF0C0EDCA4ED00F77EA2 /* psnames.c in Sources */, + 00B7DF100EDCA50100F77EA2 /* pshinter.c in Sources */, + 00B7DF120EDCA51600F77EA2 /* SkFontHost_FreeType.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = freetype; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = freetype; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + TT_CONFIG_OPTION_BYTECODE_INTERPRETER, + FT2_BUILD_LIBRARY, + DARWIN_NO_CARBON, + SK_DEBUG, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../../freetype/include ../include/**"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + TT_CONFIG_OPTION_BYTECODE_INTERPRETER, + FT2_BUILD_LIBRARY, + DARWIN_NO_CARBON, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../../freetype/include ../include/**"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "freetype" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "freetype2" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/gif.xcodeproj/project.pbxproj b/xcode/gif.xcodeproj/project.pbxproj new file mode 100644 index 0000000..0645a35 --- /dev/null +++ b/xcode/gif.xcodeproj/project.pbxproj @@ -0,0 +1,264 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 008CFC4D0C04B77E00FB4126 /* SkMovie_gif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 008CFC4C0C04B77E00FB4126 /* SkMovie_gif.cpp */; }; + 00B13BE30C0C6EFA0033F013 /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B13BE20C0C6EFA0033F013 /* SkMovie.cpp */; }; + FE08AB3F0945EFBE0057213F /* gif_lib_private.h in Headers */ = {isa = PBXBuildFile; fileRef = FE08AB3D0945EFBE0057213F /* gif_lib_private.h */; }; + FE08AB400945EFBE0057213F /* gif_lib.h in Headers */ = {isa = PBXBuildFile; fileRef = FE08AB3E0945EFBE0057213F /* gif_lib.h */; }; + FE08AB440945EFEF0057213F /* dgif_lib.c in Sources */ = {isa = PBXBuildFile; fileRef = FE08AB410945EFEF0057213F /* dgif_lib.c */; }; + FE08AB450945EFEF0057213F /* gif_err.c in Sources */ = {isa = PBXBuildFile; fileRef = FE08AB420945EFEF0057213F /* gif_err.c */; }; + FE08AB460945EFEF0057213F /* gifalloc.c in Sources */ = {isa = PBXBuildFile; fileRef = FE08AB430945EFEF0057213F /* gifalloc.c */; }; + FE7B86240948E6A1001B952C /* SkImageDecoder_libgif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE7B86230948E6A1001B952C /* SkImageDecoder_libgif.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 008CFC4C0C04B77E00FB4126 /* SkMovie_gif.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie_gif.cpp; path = ../../libs/graphics/images/SkMovie_gif.cpp; sourceTree = SOURCE_ROOT; }; + 00B13BE20C0C6EFA0033F013 /* SkMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie.cpp; path = ../../libs/graphics/images/SkMovie.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libgif.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgif.a; sourceTree = BUILT_PRODUCTS_DIR; }; + FE08AB3D0945EFBE0057213F /* gif_lib_private.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = gif_lib_private.h; path = "../../extlibs/libgif-4.0/gif_lib_private.h"; sourceTree = SOURCE_ROOT; }; + FE08AB3E0945EFBE0057213F /* gif_lib.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = gif_lib.h; path = "../../extlibs/libgif-4.0/gif_lib.h"; sourceTree = SOURCE_ROOT; }; + FE08AB410945EFEF0057213F /* dgif_lib.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = dgif_lib.c; path = "../../extlibs/libgif-4.0/dgif_lib.c"; sourceTree = SOURCE_ROOT; }; + FE08AB420945EFEF0057213F /* gif_err.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = gif_err.c; path = "../../extlibs/libgif-4.0/gif_err.c"; sourceTree = SOURCE_ROOT; }; + FE08AB430945EFEF0057213F /* gifalloc.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; name = gifalloc.c; path = "../../extlibs/libgif-4.0/gifalloc.c"; sourceTree = SOURCE_ROOT; }; + FE7B86230948E6A1001B952C /* SkImageDecoder_libgif.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libgif.cpp; path = ../../libs/graphics/images/SkImageDecoder_libgif.cpp; sourceTree = SOURCE_ROOT; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* gif */ = { + isa = PBXGroup; + children = ( + 00B13BE20C0C6EFA0033F013 /* SkMovie.cpp */, + FE08AB3C0945EF830057213F /* Include */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = gif; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 008CFC4C0C04B77E00FB4126 /* SkMovie_gif.cpp */, + FE7B86230948E6A1001B952C /* SkImageDecoder_libgif.cpp */, + FE08AB410945EFEF0057213F /* dgif_lib.c */, + FE08AB420945EFEF0057213F /* gif_err.c */, + FE08AB430945EFEF0057213F /* gifalloc.c */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libgif.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; + FE08AB3C0945EF830057213F /* Include */ = { + isa = PBXGroup; + children = ( + FE08AB3D0945EFBE0057213F /* gif_lib_private.h */, + FE08AB3E0945EFBE0057213F /* gif_lib.h */, + ); + name = Include; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + FE08AB3F0945EFBE0057213F /* gif_lib_private.h in Headers */, + FE08AB400945EFBE0057213F /* gif_lib.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* gif */ = { + isa = PBXNativeTarget; + buildConfigurationList = FE5F47EB094782A50095980F /* Build configuration list for PBXNativeTarget "gif" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = gif; + productName = gif; + productReference = D2AAC046055464E500DB518D /* libgif.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = FE5F47EF094782A50095980F /* Build configuration list for PBXProject "gif" */; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* gif */; + projectDirPath = ""; + targets = ( + D2AAC045055464E500DB518D /* gif */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + FE08AB440945EFEF0057213F /* dgif_lib.c in Sources */, + FE08AB450945EFEF0057213F /* gif_err.c in Sources */, + FE08AB460945EFEF0057213F /* gifalloc.c in Sources */, + FE7B86240948E6A1001B952C /* SkImageDecoder_libgif.cpp in Sources */, + 008CFC4D0C04B77E00FB4126 /* SkMovie_gif.cpp in Sources */, + 00B13BE30C0C6EFA0033F013 /* SkMovie.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + FE5F47EC094782A50095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + _LIB, + SK_FORCE_SCALARFIXED, + ); + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ../../include/graphics; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = gif; + ZERO_LINK = YES; + }; + name = Debug; + }; + FE5F47ED094782A50095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = gif; + ZERO_LINK = NO; + }; + name = Release; + }; + FE5F47F0094782A50095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg"; + }; + name = Debug; + }; + FE5F47F1094782A50095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + FE5F47EB094782A50095980F /* Build configuration list for PBXNativeTarget "gif" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F47EC094782A50095980F /* Debug */, + FE5F47ED094782A50095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + FE5F47EF094782A50095980F /* Build configuration list for PBXProject "gif" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F47F0094782A50095980F /* Debug */, + FE5F47F1094782A50095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/giflib.xcodeproj/project.pbxproj b/xcode/giflib.xcodeproj/project.pbxproj new file mode 100644 index 0000000..6c289a3 --- /dev/null +++ b/xcode/giflib.xcodeproj/project.pbxproj @@ -0,0 +1,235 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 44; + objects = { + +/* Begin PBXBuildFile section */ + 00B7DCD40EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD10EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp */; }; + 00B7DCD50EDCA06600F77EA2 /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD20EDCA06600F77EA2 /* SkMovie.cpp */; }; + 00B7DCD60EDCA06600F77EA2 /* SkMovie_gif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD30EDCA06600F77EA2 /* SkMovie_gif.cpp */; }; + 00B7DCDA0EDCA07F00F77EA2 /* dgif_lib.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD70EDCA07F00F77EA2 /* dgif_lib.c */; }; + 00B7DCDB0EDCA07F00F77EA2 /* gif_err.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD80EDCA07F00F77EA2 /* gif_err.c */; }; + 00B7DCDC0EDCA07F00F77EA2 /* gifalloc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DCD90EDCA07F00F77EA2 /* gifalloc.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7DCD10EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libgif.cpp; path = ../libsgl/images/SkImageDecoder_libgif.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCD20EDCA06600F77EA2 /* SkMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie.cpp; path = ../libsgl/images/SkMovie.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCD30EDCA06600F77EA2 /* SkMovie_gif.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie_gif.cpp; path = ../libsgl/images/SkMovie_gif.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DCD70EDCA07F00F77EA2 /* dgif_lib.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = dgif_lib.c; path = ../../giflib/dgif_lib.c; sourceTree = SOURCE_ROOT; }; + 00B7DCD80EDCA07F00F77EA2 /* gif_err.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gif_err.c; path = ../../giflib/gif_err.c; sourceTree = SOURCE_ROOT; }; + 00B7DCD90EDCA07F00F77EA2 /* gifalloc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = gifalloc.c; path = ../../giflib/gifalloc.c; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libgiflib.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgiflib.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* giflib */ = { + isa = PBXGroup; + children = ( + 00B7DCD10EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp */, + 00B7DCD20EDCA06600F77EA2 /* SkMovie.cpp */, + 00B7DCD30EDCA06600F77EA2 /* SkMovie_gif.cpp */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = giflib; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7DCD70EDCA07F00F77EA2 /* dgif_lib.c */, + 00B7DCD80EDCA07F00F77EA2 /* gif_err.c */, + 00B7DCD90EDCA07F00F77EA2 /* gifalloc.c */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libgiflib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* giflib */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "giflib" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = giflib; + productName = giflib; + productReference = D2AAC046055464E500DB518D /* libgiflib.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "giflib" */; + compatibilityVersion = "Xcode 3.0"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* giflib */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + D2AAC045055464E500DB518D /* giflib */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DCD40EDCA06600F77EA2 /* SkImageDecoder_libgif.cpp in Sources */, + 00B7DCD50EDCA06600F77EA2 /* SkMovie.cpp in Sources */, + 00B7DCD60EDCA06600F77EA2 /* SkMovie_gif.cpp in Sources */, + 00B7DCDA0EDCA07F00F77EA2 /* dgif_lib.c in Sources */, + 00B7DCDB0EDCA07F00F77EA2 /* gif_err.c in Sources */, + 00B7DCDC0EDCA07F00F77EA2 /* gifalloc.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = giflib; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = giflib; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + HAVE_CONFIG_H, + SK_DEBUG, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk"; + USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + HAVE_CONFIG_H, + SK_RELEASE, + ); + GCC_THREADSAFE_STATICS = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk"; + USER_HEADER_SEARCH_PATHS = "../include/graphics ../include/corecg"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "giflib" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "giflib" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/graphics.xcodeproj/project.pbxproj b/xcode/graphics.xcodeproj/project.pbxproj new file mode 100644 index 0000000..e64247c --- /dev/null +++ b/xcode/graphics.xcodeproj/project.pbxproj @@ -0,0 +1,843 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 44; + objects = { + +/* Begin PBXBuildFile section */ + 006B43940EF73CFC00F15BC4 /* SkString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43930EF73CFC00F15BC4 /* SkString.cpp */; }; + 006B43AE0EF7444A00F15BC4 /* SkUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43AD0EF7444A00F15BC4 /* SkUtils.cpp */; }; + 00B7DF260EDCA56700F77EA2 /* SkPathHeap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF1D0EDCA56700F77EA2 /* SkPathHeap.cpp */; }; + 00B7DF270EDCA56700F77EA2 /* SkPathHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF1E0EDCA56700F77EA2 /* SkPathHeap.h */; }; + 00B7DF280EDCA56700F77EA2 /* SkPicture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF1F0EDCA56700F77EA2 /* SkPicture.cpp */; }; + 00B7DF290EDCA56700F77EA2 /* SkPictureFlat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF200EDCA56700F77EA2 /* SkPictureFlat.cpp */; }; + 00B7DF2A0EDCA56700F77EA2 /* SkPictureFlat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF210EDCA56700F77EA2 /* SkPictureFlat.h */; }; + 00B7DF2B0EDCA56700F77EA2 /* SkPicturePlayback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF220EDCA56700F77EA2 /* SkPicturePlayback.cpp */; }; + 00B7DF2C0EDCA56700F77EA2 /* SkPicturePlayback.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF230EDCA56700F77EA2 /* SkPicturePlayback.h */; }; + 00B7DF2D0EDCA56700F77EA2 /* SkPictureRecord.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF240EDCA56700F77EA2 /* SkPictureRecord.cpp */; }; + 00B7DF2E0EDCA56700F77EA2 /* SkPictureRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF250EDCA56700F77EA2 /* SkPictureRecord.h */; }; + 00B7DF4E0EDCA57800F77EA2 /* Sk1DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF2F0EDCA57800F77EA2 /* Sk1DPathEffect.cpp */; }; + 00B7DF4F0EDCA57800F77EA2 /* Sk2DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF300EDCA57800F77EA2 /* Sk2DPathEffect.cpp */; }; + 00B7DF500EDCA57800F77EA2 /* SkAvoidXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF310EDCA57800F77EA2 /* SkAvoidXfermode.cpp */; }; + 00B7DF510EDCA57800F77EA2 /* SkBlurDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF320EDCA57800F77EA2 /* SkBlurDrawLooper.cpp */; }; + 00B7DF520EDCA57800F77EA2 /* SkBlurMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF330EDCA57800F77EA2 /* SkBlurMask.cpp */; }; + 00B7DF530EDCA57800F77EA2 /* SkBlurMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF340EDCA57800F77EA2 /* SkBlurMask.h */; }; + 00B7DF540EDCA57800F77EA2 /* SkBlurMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF350EDCA57800F77EA2 /* SkBlurMaskFilter.cpp */; }; + 00B7DF550EDCA57800F77EA2 /* SkCamera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF360EDCA57800F77EA2 /* SkCamera.cpp */; }; + 00B7DF560EDCA57800F77EA2 /* SkColorFilters.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF370EDCA57800F77EA2 /* SkColorFilters.cpp */; }; + 00B7DF570EDCA57800F77EA2 /* SkColorMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF380EDCA57800F77EA2 /* SkColorMatrix.cpp */; }; + 00B7DF580EDCA57800F77EA2 /* SkColorMatrixFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF390EDCA57800F77EA2 /* SkColorMatrixFilter.cpp */; }; + 00B7DF590EDCA57800F77EA2 /* SkCornerPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3A0EDCA57800F77EA2 /* SkCornerPathEffect.cpp */; }; + 00B7DF5A0EDCA57800F77EA2 /* SkCullPoints.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3B0EDCA57800F77EA2 /* SkCullPoints.cpp */; }; + 00B7DF5B0EDCA57800F77EA2 /* SkDashPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3C0EDCA57800F77EA2 /* SkDashPathEffect.cpp */; }; + 00B7DF5C0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3D0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp */; }; + 00B7DF5D0EDCA57800F77EA2 /* SkEmbossMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF3E0EDCA57800F77EA2 /* SkEmbossMask.cpp */; }; + 00B7DF5E0EDCA57800F77EA2 /* SkEmbossMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF3F0EDCA57800F77EA2 /* SkEmbossMask.h */; }; + 00B7DF5F0EDCA57800F77EA2 /* SkEmbossMask_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF400EDCA57800F77EA2 /* SkEmbossMask_Table.h */; }; + 00B7DF600EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF410EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp */; }; + 00B7DF610EDCA57800F77EA2 /* SkGradientShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF420EDCA57800F77EA2 /* SkGradientShader.cpp */; }; + 00B7DF620EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF430EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp */; }; + 00B7DF630EDCA57800F77EA2 /* SkLayerDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF440EDCA57800F77EA2 /* SkLayerDrawLooper.cpp */; }; + 00B7DF640EDCA57800F77EA2 /* SkLayerRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF450EDCA57800F77EA2 /* SkLayerRasterizer.cpp */; }; + 00B7DF650EDCA57800F77EA2 /* SkNinePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF460EDCA57800F77EA2 /* SkNinePatch.cpp */; }; + 00B7DF660EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF470EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp */; }; + 00B7DF670EDCA57800F77EA2 /* SkPixelXorXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF480EDCA57800F77EA2 /* SkPixelXorXfermode.cpp */; }; + 00B7DF680EDCA57800F77EA2 /* SkProxyCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF490EDCA57800F77EA2 /* SkProxyCanvas.cpp */; }; + 00B7DF690EDCA57800F77EA2 /* SkRadialGradient_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF4A0EDCA57800F77EA2 /* SkRadialGradient_Table.h */; }; + 00B7DF6A0EDCA57800F77EA2 /* SkShaderExtras.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF4B0EDCA57800F77EA2 /* SkShaderExtras.cpp */; }; + 00B7DF6B0EDCA57800F77EA2 /* SkTransparentShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF4C0EDCA57800F77EA2 /* SkTransparentShader.cpp */; }; + 00B7DF6C0EDCA57800F77EA2 /* SkUnitMappers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF4D0EDCA57800F77EA2 /* SkUnitMappers.cpp */; }; + 00B7DF8E0EDCA59200F77EA2 /* SkFDStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF730EDCA59200F77EA2 /* SkFDStream.cpp */; }; + 00B7DF8F0EDCA59200F77EA2 /* SkFlipPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF740EDCA59200F77EA2 /* SkFlipPixelRef.cpp */; }; + 00B7DF900EDCA59200F77EA2 /* SkImageDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF750EDCA59200F77EA2 /* SkImageDecoder.cpp */; }; + 00B7DF990EDCA59200F77EA2 /* SkImageRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF7E0EDCA59200F77EA2 /* SkImageRef.cpp */; }; + 00B7DF9A0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF7F0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp */; }; + 00B7DF9B0EDCA59200F77EA2 /* SkImageRefPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF800EDCA59200F77EA2 /* SkImageRefPool.cpp */; }; + 00B7DF9D0EDCA59200F77EA2 /* SkMMapStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF820EDCA59200F77EA2 /* SkMMapStream.cpp */; }; + 00B7DFA00EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF850EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp */; }; + 00B7DFA10EDCA59200F77EA2 /* SkScaledBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DF860EDCA59200F77EA2 /* SkScaledBitmapSampler.h */; }; + 00B7DFA20EDCA59200F77EA2 /* SkStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DF870EDCA59200F77EA2 /* SkStream.cpp */; }; + 00B7DFAD0EDCA60D00F77EA2 /* SkBML_Verbs.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFA30EDCA60D00F77EA2 /* SkBML_Verbs.h */; }; + 00B7DFAE0EDCA60D00F77EA2 /* SkBML_XMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA40EDCA60D00F77EA2 /* SkBML_XMLParser.cpp */; }; + 00B7DFAF0EDCA60D00F77EA2 /* SkDOM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA50EDCA60D00F77EA2 /* SkDOM.cpp */; }; + 00B7DFB20EDCA60D00F77EA2 /* SkParse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA80EDCA60D00F77EA2 /* SkParse.cpp */; }; + 00B7DFB30EDCA60D00F77EA2 /* SkParseColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFA90EDCA60D00F77EA2 /* SkParseColor.cpp */; }; + 00B7DFB40EDCA60D00F77EA2 /* SkXMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFAA0EDCA60D00F77EA2 /* SkXMLParser.cpp */; }; + 00B7DFB60EDCA60D00F77EA2 /* SkXMLWriter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFAC0EDCA60D00F77EA2 /* SkXMLWriter.cpp */; }; + 00B7E0120EDCA64500F77EA2 /* SkAlphaRuns.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFB70EDCA64500F77EA2 /* SkAlphaRuns.cpp */; }; + 00B7E0130EDCA64500F77EA2 /* SkAntiRun.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFB80EDCA64500F77EA2 /* SkAntiRun.h */; }; + 00B7E0140EDCA64500F77EA2 /* SkAutoKern.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFB90EDCA64500F77EA2 /* SkAutoKern.h */; }; + 00B7E0150EDCA64500F77EA2 /* SkBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBA0EDCA64500F77EA2 /* SkBitmap.cpp */; }; + 00B7E0160EDCA64500F77EA2 /* SkBitmap_scroll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBB0EDCA64500F77EA2 /* SkBitmap_scroll.cpp */; }; + 00B7E0170EDCA64500F77EA2 /* SkBitmapProcShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBC0EDCA64500F77EA2 /* SkBitmapProcShader.cpp */; }; + 00B7E0180EDCA64500F77EA2 /* SkBitmapProcShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFBD0EDCA64500F77EA2 /* SkBitmapProcShader.h */; }; + 00B7E0190EDCA64500F77EA2 /* SkBitmapProcState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFBE0EDCA64500F77EA2 /* SkBitmapProcState.cpp */; }; + 00B7E01A0EDCA64500F77EA2 /* SkBitmapProcState.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFBF0EDCA64500F77EA2 /* SkBitmapProcState.h */; }; + 00B7E01B0EDCA64500F77EA2 /* SkBitmapProcState_matrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC00EDCA64500F77EA2 /* SkBitmapProcState_matrix.h */; }; + 00B7E01C0EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFC10EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp */; }; + 00B7E01D0EDCA64500F77EA2 /* SkBitmapProcState_sample.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC20EDCA64500F77EA2 /* SkBitmapProcState_sample.h */; }; + 00B7E01E0EDCA64500F77EA2 /* SkBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFC30EDCA64500F77EA2 /* SkBitmapSampler.cpp */; }; + 00B7E01F0EDCA64500F77EA2 /* SkBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC40EDCA64500F77EA2 /* SkBitmapSampler.h */; }; + 00B7E0200EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC50EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h */; }; + 00B7E0210EDCA64500F77EA2 /* SkBitmapShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFC60EDCA64500F77EA2 /* SkBitmapShader.cpp */; }; + 00B7E0220EDCA64500F77EA2 /* SkBitmapShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC70EDCA64500F77EA2 /* SkBitmapShader.h */; }; + 00B7E0230EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC80EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h */; }; + 00B7E0240EDCA64500F77EA2 /* SkBitmapShaderTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFC90EDCA64500F77EA2 /* SkBitmapShaderTemplate.h */; }; + 00B7E0250EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFCA0EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h */; }; + 00B7E0260EDCA64500F77EA2 /* SkBlitRow.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFCB0EDCA64500F77EA2 /* SkBlitRow.h */; }; + 00B7E0270EDCA64500F77EA2 /* SkBlitRow_D16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFCC0EDCA64500F77EA2 /* SkBlitRow_D16.cpp */; }; + 00B7E0280EDCA64500F77EA2 /* SkBlitRow_D4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFCD0EDCA64500F77EA2 /* SkBlitRow_D4444.cpp */; }; + 00B7E0290EDCA64500F77EA2 /* SkBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFCE0EDCA64500F77EA2 /* SkBlitter.cpp */; }; + 00B7E02A0EDCA64500F77EA2 /* SkBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFCF0EDCA64500F77EA2 /* SkBlitter.h */; }; + 00B7E02B0EDCA64500F77EA2 /* SkBlitter_4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD00EDCA64500F77EA2 /* SkBlitter_4444.cpp */; }; + 00B7E02C0EDCA64500F77EA2 /* SkBlitter_A1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD10EDCA64500F77EA2 /* SkBlitter_A1.cpp */; }; + 00B7E02D0EDCA64500F77EA2 /* SkBlitter_A8.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD20EDCA64500F77EA2 /* SkBlitter_A8.cpp */; }; + 00B7E02E0EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD30EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp */; }; + 00B7E02F0EDCA64500F77EA2 /* SkBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD40EDCA64500F77EA2 /* SkBlitter_RGB16.cpp */; }; + 00B7E0300EDCA64500F77EA2 /* SkBlitter_Sprite.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD50EDCA64500F77EA2 /* SkBlitter_Sprite.cpp */; }; + 00B7E0310EDCA64500F77EA2 /* SkCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD60EDCA64500F77EA2 /* SkCanvas.cpp */; }; + 00B7E0320EDCA64500F77EA2 /* SkColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD70EDCA64500F77EA2 /* SkColor.cpp */; }; + 00B7E0330EDCA64500F77EA2 /* SkColorFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD80EDCA64500F77EA2 /* SkColorFilter.cpp */; }; + 00B7E0340EDCA64500F77EA2 /* SkColorTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFD90EDCA64500F77EA2 /* SkColorTable.cpp */; }; + 00B7E0350EDCA64500F77EA2 /* SkCoreBlitters.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFDA0EDCA64500F77EA2 /* SkCoreBlitters.h */; }; + 00B7E0360EDCA64500F77EA2 /* SkDeque.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDB0EDCA64500F77EA2 /* SkDeque.cpp */; }; + 00B7E0370EDCA64500F77EA2 /* SkDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDC0EDCA64500F77EA2 /* SkDevice.cpp */; }; + 00B7E0380EDCA64500F77EA2 /* SkDither.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDD0EDCA64500F77EA2 /* SkDither.cpp */; }; + 00B7E0390EDCA64500F77EA2 /* SkDraw.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFDE0EDCA64500F77EA2 /* SkDraw.cpp */; }; + 00B7E03A0EDCA64500F77EA2 /* SkDrawProcs.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFDF0EDCA64500F77EA2 /* SkDrawProcs.h */; }; + 00B7E03B0EDCA64500F77EA2 /* SkEdge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE00EDCA64500F77EA2 /* SkEdge.cpp */; }; + 00B7E03C0EDCA64500F77EA2 /* SkEdge.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE10EDCA64500F77EA2 /* SkEdge.h */; }; + 00B7E03D0EDCA64500F77EA2 /* SkFilterProc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE20EDCA64500F77EA2 /* SkFilterProc.cpp */; }; + 00B7E03E0EDCA64500F77EA2 /* SkFilterProc.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE30EDCA64500F77EA2 /* SkFilterProc.h */; }; + 00B7E03F0EDCA64500F77EA2 /* SkFlattenable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE40EDCA64500F77EA2 /* SkFlattenable.cpp */; }; + 00B7E0400EDCA64500F77EA2 /* SkFP.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE50EDCA64500F77EA2 /* SkFP.h */; }; + 00B7E0410EDCA64500F77EA2 /* SkGeometry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE60EDCA64500F77EA2 /* SkGeometry.cpp */; }; + 00B7E0420EDCA64500F77EA2 /* SkGeometry.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFE70EDCA64500F77EA2 /* SkGeometry.h */; }; + 00B7E0430EDCA64500F77EA2 /* SkGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE80EDCA64500F77EA2 /* SkGlobals.cpp */; }; + 00B7E0440EDCA64500F77EA2 /* SkGlyphCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFE90EDCA64500F77EA2 /* SkGlyphCache.cpp */; }; + 00B7E0450EDCA64500F77EA2 /* SkGlyphCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFEA0EDCA64500F77EA2 /* SkGlyphCache.h */; }; + 00B7E0460EDCA64500F77EA2 /* SkGraphics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEB0EDCA64500F77EA2 /* SkGraphics.cpp */; }; + 00B7E0470EDCA64500F77EA2 /* SkMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEC0EDCA64500F77EA2 /* SkMask.cpp */; }; + 00B7E0480EDCA64500F77EA2 /* SkMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFED0EDCA64500F77EA2 /* SkMaskFilter.cpp */; }; + 00B7E0490EDCA64500F77EA2 /* SkPackBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEE0EDCA64500F77EA2 /* SkPackBits.cpp */; }; + 00B7E04A0EDCA64500F77EA2 /* SkPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFEF0EDCA64500F77EA2 /* SkPaint.cpp */; }; + 00B7E04B0EDCA64500F77EA2 /* SkPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF00EDCA64500F77EA2 /* SkPath.cpp */; }; + 00B7E04C0EDCA64500F77EA2 /* SkPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF10EDCA64500F77EA2 /* SkPathEffect.cpp */; }; + 00B7E04D0EDCA64500F77EA2 /* SkPathMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF20EDCA64500F77EA2 /* SkPathMeasure.cpp */; }; + 00B7E04E0EDCA64500F77EA2 /* SkPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF30EDCA64500F77EA2 /* SkPixelRef.cpp */; }; + 00B7E04F0EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF40EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp */; }; + 00B7E0500EDCA64500F77EA2 /* SkPtrRecorder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF50EDCA64500F77EA2 /* SkPtrRecorder.cpp */; }; + 00B7E0510EDCA64500F77EA2 /* SkRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF60EDCA64500F77EA2 /* SkRasterizer.cpp */; }; + 00B7E0520EDCA64500F77EA2 /* SkRefCnt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF70EDCA64500F77EA2 /* SkRefCnt.cpp */; }; + 00B7E0530EDCA64500F77EA2 /* SkRegion_path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF80EDCA64500F77EA2 /* SkRegion_path.cpp */; }; + 00B7E0540EDCA64500F77EA2 /* SkScalerContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFF90EDCA64500F77EA2 /* SkScalerContext.cpp */; }; + 00B7E0550EDCA64500F77EA2 /* SkScan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFA0EDCA64500F77EA2 /* SkScan.cpp */; }; + 00B7E0560EDCA64500F77EA2 /* SkScan.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7DFFB0EDCA64500F77EA2 /* SkScan.h */; }; + 00B7E0570EDCA64500F77EA2 /* SkScan_Antihair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFC0EDCA64500F77EA2 /* SkScan_Antihair.cpp */; }; + 00B7E0580EDCA64500F77EA2 /* SkScan_AntiPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFD0EDCA64500F77EA2 /* SkScan_AntiPath.cpp */; }; + 00B7E0590EDCA64500F77EA2 /* SkScan_Hairline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFE0EDCA64500F77EA2 /* SkScan_Hairline.cpp */; }; + 00B7E05A0EDCA64500F77EA2 /* SkScan_Path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7DFFF0EDCA64500F77EA2 /* SkScan_Path.cpp */; }; + 00B7E05B0EDCA64500F77EA2 /* SkScanPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0000EDCA64500F77EA2 /* SkScanPriv.h */; }; + 00B7E05C0EDCA64500F77EA2 /* SkShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0010EDCA64500F77EA2 /* SkShader.cpp */; }; + 00B7E05D0EDCA64500F77EA2 /* SkSpriteBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0020EDCA64500F77EA2 /* SkSpriteBlitter.h */; }; + 00B7E05E0EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0030EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp */; }; + 00B7E05F0EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0040EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp */; }; + 00B7E0600EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0050EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h */; }; + 00B7E0620EDCA64500F77EA2 /* SkStroke.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0070EDCA64500F77EA2 /* SkStroke.cpp */; }; + 00B7E0630EDCA64500F77EA2 /* SkStrokerPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0080EDCA64500F77EA2 /* SkStrokerPriv.cpp */; }; + 00B7E0640EDCA64500F77EA2 /* SkStrokerPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E0090EDCA64500F77EA2 /* SkStrokerPriv.h */; }; + 00B7E0650EDCA64500F77EA2 /* SkTemplatesPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E00A0EDCA64500F77EA2 /* SkTemplatesPriv.h */; }; + 00B7E0660EDCA64500F77EA2 /* SkTSearch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E00B0EDCA64500F77EA2 /* SkTSearch.cpp */; }; + 00B7E0670EDCA64500F77EA2 /* SkTSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E00C0EDCA64500F77EA2 /* SkTSort.h */; }; + 00B7E0680EDCA64500F77EA2 /* SkTypeface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E00D0EDCA64500F77EA2 /* SkTypeface.cpp */; }; + 00B7E0690EDCA64500F77EA2 /* SkUnPreMultiply.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E00E0EDCA64500F77EA2 /* SkUnPreMultiply.cpp */; }; + 00B7E06B0EDCA64500F77EA2 /* SkWriter32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0100EDCA64500F77EA2 /* SkWriter32.cpp */; }; + 00B7E06C0EDCA64500F77EA2 /* SkXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0110EDCA64500F77EA2 /* SkXfermode.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 006B43930EF73CFC00F15BC4 /* SkString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkString.cpp; path = ../libcorecg/SkString.cpp; sourceTree = SOURCE_ROOT; }; + 006B43AD0EF7444A00F15BC4 /* SkUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUtils.cpp; path = ../libcorecg/SkUtils.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF1D0EDCA56700F77EA2 /* SkPathHeap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathHeap.cpp; path = ../libsgl/picture/SkPathHeap.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF1E0EDCA56700F77EA2 /* SkPathHeap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPathHeap.h; path = ../libsgl/picture/SkPathHeap.h; sourceTree = SOURCE_ROOT; }; + 00B7DF1F0EDCA56700F77EA2 /* SkPicture.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicture.cpp; path = ../libsgl/picture/SkPicture.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF200EDCA56700F77EA2 /* SkPictureFlat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureFlat.cpp; path = ../libsgl/picture/SkPictureFlat.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF210EDCA56700F77EA2 /* SkPictureFlat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureFlat.h; path = ../libsgl/picture/SkPictureFlat.h; sourceTree = SOURCE_ROOT; }; + 00B7DF220EDCA56700F77EA2 /* SkPicturePlayback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicturePlayback.cpp; path = ../libsgl/picture/SkPicturePlayback.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF230EDCA56700F77EA2 /* SkPicturePlayback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPicturePlayback.h; path = ../libsgl/picture/SkPicturePlayback.h; sourceTree = SOURCE_ROOT; }; + 00B7DF240EDCA56700F77EA2 /* SkPictureRecord.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureRecord.cpp; path = ../libsgl/picture/SkPictureRecord.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF250EDCA56700F77EA2 /* SkPictureRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureRecord.h; path = ../libsgl/picture/SkPictureRecord.h; sourceTree = SOURCE_ROOT; }; + 00B7DF2F0EDCA57800F77EA2 /* Sk1DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk1DPathEffect.cpp; path = ../libsgl/effects/Sk1DPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF300EDCA57800F77EA2 /* Sk2DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk2DPathEffect.cpp; path = ../libsgl/effects/Sk2DPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF310EDCA57800F77EA2 /* SkAvoidXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAvoidXfermode.cpp; path = ../libsgl/effects/SkAvoidXfermode.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF320EDCA57800F77EA2 /* SkBlurDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurDrawLooper.cpp; path = ../libsgl/effects/SkBlurDrawLooper.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF330EDCA57800F77EA2 /* SkBlurMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMask.cpp; path = ../libsgl/effects/SkBlurMask.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF340EDCA57800F77EA2 /* SkBlurMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlurMask.h; path = ../libsgl/effects/SkBlurMask.h; sourceTree = SOURCE_ROOT; }; + 00B7DF350EDCA57800F77EA2 /* SkBlurMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMaskFilter.cpp; path = ../libsgl/effects/SkBlurMaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF360EDCA57800F77EA2 /* SkCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCamera.cpp; path = ../libsgl/effects/SkCamera.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF370EDCA57800F77EA2 /* SkColorFilters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilters.cpp; path = ../libsgl/effects/SkColorFilters.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF380EDCA57800F77EA2 /* SkColorMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrix.cpp; path = ../libsgl/effects/SkColorMatrix.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF390EDCA57800F77EA2 /* SkColorMatrixFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrixFilter.cpp; path = ../libsgl/effects/SkColorMatrixFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF3A0EDCA57800F77EA2 /* SkCornerPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCornerPathEffect.cpp; path = ../libsgl/effects/SkCornerPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF3B0EDCA57800F77EA2 /* SkCullPoints.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCullPoints.cpp; path = ../libsgl/effects/SkCullPoints.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF3C0EDCA57800F77EA2 /* SkDashPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDashPathEffect.cpp; path = ../libsgl/effects/SkDashPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF3D0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDiscretePathEffect.cpp; path = ../libsgl/effects/SkDiscretePathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF3E0EDCA57800F77EA2 /* SkEmbossMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMask.cpp; path = ../libsgl/effects/SkEmbossMask.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF3F0EDCA57800F77EA2 /* SkEmbossMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask.h; path = ../libsgl/effects/SkEmbossMask.h; sourceTree = SOURCE_ROOT; }; + 00B7DF400EDCA57800F77EA2 /* SkEmbossMask_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask_Table.h; path = ../libsgl/effects/SkEmbossMask_Table.h; sourceTree = SOURCE_ROOT; }; + 00B7DF410EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMaskFilter.cpp; path = ../libsgl/effects/SkEmbossMaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF420EDCA57800F77EA2 /* SkGradientShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGradientShader.cpp; path = ../libsgl/effects/SkGradientShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF430EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkKernel33MaskFilter.cpp; path = ../libsgl/effects/SkKernel33MaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF440EDCA57800F77EA2 /* SkLayerDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerDrawLooper.cpp; path = ../libsgl/effects/SkLayerDrawLooper.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF450EDCA57800F77EA2 /* SkLayerRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerRasterizer.cpp; path = ../libsgl/effects/SkLayerRasterizer.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF460EDCA57800F77EA2 /* SkNinePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkNinePatch.cpp; path = ../libsgl/effects/SkNinePatch.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF470EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaintFlagsDrawFilter.cpp; path = ../libsgl/effects/SkPaintFlagsDrawFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF480EDCA57800F77EA2 /* SkPixelXorXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelXorXfermode.cpp; path = ../libsgl/effects/SkPixelXorXfermode.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF490EDCA57800F77EA2 /* SkProxyCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProxyCanvas.cpp; path = ../libsgl/effects/SkProxyCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF4A0EDCA57800F77EA2 /* SkRadialGradient_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkRadialGradient_Table.h; path = ../libsgl/effects/SkRadialGradient_Table.h; sourceTree = SOURCE_ROOT; }; + 00B7DF4B0EDCA57800F77EA2 /* SkShaderExtras.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShaderExtras.cpp; path = ../libsgl/effects/SkShaderExtras.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF4C0EDCA57800F77EA2 /* SkTransparentShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTransparentShader.cpp; path = ../libsgl/effects/SkTransparentShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF4D0EDCA57800F77EA2 /* SkUnitMappers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnitMappers.cpp; path = ../libsgl/effects/SkUnitMappers.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF730EDCA59200F77EA2 /* SkFDStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFDStream.cpp; path = ../libsgl/images/SkFDStream.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF740EDCA59200F77EA2 /* SkFlipPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlipPixelRef.cpp; path = ../libsgl/images/SkFlipPixelRef.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF750EDCA59200F77EA2 /* SkImageDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder.cpp; path = ../libsgl/images/SkImageDecoder.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF7E0EDCA59200F77EA2 /* SkImageRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef.cpp; path = ../libsgl/images/SkImageRef.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF7F0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef_GlobalPool.cpp; path = ../libsgl/images/SkImageRef_GlobalPool.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF800EDCA59200F77EA2 /* SkImageRefPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRefPool.cpp; path = ../libsgl/images/SkImageRefPool.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF820EDCA59200F77EA2 /* SkMMapStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMMapStream.cpp; path = ../libsgl/images/SkMMapStream.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF850EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScaledBitmapSampler.cpp; path = ../libsgl/images/SkScaledBitmapSampler.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DF860EDCA59200F77EA2 /* SkScaledBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScaledBitmapSampler.h; path = ../libsgl/images/SkScaledBitmapSampler.h; sourceTree = SOURCE_ROOT; }; + 00B7DF870EDCA59200F77EA2 /* SkStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStream.cpp; path = ../libsgl/images/SkStream.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFA30EDCA60D00F77EA2 /* SkBML_Verbs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBML_Verbs.h; path = ../libsgl/xml/SkBML_Verbs.h; sourceTree = SOURCE_ROOT; }; + 00B7DFA40EDCA60D00F77EA2 /* SkBML_XMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBML_XMLParser.cpp; path = ../libsgl/xml/SkBML_XMLParser.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFA50EDCA60D00F77EA2 /* SkDOM.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDOM.cpp; path = ../libsgl/xml/SkDOM.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFA80EDCA60D00F77EA2 /* SkParse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParse.cpp; path = ../libsgl/xml/SkParse.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFA90EDCA60D00F77EA2 /* SkParseColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParseColor.cpp; path = ../libsgl/xml/SkParseColor.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFAA0EDCA60D00F77EA2 /* SkXMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLParser.cpp; path = ../libsgl/xml/SkXMLParser.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFAC0EDCA60D00F77EA2 /* SkXMLWriter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLWriter.cpp; path = ../libsgl/xml/SkXMLWriter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFB70EDCA64500F77EA2 /* SkAlphaRuns.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAlphaRuns.cpp; path = ../libsgl/sgl/SkAlphaRuns.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFB80EDCA64500F77EA2 /* SkAntiRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAntiRun.h; path = ../libsgl/sgl/SkAntiRun.h; sourceTree = SOURCE_ROOT; }; + 00B7DFB90EDCA64500F77EA2 /* SkAutoKern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAutoKern.h; path = ../libsgl/sgl/SkAutoKern.h; sourceTree = SOURCE_ROOT; }; + 00B7DFBA0EDCA64500F77EA2 /* SkBitmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap.cpp; path = ../libsgl/sgl/SkBitmap.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFBB0EDCA64500F77EA2 /* SkBitmap_scroll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_scroll.cpp; path = ../libsgl/sgl/SkBitmap_scroll.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFBC0EDCA64500F77EA2 /* SkBitmapProcShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcShader.cpp; path = ../libsgl/sgl/SkBitmapProcShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFBD0EDCA64500F77EA2 /* SkBitmapProcShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcShader.h; path = ../libsgl/sgl/SkBitmapProcShader.h; sourceTree = SOURCE_ROOT; }; + 00B7DFBE0EDCA64500F77EA2 /* SkBitmapProcState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState.cpp; path = ../libsgl/sgl/SkBitmapProcState.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFBF0EDCA64500F77EA2 /* SkBitmapProcState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState.h; path = ../libsgl/sgl/SkBitmapProcState.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC00EDCA64500F77EA2 /* SkBitmapProcState_matrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_matrix.h; path = ../libsgl/sgl/SkBitmapProcState_matrix.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC10EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState_matrixProcs.cpp; path = ../libsgl/sgl/SkBitmapProcState_matrixProcs.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFC20EDCA64500F77EA2 /* SkBitmapProcState_sample.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_sample.h; path = ../libsgl/sgl/SkBitmapProcState_sample.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC30EDCA64500F77EA2 /* SkBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapSampler.cpp; path = ../libsgl/sgl/SkBitmapSampler.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFC40EDCA64500F77EA2 /* SkBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSampler.h; path = ../libsgl/sgl/SkBitmapSampler.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC50EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSamplerTemplate.h; path = ../libsgl/sgl/SkBitmapSamplerTemplate.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC60EDCA64500F77EA2 /* SkBitmapShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapShader.cpp; path = ../libsgl/sgl/SkBitmapShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFC70EDCA64500F77EA2 /* SkBitmapShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader.h; path = ../libsgl/sgl/SkBitmapShader.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC80EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader16BilerpTemplate.h; path = ../libsgl/sgl/SkBitmapShader16BilerpTemplate.h; sourceTree = SOURCE_ROOT; }; + 00B7DFC90EDCA64500F77EA2 /* SkBitmapShaderTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShaderTemplate.h; path = ../libsgl/sgl/SkBitmapShaderTemplate.h; sourceTree = SOURCE_ROOT; }; + 00B7DFCA0EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitBWMaskTemplate.h; path = ../libsgl/sgl/SkBlitBWMaskTemplate.h; sourceTree = SOURCE_ROOT; }; + 00B7DFCB0EDCA64500F77EA2 /* SkBlitRow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitRow.h; path = ../libsgl/sgl/SkBlitRow.h; sourceTree = SOURCE_ROOT; }; + 00B7DFCC0EDCA64500F77EA2 /* SkBlitRow_D16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D16.cpp; path = ../libsgl/sgl/SkBlitRow_D16.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFCD0EDCA64500F77EA2 /* SkBlitRow_D4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D4444.cpp; path = ../libsgl/sgl/SkBlitRow_D4444.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFCE0EDCA64500F77EA2 /* SkBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter.cpp; path = ../libsgl/sgl/SkBlitter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFCF0EDCA64500F77EA2 /* SkBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitter.h; path = ../libsgl/sgl/SkBlitter.h; sourceTree = SOURCE_ROOT; }; + 00B7DFD00EDCA64500F77EA2 /* SkBlitter_4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_4444.cpp; path = ../libsgl/sgl/SkBlitter_4444.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD10EDCA64500F77EA2 /* SkBlitter_A1.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A1.cpp; path = ../libsgl/sgl/SkBlitter_A1.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD20EDCA64500F77EA2 /* SkBlitter_A8.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A8.cpp; path = ../libsgl/sgl/SkBlitter_A8.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD30EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD40EDCA64500F77EA2 /* SkBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_RGB16.cpp; path = ../libsgl/sgl/SkBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD50EDCA64500F77EA2 /* SkBlitter_Sprite.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_Sprite.cpp; path = ../libsgl/sgl/SkBlitter_Sprite.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD60EDCA64500F77EA2 /* SkCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCanvas.cpp; path = ../libsgl/sgl/SkCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD70EDCA64500F77EA2 /* SkColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColor.cpp; path = ../libsgl/sgl/SkColor.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD80EDCA64500F77EA2 /* SkColorFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilter.cpp; path = ../libsgl/sgl/SkColorFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFD90EDCA64500F77EA2 /* SkColorTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorTable.cpp; path = ../libsgl/sgl/SkColorTable.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFDA0EDCA64500F77EA2 /* SkCoreBlitters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCoreBlitters.h; path = ../libsgl/sgl/SkCoreBlitters.h; sourceTree = SOURCE_ROOT; }; + 00B7DFDB0EDCA64500F77EA2 /* SkDeque.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDeque.cpp; path = ../libsgl/sgl/SkDeque.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFDC0EDCA64500F77EA2 /* SkDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDevice.cpp; path = ../libsgl/sgl/SkDevice.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFDD0EDCA64500F77EA2 /* SkDither.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDither.cpp; path = ../libsgl/sgl/SkDither.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFDE0EDCA64500F77EA2 /* SkDraw.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDraw.cpp; path = ../libsgl/sgl/SkDraw.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFDF0EDCA64500F77EA2 /* SkDrawProcs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawProcs.h; path = ../libsgl/sgl/SkDrawProcs.h; sourceTree = SOURCE_ROOT; }; + 00B7DFE00EDCA64500F77EA2 /* SkEdge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEdge.cpp; path = ../libsgl/sgl/SkEdge.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFE10EDCA64500F77EA2 /* SkEdge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEdge.h; path = ../libsgl/sgl/SkEdge.h; sourceTree = SOURCE_ROOT; }; + 00B7DFE20EDCA64500F77EA2 /* SkFilterProc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFilterProc.cpp; path = ../libsgl/sgl/SkFilterProc.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFE30EDCA64500F77EA2 /* SkFilterProc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFilterProc.h; path = ../libsgl/sgl/SkFilterProc.h; sourceTree = SOURCE_ROOT; }; + 00B7DFE40EDCA64500F77EA2 /* SkFlattenable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlattenable.cpp; path = ../libsgl/sgl/SkFlattenable.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFE50EDCA64500F77EA2 /* SkFP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFP.h; path = ../libsgl/sgl/SkFP.h; sourceTree = SOURCE_ROOT; }; + 00B7DFE60EDCA64500F77EA2 /* SkGeometry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGeometry.cpp; path = ../libsgl/sgl/SkGeometry.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFE70EDCA64500F77EA2 /* SkGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGeometry.h; path = ../libsgl/sgl/SkGeometry.h; sourceTree = SOURCE_ROOT; }; + 00B7DFE80EDCA64500F77EA2 /* SkGlobals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals.cpp; path = ../libsgl/sgl/SkGlobals.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFE90EDCA64500F77EA2 /* SkGlyphCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlyphCache.cpp; path = ../libsgl/sgl/SkGlyphCache.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFEA0EDCA64500F77EA2 /* SkGlyphCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGlyphCache.h; path = ../libsgl/sgl/SkGlyphCache.h; sourceTree = SOURCE_ROOT; }; + 00B7DFEB0EDCA64500F77EA2 /* SkGraphics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGraphics.cpp; path = ../libsgl/sgl/SkGraphics.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFEC0EDCA64500F77EA2 /* SkMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMask.cpp; path = ../libsgl/sgl/SkMask.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFED0EDCA64500F77EA2 /* SkMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMaskFilter.cpp; path = ../libsgl/sgl/SkMaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFEE0EDCA64500F77EA2 /* SkPackBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPackBits.cpp; path = ../libsgl/sgl/SkPackBits.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFEF0EDCA64500F77EA2 /* SkPaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaint.cpp; path = ../libsgl/sgl/SkPaint.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF00EDCA64500F77EA2 /* SkPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPath.cpp; path = ../libsgl/sgl/SkPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF10EDCA64500F77EA2 /* SkPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathEffect.cpp; path = ../libsgl/sgl/SkPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF20EDCA64500F77EA2 /* SkPathMeasure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathMeasure.cpp; path = ../libsgl/sgl/SkPathMeasure.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF30EDCA64500F77EA2 /* SkPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelRef.cpp; path = ../libsgl/sgl/SkPixelRef.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF40EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProcSpriteBlitter.cpp; path = ../libsgl/sgl/SkProcSpriteBlitter.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF50EDCA64500F77EA2 /* SkPtrRecorder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPtrRecorder.cpp; path = ../libsgl/sgl/SkPtrRecorder.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF60EDCA64500F77EA2 /* SkRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRasterizer.cpp; path = ../libsgl/sgl/SkRasterizer.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF70EDCA64500F77EA2 /* SkRefCnt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRefCnt.cpp; path = ../libsgl/sgl/SkRefCnt.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF80EDCA64500F77EA2 /* SkRegion_path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion_path.cpp; path = ../libsgl/sgl/SkRegion_path.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFF90EDCA64500F77EA2 /* SkScalerContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScalerContext.cpp; path = ../libsgl/sgl/SkScalerContext.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFFA0EDCA64500F77EA2 /* SkScan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan.cpp; path = ../libsgl/sgl/SkScan.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFFB0EDCA64500F77EA2 /* SkScan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScan.h; path = ../libsgl/sgl/SkScan.h; sourceTree = SOURCE_ROOT; }; + 00B7DFFC0EDCA64500F77EA2 /* SkScan_Antihair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Antihair.cpp; path = ../libsgl/sgl/SkScan_Antihair.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFFD0EDCA64500F77EA2 /* SkScan_AntiPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_AntiPath.cpp; path = ../libsgl/sgl/SkScan_AntiPath.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFFE0EDCA64500F77EA2 /* SkScan_Hairline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Hairline.cpp; path = ../libsgl/sgl/SkScan_Hairline.cpp; sourceTree = SOURCE_ROOT; }; + 00B7DFFF0EDCA64500F77EA2 /* SkScan_Path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Path.cpp; path = ../libsgl/sgl/SkScan_Path.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0000EDCA64500F77EA2 /* SkScanPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScanPriv.h; path = ../libsgl/sgl/SkScanPriv.h; sourceTree = SOURCE_ROOT; }; + 00B7E0010EDCA64500F77EA2 /* SkShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShader.cpp; path = ../libsgl/sgl/SkShader.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0020EDCA64500F77EA2 /* SkSpriteBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitter.h; path = ../libsgl/sgl/SkSpriteBlitter.h; sourceTree = SOURCE_ROOT; }; + 00B7E0030EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkSpriteBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0040EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_RGB16.cpp; path = ../libsgl/sgl/SkSpriteBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0050EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitterTemplate.h; path = ../libsgl/sgl/SkSpriteBlitterTemplate.h; sourceTree = SOURCE_ROOT; }; + 00B7E0070EDCA64500F77EA2 /* SkStroke.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStroke.cpp; path = ../libsgl/sgl/SkStroke.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0080EDCA64500F77EA2 /* SkStrokerPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStrokerPriv.cpp; path = ../libsgl/sgl/SkStrokerPriv.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0090EDCA64500F77EA2 /* SkStrokerPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkStrokerPriv.h; path = ../libsgl/sgl/SkStrokerPriv.h; sourceTree = SOURCE_ROOT; }; + 00B7E00A0EDCA64500F77EA2 /* SkTemplatesPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTemplatesPriv.h; path = ../libsgl/sgl/SkTemplatesPriv.h; sourceTree = SOURCE_ROOT; }; + 00B7E00B0EDCA64500F77EA2 /* SkTSearch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTSearch.cpp; path = ../libsgl/sgl/SkTSearch.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E00C0EDCA64500F77EA2 /* SkTSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTSort.h; path = ../libsgl/sgl/SkTSort.h; sourceTree = SOURCE_ROOT; }; + 00B7E00D0EDCA64500F77EA2 /* SkTypeface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTypeface.cpp; path = ../libsgl/sgl/SkTypeface.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E00E0EDCA64500F77EA2 /* SkUnPreMultiply.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnPreMultiply.cpp; path = ../libsgl/sgl/SkUnPreMultiply.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0100EDCA64500F77EA2 /* SkWriter32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWriter32.cpp; path = ../libsgl/sgl/SkWriter32.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0110EDCA64500F77EA2 /* SkXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXfermode.cpp; path = ../libsgl/sgl/SkXfermode.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC06F0554671400DB518D /* libgraphics.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libgraphics.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D2AAC06D0554671400DB518D /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 001142D10DCA3ED10070D0A3 /* picture */ = { + isa = PBXGroup; + children = ( + 00B7DF1D0EDCA56700F77EA2 /* SkPathHeap.cpp */, + 00B7DF1E0EDCA56700F77EA2 /* SkPathHeap.h */, + 00B7DF1F0EDCA56700F77EA2 /* SkPicture.cpp */, + 00B7DF200EDCA56700F77EA2 /* SkPictureFlat.cpp */, + 00B7DF210EDCA56700F77EA2 /* SkPictureFlat.h */, + 00B7DF220EDCA56700F77EA2 /* SkPicturePlayback.cpp */, + 00B7DF230EDCA56700F77EA2 /* SkPicturePlayback.h */, + 00B7DF240EDCA56700F77EA2 /* SkPictureRecord.cpp */, + 00B7DF250EDCA56700F77EA2 /* SkPictureRecord.h */, + ); + name = picture; + sourceTree = "<group>"; + }; + 034768DDFF38A45A11DB9C8B /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC06F0554671400DB518D /* libgraphics.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 0867D691FE84028FC02AAC07 /* graphics */ = { + isa = PBXGroup; + children = ( + 001142D10DCA3ED10070D0A3 /* picture */, + FE5F48C8094798660095980F /* effects */, + FE5F48C5094797E90095980F /* images */, + FE5F48B2094797A80095980F /* xml */, + 08FB77ACFE841707C02AAC07 /* sgl */, + 034768DDFF38A45A11DB9C8B /* Products */, + ); + name = graphics; + sourceTree = "<group>"; + }; + 08FB77ACFE841707C02AAC07 /* sgl */ = { + isa = PBXGroup; + children = ( + 006B43AD0EF7444A00F15BC4 /* SkUtils.cpp */, + 006B43930EF73CFC00F15BC4 /* SkString.cpp */, + 00B7DFB70EDCA64500F77EA2 /* SkAlphaRuns.cpp */, + 00B7DFB80EDCA64500F77EA2 /* SkAntiRun.h */, + 00B7DFB90EDCA64500F77EA2 /* SkAutoKern.h */, + 00B7DFBA0EDCA64500F77EA2 /* SkBitmap.cpp */, + 00B7DFBB0EDCA64500F77EA2 /* SkBitmap_scroll.cpp */, + 00B7DFBC0EDCA64500F77EA2 /* SkBitmapProcShader.cpp */, + 00B7DFBD0EDCA64500F77EA2 /* SkBitmapProcShader.h */, + 00B7DFBE0EDCA64500F77EA2 /* SkBitmapProcState.cpp */, + 00B7DFBF0EDCA64500F77EA2 /* SkBitmapProcState.h */, + 00B7DFC00EDCA64500F77EA2 /* SkBitmapProcState_matrix.h */, + 00B7DFC10EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp */, + 00B7DFC20EDCA64500F77EA2 /* SkBitmapProcState_sample.h */, + 00B7DFC30EDCA64500F77EA2 /* SkBitmapSampler.cpp */, + 00B7DFC40EDCA64500F77EA2 /* SkBitmapSampler.h */, + 00B7DFC50EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h */, + 00B7DFC60EDCA64500F77EA2 /* SkBitmapShader.cpp */, + 00B7DFC70EDCA64500F77EA2 /* SkBitmapShader.h */, + 00B7DFC80EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h */, + 00B7DFC90EDCA64500F77EA2 /* SkBitmapShaderTemplate.h */, + 00B7DFCA0EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h */, + 00B7DFCB0EDCA64500F77EA2 /* SkBlitRow.h */, + 00B7DFCC0EDCA64500F77EA2 /* SkBlitRow_D16.cpp */, + 00B7DFCD0EDCA64500F77EA2 /* SkBlitRow_D4444.cpp */, + 00B7DFCE0EDCA64500F77EA2 /* SkBlitter.cpp */, + 00B7DFCF0EDCA64500F77EA2 /* SkBlitter.h */, + 00B7DFD00EDCA64500F77EA2 /* SkBlitter_4444.cpp */, + 00B7DFD10EDCA64500F77EA2 /* SkBlitter_A1.cpp */, + 00B7DFD20EDCA64500F77EA2 /* SkBlitter_A8.cpp */, + 00B7DFD30EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp */, + 00B7DFD40EDCA64500F77EA2 /* SkBlitter_RGB16.cpp */, + 00B7DFD50EDCA64500F77EA2 /* SkBlitter_Sprite.cpp */, + 00B7DFD60EDCA64500F77EA2 /* SkCanvas.cpp */, + 00B7DFD70EDCA64500F77EA2 /* SkColor.cpp */, + 00B7DFD80EDCA64500F77EA2 /* SkColorFilter.cpp */, + 00B7DFD90EDCA64500F77EA2 /* SkColorTable.cpp */, + 00B7DFDA0EDCA64500F77EA2 /* SkCoreBlitters.h */, + 00B7DFDB0EDCA64500F77EA2 /* SkDeque.cpp */, + 00B7DFDC0EDCA64500F77EA2 /* SkDevice.cpp */, + 00B7DFDD0EDCA64500F77EA2 /* SkDither.cpp */, + 00B7DFDE0EDCA64500F77EA2 /* SkDraw.cpp */, + 00B7DFDF0EDCA64500F77EA2 /* SkDrawProcs.h */, + 00B7DFE00EDCA64500F77EA2 /* SkEdge.cpp */, + 00B7DFE10EDCA64500F77EA2 /* SkEdge.h */, + 00B7DFE20EDCA64500F77EA2 /* SkFilterProc.cpp */, + 00B7DFE30EDCA64500F77EA2 /* SkFilterProc.h */, + 00B7DFE40EDCA64500F77EA2 /* SkFlattenable.cpp */, + 00B7DFE50EDCA64500F77EA2 /* SkFP.h */, + 00B7DFE60EDCA64500F77EA2 /* SkGeometry.cpp */, + 00B7DFE70EDCA64500F77EA2 /* SkGeometry.h */, + 00B7DFE80EDCA64500F77EA2 /* SkGlobals.cpp */, + 00B7DFE90EDCA64500F77EA2 /* SkGlyphCache.cpp */, + 00B7DFEA0EDCA64500F77EA2 /* SkGlyphCache.h */, + 00B7DFEB0EDCA64500F77EA2 /* SkGraphics.cpp */, + 00B7DFEC0EDCA64500F77EA2 /* SkMask.cpp */, + 00B7DFED0EDCA64500F77EA2 /* SkMaskFilter.cpp */, + 00B7DFEE0EDCA64500F77EA2 /* SkPackBits.cpp */, + 00B7DFEF0EDCA64500F77EA2 /* SkPaint.cpp */, + 00B7DFF00EDCA64500F77EA2 /* SkPath.cpp */, + 00B7DFF10EDCA64500F77EA2 /* SkPathEffect.cpp */, + 00B7DFF20EDCA64500F77EA2 /* SkPathMeasure.cpp */, + 00B7DFF30EDCA64500F77EA2 /* SkPixelRef.cpp */, + 00B7DFF40EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp */, + 00B7DFF50EDCA64500F77EA2 /* SkPtrRecorder.cpp */, + 00B7DFF60EDCA64500F77EA2 /* SkRasterizer.cpp */, + 00B7DFF70EDCA64500F77EA2 /* SkRefCnt.cpp */, + 00B7DFF80EDCA64500F77EA2 /* SkRegion_path.cpp */, + 00B7DFF90EDCA64500F77EA2 /* SkScalerContext.cpp */, + 00B7DFFA0EDCA64500F77EA2 /* SkScan.cpp */, + 00B7DFFB0EDCA64500F77EA2 /* SkScan.h */, + 00B7DFFC0EDCA64500F77EA2 /* SkScan_Antihair.cpp */, + 00B7DFFD0EDCA64500F77EA2 /* SkScan_AntiPath.cpp */, + 00B7DFFE0EDCA64500F77EA2 /* SkScan_Hairline.cpp */, + 00B7DFFF0EDCA64500F77EA2 /* SkScan_Path.cpp */, + 00B7E0000EDCA64500F77EA2 /* SkScanPriv.h */, + 00B7E0010EDCA64500F77EA2 /* SkShader.cpp */, + 00B7E0020EDCA64500F77EA2 /* SkSpriteBlitter.h */, + 00B7E0030EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp */, + 00B7E0040EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp */, + 00B7E0050EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h */, + 00B7E0070EDCA64500F77EA2 /* SkStroke.cpp */, + 00B7E0080EDCA64500F77EA2 /* SkStrokerPriv.cpp */, + 00B7E0090EDCA64500F77EA2 /* SkStrokerPriv.h */, + 00B7E00A0EDCA64500F77EA2 /* SkTemplatesPriv.h */, + 00B7E00B0EDCA64500F77EA2 /* SkTSearch.cpp */, + 00B7E00C0EDCA64500F77EA2 /* SkTSort.h */, + 00B7E00D0EDCA64500F77EA2 /* SkTypeface.cpp */, + 00B7E00E0EDCA64500F77EA2 /* SkUnPreMultiply.cpp */, + 00B7E0100EDCA64500F77EA2 /* SkWriter32.cpp */, + 00B7E0110EDCA64500F77EA2 /* SkXfermode.cpp */, + ); + name = sgl; + sourceTree = "<group>"; + }; + FE5F48B2094797A80095980F /* xml */ = { + isa = PBXGroup; + children = ( + 00B7DFA30EDCA60D00F77EA2 /* SkBML_Verbs.h */, + 00B7DFA40EDCA60D00F77EA2 /* SkBML_XMLParser.cpp */, + 00B7DFA50EDCA60D00F77EA2 /* SkDOM.cpp */, + 00B7DFA80EDCA60D00F77EA2 /* SkParse.cpp */, + 00B7DFA90EDCA60D00F77EA2 /* SkParseColor.cpp */, + 00B7DFAA0EDCA60D00F77EA2 /* SkXMLParser.cpp */, + 00B7DFAC0EDCA60D00F77EA2 /* SkXMLWriter.cpp */, + ); + name = xml; + sourceTree = "<group>"; + }; + FE5F48C5094797E90095980F /* images */ = { + isa = PBXGroup; + children = ( + 00B7DF730EDCA59200F77EA2 /* SkFDStream.cpp */, + 00B7DF740EDCA59200F77EA2 /* SkFlipPixelRef.cpp */, + 00B7DF750EDCA59200F77EA2 /* SkImageDecoder.cpp */, + 00B7DF7E0EDCA59200F77EA2 /* SkImageRef.cpp */, + 00B7DF7F0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp */, + 00B7DF800EDCA59200F77EA2 /* SkImageRefPool.cpp */, + 00B7DF820EDCA59200F77EA2 /* SkMMapStream.cpp */, + 00B7DF850EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp */, + 00B7DF860EDCA59200F77EA2 /* SkScaledBitmapSampler.h */, + 00B7DF870EDCA59200F77EA2 /* SkStream.cpp */, + ); + name = images; + sourceTree = "<group>"; + }; + FE5F48C8094798660095980F /* effects */ = { + isa = PBXGroup; + children = ( + 00B7DF2F0EDCA57800F77EA2 /* Sk1DPathEffect.cpp */, + 00B7DF300EDCA57800F77EA2 /* Sk2DPathEffect.cpp */, + 00B7DF310EDCA57800F77EA2 /* SkAvoidXfermode.cpp */, + 00B7DF320EDCA57800F77EA2 /* SkBlurDrawLooper.cpp */, + 00B7DF330EDCA57800F77EA2 /* SkBlurMask.cpp */, + 00B7DF340EDCA57800F77EA2 /* SkBlurMask.h */, + 00B7DF350EDCA57800F77EA2 /* SkBlurMaskFilter.cpp */, + 00B7DF360EDCA57800F77EA2 /* SkCamera.cpp */, + 00B7DF370EDCA57800F77EA2 /* SkColorFilters.cpp */, + 00B7DF380EDCA57800F77EA2 /* SkColorMatrix.cpp */, + 00B7DF390EDCA57800F77EA2 /* SkColorMatrixFilter.cpp */, + 00B7DF3A0EDCA57800F77EA2 /* SkCornerPathEffect.cpp */, + 00B7DF3B0EDCA57800F77EA2 /* SkCullPoints.cpp */, + 00B7DF3C0EDCA57800F77EA2 /* SkDashPathEffect.cpp */, + 00B7DF3D0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp */, + 00B7DF3E0EDCA57800F77EA2 /* SkEmbossMask.cpp */, + 00B7DF3F0EDCA57800F77EA2 /* SkEmbossMask.h */, + 00B7DF400EDCA57800F77EA2 /* SkEmbossMask_Table.h */, + 00B7DF410EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp */, + 00B7DF420EDCA57800F77EA2 /* SkGradientShader.cpp */, + 00B7DF430EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp */, + 00B7DF440EDCA57800F77EA2 /* SkLayerDrawLooper.cpp */, + 00B7DF450EDCA57800F77EA2 /* SkLayerRasterizer.cpp */, + 00B7DF460EDCA57800F77EA2 /* SkNinePatch.cpp */, + 00B7DF470EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp */, + 00B7DF480EDCA57800F77EA2 /* SkPixelXorXfermode.cpp */, + 00B7DF490EDCA57800F77EA2 /* SkProxyCanvas.cpp */, + 00B7DF4A0EDCA57800F77EA2 /* SkRadialGradient_Table.h */, + 00B7DF4B0EDCA57800F77EA2 /* SkShaderExtras.cpp */, + 00B7DF4C0EDCA57800F77EA2 /* SkTransparentShader.cpp */, + 00B7DF4D0EDCA57800F77EA2 /* SkUnitMappers.cpp */, + ); + name = effects; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC06B0554671400DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DF270EDCA56700F77EA2 /* SkPathHeap.h in Headers */, + 00B7DF2A0EDCA56700F77EA2 /* SkPictureFlat.h in Headers */, + 00B7DF2C0EDCA56700F77EA2 /* SkPicturePlayback.h in Headers */, + 00B7DF2E0EDCA56700F77EA2 /* SkPictureRecord.h in Headers */, + 00B7DF530EDCA57800F77EA2 /* SkBlurMask.h in Headers */, + 00B7DF5E0EDCA57800F77EA2 /* SkEmbossMask.h in Headers */, + 00B7DF5F0EDCA57800F77EA2 /* SkEmbossMask_Table.h in Headers */, + 00B7DF690EDCA57800F77EA2 /* SkRadialGradient_Table.h in Headers */, + 00B7DFA10EDCA59200F77EA2 /* SkScaledBitmapSampler.h in Headers */, + 00B7DFAD0EDCA60D00F77EA2 /* SkBML_Verbs.h in Headers */, + 00B7E0130EDCA64500F77EA2 /* SkAntiRun.h in Headers */, + 00B7E0140EDCA64500F77EA2 /* SkAutoKern.h in Headers */, + 00B7E0180EDCA64500F77EA2 /* SkBitmapProcShader.h in Headers */, + 00B7E01A0EDCA64500F77EA2 /* SkBitmapProcState.h in Headers */, + 00B7E01B0EDCA64500F77EA2 /* SkBitmapProcState_matrix.h in Headers */, + 00B7E01D0EDCA64500F77EA2 /* SkBitmapProcState_sample.h in Headers */, + 00B7E01F0EDCA64500F77EA2 /* SkBitmapSampler.h in Headers */, + 00B7E0200EDCA64500F77EA2 /* SkBitmapSamplerTemplate.h in Headers */, + 00B7E0220EDCA64500F77EA2 /* SkBitmapShader.h in Headers */, + 00B7E0230EDCA64500F77EA2 /* SkBitmapShader16BilerpTemplate.h in Headers */, + 00B7E0240EDCA64500F77EA2 /* SkBitmapShaderTemplate.h in Headers */, + 00B7E0250EDCA64500F77EA2 /* SkBlitBWMaskTemplate.h in Headers */, + 00B7E0260EDCA64500F77EA2 /* SkBlitRow.h in Headers */, + 00B7E02A0EDCA64500F77EA2 /* SkBlitter.h in Headers */, + 00B7E0350EDCA64500F77EA2 /* SkCoreBlitters.h in Headers */, + 00B7E03A0EDCA64500F77EA2 /* SkDrawProcs.h in Headers */, + 00B7E03C0EDCA64500F77EA2 /* SkEdge.h in Headers */, + 00B7E03E0EDCA64500F77EA2 /* SkFilterProc.h in Headers */, + 00B7E0400EDCA64500F77EA2 /* SkFP.h in Headers */, + 00B7E0420EDCA64500F77EA2 /* SkGeometry.h in Headers */, + 00B7E0450EDCA64500F77EA2 /* SkGlyphCache.h in Headers */, + 00B7E0560EDCA64500F77EA2 /* SkScan.h in Headers */, + 00B7E05B0EDCA64500F77EA2 /* SkScanPriv.h in Headers */, + 00B7E05D0EDCA64500F77EA2 /* SkSpriteBlitter.h in Headers */, + 00B7E0600EDCA64500F77EA2 /* SkSpriteBlitterTemplate.h in Headers */, + 00B7E0640EDCA64500F77EA2 /* SkStrokerPriv.h in Headers */, + 00B7E0650EDCA64500F77EA2 /* SkTemplatesPriv.h in Headers */, + 00B7E0670EDCA64500F77EA2 /* SkTSort.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC06E0554671400DB518D /* graphics */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB920108733DBB0010E9CD /* Build configuration list for PBXNativeTarget "graphics" */; + buildPhases = ( + D2AAC06B0554671400DB518D /* Headers */, + D2AAC06C0554671400DB518D /* Sources */, + D2AAC06D0554671400DB518D /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = graphics; + productName = graphics; + productReference = D2AAC06F0554671400DB518D /* libgraphics.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 0867D690FE84028FC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB920508733DBB0010E9CD /* Build configuration list for PBXProject "graphics" */; + compatibilityVersion = "Xcode 3.0"; + hasScannedForEncodings = 1; + mainGroup = 0867D691FE84028FC02AAC07 /* graphics */; + productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */; + projectDirPath = ""; + projectRoot = ../..; + targets = ( + D2AAC06E0554671400DB518D /* graphics */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC06C0554671400DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7DF260EDCA56700F77EA2 /* SkPathHeap.cpp in Sources */, + 00B7DF280EDCA56700F77EA2 /* SkPicture.cpp in Sources */, + 00B7DF290EDCA56700F77EA2 /* SkPictureFlat.cpp in Sources */, + 00B7DF2B0EDCA56700F77EA2 /* SkPicturePlayback.cpp in Sources */, + 00B7DF2D0EDCA56700F77EA2 /* SkPictureRecord.cpp in Sources */, + 00B7DF4E0EDCA57800F77EA2 /* Sk1DPathEffect.cpp in Sources */, + 00B7DF4F0EDCA57800F77EA2 /* Sk2DPathEffect.cpp in Sources */, + 00B7DF500EDCA57800F77EA2 /* SkAvoidXfermode.cpp in Sources */, + 00B7DF510EDCA57800F77EA2 /* SkBlurDrawLooper.cpp in Sources */, + 00B7DF520EDCA57800F77EA2 /* SkBlurMask.cpp in Sources */, + 00B7DF540EDCA57800F77EA2 /* SkBlurMaskFilter.cpp in Sources */, + 00B7DF550EDCA57800F77EA2 /* SkCamera.cpp in Sources */, + 00B7DF560EDCA57800F77EA2 /* SkColorFilters.cpp in Sources */, + 00B7DF570EDCA57800F77EA2 /* SkColorMatrix.cpp in Sources */, + 00B7DF580EDCA57800F77EA2 /* SkColorMatrixFilter.cpp in Sources */, + 00B7DF590EDCA57800F77EA2 /* SkCornerPathEffect.cpp in Sources */, + 00B7DF5A0EDCA57800F77EA2 /* SkCullPoints.cpp in Sources */, + 00B7DF5B0EDCA57800F77EA2 /* SkDashPathEffect.cpp in Sources */, + 00B7DF5C0EDCA57800F77EA2 /* SkDiscretePathEffect.cpp in Sources */, + 00B7DF5D0EDCA57800F77EA2 /* SkEmbossMask.cpp in Sources */, + 00B7DF600EDCA57800F77EA2 /* SkEmbossMaskFilter.cpp in Sources */, + 00B7DF610EDCA57800F77EA2 /* SkGradientShader.cpp in Sources */, + 00B7DF620EDCA57800F77EA2 /* SkKernel33MaskFilter.cpp in Sources */, + 00B7DF630EDCA57800F77EA2 /* SkLayerDrawLooper.cpp in Sources */, + 00B7DF640EDCA57800F77EA2 /* SkLayerRasterizer.cpp in Sources */, + 00B7DF650EDCA57800F77EA2 /* SkNinePatch.cpp in Sources */, + 00B7DF660EDCA57800F77EA2 /* SkPaintFlagsDrawFilter.cpp in Sources */, + 00B7DF670EDCA57800F77EA2 /* SkPixelXorXfermode.cpp in Sources */, + 00B7DF680EDCA57800F77EA2 /* SkProxyCanvas.cpp in Sources */, + 00B7DF6A0EDCA57800F77EA2 /* SkShaderExtras.cpp in Sources */, + 00B7DF6B0EDCA57800F77EA2 /* SkTransparentShader.cpp in Sources */, + 00B7DF6C0EDCA57800F77EA2 /* SkUnitMappers.cpp in Sources */, + 00B7DF8E0EDCA59200F77EA2 /* SkFDStream.cpp in Sources */, + 00B7DF8F0EDCA59200F77EA2 /* SkFlipPixelRef.cpp in Sources */, + 00B7DF900EDCA59200F77EA2 /* SkImageDecoder.cpp in Sources */, + 00B7DF990EDCA59200F77EA2 /* SkImageRef.cpp in Sources */, + 00B7DF9A0EDCA59200F77EA2 /* SkImageRef_GlobalPool.cpp in Sources */, + 00B7DF9B0EDCA59200F77EA2 /* SkImageRefPool.cpp in Sources */, + 00B7DF9D0EDCA59200F77EA2 /* SkMMapStream.cpp in Sources */, + 00B7DFA00EDCA59200F77EA2 /* SkScaledBitmapSampler.cpp in Sources */, + 00B7DFA20EDCA59200F77EA2 /* SkStream.cpp in Sources */, + 00B7DFAE0EDCA60D00F77EA2 /* SkBML_XMLParser.cpp in Sources */, + 00B7DFAF0EDCA60D00F77EA2 /* SkDOM.cpp in Sources */, + 00B7DFB20EDCA60D00F77EA2 /* SkParse.cpp in Sources */, + 00B7DFB30EDCA60D00F77EA2 /* SkParseColor.cpp in Sources */, + 00B7DFB40EDCA60D00F77EA2 /* SkXMLParser.cpp in Sources */, + 00B7DFB60EDCA60D00F77EA2 /* SkXMLWriter.cpp in Sources */, + 00B7E0120EDCA64500F77EA2 /* SkAlphaRuns.cpp in Sources */, + 00B7E0150EDCA64500F77EA2 /* SkBitmap.cpp in Sources */, + 00B7E0160EDCA64500F77EA2 /* SkBitmap_scroll.cpp in Sources */, + 00B7E0170EDCA64500F77EA2 /* SkBitmapProcShader.cpp in Sources */, + 00B7E0190EDCA64500F77EA2 /* SkBitmapProcState.cpp in Sources */, + 00B7E01C0EDCA64500F77EA2 /* SkBitmapProcState_matrixProcs.cpp in Sources */, + 00B7E01E0EDCA64500F77EA2 /* SkBitmapSampler.cpp in Sources */, + 00B7E0210EDCA64500F77EA2 /* SkBitmapShader.cpp in Sources */, + 00B7E0270EDCA64500F77EA2 /* SkBlitRow_D16.cpp in Sources */, + 00B7E0280EDCA64500F77EA2 /* SkBlitRow_D4444.cpp in Sources */, + 00B7E0290EDCA64500F77EA2 /* SkBlitter.cpp in Sources */, + 00B7E02B0EDCA64500F77EA2 /* SkBlitter_4444.cpp in Sources */, + 00B7E02C0EDCA64500F77EA2 /* SkBlitter_A1.cpp in Sources */, + 00B7E02D0EDCA64500F77EA2 /* SkBlitter_A8.cpp in Sources */, + 00B7E02E0EDCA64500F77EA2 /* SkBlitter_ARGB32.cpp in Sources */, + 00B7E02F0EDCA64500F77EA2 /* SkBlitter_RGB16.cpp in Sources */, + 00B7E0300EDCA64500F77EA2 /* SkBlitter_Sprite.cpp in Sources */, + 00B7E0310EDCA64500F77EA2 /* SkCanvas.cpp in Sources */, + 00B7E0320EDCA64500F77EA2 /* SkColor.cpp in Sources */, + 00B7E0330EDCA64500F77EA2 /* SkColorFilter.cpp in Sources */, + 00B7E0340EDCA64500F77EA2 /* SkColorTable.cpp in Sources */, + 00B7E0360EDCA64500F77EA2 /* SkDeque.cpp in Sources */, + 00B7E0370EDCA64500F77EA2 /* SkDevice.cpp in Sources */, + 00B7E0380EDCA64500F77EA2 /* SkDither.cpp in Sources */, + 00B7E0390EDCA64500F77EA2 /* SkDraw.cpp in Sources */, + 00B7E03B0EDCA64500F77EA2 /* SkEdge.cpp in Sources */, + 00B7E03D0EDCA64500F77EA2 /* SkFilterProc.cpp in Sources */, + 00B7E03F0EDCA64500F77EA2 /* SkFlattenable.cpp in Sources */, + 00B7E0410EDCA64500F77EA2 /* SkGeometry.cpp in Sources */, + 00B7E0430EDCA64500F77EA2 /* SkGlobals.cpp in Sources */, + 00B7E0440EDCA64500F77EA2 /* SkGlyphCache.cpp in Sources */, + 00B7E0460EDCA64500F77EA2 /* SkGraphics.cpp in Sources */, + 00B7E0470EDCA64500F77EA2 /* SkMask.cpp in Sources */, + 00B7E0480EDCA64500F77EA2 /* SkMaskFilter.cpp in Sources */, + 00B7E0490EDCA64500F77EA2 /* SkPackBits.cpp in Sources */, + 00B7E04A0EDCA64500F77EA2 /* SkPaint.cpp in Sources */, + 00B7E04B0EDCA64500F77EA2 /* SkPath.cpp in Sources */, + 00B7E04C0EDCA64500F77EA2 /* SkPathEffect.cpp in Sources */, + 00B7E04D0EDCA64500F77EA2 /* SkPathMeasure.cpp in Sources */, + 00B7E04E0EDCA64500F77EA2 /* SkPixelRef.cpp in Sources */, + 00B7E04F0EDCA64500F77EA2 /* SkProcSpriteBlitter.cpp in Sources */, + 00B7E0500EDCA64500F77EA2 /* SkPtrRecorder.cpp in Sources */, + 00B7E0510EDCA64500F77EA2 /* SkRasterizer.cpp in Sources */, + 00B7E0520EDCA64500F77EA2 /* SkRefCnt.cpp in Sources */, + 00B7E0530EDCA64500F77EA2 /* SkRegion_path.cpp in Sources */, + 00B7E0540EDCA64500F77EA2 /* SkScalerContext.cpp in Sources */, + 00B7E0550EDCA64500F77EA2 /* SkScan.cpp in Sources */, + 00B7E0570EDCA64500F77EA2 /* SkScan_Antihair.cpp in Sources */, + 00B7E0580EDCA64500F77EA2 /* SkScan_AntiPath.cpp in Sources */, + 00B7E0590EDCA64500F77EA2 /* SkScan_Hairline.cpp in Sources */, + 00B7E05A0EDCA64500F77EA2 /* SkScan_Path.cpp in Sources */, + 00B7E05C0EDCA64500F77EA2 /* SkShader.cpp in Sources */, + 00B7E05E0EDCA64500F77EA2 /* SkSpriteBlitter_ARGB32.cpp in Sources */, + 00B7E05F0EDCA64500F77EA2 /* SkSpriteBlitter_RGB16.cpp in Sources */, + 00B7E0620EDCA64500F77EA2 /* SkStroke.cpp in Sources */, + 00B7E0630EDCA64500F77EA2 /* SkStrokerPriv.cpp in Sources */, + 00B7E0660EDCA64500F77EA2 /* SkTSearch.cpp in Sources */, + 00B7E0680EDCA64500F77EA2 /* SkTypeface.cpp in Sources */, + 00B7E0690EDCA64500F77EA2 /* SkUnPreMultiply.cpp in Sources */, + 00B7E06B0EDCA64500F77EA2 /* SkWriter32.cpp in Sources */, + 00B7E06C0EDCA64500F77EA2 /* SkXfermode.cpp in Sources */, + 006B43940EF73CFC00F15BC4 /* SkString.cpp in Sources */, + 006B43AE0EF7444A00F15BC4 /* SkUtils.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB920208733DBB0010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = graphics_Prefix.pch; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = graphics; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB920308733DBB0010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = graphics_Prefix.pch; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = graphics; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB920608733DBB0010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_DEBUGGING_SYMBOLS = full; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PFE_FILE_C_DIALECTS = ""; + GCC_PREPROCESSOR_DEFINITIONS = SK_DEBUG; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/** ../libcorecg"; + }; + name = Debug; + }; + 1DEB920708733DBB0010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_DEBUGGING_SYMBOLS = full; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PFE_FILE_C_DIALECTS = ""; + GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE; + GCC_SYMBOLS_PRIVATE_EXTERN = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/** ../libcorecg"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB920108733DBB0010E9CD /* Build configuration list for PBXNativeTarget "graphics" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB920208733DBB0010E9CD /* Debug */, + 1DEB920308733DBB0010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB920508733DBB0010E9CD /* Build configuration list for PBXProject "graphics" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB920608733DBB0010E9CD /* Debug */, + 1DEB920708733DBB0010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 0867D690FE84028FC02AAC07 /* Project object */; +} diff --git a/xcode/jpeg.xcodeproj/project.pbxproj b/xcode/jpeg.xcodeproj/project.pbxproj new file mode 100644 index 0000000..ee1c4b3 --- /dev/null +++ b/xcode/jpeg.xcodeproj/project.pbxproj @@ -0,0 +1,451 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7E07F0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E07E0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp */; }; + 00B7E0D60EDCA78B00F77EA2 /* jcapimin.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0890EDCA78B00F77EA2 /* jcapimin.c */; }; + 00B7E0D70EDCA78B00F77EA2 /* jcapistd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08A0EDCA78B00F77EA2 /* jcapistd.c */; }; + 00B7E0D80EDCA78B00F77EA2 /* jccoefct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08B0EDCA78B00F77EA2 /* jccoefct.c */; }; + 00B7E0D90EDCA78B00F77EA2 /* jccolor.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08C0EDCA78B00F77EA2 /* jccolor.c */; }; + 00B7E0DA0EDCA78B00F77EA2 /* jcdctmgr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08D0EDCA78B00F77EA2 /* jcdctmgr.c */; }; + 00B7E0DB0EDCA78B00F77EA2 /* jchuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E08E0EDCA78B00F77EA2 /* jchuff.c */; }; + 00B7E0DD0EDCA78B00F77EA2 /* jcinit.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0900EDCA78B00F77EA2 /* jcinit.c */; }; + 00B7E0DE0EDCA78B00F77EA2 /* jcmainct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0910EDCA78B00F77EA2 /* jcmainct.c */; }; + 00B7E0DF0EDCA78B00F77EA2 /* jcmarker.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0920EDCA78B00F77EA2 /* jcmarker.c */; }; + 00B7E0E00EDCA78B00F77EA2 /* jcmaster.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0930EDCA78B00F77EA2 /* jcmaster.c */; }; + 00B7E0E10EDCA78B00F77EA2 /* jcomapi.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0940EDCA78B00F77EA2 /* jcomapi.c */; }; + 00B7E0E30EDCA78B00F77EA2 /* jcparam.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A20EDCA78B00F77EA2 /* jcparam.c */; }; + 00B7E0E40EDCA78B00F77EA2 /* jcphuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A30EDCA78B00F77EA2 /* jcphuff.c */; }; + 00B7E0E50EDCA78B00F77EA2 /* jcprepct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A40EDCA78B00F77EA2 /* jcprepct.c */; }; + 00B7E0E60EDCA78B00F77EA2 /* jcsample.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A50EDCA78B00F77EA2 /* jcsample.c */; }; + 00B7E0E70EDCA78B00F77EA2 /* jctrans.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A60EDCA78B00F77EA2 /* jctrans.c */; }; + 00B7E0E80EDCA78B00F77EA2 /* jdapimin.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A70EDCA78B00F77EA2 /* jdapimin.c */; }; + 00B7E0E90EDCA78B00F77EA2 /* jdapistd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A80EDCA78B00F77EA2 /* jdapistd.c */; }; + 00B7E0EA0EDCA78B00F77EA2 /* jdatadst.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0A90EDCA78B00F77EA2 /* jdatadst.c */; }; + 00B7E0EB0EDCA78B00F77EA2 /* jdatasrc.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AA0EDCA78B00F77EA2 /* jdatasrc.c */; }; + 00B7E0EC0EDCA78B00F77EA2 /* jdcoefct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AB0EDCA78B00F77EA2 /* jdcoefct.c */; }; + 00B7E0ED0EDCA78B00F77EA2 /* jdcolor.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AC0EDCA78B00F77EA2 /* jdcolor.c */; }; + 00B7E0EF0EDCA78B00F77EA2 /* jddctmgr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AE0EDCA78B00F77EA2 /* jddctmgr.c */; }; + 00B7E0F00EDCA78B00F77EA2 /* jdhuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0AF0EDCA78B00F77EA2 /* jdhuff.c */; }; + 00B7E0F20EDCA78B00F77EA2 /* jdinput.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B10EDCA78B00F77EA2 /* jdinput.c */; }; + 00B7E0F30EDCA78B00F77EA2 /* jdmainct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B20EDCA78B00F77EA2 /* jdmainct.c */; }; + 00B7E0F40EDCA78B00F77EA2 /* jdmarker.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B30EDCA78B00F77EA2 /* jdmarker.c */; }; + 00B7E0F50EDCA78B00F77EA2 /* jdmaster.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B40EDCA78B00F77EA2 /* jdmaster.c */; }; + 00B7E0F60EDCA78B00F77EA2 /* jdmerge.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B50EDCA78B00F77EA2 /* jdmerge.c */; }; + 00B7E0F70EDCA78B00F77EA2 /* jdphuff.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B60EDCA78B00F77EA2 /* jdphuff.c */; }; + 00B7E0F80EDCA78B00F77EA2 /* jdpostct.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B70EDCA78B00F77EA2 /* jdpostct.c */; }; + 00B7E0F90EDCA78B00F77EA2 /* jdsample.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B80EDCA78B00F77EA2 /* jdsample.c */; }; + 00B7E0FA0EDCA78B00F77EA2 /* jdtrans.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0B90EDCA78B00F77EA2 /* jdtrans.c */; }; + 00B7E0FB0EDCA78B00F77EA2 /* jerror.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BA0EDCA78B00F77EA2 /* jerror.c */; }; + 00B7E0FD0EDCA78B00F77EA2 /* jfdctflt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BC0EDCA78B00F77EA2 /* jfdctflt.c */; }; + 00B7E0FE0EDCA78B00F77EA2 /* jfdctfst.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BD0EDCA78B00F77EA2 /* jfdctfst.c */; }; + 00B7E0FF0EDCA78B00F77EA2 /* jfdctint.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BE0EDCA78B00F77EA2 /* jfdctint.c */; }; + 00B7E1000EDCA78B00F77EA2 /* jidctflt.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0BF0EDCA78B00F77EA2 /* jidctflt.c */; }; + 00B7E1010EDCA78B00F77EA2 /* jidctfst.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C00EDCA78B00F77EA2 /* jidctfst.c */; }; + 00B7E1030EDCA78B00F77EA2 /* jidctint.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C20EDCA78B00F77EA2 /* jidctint.c */; }; + 00B7E1040EDCA78B00F77EA2 /* jidctred.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C30EDCA78B00F77EA2 /* jidctred.c */; }; + 00B7E1070EDCA78B00F77EA2 /* jmemansi.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0C60EDCA78B00F77EA2 /* jmemansi.c */; }; + 00B7E10B0EDCA78B00F77EA2 /* jmemmgr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0CA0EDCA78B00F77EA2 /* jmemmgr.c */; }; + 00B7E1130EDCA78B00F77EA2 /* jquant1.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0D30EDCA78B00F77EA2 /* jquant1.c */; }; + 00B7E1140EDCA78B00F77EA2 /* jquant2.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0D40EDCA78B00F77EA2 /* jquant2.c */; }; + 00B7E1150EDCA78B00F77EA2 /* jutils.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E0D50EDCA78B00F77EA2 /* jutils.c */; }; + 00B7E11C0EDCA84F00F77EA2 /* jchuff.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1180EDCA84F00F77EA2 /* jchuff.h */; }; + 00B7E11D0EDCA84F00F77EA2 /* jconfig.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1190EDCA84F00F77EA2 /* jconfig.h */; }; + 00B7E11E0EDCA84F00F77EA2 /* jerror.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E11A0EDCA84F00F77EA2 /* jerror.h */; }; + 00B7E11F0EDCA84F00F77EA2 /* jpeglib.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E11B0EDCA84F00F77EA2 /* jpeglib.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7E07E0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libjpeg.cpp; path = ../libsgl/images/SkImageDecoder_libjpeg.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E0890EDCA78B00F77EA2 /* jcapimin.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcapimin.c; path = ../../jpeg/jcapimin.c; sourceTree = SOURCE_ROOT; }; + 00B7E08A0EDCA78B00F77EA2 /* jcapistd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcapistd.c; path = ../../jpeg/jcapistd.c; sourceTree = SOURCE_ROOT; }; + 00B7E08B0EDCA78B00F77EA2 /* jccoefct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jccoefct.c; path = ../../jpeg/jccoefct.c; sourceTree = SOURCE_ROOT; }; + 00B7E08C0EDCA78B00F77EA2 /* jccolor.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jccolor.c; path = ../../jpeg/jccolor.c; sourceTree = SOURCE_ROOT; }; + 00B7E08D0EDCA78B00F77EA2 /* jcdctmgr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcdctmgr.c; path = ../../jpeg/jcdctmgr.c; sourceTree = SOURCE_ROOT; }; + 00B7E08E0EDCA78B00F77EA2 /* jchuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jchuff.c; path = ../../jpeg/jchuff.c; sourceTree = SOURCE_ROOT; }; + 00B7E0900EDCA78B00F77EA2 /* jcinit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcinit.c; path = ../../jpeg/jcinit.c; sourceTree = SOURCE_ROOT; }; + 00B7E0910EDCA78B00F77EA2 /* jcmainct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcmainct.c; path = ../../jpeg/jcmainct.c; sourceTree = SOURCE_ROOT; }; + 00B7E0920EDCA78B00F77EA2 /* jcmarker.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcmarker.c; path = ../../jpeg/jcmarker.c; sourceTree = SOURCE_ROOT; }; + 00B7E0930EDCA78B00F77EA2 /* jcmaster.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcmaster.c; path = ../../jpeg/jcmaster.c; sourceTree = SOURCE_ROOT; }; + 00B7E0940EDCA78B00F77EA2 /* jcomapi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcomapi.c; path = ../../jpeg/jcomapi.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A20EDCA78B00F77EA2 /* jcparam.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcparam.c; path = ../../jpeg/jcparam.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A30EDCA78B00F77EA2 /* jcphuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcphuff.c; path = ../../jpeg/jcphuff.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A40EDCA78B00F77EA2 /* jcprepct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcprepct.c; path = ../../jpeg/jcprepct.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A50EDCA78B00F77EA2 /* jcsample.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jcsample.c; path = ../../jpeg/jcsample.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A60EDCA78B00F77EA2 /* jctrans.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jctrans.c; path = ../../jpeg/jctrans.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A70EDCA78B00F77EA2 /* jdapimin.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdapimin.c; path = ../../jpeg/jdapimin.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A80EDCA78B00F77EA2 /* jdapistd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdapistd.c; path = ../../jpeg/jdapistd.c; sourceTree = SOURCE_ROOT; }; + 00B7E0A90EDCA78B00F77EA2 /* jdatadst.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdatadst.c; path = ../../jpeg/jdatadst.c; sourceTree = SOURCE_ROOT; }; + 00B7E0AA0EDCA78B00F77EA2 /* jdatasrc.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdatasrc.c; path = ../../jpeg/jdatasrc.c; sourceTree = SOURCE_ROOT; }; + 00B7E0AB0EDCA78B00F77EA2 /* jdcoefct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdcoefct.c; path = ../../jpeg/jdcoefct.c; sourceTree = SOURCE_ROOT; }; + 00B7E0AC0EDCA78B00F77EA2 /* jdcolor.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdcolor.c; path = ../../jpeg/jdcolor.c; sourceTree = SOURCE_ROOT; }; + 00B7E0AE0EDCA78B00F77EA2 /* jddctmgr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jddctmgr.c; path = ../../jpeg/jddctmgr.c; sourceTree = SOURCE_ROOT; }; + 00B7E0AF0EDCA78B00F77EA2 /* jdhuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdhuff.c; path = ../../jpeg/jdhuff.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B10EDCA78B00F77EA2 /* jdinput.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdinput.c; path = ../../jpeg/jdinput.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B20EDCA78B00F77EA2 /* jdmainct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmainct.c; path = ../../jpeg/jdmainct.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B30EDCA78B00F77EA2 /* jdmarker.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmarker.c; path = ../../jpeg/jdmarker.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B40EDCA78B00F77EA2 /* jdmaster.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmaster.c; path = ../../jpeg/jdmaster.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B50EDCA78B00F77EA2 /* jdmerge.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdmerge.c; path = ../../jpeg/jdmerge.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B60EDCA78B00F77EA2 /* jdphuff.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdphuff.c; path = ../../jpeg/jdphuff.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B70EDCA78B00F77EA2 /* jdpostct.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdpostct.c; path = ../../jpeg/jdpostct.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B80EDCA78B00F77EA2 /* jdsample.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdsample.c; path = ../../jpeg/jdsample.c; sourceTree = SOURCE_ROOT; }; + 00B7E0B90EDCA78B00F77EA2 /* jdtrans.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jdtrans.c; path = ../../jpeg/jdtrans.c; sourceTree = SOURCE_ROOT; }; + 00B7E0BA0EDCA78B00F77EA2 /* jerror.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jerror.c; path = ../../jpeg/jerror.c; sourceTree = SOURCE_ROOT; }; + 00B7E0BC0EDCA78B00F77EA2 /* jfdctflt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jfdctflt.c; path = ../../jpeg/jfdctflt.c; sourceTree = SOURCE_ROOT; }; + 00B7E0BD0EDCA78B00F77EA2 /* jfdctfst.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jfdctfst.c; path = ../../jpeg/jfdctfst.c; sourceTree = SOURCE_ROOT; }; + 00B7E0BE0EDCA78B00F77EA2 /* jfdctint.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jfdctint.c; path = ../../jpeg/jfdctint.c; sourceTree = SOURCE_ROOT; }; + 00B7E0BF0EDCA78B00F77EA2 /* jidctflt.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctflt.c; path = ../../jpeg/jidctflt.c; sourceTree = SOURCE_ROOT; }; + 00B7E0C00EDCA78B00F77EA2 /* jidctfst.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctfst.c; path = ../../jpeg/jidctfst.c; sourceTree = SOURCE_ROOT; }; + 00B7E0C20EDCA78B00F77EA2 /* jidctint.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctint.c; path = ../../jpeg/jidctint.c; sourceTree = SOURCE_ROOT; }; + 00B7E0C30EDCA78B00F77EA2 /* jidctred.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jidctred.c; path = ../../jpeg/jidctred.c; sourceTree = SOURCE_ROOT; }; + 00B7E0C60EDCA78B00F77EA2 /* jmemansi.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jmemansi.c; path = ../../jpeg/jmemansi.c; sourceTree = SOURCE_ROOT; }; + 00B7E0CA0EDCA78B00F77EA2 /* jmemmgr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jmemmgr.c; path = ../../jpeg/jmemmgr.c; sourceTree = SOURCE_ROOT; }; + 00B7E0D30EDCA78B00F77EA2 /* jquant1.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jquant1.c; path = ../../jpeg/jquant1.c; sourceTree = SOURCE_ROOT; }; + 00B7E0D40EDCA78B00F77EA2 /* jquant2.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jquant2.c; path = ../../jpeg/jquant2.c; sourceTree = SOURCE_ROOT; }; + 00B7E0D50EDCA78B00F77EA2 /* jutils.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = jutils.c; path = ../../jpeg/jutils.c; sourceTree = SOURCE_ROOT; }; + 00B7E1180EDCA84F00F77EA2 /* jchuff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jchuff.h; path = ../../jpeg/jchuff.h; sourceTree = SOURCE_ROOT; }; + 00B7E1190EDCA84F00F77EA2 /* jconfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jconfig.h; path = ../../jpeg/jconfig.h; sourceTree = SOURCE_ROOT; }; + 00B7E11A0EDCA84F00F77EA2 /* jerror.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jerror.h; path = ../../jpeg/jerror.h; sourceTree = SOURCE_ROOT; }; + 00B7E11B0EDCA84F00F77EA2 /* jpeglib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = jpeglib.h; path = ../../jpeg/jpeglib.h; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libjpeg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libjpeg.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* jpeg */ = { + isa = PBXGroup; + children = ( + 00B7E07E0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp */, + FE08AA3E0945D5620057213F /* Include */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = jpeg; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7E0890EDCA78B00F77EA2 /* jcapimin.c */, + 00B7E08A0EDCA78B00F77EA2 /* jcapistd.c */, + 00B7E08B0EDCA78B00F77EA2 /* jccoefct.c */, + 00B7E08C0EDCA78B00F77EA2 /* jccolor.c */, + 00B7E08D0EDCA78B00F77EA2 /* jcdctmgr.c */, + 00B7E08E0EDCA78B00F77EA2 /* jchuff.c */, + 00B7E0900EDCA78B00F77EA2 /* jcinit.c */, + 00B7E0910EDCA78B00F77EA2 /* jcmainct.c */, + 00B7E0920EDCA78B00F77EA2 /* jcmarker.c */, + 00B7E0930EDCA78B00F77EA2 /* jcmaster.c */, + 00B7E0940EDCA78B00F77EA2 /* jcomapi.c */, + 00B7E0A20EDCA78B00F77EA2 /* jcparam.c */, + 00B7E0A30EDCA78B00F77EA2 /* jcphuff.c */, + 00B7E0A40EDCA78B00F77EA2 /* jcprepct.c */, + 00B7E0A50EDCA78B00F77EA2 /* jcsample.c */, + 00B7E0A60EDCA78B00F77EA2 /* jctrans.c */, + 00B7E0A70EDCA78B00F77EA2 /* jdapimin.c */, + 00B7E0A80EDCA78B00F77EA2 /* jdapistd.c */, + 00B7E0A90EDCA78B00F77EA2 /* jdatadst.c */, + 00B7E0AA0EDCA78B00F77EA2 /* jdatasrc.c */, + 00B7E0AB0EDCA78B00F77EA2 /* jdcoefct.c */, + 00B7E0AC0EDCA78B00F77EA2 /* jdcolor.c */, + 00B7E0AE0EDCA78B00F77EA2 /* jddctmgr.c */, + 00B7E0AF0EDCA78B00F77EA2 /* jdhuff.c */, + 00B7E0B10EDCA78B00F77EA2 /* jdinput.c */, + 00B7E0B20EDCA78B00F77EA2 /* jdmainct.c */, + 00B7E0B30EDCA78B00F77EA2 /* jdmarker.c */, + 00B7E0B40EDCA78B00F77EA2 /* jdmaster.c */, + 00B7E0B50EDCA78B00F77EA2 /* jdmerge.c */, + 00B7E0B60EDCA78B00F77EA2 /* jdphuff.c */, + 00B7E0B70EDCA78B00F77EA2 /* jdpostct.c */, + 00B7E0B80EDCA78B00F77EA2 /* jdsample.c */, + 00B7E0B90EDCA78B00F77EA2 /* jdtrans.c */, + 00B7E0BA0EDCA78B00F77EA2 /* jerror.c */, + 00B7E0BC0EDCA78B00F77EA2 /* jfdctflt.c */, + 00B7E0BD0EDCA78B00F77EA2 /* jfdctfst.c */, + 00B7E0BE0EDCA78B00F77EA2 /* jfdctint.c */, + 00B7E0BF0EDCA78B00F77EA2 /* jidctflt.c */, + 00B7E0C00EDCA78B00F77EA2 /* jidctfst.c */, + 00B7E0C20EDCA78B00F77EA2 /* jidctint.c */, + 00B7E0C30EDCA78B00F77EA2 /* jidctred.c */, + 00B7E0C60EDCA78B00F77EA2 /* jmemansi.c */, + 00B7E0CA0EDCA78B00F77EA2 /* jmemmgr.c */, + 00B7E0D30EDCA78B00F77EA2 /* jquant1.c */, + 00B7E0D40EDCA78B00F77EA2 /* jquant2.c */, + 00B7E0D50EDCA78B00F77EA2 /* jutils.c */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libjpeg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; + FE08AA3E0945D5620057213F /* Include */ = { + isa = PBXGroup; + children = ( + 00B7E1180EDCA84F00F77EA2 /* jchuff.h */, + 00B7E1190EDCA84F00F77EA2 /* jconfig.h */, + 00B7E11A0EDCA84F00F77EA2 /* jerror.h */, + 00B7E11B0EDCA84F00F77EA2 /* jpeglib.h */, + ); + name = Include; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E11C0EDCA84F00F77EA2 /* jchuff.h in Headers */, + 00B7E11D0EDCA84F00F77EA2 /* jconfig.h in Headers */, + 00B7E11E0EDCA84F00F77EA2 /* jerror.h in Headers */, + 00B7E11F0EDCA84F00F77EA2 /* jpeglib.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* jpeg */ = { + isa = PBXNativeTarget; + buildConfigurationList = FE5F48080947840B0095980F /* Build configuration list for PBXNativeTarget "jpeg" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = jpeg; + productName = jpeg; + productReference = D2AAC046055464E500DB518D /* libjpeg.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = FE5F480C0947840B0095980F /* Build configuration list for PBXProject "jpeg" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* jpeg */; + projectDirPath = ""; + projectRoot = ../..; + targets = ( + D2AAC045055464E500DB518D /* jpeg */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E07F0EDCA73700F77EA2 /* SkImageDecoder_libjpeg.cpp in Sources */, + 00B7E0D60EDCA78B00F77EA2 /* jcapimin.c in Sources */, + 00B7E0D70EDCA78B00F77EA2 /* jcapistd.c in Sources */, + 00B7E0D80EDCA78B00F77EA2 /* jccoefct.c in Sources */, + 00B7E0D90EDCA78B00F77EA2 /* jccolor.c in Sources */, + 00B7E0DA0EDCA78B00F77EA2 /* jcdctmgr.c in Sources */, + 00B7E0DB0EDCA78B00F77EA2 /* jchuff.c in Sources */, + 00B7E0DD0EDCA78B00F77EA2 /* jcinit.c in Sources */, + 00B7E0DE0EDCA78B00F77EA2 /* jcmainct.c in Sources */, + 00B7E0DF0EDCA78B00F77EA2 /* jcmarker.c in Sources */, + 00B7E0E00EDCA78B00F77EA2 /* jcmaster.c in Sources */, + 00B7E0E10EDCA78B00F77EA2 /* jcomapi.c in Sources */, + 00B7E0E30EDCA78B00F77EA2 /* jcparam.c in Sources */, + 00B7E0E40EDCA78B00F77EA2 /* jcphuff.c in Sources */, + 00B7E0E50EDCA78B00F77EA2 /* jcprepct.c in Sources */, + 00B7E0E60EDCA78B00F77EA2 /* jcsample.c in Sources */, + 00B7E0E70EDCA78B00F77EA2 /* jctrans.c in Sources */, + 00B7E0E80EDCA78B00F77EA2 /* jdapimin.c in Sources */, + 00B7E0E90EDCA78B00F77EA2 /* jdapistd.c in Sources */, + 00B7E0EA0EDCA78B00F77EA2 /* jdatadst.c in Sources */, + 00B7E0EB0EDCA78B00F77EA2 /* jdatasrc.c in Sources */, + 00B7E0EC0EDCA78B00F77EA2 /* jdcoefct.c in Sources */, + 00B7E0ED0EDCA78B00F77EA2 /* jdcolor.c in Sources */, + 00B7E0EF0EDCA78B00F77EA2 /* jddctmgr.c in Sources */, + 00B7E0F00EDCA78B00F77EA2 /* jdhuff.c in Sources */, + 00B7E0F20EDCA78B00F77EA2 /* jdinput.c in Sources */, + 00B7E0F30EDCA78B00F77EA2 /* jdmainct.c in Sources */, + 00B7E0F40EDCA78B00F77EA2 /* jdmarker.c in Sources */, + 00B7E0F50EDCA78B00F77EA2 /* jdmaster.c in Sources */, + 00B7E0F60EDCA78B00F77EA2 /* jdmerge.c in Sources */, + 00B7E0F70EDCA78B00F77EA2 /* jdphuff.c in Sources */, + 00B7E0F80EDCA78B00F77EA2 /* jdpostct.c in Sources */, + 00B7E0F90EDCA78B00F77EA2 /* jdsample.c in Sources */, + 00B7E0FA0EDCA78B00F77EA2 /* jdtrans.c in Sources */, + 00B7E0FB0EDCA78B00F77EA2 /* jerror.c in Sources */, + 00B7E0FD0EDCA78B00F77EA2 /* jfdctflt.c in Sources */, + 00B7E0FE0EDCA78B00F77EA2 /* jfdctfst.c in Sources */, + 00B7E0FF0EDCA78B00F77EA2 /* jfdctint.c in Sources */, + 00B7E1000EDCA78B00F77EA2 /* jidctflt.c in Sources */, + 00B7E1010EDCA78B00F77EA2 /* jidctfst.c in Sources */, + 00B7E1030EDCA78B00F77EA2 /* jidctint.c in Sources */, + 00B7E1040EDCA78B00F77EA2 /* jidctred.c in Sources */, + 00B7E1070EDCA78B00F77EA2 /* jmemansi.c in Sources */, + 00B7E10B0EDCA78B00F77EA2 /* jmemmgr.c in Sources */, + 00B7E1130EDCA78B00F77EA2 /* jquant1.c in Sources */, + 00B7E1140EDCA78B00F77EA2 /* jquant2.c in Sources */, + 00B7E1150EDCA78B00F77EA2 /* jutils.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + FE5F48090947840B0095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = jpeg; + PUBLIC_HEADERS_FOLDER_PATH = ""; + REZ_PREPROCESSOR_DEFINITIONS = "_LIB SK_FORCE_SCALARFIXED"; + ZERO_LINK = YES; + }; + name = Debug; + }; + FE5F480A0947840B0095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = jpeg; + ZERO_LINK = NO; + }; + name = Release; + }; + FE5F480D0947840B0095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_DEBUG, + SK_BUILD_FOR_MAC, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Debug; + }; + FE5F480E0947840B0095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_RELEASE, + SK_BUILD_FOR_MAC, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + FE5F48080947840B0095980F /* Build configuration list for PBXNativeTarget "jpeg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F48090947840B0095980F /* Debug */, + FE5F480A0947840B0095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + FE5F480C0947840B0095980F /* Build configuration list for PBXProject "jpeg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F480D0947840B0095980F /* Debug */, + FE5F480E0947840B0095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/libpng.xcodeproj/project.pbxproj b/xcode/libpng.xcodeproj/project.pbxproj new file mode 100644 index 0000000..7e12316 --- /dev/null +++ b/xcode/libpng.xcodeproj/project.pbxproj @@ -0,0 +1,306 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7E1390EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1380EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp */; }; + 00B7E14B0EDCA98D00F77EA2 /* png.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13A0EDCA98D00F77EA2 /* png.c */; }; + 00B7E14C0EDCA98D00F77EA2 /* pngerror.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13B0EDCA98D00F77EA2 /* pngerror.c */; }; + 00B7E14D0EDCA98D00F77EA2 /* pnggccrd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13C0EDCA98D00F77EA2 /* pnggccrd.c */; }; + 00B7E14E0EDCA98D00F77EA2 /* pngget.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13D0EDCA98D00F77EA2 /* pngget.c */; }; + 00B7E14F0EDCA98D00F77EA2 /* pngmem.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13E0EDCA98D00F77EA2 /* pngmem.c */; }; + 00B7E1500EDCA98D00F77EA2 /* pngpread.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E13F0EDCA98D00F77EA2 /* pngpread.c */; }; + 00B7E1510EDCA98D00F77EA2 /* pngread.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1400EDCA98D00F77EA2 /* pngread.c */; }; + 00B7E1520EDCA98D00F77EA2 /* pngrio.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1410EDCA98D00F77EA2 /* pngrio.c */; }; + 00B7E1530EDCA98D00F77EA2 /* pngrtran.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1420EDCA98D00F77EA2 /* pngrtran.c */; }; + 00B7E1540EDCA98D00F77EA2 /* pngrutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1430EDCA98D00F77EA2 /* pngrutil.c */; }; + 00B7E1550EDCA98D00F77EA2 /* pngset.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1440EDCA98D00F77EA2 /* pngset.c */; }; + 00B7E1560EDCA98D00F77EA2 /* pngtrans.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1450EDCA98D00F77EA2 /* pngtrans.c */; }; + 00B7E1570EDCA98D00F77EA2 /* pngvcrd.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1460EDCA98D00F77EA2 /* pngvcrd.c */; }; + 00B7E1580EDCA98D00F77EA2 /* pngwio.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1470EDCA98D00F77EA2 /* pngwio.c */; }; + 00B7E1590EDCA98D00F77EA2 /* pngwrite.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1480EDCA98D00F77EA2 /* pngwrite.c */; }; + 00B7E15A0EDCA98D00F77EA2 /* pngwtran.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1490EDCA98D00F77EA2 /* pngwtran.c */; }; + 00B7E15B0EDCA98D00F77EA2 /* pngwutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E14A0EDCA98D00F77EA2 /* pngwutil.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7E1380EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libpng.cpp; path = ../libsgl/images/SkImageDecoder_libpng.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E13A0EDCA98D00F77EA2 /* png.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = png.c; path = ../../libpng/png.c; sourceTree = SOURCE_ROOT; }; + 00B7E13B0EDCA98D00F77EA2 /* pngerror.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngerror.c; path = ../../libpng/pngerror.c; sourceTree = SOURCE_ROOT; }; + 00B7E13C0EDCA98D00F77EA2 /* pnggccrd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pnggccrd.c; path = ../../libpng/pnggccrd.c; sourceTree = SOURCE_ROOT; }; + 00B7E13D0EDCA98D00F77EA2 /* pngget.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngget.c; path = ../../libpng/pngget.c; sourceTree = SOURCE_ROOT; }; + 00B7E13E0EDCA98D00F77EA2 /* pngmem.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngmem.c; path = ../../libpng/pngmem.c; sourceTree = SOURCE_ROOT; }; + 00B7E13F0EDCA98D00F77EA2 /* pngpread.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngpread.c; path = ../../libpng/pngpread.c; sourceTree = SOURCE_ROOT; }; + 00B7E1400EDCA98D00F77EA2 /* pngread.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngread.c; path = ../../libpng/pngread.c; sourceTree = SOURCE_ROOT; }; + 00B7E1410EDCA98D00F77EA2 /* pngrio.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngrio.c; path = ../../libpng/pngrio.c; sourceTree = SOURCE_ROOT; }; + 00B7E1420EDCA98D00F77EA2 /* pngrtran.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngrtran.c; path = ../../libpng/pngrtran.c; sourceTree = SOURCE_ROOT; }; + 00B7E1430EDCA98D00F77EA2 /* pngrutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngrutil.c; path = ../../libpng/pngrutil.c; sourceTree = SOURCE_ROOT; }; + 00B7E1440EDCA98D00F77EA2 /* pngset.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngset.c; path = ../../libpng/pngset.c; sourceTree = SOURCE_ROOT; }; + 00B7E1450EDCA98D00F77EA2 /* pngtrans.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngtrans.c; path = ../../libpng/pngtrans.c; sourceTree = SOURCE_ROOT; }; + 00B7E1460EDCA98D00F77EA2 /* pngvcrd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngvcrd.c; path = ../../libpng/pngvcrd.c; sourceTree = SOURCE_ROOT; }; + 00B7E1470EDCA98D00F77EA2 /* pngwio.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwio.c; path = ../../libpng/pngwio.c; sourceTree = SOURCE_ROOT; }; + 00B7E1480EDCA98D00F77EA2 /* pngwrite.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwrite.c; path = ../../libpng/pngwrite.c; sourceTree = SOURCE_ROOT; }; + 00B7E1490EDCA98D00F77EA2 /* pngwtran.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwtran.c; path = ../../libpng/pngwtran.c; sourceTree = SOURCE_ROOT; }; + 00B7E14A0EDCA98D00F77EA2 /* pngwutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = pngwutil.c; path = ../../libpng/pngwutil.c; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* liblibpng.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = liblibpng.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* libpng */ = { + isa = PBXGroup; + children = ( + 00B7E1380EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = libpng; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7E13A0EDCA98D00F77EA2 /* png.c */, + 00B7E13B0EDCA98D00F77EA2 /* pngerror.c */, + 00B7E13C0EDCA98D00F77EA2 /* pnggccrd.c */, + 00B7E13D0EDCA98D00F77EA2 /* pngget.c */, + 00B7E13E0EDCA98D00F77EA2 /* pngmem.c */, + 00B7E13F0EDCA98D00F77EA2 /* pngpread.c */, + 00B7E1400EDCA98D00F77EA2 /* pngread.c */, + 00B7E1410EDCA98D00F77EA2 /* pngrio.c */, + 00B7E1420EDCA98D00F77EA2 /* pngrtran.c */, + 00B7E1430EDCA98D00F77EA2 /* pngrutil.c */, + 00B7E1440EDCA98D00F77EA2 /* pngset.c */, + 00B7E1450EDCA98D00F77EA2 /* pngtrans.c */, + 00B7E1460EDCA98D00F77EA2 /* pngvcrd.c */, + 00B7E1470EDCA98D00F77EA2 /* pngwio.c */, + 00B7E1480EDCA98D00F77EA2 /* pngwrite.c */, + 00B7E1490EDCA98D00F77EA2 /* pngwtran.c */, + 00B7E14A0EDCA98D00F77EA2 /* pngwutil.c */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* liblibpng.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* libpng */ = { + isa = PBXNativeTarget; + buildConfigurationList = FE5F4815094784400095980F /* Build configuration list for PBXNativeTarget "libpng" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = libpng; + productName = libpng; + productReference = D2AAC046055464E500DB518D /* liblibpng.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = FE5F4819094784400095980F /* Build configuration list for PBXProject "libpng" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* libpng */; + projectDirPath = ""; + projectRoot = ../..; + targets = ( + D2AAC045055464E500DB518D /* libpng */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E1390EDCA95200F77EA2 /* SkImageDecoder_libpng.cpp in Sources */, + 00B7E14B0EDCA98D00F77EA2 /* png.c in Sources */, + 00B7E14C0EDCA98D00F77EA2 /* pngerror.c in Sources */, + 00B7E14D0EDCA98D00F77EA2 /* pnggccrd.c in Sources */, + 00B7E14E0EDCA98D00F77EA2 /* pngget.c in Sources */, + 00B7E14F0EDCA98D00F77EA2 /* pngmem.c in Sources */, + 00B7E1500EDCA98D00F77EA2 /* pngpread.c in Sources */, + 00B7E1510EDCA98D00F77EA2 /* pngread.c in Sources */, + 00B7E1520EDCA98D00F77EA2 /* pngrio.c in Sources */, + 00B7E1530EDCA98D00F77EA2 /* pngrtran.c in Sources */, + 00B7E1540EDCA98D00F77EA2 /* pngrutil.c in Sources */, + 00B7E1550EDCA98D00F77EA2 /* pngset.c in Sources */, + 00B7E1560EDCA98D00F77EA2 /* pngtrans.c in Sources */, + 00B7E1570EDCA98D00F77EA2 /* pngvcrd.c in Sources */, + 00B7E1580EDCA98D00F77EA2 /* pngwio.c in Sources */, + 00B7E1590EDCA98D00F77EA2 /* pngwrite.c in Sources */, + 00B7E15A0EDCA98D00F77EA2 /* pngwtran.c in Sources */, + 00B7E15B0EDCA98D00F77EA2 /* pngwutil.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + FE5F4816094784400095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = ( + ../../include/graphics, + ../../extlibs/png, + ../../extlibs/zlib, + ); + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = libpng; + REZ_PREPROCESSOR_DEFINITIONS = "_LIB PNG_USER_CONFIG SK_FORCE_SCALARFIXED"; + ZERO_LINK = YES; + }; + name = Debug; + }; + FE5F4817094784400095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = libpng; + ZERO_LINK = NO; + }; + name = Release; + }; + FE5F481A094784400095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_DEBUG, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Debug; + }; + FE5F481B094784400095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + FE5F4815094784400095980F /* Build configuration list for PBXNativeTarget "libpng" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F4816094784400095980F /* Debug */, + FE5F4817094784400095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + FE5F4819094784400095980F /* Build configuration list for PBXProject "libpng" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F481A094784400095980F /* Debug */, + FE5F481B094784400095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/ports-mac.xcodeproj/project.pbxproj b/xcode/ports-mac.xcodeproj/project.pbxproj new file mode 100644 index 0000000..e4aba44 --- /dev/null +++ b/xcode/ports-mac.xcodeproj/project.pbxproj @@ -0,0 +1,248 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7E16C0EDCA9EA00F77EA2 /* SkThread_pthread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E16A0EDCA9EA00F77EA2 /* SkThread_pthread.cpp */; }; + 00B7E16D0EDCA9EA00F77EA2 /* SkTime_Unix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E16B0EDCA9EA00F77EA2 /* SkTime_Unix.cpp */; }; + 00B7E16F0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E16E0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp */; }; + FE33C956094E031400C4A640 /* SkBitmap_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE33C954094E031400C4A640 /* SkBitmap_Mac.cpp */; }; + FE33C957094E031400C4A640 /* SkOSWindow_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE33C955094E031400C4A640 /* SkOSWindow_Mac.cpp */; }; + FE33C959094E041D00C4A640 /* skia_mac.cp in Sources */ = {isa = PBXBuildFile; fileRef = FE33C958094E041D00C4A640 /* skia_mac.cp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7E16A0EDCA9EA00F77EA2 /* SkThread_pthread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkThread_pthread.cpp; path = ../libsgl/ports/SkThread_pthread.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E16B0EDCA9EA00F77EA2 /* SkTime_Unix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTime_Unix.cpp; path = ../libsgl/ports/SkTime_Unix.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E16E0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_wbmp.cpp; path = ../libsgl/images/SkImageDecoder_wbmp.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libports-mac.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libports-mac.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + FE33C954094E031400C4A640 /* SkBitmap_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_Mac.cpp; path = ports/SkBitmap_Mac.cpp; sourceTree = "<group>"; }; + FE33C955094E031400C4A640 /* SkOSWindow_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSWindow_Mac.cpp; path = ports/SkOSWindow_Mac.cpp; sourceTree = "<group>"; }; + FE33C958094E041D00C4A640 /* skia_mac.cp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = skia_mac.cp; path = ports/skia_mac.cp; sourceTree = "<group>"; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* ports-mac */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = "ports-mac"; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7E16E0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp */, + 00B7E16A0EDCA9EA00F77EA2 /* SkThread_pthread.cpp */, + 00B7E16B0EDCA9EA00F77EA2 /* SkTime_Unix.cpp */, + FE33C958094E041D00C4A640 /* skia_mac.cp */, + FE33C954094E031400C4A640 /* SkBitmap_Mac.cpp */, + FE33C955094E031400C4A640 /* SkOSWindow_Mac.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libports-mac.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* ports-mac */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports-mac" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = "ports-mac"; + productName = "ports-mac"; + productReference = D2AAC046055464E500DB518D /* libports-mac.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports-mac" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* ports-mac */; + projectDirPath = ""; + projectRoot = ..; + targets = ( + D2AAC045055464E500DB518D /* ports-mac */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + FE33C956094E031400C4A640 /* SkBitmap_Mac.cpp in Sources */, + FE33C957094E031400C4A640 /* SkOSWindow_Mac.cpp in Sources */, + FE33C959094E041D00C4A640 /* skia_mac.cp in Sources */, + 00B7E16C0EDCA9EA00F77EA2 /* SkThread_pthread.cpp in Sources */, + 00B7E16D0EDCA9EA00F77EA2 /* SkTime_Unix.cpp in Sources */, + 00B7E16F0EDCA9FA00F77EA2 /* SkImageDecoder_wbmp.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = "ports-mac"; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = "ports-mac"; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports-mac" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports-mac" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/ports.xcodeproj/project.pbxproj b/xcode/ports.xcodeproj/project.pbxproj new file mode 100644 index 0000000..7d22634 --- /dev/null +++ b/xcode/ports.xcodeproj/project.pbxproj @@ -0,0 +1,251 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7E18F0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E18D0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp */; }; + 00B7E1900EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E18E0EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp */; }; + 00B7E1950EDCAA9300F77EA2 /* SkFontHost_android.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1910EDCAA9300F77EA2 /* SkFontHost_android.cpp */; }; + 00B7E1960EDCAA9300F77EA2 /* SkGlobals_global.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1920EDCAA9300F77EA2 /* SkGlobals_global.cpp */; }; + 00B7E1970EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1930EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp */; }; + 00B7E1980EDCAA9300F77EA2 /* SkOSFile_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1940EDCAA9300F77EA2 /* SkOSFile_stdio.cpp */; }; + 00B7E19A0EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1990EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp */; }; + 00B7E3610EDCB05400F77EA2 /* SkFontHost_gamma.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E3600EDCB05400F77EA2 /* SkFontHost_gamma.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7E18D0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = bmpdecoderhelper.cpp; path = ../libsgl/images/bmpdecoderhelper.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E18E0EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libbmp.cpp; path = ../libsgl/images/SkImageDecoder_libbmp.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1910EDCAA9300F77EA2 /* SkFontHost_android.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_android.cpp; path = ../libsgl/ports/SkFontHost_android.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1920EDCAA9300F77EA2 /* SkGlobals_global.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals_global.cpp; path = ../libsgl/ports/SkGlobals_global.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1930EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_Factory.cpp; path = ../libsgl/ports/SkImageDecoder_Factory.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1940EDCAA9300F77EA2 /* SkOSFile_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile_stdio.cpp; path = ../libsgl/ports/SkOSFile_stdio.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1990EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libico.cpp; path = ../libsgl/images/SkImageDecoder_libico.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E3600EDCB05400F77EA2 /* SkFontHost_gamma.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_gamma.cpp; path = ../libsgl/ports/SkFontHost_gamma.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libports.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libports.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* ports */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = ports; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7E3600EDCB05400F77EA2 /* SkFontHost_gamma.cpp */, + 00B7E1990EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp */, + 00B7E1910EDCAA9300F77EA2 /* SkFontHost_android.cpp */, + 00B7E1920EDCAA9300F77EA2 /* SkGlobals_global.cpp */, + 00B7E1930EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp */, + 00B7E1940EDCAA9300F77EA2 /* SkOSFile_stdio.cpp */, + 00B7E18D0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp */, + 00B7E18E0EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libports.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* ports */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = ports; + productName = ports; + productReference = D2AAC046055464E500DB518D /* libports.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* ports */; + projectDirPath = ""; + projectRoot = ../..; + targets = ( + D2AAC045055464E500DB518D /* ports */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E18F0EDCAA5900F77EA2 /* bmpdecoderhelper.cpp in Sources */, + 00B7E1900EDCAA5900F77EA2 /* SkImageDecoder_libbmp.cpp in Sources */, + 00B7E1950EDCAA9300F77EA2 /* SkFontHost_android.cpp in Sources */, + 00B7E1960EDCAA9300F77EA2 /* SkGlobals_global.cpp in Sources */, + 00B7E1970EDCAA9300F77EA2 /* SkImageDecoder_Factory.cpp in Sources */, + 00B7E1980EDCAA9300F77EA2 /* SkOSFile_stdio.cpp in Sources */, + 00B7E19A0EDCAAA100F77EA2 /* SkImageDecoder_libico.cpp in Sources */, + 00B7E3610EDCB05400F77EA2 /* SkFontHost_gamma.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = ports; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = ports; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_BUILD_FOR_MAC; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_RELEASE, + ); + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "ports" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "ports" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/ports/SkBitmap_Mac.cpp b/xcode/ports/SkBitmap_Mac.cpp new file mode 100644 index 0000000..06c2b27 --- /dev/null +++ b/xcode/ports/SkBitmap_Mac.cpp @@ -0,0 +1,142 @@ +#include "SkBitmap.h" +#include "SkColorPriv.h" +#include "SkMath.h" + +#if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS) + +#include <ApplicationServices/ApplicationServices.h> + +#ifndef __ppc__ + #define SWAP_16BIT +#endif + +static void convertGL32_to_Mac32(uint32_t dst[], const SkBitmap& bm) { + memcpy(dst, bm.getPixels(), bm.getSize()); + return; + + uint32_t* stop = dst + (bm.getSize() >> 2); + const uint8_t* src = (const uint8_t*)bm.getPixels(); + while (dst < stop) { + *dst++ = src[2] << 24 | src[1] << 16 | src[0] << 8 | src[3] << 0; + src += sizeof(uint32_t); + } +} + +static void convert565_to_32(uint32_t dst[], const SkBitmap& bm) { + for (int y = 0; y < bm.height(); y++) { + const uint16_t* src = bm.getAddr16(0, y); + const uint16_t* stop = src + bm.width(); + while (src < stop) { + unsigned c = *src++; + unsigned r = SkPacked16ToR32(c); + unsigned g = SkPacked16ToG32(c); + unsigned b = SkPacked16ToB32(c); + + *dst++ = (b << 24) | (g << 16) | (r << 8) | 0xFF; + } + } +} + +static void convert4444_to_555(uint16_t dst[], const uint16_t src[], int count) +{ + const uint16_t* stop = src + count; + + while (src < stop) + { + unsigned c = *src++; + + unsigned r = SkGetPackedR4444(c); + unsigned g = SkGetPackedG4444(c); + unsigned b = SkGetPackedB4444(c); + // convert to 5 bits + r = (r << 1) | (r >> 3); + g = (g << 1) | (g >> 3); + b = (b << 1) | (b >> 3); + // build the 555 + c = (r << 10) | (g << 5) | b; + +#ifdef SWAP_16BIT + c = (c >> 8) | (c << 8); +#endif + *dst++ = c; + } +} + +#include "SkTemplates.h" + +static CGImageRef bitmap2imageref(const SkBitmap& bm) { + size_t bitsPerComp; + size_t bitsPerPixel; + CGBitmapInfo info; + CGColorSpaceRef cs = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB); + CGDataProviderRef data = CGDataProviderCreateWithData(NULL, + bm.getPixels(), + bm.getSize(), + NULL); + SkAutoTCallVProc<CGDataProvider, CGDataProviderRelease> acp(data); + SkAutoTCallVProc<CGColorSpace, CGColorSpaceRelease> acp2(cs); + + switch (bm.config()) { + case SkBitmap::kARGB_8888_Config: + bitsPerComp = 8; + bitsPerPixel = 32; + info = kCGImageAlphaPremultipliedLast; + break; + case SkBitmap::kARGB_4444_Config: + bitsPerComp = 4; + bitsPerPixel = 16; + info = kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder16Little; + break; +#if 0 // not supported by quartz !!! + case SkBitmap::kRGB_565_Config: + bitsPerComp = 5; + bitsPerPixel = 16; + info = kCGImageAlphaNone | kCGBitmapByteOrder16Little; + break; +#endif + default: + return NULL; + } + + return CGImageCreate(bm.width(), bm.height(), bitsPerComp, bitsPerPixel, + bm.rowBytes(), cs, info, data, + NULL, false, kCGRenderingIntentDefault); +} + +void SkBitmap::drawToPort(WindowRef wind, CGContextRef cg) const { + if (fPixels == NULL || fWidth == 0 || fHeight == 0) { + return; + } + + bool useQD = false; + if (NULL == cg) { + SetPortWindowPort(wind); + QDBeginCGContext(GetWindowPort(wind), &cg); + useQD = true; + } + + SkBitmap bm; + if (this->config() == kRGB_565_Config) { + this->copyTo(&bm, kARGB_8888_Config); + } else { + bm = *this; + } + bm.lockPixels(); + + CGImageRef image = bitmap2imageref(bm); + if (image) { + CGRect rect; + rect.origin.x = rect.origin.y = 0; + rect.size.width = bm.width(); + rect.size.height = bm.height(); + + CGContextDrawImage(cg, rect, image); + CGImageRelease(image); + } + + if (useQD) { + QDEndCGContext(GetWindowPort(wind), &cg); + } +} + +#endif diff --git a/xcode/ports/SkOSWindow_Mac.cpp b/xcode/ports/SkOSWindow_Mac.cpp new file mode 100644 index 0000000..0937a11 --- /dev/null +++ b/xcode/ports/SkOSWindow_Mac.cpp @@ -0,0 +1,330 @@ +#include "SkTypes.h" + +#if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS) + +#include "SkWindow.h" +#include "SkCanvas.h" +#include "SkOSMenu.h" +#include "SkTime.h" + +#include "SkGraphics.h" +#include <new.h> + +static void (*gPrevNewHandler)(); + +extern "C" { + static void sk_new_handler() + { + if (SkGraphics::SetFontCacheUsed(0)) + return; + if (gPrevNewHandler) + gPrevNewHandler(); + else + sk_throw(); + } +} + +static SkOSWindow* gCurrOSWin; +static EventTargetRef gEventTarget; +static EventQueueRef gCurrEventQ; + +#define SK_MacEventClass FOUR_CHAR_CODE('SKec') +#define SK_MacEventKind FOUR_CHAR_CODE('SKek') +#define SK_MacEventParamName FOUR_CHAR_CODE('SKev') +#define SK_MacEventSinkIDParamName FOUR_CHAR_CODE('SKes') + +SkOSWindow::SkOSWindow(void* hWnd) : fHWND(hWnd) +{ + static const EventTypeSpec gTypes[] = { + { kEventClassKeyboard, kEventRawKeyDown }, + { kEventClassKeyboard, kEventRawKeyUp }, + { kEventClassMouse, kEventMouseDown }, + { kEventClassMouse, kEventMouseDragged }, + { kEventClassMouse, kEventMouseUp }, + { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }, + { kEventClassWindow, kEventWindowBoundsChanged }, + { kEventClassWindow, kEventWindowDrawContent }, + { SK_MacEventClass, SK_MacEventKind } + }; + + EventHandlerUPP handlerUPP = NewEventHandlerUPP(SkOSWindow::EventHandler); + int count = SK_ARRAY_COUNT(gTypes); + OSStatus result; + + result = InstallEventHandler(GetWindowEventTarget((WindowRef)hWnd), handlerUPP, + count, gTypes, this, nil); + SkASSERT(result == noErr); + + gCurrOSWin = this; + gCurrEventQ = GetCurrentEventQueue(); + gEventTarget = GetWindowEventTarget((WindowRef)hWnd); + + static bool gOnce = true; + if (gOnce) { + gOnce = false; + gPrevNewHandler = set_new_handler(sk_new_handler); + } +} + +void SkOSWindow::doPaint(void* ctx) +{ + this->update(NULL); + + this->getBitmap().drawToPort((WindowRef)fHWND, (CGContextRef)ctx); +} + +void SkOSWindow::updateSize() +{ + Rect r; + + GetWindowBounds((WindowRef)fHWND, kWindowContentRgn, &r); + this->resize(r.right - r.left, r.bottom - r.top); +} + +void SkOSWindow::onHandleInval(const SkIRect& r) +{ + Rect rect; + + rect.left = r.fLeft; + rect.top = r.fTop; + rect.right = r.fRight; + rect.bottom = r.fBottom; + InvalWindowRect((WindowRef)fHWND, &rect); +} + +void SkOSWindow::onSetTitle(const char title[]) +{ + CFStringRef str = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8); + SetWindowTitleWithCFString((WindowRef)fHWND, str); + CFRelease(str); +} + +void SkOSWindow::onAddMenu(const SkOSMenu* sk_menu) +{ +} + +static void getparam(EventRef inEvent, OSType name, OSType type, UInt32 size, void* data) +{ + EventParamType actualType; + UInt32 actualSize; + OSStatus status; + + status = GetEventParameter(inEvent, name, type, &actualType, size, &actualSize, data); + SkASSERT(status == noErr); + SkASSERT(actualType == type); + SkASSERT(actualSize == size); +} + +enum { + SK_MacReturnKey = 36, + SK_MacDeleteKey = 51, + SK_MacEndKey = 119, + SK_MacLeftKey = 123, + SK_MacRightKey = 124, + SK_MacDownKey = 125, + SK_MacUpKey = 126, + + SK_Mac0Key = 0x52, + SK_Mac1Key = 0x53, + SK_Mac2Key = 0x54, + SK_Mac3Key = 0x55, + SK_Mac4Key = 0x56, + SK_Mac5Key = 0x57, + SK_Mac6Key = 0x58, + SK_Mac7Key = 0x59, + SK_Mac8Key = 0x5b, + SK_Mac9Key = 0x5c +}; + +static SkKey raw2key(UInt32 raw) +{ + static const struct { + UInt32 fRaw; + SkKey fKey; + } gKeys[] = { + { SK_MacUpKey, kUp_SkKey }, + { SK_MacDownKey, kDown_SkKey }, + { SK_MacLeftKey, kLeft_SkKey }, + { SK_MacRightKey, kRight_SkKey }, + { SK_MacReturnKey, kOK_SkKey }, + { SK_MacDeleteKey, kBack_SkKey }, + { SK_MacEndKey, kEnd_SkKey }, + { SK_Mac0Key, k0_SkKey }, + { SK_Mac1Key, k1_SkKey }, + { SK_Mac2Key, k2_SkKey }, + { SK_Mac3Key, k3_SkKey }, + { SK_Mac4Key, k4_SkKey }, + { SK_Mac5Key, k5_SkKey }, + { SK_Mac6Key, k6_SkKey }, + { SK_Mac7Key, k7_SkKey }, + { SK_Mac8Key, k8_SkKey }, + { SK_Mac9Key, k9_SkKey } + }; + + for (unsigned i = 0; i < SK_ARRAY_COUNT(gKeys); i++) + if (gKeys[i].fRaw == raw) + return gKeys[i].fKey; + return kNONE_SkKey; +} + +static void post_skmacevent() +{ + EventRef ref; + OSStatus status = CreateEvent(nil, SK_MacEventClass, SK_MacEventKind, 0, 0, &ref); + SkASSERT(status == noErr); + +#if 0 + status = SetEventParameter(ref, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt); + SkASSERT(status == noErr); + status = SetEventParameter(ref, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID); + SkASSERT(status == noErr); +#endif + + EventTargetRef target = gEventTarget; + SetEventParameter(ref, kEventParamPostTarget, typeEventTargetRef, sizeof(target), &target); + SkASSERT(status == noErr); + + status = PostEventToQueue(gCurrEventQ, ref, kEventPriorityStandard); + SkASSERT(status == noErr); + + ReleaseEvent(ref); +} + +pascal OSStatus SkOSWindow::EventHandler( EventHandlerCallRef inHandler, EventRef inEvent, void* userData ) +{ + SkOSWindow* win = (SkOSWindow*)userData; + OSStatus result = eventNotHandledErr; + UInt32 wClass = GetEventClass(inEvent); + UInt32 wKind = GetEventKind(inEvent); + + gCurrOSWin = win; // will need to be in TLS. Set this so PostEvent will work + + switch (wClass) { + case kEventClassMouse: { + Point pt; + getparam(inEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pt), &pt); + SetPortWindowPort((WindowRef)win->getHWND()); + GlobalToLocal(&pt); + + switch (wKind) { + case kEventMouseDown: + (void)win->handleClick(pt.h, pt.v, Click::kDown_State); + break; + case kEventMouseDragged: + (void)win->handleClick(pt.h, pt.v, Click::kMoved_State); + break; + case kEventMouseUp: + (void)win->handleClick(pt.h, pt.v, Click::kUp_State); + break; + default: + break; + } + break; + } + case kEventClassKeyboard: + if (wKind == kEventRawKeyDown) { + UInt32 raw; + getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw); + SkKey key = raw2key(raw); + if (key != kNONE_SkKey) + (void)win->handleKey(key); + } else if (wKind == kEventRawKeyUp) { + UInt32 raw; + getparam(inEvent, kEventParamKeyCode, typeUInt32, sizeof(raw), &raw); + SkKey key = raw2key(raw); + if (key != kNONE_SkKey) + (void)win->handleKeyUp(key); + } + break; + case kEventClassTextInput: + if (wKind == kEventTextInputUnicodeForKeyEvent) { + UInt16 uni; + getparam(inEvent, kEventParamTextInputSendText, typeUnicodeText, sizeof(uni), &uni); + win->handleChar(uni); + } + break; + case kEventClassWindow: + switch (wKind) { + case kEventWindowBoundsChanged: + win->updateSize(); + break; + case kEventWindowDrawContent: { + CGContextRef cg; + result = GetEventParameter(inEvent, + kEventParamCGContextRef, + typeCGContextRef, + NULL, + sizeof (CGContextRef), + NULL, + &cg); + if (result != 0) { + cg = NULL; + } + win->doPaint(cg); + break; + } + default: + break; + } + break; + case SK_MacEventClass: { + SkASSERT(wKind == SK_MacEventKind); + if (SkEvent::ProcessEvent()) { + post_skmacevent(); + } + #if 0 + SkEvent* evt; + SkEventSinkID sinkID; + getparam(inEvent, SK_MacEventParamName, SK_MacEventParamName, sizeof(evt), &evt); + getparam(inEvent, SK_MacEventSinkIDParamName, SK_MacEventSinkIDParamName, sizeof(sinkID), &sinkID); + #endif + result = noErr; + break; + } + default: + break; + } + if (result == eventNotHandledErr) { + result = CallNextEventHandler(inHandler, inEvent); + } + return result; +} + +/////////////////////////////////////////////////////////////////////////////////////// + +void SkEvent::SignalNonEmptyQueue() +{ + post_skmacevent(); +// SkDebugf("signal nonempty\n"); +} + +static TMTask gTMTaskRec; +static TMTask* gTMTaskPtr; + +static void sk_timer_proc(TMTask* rec) +{ + SkEvent::ServiceQueueTimer(); +// SkDebugf("timer task fired\n"); +} + +void SkEvent::SignalQueueTimer(SkMSec delay) +{ + if (gTMTaskPtr) + { + RemoveTimeTask((QElem*)gTMTaskPtr); + DisposeTimerUPP(gTMTaskPtr->tmAddr); + gTMTaskPtr = nil; + } + if (delay) + { + gTMTaskPtr = &gTMTaskRec; + memset(gTMTaskPtr, 0, sizeof(gTMTaskRec)); + gTMTaskPtr->tmAddr = NewTimerUPP(sk_timer_proc); + OSErr err = InstallTimeTask((QElem*)gTMTaskPtr); +// SkDebugf("installtimetask of %d returned %d\n", delay, err); + PrimeTimeTask((QElem*)gTMTaskPtr, delay); + } +} + +#endif + diff --git a/xcode/ports/skia_mac.cp b/xcode/ports/skia_mac.cp new file mode 100644 index 0000000..81b26e1 --- /dev/null +++ b/xcode/ports/skia_mac.cp @@ -0,0 +1,97 @@ +#include "SkTypes.h" + +#if defined(SK_BUILD_FOR_MAC) && !defined(SK_USE_WXWIDGETS) +#include <Carbon/Carbon.h> +#include <unistd.h> +#include <cerrno> +#include "SkApplication.h" + +extern void get_preferred_size(int*, int*, int*, int* ); + +int main(int argc, char* argv[]) +{ + +#if 0 +{ + FILE* f = ::fopen("/whereami.txt", "w"); + for (int i = 0; i < argc; i++) + fprintf(f, "[%d] %s\n", i, argv[i]); + ::fclose(f); +} +#else +// argv[0] is set to the execution path of the application, e.g. +// /Users/caryclark/android/device/build/ide/xcode/animatorTest/build/Debug/animatorTest.app/Contents/MacOS/animatorTest +// the desired directory path is : +// /Users/caryclark/android/device/jsapps +// the variable (client-specific) part is : +// /Users/caryclark/android/ +// since different applications share this library, they only have in common: +// {client}/device/build/ide/xcode/{application} +{ + const char* applicationPath = argv[0]; + const char* common = strstr(applicationPath, "build/ide/xcode/"); + const char systemParent[] = "apps/"; + if (common != 0) { + size_t prefixLength = common - applicationPath; + char* workingDirectory = new char[prefixLength + sizeof(systemParent)]; + strncpy(workingDirectory, applicationPath, prefixLength); + strcpy(&workingDirectory[prefixLength], systemParent); + int error = chdir(workingDirectory); + if (error != 0) { + error = errno; + SkASSERT(error != ENOENT); + SkASSERT(error != ENOTDIR); + SkASSERT(error != EACCES); + SkASSERT(error != EIO); + SkASSERT(0); + } + delete workingDirectory; + } +} +#endif + IBNibRef nibRef; + WindowRef window; + + OSStatus err; + + // Create a Nib reference passing the name of the nib file (without the .nib extension) + // CreateNibReference only searches into the application bundle. + err = CreateNibReference(CFSTR("main"), &nibRef); + require_noerr( err, CantGetNibRef ); + + // Once the nib reference is created, set the menu bar. "MainMenu" is the name of the menu bar + // object. This name is set in InterfaceBuilder when the nib is created. + err = SetMenuBarFromNib(nibRef, CFSTR("MenuBar")); + require_noerr( err, CantSetMenuBar ); + + // Then create a window. "MainWindow" is the name of the window object. This name is set in + // InterfaceBuilder when the nib is created. + err = CreateWindowFromNib(nibRef, CFSTR("MainWindow"), &window); + require_noerr( err, CantCreateWindow ); + + // We don't need the nib reference anymore. + DisposeNibReference(nibRef); + { + // if we get here, we can start our normal Skia sequence + application_init(); + (void)create_sk_window(window); + int x =0, y =0, width =640, height=480; + get_preferred_size(&x, &y, &width, &height); + MoveWindow(window, x, y, false); + SizeWindow(window, width, height, false); + } + // The window was created hidden so show it. + ShowWindow( window ); + + // Call the event loop + RunApplicationEventLoop(); + + application_term(); + +CantCreateWindow: +CantSetMenuBar: +CantGetNibRef: + return err; +} + +#endif
\ No newline at end of file diff --git a/xcode/pvjpeg.xcodeproj/project.pbxproj b/xcode/pvjpeg.xcodeproj/project.pbxproj new file mode 100644 index 0000000..5d09e2d --- /dev/null +++ b/xcode/pvjpeg.xcodeproj/project.pbxproj @@ -0,0 +1,261 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 44; + objects = { + +/* Begin PBXBuildFile section */ + 007ECA0E0DA67F7B0086775A /* jpgdec_bitstream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA010DA67F7B0086775A /* jpgdec_bitstream.cpp */; }; + 007ECA0F0DA67F7B0086775A /* jpgdec_cint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA020DA67F7B0086775A /* jpgdec_cint.cpp */; }; + 007ECA100DA67F7B0086775A /* jpgdec_colorconv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA030DA67F7B0086775A /* jpgdec_colorconv.cpp */; }; + 007ECA110DA67F7B0086775A /* jpgdec_ct.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA040DA67F7B0086775A /* jpgdec_ct.cpp */; }; + 007ECA120DA67F7B0086775A /* jpgdec_decoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA050DA67F7B0086775A /* jpgdec_decoder.cpp */; }; + 007ECA130DA67F7B0086775A /* jpgdec_header.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA060DA67F7B0086775A /* jpgdec_header.cpp */; }; + 007ECA140DA67F7B0086775A /* jpgdec_huffman.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA070DA67F7B0086775A /* jpgdec_huffman.cpp */; }; + 007ECA150DA67F7B0086775A /* jpgdec_idctp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA080DA67F7B0086775A /* jpgdec_idctp.cpp */; }; + 007ECA160DA67F7B0086775A /* jpgdec_idcts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA090DA67F7B0086775A /* jpgdec_idcts.cpp */; }; + 007ECA170DA67F7B0086775A /* jpgdec_scan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0A0DA67F7B0086775A /* jpgdec_scan.cpp */; }; + 007ECA180DA67F7B0086775A /* jpgdec_table.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0B0DA67F7B0086775A /* jpgdec_table.cpp */; }; + 007ECA190DA67F7B0086775A /* jpgdec_utils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0C0DA67F7B0086775A /* jpgdec_utils.cpp */; }; + 007ECA1A0DA67F7B0086775A /* pvjpgdecoder_factory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA0D0DA67F7B0086775A /* pvjpgdecoder_factory.cpp */; }; + 007ECA500DA683160086775A /* SkImageDecoder_libpvjpeg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 007ECA4F0DA683160086775A /* SkImageDecoder_libpvjpeg.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 007ECA010DA67F7B0086775A /* jpgdec_bitstream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_bitstream.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_bitstream.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA020DA67F7B0086775A /* jpgdec_cint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_cint.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_cint.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA030DA67F7B0086775A /* jpgdec_colorconv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_colorconv.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_colorconv.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA040DA67F7B0086775A /* jpgdec_ct.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_ct.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_ct.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA050DA67F7B0086775A /* jpgdec_decoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_decoder.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_decoder.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA060DA67F7B0086775A /* jpgdec_header.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_header.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_header.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA070DA67F7B0086775A /* jpgdec_huffman.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_huffman.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_huffman.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA080DA67F7B0086775A /* jpgdec_idctp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_idctp.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_idctp.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA090DA67F7B0086775A /* jpgdec_idcts.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_idcts.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_idcts.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA0A0DA67F7B0086775A /* jpgdec_scan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_scan.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_scan.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA0B0DA67F7B0086775A /* jpgdec_table.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_table.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_table.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA0C0DA67F7B0086775A /* jpgdec_utils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = jpgdec_utils.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/jpgdec_utils.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA0D0DA67F7B0086775A /* pvjpgdecoder_factory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pvjpgdecoder_factory.cpp; path = ../../extlibs/pv/codecs_v2/image/jpeg/dec/src/pvjpgdecoder_factory.cpp; sourceTree = SOURCE_ROOT; }; + 007ECA4F0DA683160086775A /* SkImageDecoder_libpvjpeg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libpvjpeg.cpp; path = ../../libs/graphics/images/SkImageDecoder_libpvjpeg.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libpvjpeg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libpvjpeg.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* pvjpeg */ = { + isa = PBXGroup; + children = ( + 007ECA4F0DA683160086775A /* SkImageDecoder_libpvjpeg.cpp */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = pvjpeg; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 007ECA010DA67F7B0086775A /* jpgdec_bitstream.cpp */, + 007ECA020DA67F7B0086775A /* jpgdec_cint.cpp */, + 007ECA030DA67F7B0086775A /* jpgdec_colorconv.cpp */, + 007ECA040DA67F7B0086775A /* jpgdec_ct.cpp */, + 007ECA050DA67F7B0086775A /* jpgdec_decoder.cpp */, + 007ECA060DA67F7B0086775A /* jpgdec_header.cpp */, + 007ECA070DA67F7B0086775A /* jpgdec_huffman.cpp */, + 007ECA080DA67F7B0086775A /* jpgdec_idctp.cpp */, + 007ECA090DA67F7B0086775A /* jpgdec_idcts.cpp */, + 007ECA0A0DA67F7B0086775A /* jpgdec_scan.cpp */, + 007ECA0B0DA67F7B0086775A /* jpgdec_table.cpp */, + 007ECA0C0DA67F7B0086775A /* jpgdec_utils.cpp */, + 007ECA0D0DA67F7B0086775A /* pvjpgdecoder_factory.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libpvjpeg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* pvjpeg */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "pvjpeg" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = pvjpeg; + productName = pvjpeg; + productReference = D2AAC046055464E500DB518D /* libpvjpeg.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "pvjpeg" */; + compatibilityVersion = "Xcode 3.0"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* pvjpeg */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + D2AAC045055464E500DB518D /* pvjpeg */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 007ECA0E0DA67F7B0086775A /* jpgdec_bitstream.cpp in Sources */, + 007ECA0F0DA67F7B0086775A /* jpgdec_cint.cpp in Sources */, + 007ECA100DA67F7B0086775A /* jpgdec_colorconv.cpp in Sources */, + 007ECA110DA67F7B0086775A /* jpgdec_ct.cpp in Sources */, + 007ECA120DA67F7B0086775A /* jpgdec_decoder.cpp in Sources */, + 007ECA130DA67F7B0086775A /* jpgdec_header.cpp in Sources */, + 007ECA140DA67F7B0086775A /* jpgdec_huffman.cpp in Sources */, + 007ECA150DA67F7B0086775A /* jpgdec_idctp.cpp in Sources */, + 007ECA160DA67F7B0086775A /* jpgdec_idcts.cpp in Sources */, + 007ECA170DA67F7B0086775A /* jpgdec_scan.cpp in Sources */, + 007ECA180DA67F7B0086775A /* jpgdec_table.cpp in Sources */, + 007ECA190DA67F7B0086775A /* jpgdec_utils.cpp in Sources */, + 007ECA1A0DA67F7B0086775A /* pvjpgdecoder_factory.cpp in Sources */, + 007ECA500DA683160086775A /* SkImageDecoder_libpvjpeg.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = pvjpeg; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = pvjpeg; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = "USE_PV_OSCL_LIB=0"; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk"; + USER_HEADER_SEARCH_PATHS = "../../extlibs/pv/** ../../include/corecg ../../include/graphics"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = "USE_PV_OSCL_LIB=0"; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.5.sdk"; + USER_HEADER_SEARCH_PATHS = "../../extlibs/pv/** ../../include/corecg ../../include/graphics"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "pvjpeg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "pvjpeg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/skia2.xcodeproj/project.pbxproj b/xcode/skia2.xcodeproj/project.pbxproj new file mode 100644 index 0000000..1a27e69 --- /dev/null +++ b/xcode/skia2.xcodeproj/project.pbxproj @@ -0,0 +1,1389 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 003E926F0EED78220091D85B /* libfreetype.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00A5676D0EED77850096A2A1 /* libfreetype.a */; }; + 006B43FE0EF7526E00F15BC4 /* SkString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43FC0EF7526E00F15BC4 /* SkString.cpp */; }; + 006B43FF0EF7526E00F15BC4 /* SkUtils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 006B43FD0EF7526E00F15BC4 /* SkUtils.cpp */; }; + 00A567300EED6F6E0096A2A1 /* libgiflib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE44670EE9D1780008420F /* libgiflib.a */; }; + 00AFCD710EF1672C00BD2FF1 /* SkDOM.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD700EF1672C00BD2FF1 /* SkDOM.cpp */; }; + 00AFCD7C0EF167BC00BD2FF1 /* SkParse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD790EF167BC00BD2FF1 /* SkParse.cpp */; }; + 00AFCD7D0EF167BC00BD2FF1 /* SkParseColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD7A0EF167BC00BD2FF1 /* SkParseColor.cpp */; }; + 00AFCD7E0EF167BC00BD2FF1 /* SkXMLParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD7B0EF167BC00BD2FF1 /* SkXMLParser.cpp */; }; + 00AFCD890EF1684200BD2FF1 /* SkBitmap_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD880EF1684200BD2FF1 /* SkBitmap_Mac.cpp */; }; + 00AFCD8B0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00AFCD8A0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp */; }; + 00AFCE240EF16C0500BD2FF1 /* libexpat.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00AFCE150EF16BA400BD2FF1 /* libexpat.a */; }; + 00BE435D0EE9CDFA0008420F /* Sk1DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42800EE9CDFA0008420F /* Sk1DPathEffect.cpp */; }; + 00BE435E0EE9CDFA0008420F /* Sk2DPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42810EE9CDFA0008420F /* Sk2DPathEffect.cpp */; }; + 00BE435F0EE9CDFA0008420F /* SkAvoidXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42820EE9CDFA0008420F /* SkAvoidXfermode.cpp */; }; + 00BE43600EE9CDFA0008420F /* SkBlurDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42830EE9CDFA0008420F /* SkBlurDrawLooper.cpp */; }; + 00BE43610EE9CDFA0008420F /* SkBlurMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42840EE9CDFA0008420F /* SkBlurMask.cpp */; }; + 00BE43620EE9CDFA0008420F /* SkBlurMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42850EE9CDFA0008420F /* SkBlurMask.h */; }; + 00BE43630EE9CDFA0008420F /* SkBlurMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42860EE9CDFA0008420F /* SkBlurMaskFilter.cpp */; }; + 00BE43640EE9CDFA0008420F /* SkCamera.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42870EE9CDFA0008420F /* SkCamera.cpp */; }; + 00BE43650EE9CDFA0008420F /* SkColorFilters.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42880EE9CDFA0008420F /* SkColorFilters.cpp */; }; + 00BE43660EE9CDFA0008420F /* SkColorMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42890EE9CDFA0008420F /* SkColorMatrix.cpp */; }; + 00BE43670EE9CDFA0008420F /* SkColorMatrixFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428A0EE9CDFA0008420F /* SkColorMatrixFilter.cpp */; }; + 00BE43680EE9CDFA0008420F /* SkCornerPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428B0EE9CDFA0008420F /* SkCornerPathEffect.cpp */; }; + 00BE43690EE9CDFA0008420F /* SkCullPoints.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428C0EE9CDFA0008420F /* SkCullPoints.cpp */; }; + 00BE436A0EE9CDFA0008420F /* SkDashPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428D0EE9CDFA0008420F /* SkDashPathEffect.cpp */; }; + 00BE436B0EE9CDFA0008420F /* SkDiscretePathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428E0EE9CDFA0008420F /* SkDiscretePathEffect.cpp */; }; + 00BE436C0EE9CDFA0008420F /* SkDumpCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE428F0EE9CDFA0008420F /* SkDumpCanvas.cpp */; }; + 00BE436D0EE9CDFA0008420F /* SkEmbossMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42900EE9CDFA0008420F /* SkEmbossMask.cpp */; }; + 00BE436E0EE9CDFA0008420F /* SkEmbossMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42910EE9CDFA0008420F /* SkEmbossMask.h */; }; + 00BE436F0EE9CDFA0008420F /* SkEmbossMask_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42920EE9CDFA0008420F /* SkEmbossMask_Table.h */; }; + 00BE43700EE9CDFA0008420F /* SkEmbossMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42930EE9CDFA0008420F /* SkEmbossMaskFilter.cpp */; }; + 00BE43710EE9CDFA0008420F /* SkGradientShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42940EE9CDFA0008420F /* SkGradientShader.cpp */; }; + 00BE43720EE9CDFA0008420F /* SkKernel33MaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42950EE9CDFA0008420F /* SkKernel33MaskFilter.cpp */; }; + 00BE43730EE9CDFA0008420F /* SkLayerDrawLooper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42960EE9CDFA0008420F /* SkLayerDrawLooper.cpp */; }; + 00BE43740EE9CDFA0008420F /* SkLayerRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42970EE9CDFA0008420F /* SkLayerRasterizer.cpp */; }; + 00BE43750EE9CDFA0008420F /* SkNinePatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42980EE9CDFA0008420F /* SkNinePatch.cpp */; }; + 00BE43760EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42990EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp */; }; + 00BE43770EE9CDFA0008420F /* SkPixelXorXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429A0EE9CDFA0008420F /* SkPixelXorXfermode.cpp */; }; + 00BE43780EE9CDFA0008420F /* SkProxyCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429B0EE9CDFA0008420F /* SkProxyCanvas.cpp */; }; + 00BE43790EE9CDFA0008420F /* SkRadialGradient_Table.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE429C0EE9CDFA0008420F /* SkRadialGradient_Table.h */; }; + 00BE437A0EE9CDFA0008420F /* SkShaderExtras.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429D0EE9CDFA0008420F /* SkShaderExtras.cpp */; }; + 00BE437B0EE9CDFA0008420F /* SkTransparentShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429E0EE9CDFA0008420F /* SkTransparentShader.cpp */; }; + 00BE437C0EE9CDFA0008420F /* SkUnitMappers.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE429F0EE9CDFA0008420F /* SkUnitMappers.cpp */; }; + 00BE437D0EE9CDFA0008420F /* SkBGViewArtist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A10EE9CDFA0008420F /* SkBGViewArtist.cpp */; }; + 00BE437E0EE9CDFA0008420F /* SkBorderView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A20EE9CDFA0008420F /* SkBorderView.cpp */; }; + 00BE437F0EE9CDFA0008420F /* SkEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A30EE9CDFA0008420F /* SkEvent.cpp */; }; + 00BE43800EE9CDFA0008420F /* SkEventSink.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A40EE9CDFA0008420F /* SkEventSink.cpp */; }; + 00BE43810EE9CDFA0008420F /* SkImageView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A50EE9CDFA0008420F /* SkImageView.cpp */; }; + 00BE43820EE9CDFA0008420F /* SkListView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A60EE9CDFA0008420F /* SkListView.cpp */; }; + 00BE43830EE9CDFA0008420F /* SkListWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A70EE9CDFA0008420F /* SkListWidget.cpp */; }; + 00BE43840EE9CDFA0008420F /* SkMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A80EE9CDFA0008420F /* SkMetaData.cpp */; }; + 00BE43850EE9CDFA0008420F /* SkOSFile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42A90EE9CDFA0008420F /* SkOSFile.cpp */; }; + 00BE43860EE9CDFA0008420F /* SkOSMenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AA0EE9CDFA0008420F /* SkOSMenu.cpp */; }; + 00BE43870EE9CDFA0008420F /* SkOSSound.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AB0EE9CDFA0008420F /* SkOSSound.cpp */; }; + 00BE43880EE9CDFA0008420F /* SkParsePaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AC0EE9CDFA0008420F /* SkParsePaint.cpp */; }; + 00BE43890EE9CDFA0008420F /* SkProgressBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AD0EE9CDFA0008420F /* SkProgressBarView.cpp */; }; + 00BE438A0EE9CDFA0008420F /* SkProgressView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AE0EE9CDFA0008420F /* SkProgressView.cpp */; }; + 00BE438B0EE9CDFA0008420F /* SkScrollBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42AF0EE9CDFA0008420F /* SkScrollBarView.cpp */; }; + 00BE438C0EE9CDFA0008420F /* SkStackViewLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B00EE9CDFA0008420F /* SkStackViewLayout.cpp */; }; + 00BE438D0EE9CDFA0008420F /* SkTagList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B10EE9CDFA0008420F /* SkTagList.cpp */; }; + 00BE438E0EE9CDFA0008420F /* SkTagList.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42B20EE9CDFA0008420F /* SkTagList.h */; }; + 00BE438F0EE9CDFA0008420F /* SkTextBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B30EE9CDFA0008420F /* SkTextBox.cpp */; }; + 00BE43900EE9CDFA0008420F /* SkView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B40EE9CDFA0008420F /* SkView.cpp */; }; + 00BE43910EE9CDFA0008420F /* SkViewInflate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B50EE9CDFA0008420F /* SkViewInflate.cpp */; }; + 00BE43920EE9CDFA0008420F /* SkViewPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B60EE9CDFA0008420F /* SkViewPriv.cpp */; }; + 00BE43930EE9CDFA0008420F /* SkViewPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42B70EE9CDFA0008420F /* SkViewPriv.h */; }; + 00BE43940EE9CDFA0008420F /* SkWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B80EE9CDFA0008420F /* SkWidget.cpp */; }; + 00BE43950EE9CDFA0008420F /* SkWidgets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42B90EE9CDFA0008420F /* SkWidgets.cpp */; }; + 00BE43960EE9CDFA0008420F /* SkWidgetViews.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BA0EE9CDFA0008420F /* SkWidgetViews.cpp */; }; + 00BE43970EE9CDFA0008420F /* SkWindow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BB0EE9CDFA0008420F /* SkWindow.cpp */; }; + 00BE43980EE9CDFA0008420F /* SkFDStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BD0EE9CDFA0008420F /* SkFDStream.cpp */; }; + 00BE43990EE9CDFA0008420F /* SkFlipPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BE0EE9CDFA0008420F /* SkFlipPixelRef.cpp */; }; + 00BE439A0EE9CDFA0008420F /* SkImageDecoder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42BF0EE9CDFA0008420F /* SkImageDecoder.cpp */; }; + 00BE439C0EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C10EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp */; }; + 00BE439E0EE9CDFA0008420F /* SkImageDecoder_libico.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C30EE9CDFA0008420F /* SkImageDecoder_libico.cpp */; }; + 00BE43A20EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C70EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp */; }; + 00BE43A30EE9CDFA0008420F /* SkImageRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C80EE9CDFA0008420F /* SkImageRef.cpp */; }; + 00BE43A40EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42C90EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp */; }; + 00BE43A50EE9CDFA0008420F /* SkImageRefPool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CA0EE9CDFA0008420F /* SkImageRefPool.cpp */; }; + 00BE43A60EE9CDFA0008420F /* SkImageRefPool.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42CB0EE9CDFA0008420F /* SkImageRefPool.h */; }; + 00BE43A70EE9CDFA0008420F /* SkMMapStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CC0EE9CDFA0008420F /* SkMMapStream.cpp */; }; + 00BE43A80EE9CDFA0008420F /* SkMovie.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CD0EE9CDFA0008420F /* SkMovie.cpp */; }; + 00BE43AA0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42CF0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp */; }; + 00BE43AB0EE9CDFA0008420F /* SkScaledBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42D00EE9CDFA0008420F /* SkScaledBitmapSampler.h */; }; + 00BE43AC0EE9CDFA0008420F /* SkStream.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D10EE9CDFA0008420F /* SkStream.cpp */; }; + 00BE43AD0EE9CDFA0008420F /* SkFontHost_android.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D30EE9CDFA0008420F /* SkFontHost_android.cpp */; }; + 00BE43AE0EE9CDFA0008420F /* SkFontHost_gamma.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D40EE9CDFA0008420F /* SkFontHost_gamma.cpp */; }; + 00BE43AF0EE9CDFA0008420F /* SkGlobals_global.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D50EE9CDFA0008420F /* SkGlobals_global.cpp */; }; + 00BE43B00EE9CDFA0008420F /* SkImageDecoder_Factory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D60EE9CDFA0008420F /* SkImageDecoder_Factory.cpp */; }; + 00BE43B10EE9CDFA0008420F /* SkThread_pthread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D70EE9CDFA0008420F /* SkThread_pthread.cpp */; }; + 00BE43B20EE9CDFA0008420F /* SkTime_Unix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42D80EE9CDFA0008420F /* SkTime_Unix.cpp */; }; + 00BE43B30EE9CDFA0008420F /* SkPathHeap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DA0EE9CDFA0008420F /* SkPathHeap.cpp */; }; + 00BE43B40EE9CDFA0008420F /* SkPathHeap.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42DB0EE9CDFA0008420F /* SkPathHeap.h */; }; + 00BE43B50EE9CDFA0008420F /* SkPicture.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DC0EE9CDFA0008420F /* SkPicture.cpp */; }; + 00BE43B60EE9CDFA0008420F /* SkPictureFlat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DD0EE9CDFA0008420F /* SkPictureFlat.cpp */; }; + 00BE43B70EE9CDFA0008420F /* SkPictureFlat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42DE0EE9CDFA0008420F /* SkPictureFlat.h */; }; + 00BE43B80EE9CDFA0008420F /* SkPicturePlayback.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42DF0EE9CDFA0008420F /* SkPicturePlayback.cpp */; }; + 00BE43B90EE9CDFA0008420F /* SkPicturePlayback.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E00EE9CDFA0008420F /* SkPicturePlayback.h */; }; + 00BE43BA0EE9CDFA0008420F /* SkPictureRecord.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E10EE9CDFA0008420F /* SkPictureRecord.cpp */; }; + 00BE43BB0EE9CDFA0008420F /* SkPictureRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E20EE9CDFA0008420F /* SkPictureRecord.h */; }; + 00BE43BC0EE9CDFA0008420F /* SkGL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E30EE9CDFA0008420F /* SkGL.cpp */; }; + 00BE43BD0EE9CDFA0008420F /* SkGL.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E40EE9CDFA0008420F /* SkGL.h */; }; + 00BE43BE0EE9CDFA0008420F /* SkGLCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E50EE9CDFA0008420F /* SkGLCanvas.cpp */; }; + 00BE43BF0EE9CDFA0008420F /* SkGLDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E60EE9CDFA0008420F /* SkGLDevice.cpp */; }; + 00BE43C00EE9CDFA0008420F /* SkGLDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E70EE9CDFA0008420F /* SkGLDevice.h */; }; + 00BE43C10EE9CDFA0008420F /* SkGLDevice_FBO.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42E80EE9CDFA0008420F /* SkGLDevice_FBO.cpp */; }; + 00BE43C20EE9CDFA0008420F /* SkGLDevice_FBO.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42E90EE9CDFA0008420F /* SkGLDevice_FBO.h */; }; + 00BE43C30EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42EA0EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp */; }; + 00BE43C40EE9CDFA0008420F /* SkGLDevice_SWLayer.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42EB0EE9CDFA0008420F /* SkGLDevice_SWLayer.h */; }; + 00BE43C50EE9CDFA0008420F /* SkGLTextCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42EC0EE9CDFA0008420F /* SkGLTextCache.cpp */; }; + 00BE43C60EE9CDFA0008420F /* SkGLTextCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42ED0EE9CDFA0008420F /* SkGLTextCache.h */; }; + 00BE43C70EE9CDFA0008420F /* SkTextureCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42EE0EE9CDFA0008420F /* SkTextureCache.cpp */; }; + 00BE43C80EE9CDFA0008420F /* SkTextureCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42EF0EE9CDFA0008420F /* SkTextureCache.h */; }; + 00BE43C90EE9CDFA0008420F /* SkAlphaRuns.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F00EE9CDFA0008420F /* SkAlphaRuns.cpp */; }; + 00BE43CA0EE9CDFA0008420F /* SkAntiRun.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F10EE9CDFA0008420F /* SkAntiRun.h */; }; + 00BE43CB0EE9CDFA0008420F /* SkAutoKern.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F20EE9CDFA0008420F /* SkAutoKern.h */; }; + 00BE43CC0EE9CDFA0008420F /* SkBitmap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F30EE9CDFA0008420F /* SkBitmap.cpp */; }; + 00BE43CD0EE9CDFA0008420F /* SkBitmap_scroll.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F40EE9CDFA0008420F /* SkBitmap_scroll.cpp */; }; + 00BE43CE0EE9CDFA0008420F /* SkBitmapProcShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F50EE9CDFA0008420F /* SkBitmapProcShader.cpp */; }; + 00BE43CF0EE9CDFA0008420F /* SkBitmapProcShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F60EE9CDFA0008420F /* SkBitmapProcShader.h */; }; + 00BE43D00EE9CDFA0008420F /* SkBitmapProcState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42F70EE9CDFA0008420F /* SkBitmapProcState.cpp */; }; + 00BE43D10EE9CDFA0008420F /* SkBitmapProcState.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F80EE9CDFA0008420F /* SkBitmapProcState.h */; }; + 00BE43D20EE9CDFA0008420F /* SkBitmapProcState_matrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42F90EE9CDFA0008420F /* SkBitmapProcState_matrix.h */; }; + 00BE43D30EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42FA0EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp */; }; + 00BE43D40EE9CDFA0008420F /* SkBitmapProcState_sample.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42FB0EE9CDFA0008420F /* SkBitmapProcState_sample.h */; }; + 00BE43D50EE9CDFA0008420F /* SkBitmapSampler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42FC0EE9CDFA0008420F /* SkBitmapSampler.cpp */; }; + 00BE43D60EE9CDFA0008420F /* SkBitmapSampler.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42FD0EE9CDFA0008420F /* SkBitmapSampler.h */; }; + 00BE43D70EE9CDFA0008420F /* SkBitmapSamplerTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE42FE0EE9CDFA0008420F /* SkBitmapSamplerTemplate.h */; }; + 00BE43D80EE9CDFA0008420F /* SkBitmapShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE42FF0EE9CDFA0008420F /* SkBitmapShader.cpp */; }; + 00BE43D90EE9CDFA0008420F /* SkBitmapShader.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43000EE9CDFA0008420F /* SkBitmapShader.h */; }; + 00BE43DA0EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43010EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h */; }; + 00BE43DB0EE9CDFA0008420F /* SkBitmapShaderTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43020EE9CDFA0008420F /* SkBitmapShaderTemplate.h */; }; + 00BE43DC0EE9CDFA0008420F /* SkBlitBWMaskTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43030EE9CDFA0008420F /* SkBlitBWMaskTemplate.h */; }; + 00BE43DD0EE9CDFA0008420F /* SkBlitRow.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43040EE9CDFA0008420F /* SkBlitRow.h */; }; + 00BE43DE0EE9CDFA0008420F /* SkBlitRow_D16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43050EE9CDFA0008420F /* SkBlitRow_D16.cpp */; }; + 00BE43DF0EE9CDFA0008420F /* SkBlitRow_D4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43060EE9CDFA0008420F /* SkBlitRow_D4444.cpp */; }; + 00BE43E00EE9CDFA0008420F /* SkBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43070EE9CDFA0008420F /* SkBlitter.cpp */; }; + 00BE43E10EE9CDFA0008420F /* SkBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43080EE9CDFA0008420F /* SkBlitter.h */; }; + 00BE43E20EE9CDFA0008420F /* SkBlitter_4444.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43090EE9CDFA0008420F /* SkBlitter_4444.cpp */; }; + 00BE43E30EE9CDFA0008420F /* SkBlitter_A1.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430A0EE9CDFA0008420F /* SkBlitter_A1.cpp */; }; + 00BE43E40EE9CDFA0008420F /* SkBlitter_A8.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430B0EE9CDFA0008420F /* SkBlitter_A8.cpp */; }; + 00BE43E50EE9CDFA0008420F /* SkBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430C0EE9CDFA0008420F /* SkBlitter_ARGB32.cpp */; }; + 00BE43E60EE9CDFA0008420F /* SkBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430D0EE9CDFA0008420F /* SkBlitter_RGB16.cpp */; }; + 00BE43E70EE9CDFA0008420F /* SkBlitter_Sprite.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430E0EE9CDFA0008420F /* SkBlitter_Sprite.cpp */; }; + 00BE43E80EE9CDFA0008420F /* SkCanvas.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE430F0EE9CDFA0008420F /* SkCanvas.cpp */; }; + 00BE43E90EE9CDFA0008420F /* SkColor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43100EE9CDFA0008420F /* SkColor.cpp */; }; + 00BE43EA0EE9CDFA0008420F /* SkColorFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43110EE9CDFA0008420F /* SkColorFilter.cpp */; }; + 00BE43EB0EE9CDFA0008420F /* SkColorTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43120EE9CDFA0008420F /* SkColorTable.cpp */; }; + 00BE43EC0EE9CDFA0008420F /* SkCoreBlitters.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43130EE9CDFA0008420F /* SkCoreBlitters.h */; }; + 00BE43ED0EE9CDFA0008420F /* SkDeque.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43140EE9CDFA0008420F /* SkDeque.cpp */; }; + 00BE43EE0EE9CDFA0008420F /* SkDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43150EE9CDFA0008420F /* SkDevice.cpp */; }; + 00BE43EF0EE9CDFA0008420F /* SkDither.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43160EE9CDFA0008420F /* SkDither.cpp */; }; + 00BE43F00EE9CDFA0008420F /* SkDraw.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43170EE9CDFA0008420F /* SkDraw.cpp */; }; + 00BE43F10EE9CDFA0008420F /* SkDrawProcs.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43180EE9CDFA0008420F /* SkDrawProcs.h */; }; + 00BE43F20EE9CDFA0008420F /* SkEdge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43190EE9CDFA0008420F /* SkEdge.cpp */; }; + 00BE43F30EE9CDFA0008420F /* SkEdge.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE431A0EE9CDFA0008420F /* SkEdge.h */; }; + 00BE43F40EE9CDFA0008420F /* SkFilterProc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE431B0EE9CDFA0008420F /* SkFilterProc.cpp */; }; + 00BE43F50EE9CDFA0008420F /* SkFilterProc.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE431C0EE9CDFA0008420F /* SkFilterProc.h */; }; + 00BE43F60EE9CDFA0008420F /* SkFlattenable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE431D0EE9CDFA0008420F /* SkFlattenable.cpp */; }; + 00BE43F70EE9CDFA0008420F /* SkFP.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE431E0EE9CDFA0008420F /* SkFP.h */; }; + 00BE43F80EE9CDFA0008420F /* SkGeometry.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE431F0EE9CDFA0008420F /* SkGeometry.cpp */; }; + 00BE43F90EE9CDFA0008420F /* SkGeometry.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43200EE9CDFA0008420F /* SkGeometry.h */; }; + 00BE43FA0EE9CDFA0008420F /* SkGlobals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43210EE9CDFA0008420F /* SkGlobals.cpp */; }; + 00BE43FB0EE9CDFA0008420F /* SkGlyphCache.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43220EE9CDFA0008420F /* SkGlyphCache.cpp */; }; + 00BE43FC0EE9CDFA0008420F /* SkGlyphCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43230EE9CDFA0008420F /* SkGlyphCache.h */; }; + 00BE43FD0EE9CDFA0008420F /* SkGraphics.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43240EE9CDFA0008420F /* SkGraphics.cpp */; }; + 00BE43FE0EE9CDFA0008420F /* SkMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43250EE9CDFA0008420F /* SkMask.cpp */; }; + 00BE43FF0EE9CDFA0008420F /* SkMaskFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43260EE9CDFA0008420F /* SkMaskFilter.cpp */; }; + 00BE44000EE9CDFA0008420F /* SkPackBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43270EE9CDFA0008420F /* SkPackBits.cpp */; }; + 00BE44010EE9CDFA0008420F /* SkPaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43280EE9CDFA0008420F /* SkPaint.cpp */; }; + 00BE44020EE9CDFA0008420F /* SkPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43290EE9CDFA0008420F /* SkPath.cpp */; }; + 00BE44030EE9CDFA0008420F /* SkPathEffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432A0EE9CDFA0008420F /* SkPathEffect.cpp */; }; + 00BE44040EE9CDFA0008420F /* SkPathMeasure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432B0EE9CDFA0008420F /* SkPathMeasure.cpp */; }; + 00BE44050EE9CDFA0008420F /* SkPixelRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432C0EE9CDFA0008420F /* SkPixelRef.cpp */; }; + 00BE44060EE9CDFA0008420F /* SkProcSpriteBlitter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432D0EE9CDFA0008420F /* SkProcSpriteBlitter.cpp */; }; + 00BE44070EE9CDFA0008420F /* SkPtrRecorder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432E0EE9CDFA0008420F /* SkPtrRecorder.cpp */; }; + 00BE44080EE9CDFA0008420F /* SkRasterizer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE432F0EE9CDFA0008420F /* SkRasterizer.cpp */; }; + 00BE44090EE9CDFA0008420F /* SkRefCnt.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43300EE9CDFA0008420F /* SkRefCnt.cpp */; }; + 00BE440A0EE9CDFA0008420F /* SkRegion_path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43310EE9CDFA0008420F /* SkRegion_path.cpp */; }; + 00BE440B0EE9CDFA0008420F /* SkScalerContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43320EE9CDFA0008420F /* SkScalerContext.cpp */; }; + 00BE440C0EE9CDFA0008420F /* SkScan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43330EE9CDFA0008420F /* SkScan.cpp */; }; + 00BE440D0EE9CDFA0008420F /* SkScan.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43340EE9CDFA0008420F /* SkScan.h */; }; + 00BE440E0EE9CDFA0008420F /* SkScan_Antihair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43350EE9CDFA0008420F /* SkScan_Antihair.cpp */; }; + 00BE440F0EE9CDFA0008420F /* SkScan_AntiPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43360EE9CDFA0008420F /* SkScan_AntiPath.cpp */; }; + 00BE44100EE9CDFA0008420F /* SkScan_Hairline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43370EE9CDFA0008420F /* SkScan_Hairline.cpp */; }; + 00BE44110EE9CDFA0008420F /* SkScan_Path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43380EE9CDFA0008420F /* SkScan_Path.cpp */; }; + 00BE44120EE9CDFA0008420F /* SkScanPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43390EE9CDFA0008420F /* SkScanPriv.h */; }; + 00BE44130EE9CDFA0008420F /* SkShader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE433A0EE9CDFA0008420F /* SkShader.cpp */; }; + 00BE44140EE9CDFA0008420F /* SkSpriteBlitter.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE433B0EE9CDFA0008420F /* SkSpriteBlitter.h */; }; + 00BE44150EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE433C0EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp */; }; + 00BE44160EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE433D0EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp */; }; + 00BE44170EE9CDFA0008420F /* SkSpriteBlitterTemplate.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE433E0EE9CDFA0008420F /* SkSpriteBlitterTemplate.h */; }; + 00BE44190EE9CDFA0008420F /* SkStroke.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43400EE9CDFA0008420F /* SkStroke.cpp */; }; + 00BE441A0EE9CDFA0008420F /* SkStrokerPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43410EE9CDFA0008420F /* SkStrokerPriv.cpp */; }; + 00BE441B0EE9CDFA0008420F /* SkStrokerPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43420EE9CDFA0008420F /* SkStrokerPriv.h */; }; + 00BE441C0EE9CDFA0008420F /* SkTemplatesPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43430EE9CDFA0008420F /* SkTemplatesPriv.h */; }; + 00BE441D0EE9CDFA0008420F /* SkTSearch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43440EE9CDFA0008420F /* SkTSearch.cpp */; }; + 00BE441E0EE9CDFA0008420F /* SkTSort.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43450EE9CDFA0008420F /* SkTSort.h */; }; + 00BE441F0EE9CDFA0008420F /* SkTypeface.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43460EE9CDFA0008420F /* SkTypeface.cpp */; }; + 00BE44200EE9CDFA0008420F /* SkUnPreMultiply.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43470EE9CDFA0008420F /* SkUnPreMultiply.cpp */; }; + 00BE44220EE9CDFA0008420F /* SkWriter32.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43490EE9CDFA0008420F /* SkWriter32.cpp */; }; + 00BE44230EE9CDFA0008420F /* SkXfermode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434A0EE9CDFA0008420F /* SkXfermode.cpp */; }; + 00BE44240EE9CDFA0008420F /* Sk64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434B0EE9CDFA0008420F /* Sk64.cpp */; }; + 00BE44250EE9CDFA0008420F /* SkBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434C0EE9CDFA0008420F /* SkBuffer.cpp */; }; + 00BE44260EE9CDFA0008420F /* SkChunkAlloc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434D0EE9CDFA0008420F /* SkChunkAlloc.cpp */; }; + 00BE44270EE9CDFA0008420F /* SkCordic.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE434E0EE9CDFA0008420F /* SkCordic.cpp */; }; + 00BE44280EE9CDFA0008420F /* SkCordic.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE434F0EE9CDFA0008420F /* SkCordic.h */; }; + 00BE44290EE9CDFA0008420F /* SkDebug.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43500EE9CDFA0008420F /* SkDebug.cpp */; }; + 00BE442A0EE9CDFA0008420F /* SkDebug_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43510EE9CDFA0008420F /* SkDebug_stdio.cpp */; }; + 00BE442B0EE9CDFA0008420F /* SkFloat.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43520EE9CDFA0008420F /* SkFloat.cpp */; }; + 00BE442C0EE9CDFA0008420F /* SkFloat.h in Headers */ = {isa = PBXBuildFile; fileRef = 00BE43530EE9CDFA0008420F /* SkFloat.h */; }; + 00BE442D0EE9CDFA0008420F /* SkFloatBits.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43540EE9CDFA0008420F /* SkFloatBits.cpp */; }; + 00BE442E0EE9CDFA0008420F /* SkInterpolator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43550EE9CDFA0008420F /* SkInterpolator.cpp */; }; + 00BE442F0EE9CDFA0008420F /* SkMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43560EE9CDFA0008420F /* SkMath.cpp */; }; + 00BE44300EE9CDFA0008420F /* SkMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43570EE9CDFA0008420F /* SkMatrix.cpp */; }; + 00BE44310EE9CDFA0008420F /* SkMemory_stdlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43580EE9CDFA0008420F /* SkMemory_stdlib.cpp */; }; + 00BE44320EE9CDFA0008420F /* SkPageFlipper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE43590EE9CDFA0008420F /* SkPageFlipper.cpp */; }; + 00BE44330EE9CDFA0008420F /* SkPoint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE435A0EE9CDFA0008420F /* SkPoint.cpp */; }; + 00BE44340EE9CDFA0008420F /* SkRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE435B0EE9CDFA0008420F /* SkRect.cpp */; }; + 00BE44350EE9CDFA0008420F /* SkRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE435C0EE9CDFA0008420F /* SkRegion.cpp */; }; + 00BE44C90EE9D4FC0008420F /* SkOSFile_stdio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE44C80EE9D4FC0008420F /* SkOSFile_stdio.cpp */; }; + 00BE44D40EE9D5660008420F /* libjpeg.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE446A0EE9D1780008420F /* libjpeg.a */; }; + 00BE44D50EE9D5670008420F /* liblibpng.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE446D0EE9D1780008420F /* liblibpng.a */; }; + 00BE44D60EE9D5690008420F /* libzlib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 00BE44700EE9D1780008420F /* libzlib.a */; }; + 00BE45070EE9D8120008420F /* bmpdecoderhelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00BE45060EE9D8120008420F /* bmpdecoderhelper.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 003E929A0EED79240091D85B /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00A567680EED77850096A2A1 /* freetype2.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = freetype; + }; + 003E92D90EED7C3B0091D85B /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE445C0EE9D1780008420F /* zlib.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = zlib; + }; + 00A5676C0EED77850096A2A1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00A567680EED77850096A2A1 /* freetype2.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = freetype; + }; + 00AFCE140EF16BA400BD2FF1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = expat; + }; + 00AFCE170EF16BBB00BD2FF1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = expat; + }; + 00BE44660EE9D1780008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE444D0EE9D1780008420F /* giflib.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = giflib; + }; + 00BE44690EE9D1780008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE44560EE9D1780008420F /* jpeg.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = jpeg; + }; + 00BE446C0EE9D1780008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE44590EE9D1780008420F /* libpng.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = libpng; + }; + 00BE446F0EE9D1780008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE445C0EE9D1780008420F /* zlib.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = D2AAC046055464E500DB518D; + remoteInfo = zlib; + }; + 00BE44F00EE9D70D0008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE44560EE9D1780008420F /* jpeg.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = jpeg; + }; + 00BE44F40EE9D70D0008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE444D0EE9D1780008420F /* giflib.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = giflib; + }; + 00BE44F60EE9D70D0008420F /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 00BE44590EE9D1780008420F /* libpng.xcodeproj */; + proxyType = 1; + remoteGlobalIDString = D2AAC045055464E500DB518D; + remoteInfo = libpng; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 006B43FC0EF7526E00F15BC4 /* SkString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkString.cpp; path = ../libcorecg/SkString.cpp; sourceTree = SOURCE_ROOT; }; + 006B43FD0EF7526E00F15BC4 /* SkUtils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUtils.cpp; path = ../libcorecg/SkUtils.cpp; sourceTree = SOURCE_ROOT; }; + 00A567680EED77850096A2A1 /* freetype2.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = freetype2.xcodeproj; sourceTree = "<group>"; }; + 00AFCD700EF1672C00BD2FF1 /* SkDOM.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDOM.cpp; path = ../libsgl/xml/SkDOM.cpp; sourceTree = SOURCE_ROOT; }; + 00AFCD790EF167BC00BD2FF1 /* SkParse.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParse.cpp; path = ../libsgl/xml/SkParse.cpp; sourceTree = SOURCE_ROOT; }; + 00AFCD7A0EF167BC00BD2FF1 /* SkParseColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParseColor.cpp; path = ../libsgl/xml/SkParseColor.cpp; sourceTree = SOURCE_ROOT; }; + 00AFCD7B0EF167BC00BD2FF1 /* SkXMLParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXMLParser.cpp; path = ../libsgl/xml/SkXMLParser.cpp; sourceTree = SOURCE_ROOT; }; + 00AFCD880EF1684200BD2FF1 /* SkBitmap_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_Mac.cpp; path = ports/SkBitmap_Mac.cpp; sourceTree = "<group>"; }; + 00AFCD8A0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSWindow_Mac.cpp; path = ports/SkOSWindow_Mac.cpp; sourceTree = "<group>"; }; + 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = expat.xcodeproj; sourceTree = "<group>"; }; + 00BE42800EE9CDFA0008420F /* Sk1DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk1DPathEffect.cpp; path = ../libsgl/effects/Sk1DPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42810EE9CDFA0008420F /* Sk2DPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk2DPathEffect.cpp; path = ../libsgl/effects/Sk2DPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42820EE9CDFA0008420F /* SkAvoidXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAvoidXfermode.cpp; path = ../libsgl/effects/SkAvoidXfermode.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42830EE9CDFA0008420F /* SkBlurDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurDrawLooper.cpp; path = ../libsgl/effects/SkBlurDrawLooper.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42840EE9CDFA0008420F /* SkBlurMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMask.cpp; path = ../libsgl/effects/SkBlurMask.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42850EE9CDFA0008420F /* SkBlurMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlurMask.h; path = ../libsgl/effects/SkBlurMask.h; sourceTree = SOURCE_ROOT; }; + 00BE42860EE9CDFA0008420F /* SkBlurMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlurMaskFilter.cpp; path = ../libsgl/effects/SkBlurMaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42870EE9CDFA0008420F /* SkCamera.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCamera.cpp; path = ../libsgl/effects/SkCamera.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42880EE9CDFA0008420F /* SkColorFilters.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilters.cpp; path = ../libsgl/effects/SkColorFilters.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42890EE9CDFA0008420F /* SkColorMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrix.cpp; path = ../libsgl/effects/SkColorMatrix.cpp; sourceTree = SOURCE_ROOT; }; + 00BE428A0EE9CDFA0008420F /* SkColorMatrixFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorMatrixFilter.cpp; path = ../libsgl/effects/SkColorMatrixFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE428B0EE9CDFA0008420F /* SkCornerPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCornerPathEffect.cpp; path = ../libsgl/effects/SkCornerPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE428C0EE9CDFA0008420F /* SkCullPoints.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCullPoints.cpp; path = ../libsgl/effects/SkCullPoints.cpp; sourceTree = SOURCE_ROOT; }; + 00BE428D0EE9CDFA0008420F /* SkDashPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDashPathEffect.cpp; path = ../libsgl/effects/SkDashPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE428E0EE9CDFA0008420F /* SkDiscretePathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDiscretePathEffect.cpp; path = ../libsgl/effects/SkDiscretePathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE428F0EE9CDFA0008420F /* SkDumpCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDumpCanvas.cpp; path = ../libsgl/effects/SkDumpCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42900EE9CDFA0008420F /* SkEmbossMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMask.cpp; path = ../libsgl/effects/SkEmbossMask.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42910EE9CDFA0008420F /* SkEmbossMask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask.h; path = ../libsgl/effects/SkEmbossMask.h; sourceTree = SOURCE_ROOT; }; + 00BE42920EE9CDFA0008420F /* SkEmbossMask_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEmbossMask_Table.h; path = ../libsgl/effects/SkEmbossMask_Table.h; sourceTree = SOURCE_ROOT; }; + 00BE42930EE9CDFA0008420F /* SkEmbossMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEmbossMaskFilter.cpp; path = ../libsgl/effects/SkEmbossMaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42940EE9CDFA0008420F /* SkGradientShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGradientShader.cpp; path = ../libsgl/effects/SkGradientShader.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42950EE9CDFA0008420F /* SkKernel33MaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkKernel33MaskFilter.cpp; path = ../libsgl/effects/SkKernel33MaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42960EE9CDFA0008420F /* SkLayerDrawLooper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerDrawLooper.cpp; path = ../libsgl/effects/SkLayerDrawLooper.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42970EE9CDFA0008420F /* SkLayerRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkLayerRasterizer.cpp; path = ../libsgl/effects/SkLayerRasterizer.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42980EE9CDFA0008420F /* SkNinePatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkNinePatch.cpp; path = ../libsgl/effects/SkNinePatch.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42990EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaintFlagsDrawFilter.cpp; path = ../libsgl/effects/SkPaintFlagsDrawFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE429A0EE9CDFA0008420F /* SkPixelXorXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelXorXfermode.cpp; path = ../libsgl/effects/SkPixelXorXfermode.cpp; sourceTree = SOURCE_ROOT; }; + 00BE429B0EE9CDFA0008420F /* SkProxyCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProxyCanvas.cpp; path = ../libsgl/effects/SkProxyCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00BE429C0EE9CDFA0008420F /* SkRadialGradient_Table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkRadialGradient_Table.h; path = ../libsgl/effects/SkRadialGradient_Table.h; sourceTree = SOURCE_ROOT; }; + 00BE429D0EE9CDFA0008420F /* SkShaderExtras.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShaderExtras.cpp; path = ../libsgl/effects/SkShaderExtras.cpp; sourceTree = SOURCE_ROOT; }; + 00BE429E0EE9CDFA0008420F /* SkTransparentShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTransparentShader.cpp; path = ../libsgl/effects/SkTransparentShader.cpp; sourceTree = SOURCE_ROOT; }; + 00BE429F0EE9CDFA0008420F /* SkUnitMappers.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnitMappers.cpp; path = ../libsgl/effects/SkUnitMappers.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A10EE9CDFA0008420F /* SkBGViewArtist.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBGViewArtist.cpp; path = ../libsgl/views/SkBGViewArtist.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A20EE9CDFA0008420F /* SkBorderView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBorderView.cpp; path = ../libsgl/views/SkBorderView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A30EE9CDFA0008420F /* SkEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEvent.cpp; path = ../libsgl/views/SkEvent.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A40EE9CDFA0008420F /* SkEventSink.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEventSink.cpp; path = ../libsgl/views/SkEventSink.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A50EE9CDFA0008420F /* SkImageView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageView.cpp; path = ../libsgl/views/SkImageView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A60EE9CDFA0008420F /* SkListView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListView.cpp; path = ../libsgl/views/SkListView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A70EE9CDFA0008420F /* SkListWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListWidget.cpp; path = ../libsgl/views/SkListWidget.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A80EE9CDFA0008420F /* SkMetaData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMetaData.cpp; path = ../libsgl/views/SkMetaData.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42A90EE9CDFA0008420F /* SkOSFile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile.cpp; path = ../libsgl/views/SkOSFile.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42AA0EE9CDFA0008420F /* SkOSMenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSMenu.cpp; path = ../libsgl/views/SkOSMenu.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42AB0EE9CDFA0008420F /* SkOSSound.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSSound.cpp; path = ../libsgl/views/SkOSSound.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42AC0EE9CDFA0008420F /* SkParsePaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParsePaint.cpp; path = ../libsgl/views/SkParsePaint.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42AD0EE9CDFA0008420F /* SkProgressBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressBarView.cpp; path = ../libsgl/views/SkProgressBarView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42AE0EE9CDFA0008420F /* SkProgressView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressView.cpp; path = ../libsgl/views/SkProgressView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42AF0EE9CDFA0008420F /* SkScrollBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScrollBarView.cpp; path = ../libsgl/views/SkScrollBarView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B00EE9CDFA0008420F /* SkStackViewLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStackViewLayout.cpp; path = ../libsgl/views/SkStackViewLayout.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B10EE9CDFA0008420F /* SkTagList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTagList.cpp; path = ../libsgl/views/SkTagList.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B20EE9CDFA0008420F /* SkTagList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTagList.h; path = ../libsgl/views/SkTagList.h; sourceTree = SOURCE_ROOT; }; + 00BE42B30EE9CDFA0008420F /* SkTextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextBox.cpp; path = ../libsgl/views/SkTextBox.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B40EE9CDFA0008420F /* SkView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkView.cpp; path = ../libsgl/views/SkView.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B50EE9CDFA0008420F /* SkViewInflate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewInflate.cpp; path = ../libsgl/views/SkViewInflate.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B60EE9CDFA0008420F /* SkViewPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewPriv.cpp; path = ../libsgl/views/SkViewPriv.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B70EE9CDFA0008420F /* SkViewPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkViewPriv.h; path = ../libsgl/views/SkViewPriv.h; sourceTree = SOURCE_ROOT; }; + 00BE42B80EE9CDFA0008420F /* SkWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidget.cpp; path = ../libsgl/views/SkWidget.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42B90EE9CDFA0008420F /* SkWidgets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgets.cpp; path = ../libsgl/views/SkWidgets.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42BA0EE9CDFA0008420F /* SkWidgetViews.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgetViews.cpp; path = ../libsgl/views/SkWidgetViews.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42BB0EE9CDFA0008420F /* SkWindow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWindow.cpp; path = ../libsgl/views/SkWindow.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42BD0EE9CDFA0008420F /* SkFDStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFDStream.cpp; path = ../libsgl/images/SkFDStream.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42BE0EE9CDFA0008420F /* SkFlipPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlipPixelRef.cpp; path = ../libsgl/images/SkFlipPixelRef.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42BF0EE9CDFA0008420F /* SkImageDecoder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder.cpp; path = ../libsgl/images/SkImageDecoder.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42C10EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libbmp.cpp; path = ../libsgl/images/SkImageDecoder_libbmp.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42C30EE9CDFA0008420F /* SkImageDecoder_libico.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_libico.cpp; path = ../libsgl/images/SkImageDecoder_libico.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42C70EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_wbmp.cpp; path = ../libsgl/images/SkImageDecoder_wbmp.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42C80EE9CDFA0008420F /* SkImageRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef.cpp; path = ../libsgl/images/SkImageRef.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42C90EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRef_GlobalPool.cpp; path = ../libsgl/images/SkImageRef_GlobalPool.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42CA0EE9CDFA0008420F /* SkImageRefPool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageRefPool.cpp; path = ../libsgl/images/SkImageRefPool.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42CB0EE9CDFA0008420F /* SkImageRefPool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkImageRefPool.h; path = ../libsgl/images/SkImageRefPool.h; sourceTree = SOURCE_ROOT; }; + 00BE42CC0EE9CDFA0008420F /* SkMMapStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMMapStream.cpp; path = ../libsgl/images/SkMMapStream.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42CD0EE9CDFA0008420F /* SkMovie.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMovie.cpp; path = ../libsgl/images/SkMovie.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42CF0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScaledBitmapSampler.cpp; path = ../libsgl/images/SkScaledBitmapSampler.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D00EE9CDFA0008420F /* SkScaledBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScaledBitmapSampler.h; path = ../libsgl/images/SkScaledBitmapSampler.h; sourceTree = SOURCE_ROOT; }; + 00BE42D10EE9CDFA0008420F /* SkStream.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStream.cpp; path = ../libsgl/images/SkStream.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D30EE9CDFA0008420F /* SkFontHost_android.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_android.cpp; path = ../libsgl/ports/SkFontHost_android.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D40EE9CDFA0008420F /* SkFontHost_gamma.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFontHost_gamma.cpp; path = ../libsgl/ports/SkFontHost_gamma.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D50EE9CDFA0008420F /* SkGlobals_global.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals_global.cpp; path = ../libsgl/ports/SkGlobals_global.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D60EE9CDFA0008420F /* SkImageDecoder_Factory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageDecoder_Factory.cpp; path = ../libsgl/ports/SkImageDecoder_Factory.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D70EE9CDFA0008420F /* SkThread_pthread.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkThread_pthread.cpp; path = ../libsgl/ports/SkThread_pthread.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42D80EE9CDFA0008420F /* SkTime_Unix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTime_Unix.cpp; path = ../libsgl/ports/SkTime_Unix.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42DA0EE9CDFA0008420F /* SkPathHeap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathHeap.cpp; path = ../libsgl/picture/SkPathHeap.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42DB0EE9CDFA0008420F /* SkPathHeap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPathHeap.h; path = ../libsgl/picture/SkPathHeap.h; sourceTree = SOURCE_ROOT; }; + 00BE42DC0EE9CDFA0008420F /* SkPicture.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicture.cpp; path = ../libsgl/picture/SkPicture.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42DD0EE9CDFA0008420F /* SkPictureFlat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureFlat.cpp; path = ../libsgl/picture/SkPictureFlat.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42DE0EE9CDFA0008420F /* SkPictureFlat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureFlat.h; path = ../libsgl/picture/SkPictureFlat.h; sourceTree = SOURCE_ROOT; }; + 00BE42DF0EE9CDFA0008420F /* SkPicturePlayback.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPicturePlayback.cpp; path = ../libsgl/picture/SkPicturePlayback.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42E00EE9CDFA0008420F /* SkPicturePlayback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPicturePlayback.h; path = ../libsgl/picture/SkPicturePlayback.h; sourceTree = SOURCE_ROOT; }; + 00BE42E10EE9CDFA0008420F /* SkPictureRecord.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPictureRecord.cpp; path = ../libsgl/picture/SkPictureRecord.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42E20EE9CDFA0008420F /* SkPictureRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkPictureRecord.h; path = ../libsgl/picture/SkPictureRecord.h; sourceTree = SOURCE_ROOT; }; + 00BE42E30EE9CDFA0008420F /* SkGL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGL.cpp; path = ../libsgl/gl/SkGL.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42E40EE9CDFA0008420F /* SkGL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGL.h; path = ../libsgl/gl/SkGL.h; sourceTree = SOURCE_ROOT; }; + 00BE42E50EE9CDFA0008420F /* SkGLCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLCanvas.cpp; path = ../libsgl/gl/SkGLCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42E60EE9CDFA0008420F /* SkGLDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice.cpp; path = ../libsgl/gl/SkGLDevice.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42E70EE9CDFA0008420F /* SkGLDevice.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice.h; path = ../libsgl/gl/SkGLDevice.h; sourceTree = SOURCE_ROOT; }; + 00BE42E80EE9CDFA0008420F /* SkGLDevice_FBO.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_FBO.cpp; path = ../libsgl/gl/SkGLDevice_FBO.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42E90EE9CDFA0008420F /* SkGLDevice_FBO.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_FBO.h; path = ../libsgl/gl/SkGLDevice_FBO.h; sourceTree = SOURCE_ROOT; }; + 00BE42EA0EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLDevice_SWLayer.cpp; path = ../libsgl/gl/SkGLDevice_SWLayer.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42EB0EE9CDFA0008420F /* SkGLDevice_SWLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLDevice_SWLayer.h; path = ../libsgl/gl/SkGLDevice_SWLayer.h; sourceTree = SOURCE_ROOT; }; + 00BE42EC0EE9CDFA0008420F /* SkGLTextCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGLTextCache.cpp; path = ../libsgl/gl/SkGLTextCache.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42ED0EE9CDFA0008420F /* SkGLTextCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGLTextCache.h; path = ../libsgl/gl/SkGLTextCache.h; sourceTree = SOURCE_ROOT; }; + 00BE42EE0EE9CDFA0008420F /* SkTextureCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextureCache.cpp; path = ../libsgl/gl/SkTextureCache.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42EF0EE9CDFA0008420F /* SkTextureCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTextureCache.h; path = ../libsgl/gl/SkTextureCache.h; sourceTree = SOURCE_ROOT; }; + 00BE42F00EE9CDFA0008420F /* SkAlphaRuns.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkAlphaRuns.cpp; path = ../libsgl/sgl/SkAlphaRuns.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42F10EE9CDFA0008420F /* SkAntiRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAntiRun.h; path = ../libsgl/sgl/SkAntiRun.h; sourceTree = SOURCE_ROOT; }; + 00BE42F20EE9CDFA0008420F /* SkAutoKern.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkAutoKern.h; path = ../libsgl/sgl/SkAutoKern.h; sourceTree = SOURCE_ROOT; }; + 00BE42F30EE9CDFA0008420F /* SkBitmap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap.cpp; path = ../libsgl/sgl/SkBitmap.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42F40EE9CDFA0008420F /* SkBitmap_scroll.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmap_scroll.cpp; path = ../libsgl/sgl/SkBitmap_scroll.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42F50EE9CDFA0008420F /* SkBitmapProcShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcShader.cpp; path = ../libsgl/sgl/SkBitmapProcShader.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42F60EE9CDFA0008420F /* SkBitmapProcShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcShader.h; path = ../libsgl/sgl/SkBitmapProcShader.h; sourceTree = SOURCE_ROOT; }; + 00BE42F70EE9CDFA0008420F /* SkBitmapProcState.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState.cpp; path = ../libsgl/sgl/SkBitmapProcState.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42F80EE9CDFA0008420F /* SkBitmapProcState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState.h; path = ../libsgl/sgl/SkBitmapProcState.h; sourceTree = SOURCE_ROOT; }; + 00BE42F90EE9CDFA0008420F /* SkBitmapProcState_matrix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_matrix.h; path = ../libsgl/sgl/SkBitmapProcState_matrix.h; sourceTree = SOURCE_ROOT; }; + 00BE42FA0EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapProcState_matrixProcs.cpp; path = ../libsgl/sgl/SkBitmapProcState_matrixProcs.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42FB0EE9CDFA0008420F /* SkBitmapProcState_sample.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapProcState_sample.h; path = ../libsgl/sgl/SkBitmapProcState_sample.h; sourceTree = SOURCE_ROOT; }; + 00BE42FC0EE9CDFA0008420F /* SkBitmapSampler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapSampler.cpp; path = ../libsgl/sgl/SkBitmapSampler.cpp; sourceTree = SOURCE_ROOT; }; + 00BE42FD0EE9CDFA0008420F /* SkBitmapSampler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSampler.h; path = ../libsgl/sgl/SkBitmapSampler.h; sourceTree = SOURCE_ROOT; }; + 00BE42FE0EE9CDFA0008420F /* SkBitmapSamplerTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapSamplerTemplate.h; path = ../libsgl/sgl/SkBitmapSamplerTemplate.h; sourceTree = SOURCE_ROOT; }; + 00BE42FF0EE9CDFA0008420F /* SkBitmapShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBitmapShader.cpp; path = ../libsgl/sgl/SkBitmapShader.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43000EE9CDFA0008420F /* SkBitmapShader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader.h; path = ../libsgl/sgl/SkBitmapShader.h; sourceTree = SOURCE_ROOT; }; + 00BE43010EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShader16BilerpTemplate.h; path = ../libsgl/sgl/SkBitmapShader16BilerpTemplate.h; sourceTree = SOURCE_ROOT; }; + 00BE43020EE9CDFA0008420F /* SkBitmapShaderTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBitmapShaderTemplate.h; path = ../libsgl/sgl/SkBitmapShaderTemplate.h; sourceTree = SOURCE_ROOT; }; + 00BE43030EE9CDFA0008420F /* SkBlitBWMaskTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitBWMaskTemplate.h; path = ../libsgl/sgl/SkBlitBWMaskTemplate.h; sourceTree = SOURCE_ROOT; }; + 00BE43040EE9CDFA0008420F /* SkBlitRow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitRow.h; path = ../libsgl/sgl/SkBlitRow.h; sourceTree = SOURCE_ROOT; }; + 00BE43050EE9CDFA0008420F /* SkBlitRow_D16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D16.cpp; path = ../libsgl/sgl/SkBlitRow_D16.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43060EE9CDFA0008420F /* SkBlitRow_D4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitRow_D4444.cpp; path = ../libsgl/sgl/SkBlitRow_D4444.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43070EE9CDFA0008420F /* SkBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter.cpp; path = ../libsgl/sgl/SkBlitter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43080EE9CDFA0008420F /* SkBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkBlitter.h; path = ../libsgl/sgl/SkBlitter.h; sourceTree = SOURCE_ROOT; }; + 00BE43090EE9CDFA0008420F /* SkBlitter_4444.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_4444.cpp; path = ../libsgl/sgl/SkBlitter_4444.cpp; sourceTree = SOURCE_ROOT; }; + 00BE430A0EE9CDFA0008420F /* SkBlitter_A1.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A1.cpp; path = ../libsgl/sgl/SkBlitter_A1.cpp; sourceTree = SOURCE_ROOT; }; + 00BE430B0EE9CDFA0008420F /* SkBlitter_A8.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_A8.cpp; path = ../libsgl/sgl/SkBlitter_A8.cpp; sourceTree = SOURCE_ROOT; }; + 00BE430C0EE9CDFA0008420F /* SkBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; }; + 00BE430D0EE9CDFA0008420F /* SkBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_RGB16.cpp; path = ../libsgl/sgl/SkBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; }; + 00BE430E0EE9CDFA0008420F /* SkBlitter_Sprite.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBlitter_Sprite.cpp; path = ../libsgl/sgl/SkBlitter_Sprite.cpp; sourceTree = SOURCE_ROOT; }; + 00BE430F0EE9CDFA0008420F /* SkCanvas.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCanvas.cpp; path = ../libsgl/sgl/SkCanvas.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43100EE9CDFA0008420F /* SkColor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColor.cpp; path = ../libsgl/sgl/SkColor.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43110EE9CDFA0008420F /* SkColorFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorFilter.cpp; path = ../libsgl/sgl/SkColorFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43120EE9CDFA0008420F /* SkColorTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkColorTable.cpp; path = ../libsgl/sgl/SkColorTable.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43130EE9CDFA0008420F /* SkCoreBlitters.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCoreBlitters.h; path = ../libsgl/sgl/SkCoreBlitters.h; sourceTree = SOURCE_ROOT; }; + 00BE43140EE9CDFA0008420F /* SkDeque.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDeque.cpp; path = ../libsgl/sgl/SkDeque.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43150EE9CDFA0008420F /* SkDevice.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDevice.cpp; path = ../libsgl/sgl/SkDevice.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43160EE9CDFA0008420F /* SkDither.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDither.cpp; path = ../libsgl/sgl/SkDither.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43170EE9CDFA0008420F /* SkDraw.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDraw.cpp; path = ../libsgl/sgl/SkDraw.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43180EE9CDFA0008420F /* SkDrawProcs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkDrawProcs.h; path = ../libsgl/sgl/SkDrawProcs.h; sourceTree = SOURCE_ROOT; }; + 00BE43190EE9CDFA0008420F /* SkEdge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEdge.cpp; path = ../libsgl/sgl/SkEdge.cpp; sourceTree = SOURCE_ROOT; }; + 00BE431A0EE9CDFA0008420F /* SkEdge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkEdge.h; path = ../libsgl/sgl/SkEdge.h; sourceTree = SOURCE_ROOT; }; + 00BE431B0EE9CDFA0008420F /* SkFilterProc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFilterProc.cpp; path = ../libsgl/sgl/SkFilterProc.cpp; sourceTree = SOURCE_ROOT; }; + 00BE431C0EE9CDFA0008420F /* SkFilterProc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFilterProc.h; path = ../libsgl/sgl/SkFilterProc.h; sourceTree = SOURCE_ROOT; }; + 00BE431D0EE9CDFA0008420F /* SkFlattenable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFlattenable.cpp; path = ../libsgl/sgl/SkFlattenable.cpp; sourceTree = SOURCE_ROOT; }; + 00BE431E0EE9CDFA0008420F /* SkFP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFP.h; path = ../libsgl/sgl/SkFP.h; sourceTree = SOURCE_ROOT; }; + 00BE431F0EE9CDFA0008420F /* SkGeometry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGeometry.cpp; path = ../libsgl/sgl/SkGeometry.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43200EE9CDFA0008420F /* SkGeometry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGeometry.h; path = ../libsgl/sgl/SkGeometry.h; sourceTree = SOURCE_ROOT; }; + 00BE43210EE9CDFA0008420F /* SkGlobals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlobals.cpp; path = ../libsgl/sgl/SkGlobals.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43220EE9CDFA0008420F /* SkGlyphCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGlyphCache.cpp; path = ../libsgl/sgl/SkGlyphCache.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43230EE9CDFA0008420F /* SkGlyphCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkGlyphCache.h; path = ../libsgl/sgl/SkGlyphCache.h; sourceTree = SOURCE_ROOT; }; + 00BE43240EE9CDFA0008420F /* SkGraphics.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkGraphics.cpp; path = ../libsgl/sgl/SkGraphics.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43250EE9CDFA0008420F /* SkMask.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMask.cpp; path = ../libsgl/sgl/SkMask.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43260EE9CDFA0008420F /* SkMaskFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMaskFilter.cpp; path = ../libsgl/sgl/SkMaskFilter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43270EE9CDFA0008420F /* SkPackBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPackBits.cpp; path = ../libsgl/sgl/SkPackBits.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43280EE9CDFA0008420F /* SkPaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPaint.cpp; path = ../libsgl/sgl/SkPaint.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43290EE9CDFA0008420F /* SkPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPath.cpp; path = ../libsgl/sgl/SkPath.cpp; sourceTree = SOURCE_ROOT; }; + 00BE432A0EE9CDFA0008420F /* SkPathEffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathEffect.cpp; path = ../libsgl/sgl/SkPathEffect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE432B0EE9CDFA0008420F /* SkPathMeasure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPathMeasure.cpp; path = ../libsgl/sgl/SkPathMeasure.cpp; sourceTree = SOURCE_ROOT; }; + 00BE432C0EE9CDFA0008420F /* SkPixelRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPixelRef.cpp; path = ../libsgl/sgl/SkPixelRef.cpp; sourceTree = SOURCE_ROOT; }; + 00BE432D0EE9CDFA0008420F /* SkProcSpriteBlitter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProcSpriteBlitter.cpp; path = ../libsgl/sgl/SkProcSpriteBlitter.cpp; sourceTree = SOURCE_ROOT; }; + 00BE432E0EE9CDFA0008420F /* SkPtrRecorder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPtrRecorder.cpp; path = ../libsgl/sgl/SkPtrRecorder.cpp; sourceTree = SOURCE_ROOT; }; + 00BE432F0EE9CDFA0008420F /* SkRasterizer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRasterizer.cpp; path = ../libsgl/sgl/SkRasterizer.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43300EE9CDFA0008420F /* SkRefCnt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRefCnt.cpp; path = ../libsgl/sgl/SkRefCnt.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43310EE9CDFA0008420F /* SkRegion_path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion_path.cpp; path = ../libsgl/sgl/SkRegion_path.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43320EE9CDFA0008420F /* SkScalerContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScalerContext.cpp; path = ../libsgl/sgl/SkScalerContext.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43330EE9CDFA0008420F /* SkScan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan.cpp; path = ../libsgl/sgl/SkScan.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43340EE9CDFA0008420F /* SkScan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScan.h; path = ../libsgl/sgl/SkScan.h; sourceTree = SOURCE_ROOT; }; + 00BE43350EE9CDFA0008420F /* SkScan_Antihair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Antihair.cpp; path = ../libsgl/sgl/SkScan_Antihair.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43360EE9CDFA0008420F /* SkScan_AntiPath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_AntiPath.cpp; path = ../libsgl/sgl/SkScan_AntiPath.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43370EE9CDFA0008420F /* SkScan_Hairline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Hairline.cpp; path = ../libsgl/sgl/SkScan_Hairline.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43380EE9CDFA0008420F /* SkScan_Path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScan_Path.cpp; path = ../libsgl/sgl/SkScan_Path.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43390EE9CDFA0008420F /* SkScanPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkScanPriv.h; path = ../libsgl/sgl/SkScanPriv.h; sourceTree = SOURCE_ROOT; }; + 00BE433A0EE9CDFA0008420F /* SkShader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkShader.cpp; path = ../libsgl/sgl/SkShader.cpp; sourceTree = SOURCE_ROOT; }; + 00BE433B0EE9CDFA0008420F /* SkSpriteBlitter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitter.h; path = ../libsgl/sgl/SkSpriteBlitter.h; sourceTree = SOURCE_ROOT; }; + 00BE433C0EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_ARGB32.cpp; path = ../libsgl/sgl/SkSpriteBlitter_ARGB32.cpp; sourceTree = SOURCE_ROOT; }; + 00BE433D0EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkSpriteBlitter_RGB16.cpp; path = ../libsgl/sgl/SkSpriteBlitter_RGB16.cpp; sourceTree = SOURCE_ROOT; }; + 00BE433E0EE9CDFA0008420F /* SkSpriteBlitterTemplate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkSpriteBlitterTemplate.h; path = ../libsgl/sgl/SkSpriteBlitterTemplate.h; sourceTree = SOURCE_ROOT; }; + 00BE43400EE9CDFA0008420F /* SkStroke.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStroke.cpp; path = ../libsgl/sgl/SkStroke.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43410EE9CDFA0008420F /* SkStrokerPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStrokerPriv.cpp; path = ../libsgl/sgl/SkStrokerPriv.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43420EE9CDFA0008420F /* SkStrokerPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkStrokerPriv.h; path = ../libsgl/sgl/SkStrokerPriv.h; sourceTree = SOURCE_ROOT; }; + 00BE43430EE9CDFA0008420F /* SkTemplatesPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTemplatesPriv.h; path = ../libsgl/sgl/SkTemplatesPriv.h; sourceTree = SOURCE_ROOT; }; + 00BE43440EE9CDFA0008420F /* SkTSearch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTSearch.cpp; path = ../libsgl/sgl/SkTSearch.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43450EE9CDFA0008420F /* SkTSort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTSort.h; path = ../libsgl/sgl/SkTSort.h; sourceTree = SOURCE_ROOT; }; + 00BE43460EE9CDFA0008420F /* SkTypeface.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTypeface.cpp; path = ../libsgl/sgl/SkTypeface.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43470EE9CDFA0008420F /* SkUnPreMultiply.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkUnPreMultiply.cpp; path = ../libsgl/sgl/SkUnPreMultiply.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43490EE9CDFA0008420F /* SkWriter32.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWriter32.cpp; path = ../libsgl/sgl/SkWriter32.cpp; sourceTree = SOURCE_ROOT; }; + 00BE434A0EE9CDFA0008420F /* SkXfermode.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkXfermode.cpp; path = ../libsgl/sgl/SkXfermode.cpp; sourceTree = SOURCE_ROOT; }; + 00BE434B0EE9CDFA0008420F /* Sk64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Sk64.cpp; path = ../libcorecg/Sk64.cpp; sourceTree = SOURCE_ROOT; }; + 00BE434C0EE9CDFA0008420F /* SkBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBuffer.cpp; path = ../libcorecg/SkBuffer.cpp; sourceTree = SOURCE_ROOT; }; + 00BE434D0EE9CDFA0008420F /* SkChunkAlloc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkChunkAlloc.cpp; path = ../libcorecg/SkChunkAlloc.cpp; sourceTree = SOURCE_ROOT; }; + 00BE434E0EE9CDFA0008420F /* SkCordic.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkCordic.cpp; path = ../libcorecg/SkCordic.cpp; sourceTree = SOURCE_ROOT; }; + 00BE434F0EE9CDFA0008420F /* SkCordic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkCordic.h; path = ../libcorecg/SkCordic.h; sourceTree = SOURCE_ROOT; }; + 00BE43500EE9CDFA0008420F /* SkDebug.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug.cpp; path = ../libcorecg/SkDebug.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43510EE9CDFA0008420F /* SkDebug_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkDebug_stdio.cpp; path = ../libcorecg/SkDebug_stdio.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43520EE9CDFA0008420F /* SkFloat.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloat.cpp; path = ../libcorecg/SkFloat.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43530EE9CDFA0008420F /* SkFloat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkFloat.h; path = ../libcorecg/SkFloat.h; sourceTree = SOURCE_ROOT; }; + 00BE43540EE9CDFA0008420F /* SkFloatBits.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkFloatBits.cpp; path = ../libcorecg/SkFloatBits.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43550EE9CDFA0008420F /* SkInterpolator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkInterpolator.cpp; path = ../libcorecg/SkInterpolator.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43560EE9CDFA0008420F /* SkMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMath.cpp; path = ../libcorecg/SkMath.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43570EE9CDFA0008420F /* SkMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMatrix.cpp; path = ../libcorecg/SkMatrix.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43580EE9CDFA0008420F /* SkMemory_stdlib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMemory_stdlib.cpp; path = ../libcorecg/SkMemory_stdlib.cpp; sourceTree = SOURCE_ROOT; }; + 00BE43590EE9CDFA0008420F /* SkPageFlipper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPageFlipper.cpp; path = ../libcorecg/SkPageFlipper.cpp; sourceTree = SOURCE_ROOT; }; + 00BE435A0EE9CDFA0008420F /* SkPoint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkPoint.cpp; path = ../libcorecg/SkPoint.cpp; sourceTree = SOURCE_ROOT; }; + 00BE435B0EE9CDFA0008420F /* SkRect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRect.cpp; path = ../libcorecg/SkRect.cpp; sourceTree = SOURCE_ROOT; }; + 00BE435C0EE9CDFA0008420F /* SkRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkRegion.cpp; path = ../libcorecg/SkRegion.cpp; sourceTree = SOURCE_ROOT; }; + 00BE444D0EE9D1780008420F /* giflib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = giflib.xcodeproj; sourceTree = "<group>"; }; + 00BE44560EE9D1780008420F /* jpeg.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = jpeg.xcodeproj; sourceTree = "<group>"; }; + 00BE44590EE9D1780008420F /* libpng.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = libpng.xcodeproj; sourceTree = "<group>"; }; + 00BE445C0EE9D1780008420F /* zlib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = zlib.xcodeproj; sourceTree = "<group>"; }; + 00BE44C80EE9D4FC0008420F /* SkOSFile_stdio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile_stdio.cpp; path = ../libsgl/ports/SkOSFile_stdio.cpp; sourceTree = SOURCE_ROOT; }; + 00BE45060EE9D8120008420F /* bmpdecoderhelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = bmpdecoderhelper.cpp; path = ../libsgl/images/bmpdecoderhelper.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libskia2.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libskia2.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 00BE44D40EE9D5660008420F /* libjpeg.a in Frameworks */, + 00BE44D50EE9D5670008420F /* liblibpng.a in Frameworks */, + 00BE44D60EE9D5690008420F /* libzlib.a in Frameworks */, + 00A567300EED6F6E0096A2A1 /* libgiflib.a in Frameworks */, + 003E926F0EED78220091D85B /* libfreetype.a in Frameworks */, + 00AFCE240EF16C0500BD2FF1 /* libexpat.a in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 00A567690EED77850096A2A1 /* Products */ = { + isa = PBXGroup; + children = ( + 00A5676D0EED77850096A2A1 /* libfreetype.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00AFCD780EF167A300BD2FF1 /* xml */ = { + isa = PBXGroup; + children = ( + 00AFCD790EF167BC00BD2FF1 /* SkParse.cpp */, + 00AFCD7A0EF167BC00BD2FF1 /* SkParseColor.cpp */, + 00AFCD7B0EF167BC00BD2FF1 /* SkXMLParser.cpp */, + 00AFCD700EF1672C00BD2FF1 /* SkDOM.cpp */, + ); + name = xml; + sourceTree = "<group>"; + }; + 00AFCE0E0EF16BA400BD2FF1 /* Products */ = { + isa = PBXGroup; + children = ( + 00AFCE150EF16BA400BD2FF1 /* libexpat.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00BE427F0EE9CDFA0008420F /* effects */ = { + isa = PBXGroup; + children = ( + 00BE42800EE9CDFA0008420F /* Sk1DPathEffect.cpp */, + 00BE42810EE9CDFA0008420F /* Sk2DPathEffect.cpp */, + 00BE42820EE9CDFA0008420F /* SkAvoidXfermode.cpp */, + 00BE42830EE9CDFA0008420F /* SkBlurDrawLooper.cpp */, + 00BE42840EE9CDFA0008420F /* SkBlurMask.cpp */, + 00BE42850EE9CDFA0008420F /* SkBlurMask.h */, + 00BE42860EE9CDFA0008420F /* SkBlurMaskFilter.cpp */, + 00BE42870EE9CDFA0008420F /* SkCamera.cpp */, + 00BE42880EE9CDFA0008420F /* SkColorFilters.cpp */, + 00BE42890EE9CDFA0008420F /* SkColorMatrix.cpp */, + 00BE428A0EE9CDFA0008420F /* SkColorMatrixFilter.cpp */, + 00BE428B0EE9CDFA0008420F /* SkCornerPathEffect.cpp */, + 00BE428C0EE9CDFA0008420F /* SkCullPoints.cpp */, + 00BE428D0EE9CDFA0008420F /* SkDashPathEffect.cpp */, + 00BE428E0EE9CDFA0008420F /* SkDiscretePathEffect.cpp */, + 00BE428F0EE9CDFA0008420F /* SkDumpCanvas.cpp */, + 00BE42900EE9CDFA0008420F /* SkEmbossMask.cpp */, + 00BE42910EE9CDFA0008420F /* SkEmbossMask.h */, + 00BE42920EE9CDFA0008420F /* SkEmbossMask_Table.h */, + 00BE42930EE9CDFA0008420F /* SkEmbossMaskFilter.cpp */, + 00BE42940EE9CDFA0008420F /* SkGradientShader.cpp */, + 00BE42950EE9CDFA0008420F /* SkKernel33MaskFilter.cpp */, + 00BE42960EE9CDFA0008420F /* SkLayerDrawLooper.cpp */, + 00BE42970EE9CDFA0008420F /* SkLayerRasterizer.cpp */, + 00BE42980EE9CDFA0008420F /* SkNinePatch.cpp */, + 00BE42990EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp */, + 00BE429A0EE9CDFA0008420F /* SkPixelXorXfermode.cpp */, + 00BE429B0EE9CDFA0008420F /* SkProxyCanvas.cpp */, + 00BE429C0EE9CDFA0008420F /* SkRadialGradient_Table.h */, + 00BE429D0EE9CDFA0008420F /* SkShaderExtras.cpp */, + 00BE429E0EE9CDFA0008420F /* SkTransparentShader.cpp */, + 00BE429F0EE9CDFA0008420F /* SkUnitMappers.cpp */, + ); + name = effects; + sourceTree = "<group>"; + }; + 00BE42A00EE9CDFA0008420F /* view */ = { + isa = PBXGroup; + children = ( + 00BE42A10EE9CDFA0008420F /* SkBGViewArtist.cpp */, + 00BE42A20EE9CDFA0008420F /* SkBorderView.cpp */, + 00BE42A30EE9CDFA0008420F /* SkEvent.cpp */, + 00BE42A40EE9CDFA0008420F /* SkEventSink.cpp */, + 00BE42A50EE9CDFA0008420F /* SkImageView.cpp */, + 00BE42A60EE9CDFA0008420F /* SkListView.cpp */, + 00BE42A70EE9CDFA0008420F /* SkListWidget.cpp */, + 00BE42A80EE9CDFA0008420F /* SkMetaData.cpp */, + 00BE42A90EE9CDFA0008420F /* SkOSFile.cpp */, + 00BE42AA0EE9CDFA0008420F /* SkOSMenu.cpp */, + 00BE42AB0EE9CDFA0008420F /* SkOSSound.cpp */, + 00BE42AC0EE9CDFA0008420F /* SkParsePaint.cpp */, + 00BE42AD0EE9CDFA0008420F /* SkProgressBarView.cpp */, + 00BE42AE0EE9CDFA0008420F /* SkProgressView.cpp */, + 00BE42AF0EE9CDFA0008420F /* SkScrollBarView.cpp */, + 00BE42B00EE9CDFA0008420F /* SkStackViewLayout.cpp */, + 00BE42B10EE9CDFA0008420F /* SkTagList.cpp */, + 00BE42B20EE9CDFA0008420F /* SkTagList.h */, + 00BE42B30EE9CDFA0008420F /* SkTextBox.cpp */, + 00BE42B40EE9CDFA0008420F /* SkView.cpp */, + 00BE42B50EE9CDFA0008420F /* SkViewInflate.cpp */, + 00BE42B60EE9CDFA0008420F /* SkViewPriv.cpp */, + 00BE42B70EE9CDFA0008420F /* SkViewPriv.h */, + 00BE42B80EE9CDFA0008420F /* SkWidget.cpp */, + 00BE42B90EE9CDFA0008420F /* SkWidgets.cpp */, + 00BE42BA0EE9CDFA0008420F /* SkWidgetViews.cpp */, + 00BE42BB0EE9CDFA0008420F /* SkWindow.cpp */, + ); + name = view; + sourceTree = "<group>"; + }; + 00BE42BC0EE9CDFA0008420F /* image */ = { + isa = PBXGroup; + children = ( + 00BE45060EE9D8120008420F /* bmpdecoderhelper.cpp */, + 00BE42BD0EE9CDFA0008420F /* SkFDStream.cpp */, + 00BE42BE0EE9CDFA0008420F /* SkFlipPixelRef.cpp */, + 00BE42BF0EE9CDFA0008420F /* SkImageDecoder.cpp */, + 00BE42C10EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp */, + 00BE42C30EE9CDFA0008420F /* SkImageDecoder_libico.cpp */, + 00BE42C70EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp */, + 00BE42C80EE9CDFA0008420F /* SkImageRef.cpp */, + 00BE42C90EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp */, + 00BE42CA0EE9CDFA0008420F /* SkImageRefPool.cpp */, + 00BE42CB0EE9CDFA0008420F /* SkImageRefPool.h */, + 00BE42CC0EE9CDFA0008420F /* SkMMapStream.cpp */, + 00BE42CD0EE9CDFA0008420F /* SkMovie.cpp */, + 00BE42CF0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp */, + 00BE42D00EE9CDFA0008420F /* SkScaledBitmapSampler.h */, + 00BE42D10EE9CDFA0008420F /* SkStream.cpp */, + ); + name = image; + sourceTree = "<group>"; + }; + 00BE42D20EE9CDFA0008420F /* port */ = { + isa = PBXGroup; + children = ( + 00AFCD8A0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp */, + 00AFCD880EF1684200BD2FF1 /* SkBitmap_Mac.cpp */, + 00BE44C80EE9D4FC0008420F /* SkOSFile_stdio.cpp */, + 00BE42D30EE9CDFA0008420F /* SkFontHost_android.cpp */, + 00BE42D40EE9CDFA0008420F /* SkFontHost_gamma.cpp */, + 00BE42D50EE9CDFA0008420F /* SkGlobals_global.cpp */, + 00BE42D60EE9CDFA0008420F /* SkImageDecoder_Factory.cpp */, + 00BE42D70EE9CDFA0008420F /* SkThread_pthread.cpp */, + 00BE42D80EE9CDFA0008420F /* SkTime_Unix.cpp */, + ); + name = port; + sourceTree = "<group>"; + }; + 00BE42D90EE9CDFA0008420F /* core */ = { + isa = PBXGroup; + children = ( + 006B43FC0EF7526E00F15BC4 /* SkString.cpp */, + 006B43FD0EF7526E00F15BC4 /* SkUtils.cpp */, + 00BE42DA0EE9CDFA0008420F /* SkPathHeap.cpp */, + 00BE42DB0EE9CDFA0008420F /* SkPathHeap.h */, + 00BE42DC0EE9CDFA0008420F /* SkPicture.cpp */, + 00BE42DD0EE9CDFA0008420F /* SkPictureFlat.cpp */, + 00BE42DE0EE9CDFA0008420F /* SkPictureFlat.h */, + 00BE42DF0EE9CDFA0008420F /* SkPicturePlayback.cpp */, + 00BE42E00EE9CDFA0008420F /* SkPicturePlayback.h */, + 00BE42E10EE9CDFA0008420F /* SkPictureRecord.cpp */, + 00BE42E20EE9CDFA0008420F /* SkPictureRecord.h */, + 00BE42E30EE9CDFA0008420F /* SkGL.cpp */, + 00BE42E40EE9CDFA0008420F /* SkGL.h */, + 00BE42E50EE9CDFA0008420F /* SkGLCanvas.cpp */, + 00BE42E60EE9CDFA0008420F /* SkGLDevice.cpp */, + 00BE42E70EE9CDFA0008420F /* SkGLDevice.h */, + 00BE42E80EE9CDFA0008420F /* SkGLDevice_FBO.cpp */, + 00BE42E90EE9CDFA0008420F /* SkGLDevice_FBO.h */, + 00BE42EA0EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp */, + 00BE42EB0EE9CDFA0008420F /* SkGLDevice_SWLayer.h */, + 00BE42EC0EE9CDFA0008420F /* SkGLTextCache.cpp */, + 00BE42ED0EE9CDFA0008420F /* SkGLTextCache.h */, + 00BE42EE0EE9CDFA0008420F /* SkTextureCache.cpp */, + 00BE42EF0EE9CDFA0008420F /* SkTextureCache.h */, + 00BE42F00EE9CDFA0008420F /* SkAlphaRuns.cpp */, + 00BE42F10EE9CDFA0008420F /* SkAntiRun.h */, + 00BE42F20EE9CDFA0008420F /* SkAutoKern.h */, + 00BE42F30EE9CDFA0008420F /* SkBitmap.cpp */, + 00BE42F40EE9CDFA0008420F /* SkBitmap_scroll.cpp */, + 00BE42F50EE9CDFA0008420F /* SkBitmapProcShader.cpp */, + 00BE42F60EE9CDFA0008420F /* SkBitmapProcShader.h */, + 00BE42F70EE9CDFA0008420F /* SkBitmapProcState.cpp */, + 00BE42F80EE9CDFA0008420F /* SkBitmapProcState.h */, + 00BE42F90EE9CDFA0008420F /* SkBitmapProcState_matrix.h */, + 00BE42FA0EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp */, + 00BE42FB0EE9CDFA0008420F /* SkBitmapProcState_sample.h */, + 00BE42FC0EE9CDFA0008420F /* SkBitmapSampler.cpp */, + 00BE42FD0EE9CDFA0008420F /* SkBitmapSampler.h */, + 00BE42FE0EE9CDFA0008420F /* SkBitmapSamplerTemplate.h */, + 00BE42FF0EE9CDFA0008420F /* SkBitmapShader.cpp */, + 00BE43000EE9CDFA0008420F /* SkBitmapShader.h */, + 00BE43010EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h */, + 00BE43020EE9CDFA0008420F /* SkBitmapShaderTemplate.h */, + 00BE43030EE9CDFA0008420F /* SkBlitBWMaskTemplate.h */, + 00BE43040EE9CDFA0008420F /* SkBlitRow.h */, + 00BE43050EE9CDFA0008420F /* SkBlitRow_D16.cpp */, + 00BE43060EE9CDFA0008420F /* SkBlitRow_D4444.cpp */, + 00BE43070EE9CDFA0008420F /* SkBlitter.cpp */, + 00BE43080EE9CDFA0008420F /* SkBlitter.h */, + 00BE43090EE9CDFA0008420F /* SkBlitter_4444.cpp */, + 00BE430A0EE9CDFA0008420F /* SkBlitter_A1.cpp */, + 00BE430B0EE9CDFA0008420F /* SkBlitter_A8.cpp */, + 00BE430C0EE9CDFA0008420F /* SkBlitter_ARGB32.cpp */, + 00BE430D0EE9CDFA0008420F /* SkBlitter_RGB16.cpp */, + 00BE430E0EE9CDFA0008420F /* SkBlitter_Sprite.cpp */, + 00BE430F0EE9CDFA0008420F /* SkCanvas.cpp */, + 00BE43100EE9CDFA0008420F /* SkColor.cpp */, + 00BE43110EE9CDFA0008420F /* SkColorFilter.cpp */, + 00BE43120EE9CDFA0008420F /* SkColorTable.cpp */, + 00BE43130EE9CDFA0008420F /* SkCoreBlitters.h */, + 00BE43140EE9CDFA0008420F /* SkDeque.cpp */, + 00BE43150EE9CDFA0008420F /* SkDevice.cpp */, + 00BE43160EE9CDFA0008420F /* SkDither.cpp */, + 00BE43170EE9CDFA0008420F /* SkDraw.cpp */, + 00BE43180EE9CDFA0008420F /* SkDrawProcs.h */, + 00BE43190EE9CDFA0008420F /* SkEdge.cpp */, + 00BE431A0EE9CDFA0008420F /* SkEdge.h */, + 00BE431B0EE9CDFA0008420F /* SkFilterProc.cpp */, + 00BE431C0EE9CDFA0008420F /* SkFilterProc.h */, + 00BE431D0EE9CDFA0008420F /* SkFlattenable.cpp */, + 00BE431E0EE9CDFA0008420F /* SkFP.h */, + 00BE431F0EE9CDFA0008420F /* SkGeometry.cpp */, + 00BE43200EE9CDFA0008420F /* SkGeometry.h */, + 00BE43210EE9CDFA0008420F /* SkGlobals.cpp */, + 00BE43220EE9CDFA0008420F /* SkGlyphCache.cpp */, + 00BE43230EE9CDFA0008420F /* SkGlyphCache.h */, + 00BE43240EE9CDFA0008420F /* SkGraphics.cpp */, + 00BE43250EE9CDFA0008420F /* SkMask.cpp */, + 00BE43260EE9CDFA0008420F /* SkMaskFilter.cpp */, + 00BE43270EE9CDFA0008420F /* SkPackBits.cpp */, + 00BE43280EE9CDFA0008420F /* SkPaint.cpp */, + 00BE43290EE9CDFA0008420F /* SkPath.cpp */, + 00BE432A0EE9CDFA0008420F /* SkPathEffect.cpp */, + 00BE432B0EE9CDFA0008420F /* SkPathMeasure.cpp */, + 00BE432C0EE9CDFA0008420F /* SkPixelRef.cpp */, + 00BE432D0EE9CDFA0008420F /* SkProcSpriteBlitter.cpp */, + 00BE432E0EE9CDFA0008420F /* SkPtrRecorder.cpp */, + 00BE432F0EE9CDFA0008420F /* SkRasterizer.cpp */, + 00BE43300EE9CDFA0008420F /* SkRefCnt.cpp */, + 00BE43310EE9CDFA0008420F /* SkRegion_path.cpp */, + 00BE43320EE9CDFA0008420F /* SkScalerContext.cpp */, + 00BE43330EE9CDFA0008420F /* SkScan.cpp */, + 00BE43340EE9CDFA0008420F /* SkScan.h */, + 00BE43350EE9CDFA0008420F /* SkScan_Antihair.cpp */, + 00BE43360EE9CDFA0008420F /* SkScan_AntiPath.cpp */, + 00BE43370EE9CDFA0008420F /* SkScan_Hairline.cpp */, + 00BE43380EE9CDFA0008420F /* SkScan_Path.cpp */, + 00BE43390EE9CDFA0008420F /* SkScanPriv.h */, + 00BE433A0EE9CDFA0008420F /* SkShader.cpp */, + 00BE433B0EE9CDFA0008420F /* SkSpriteBlitter.h */, + 00BE433C0EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp */, + 00BE433D0EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp */, + 00BE433E0EE9CDFA0008420F /* SkSpriteBlitterTemplate.h */, + 00BE43400EE9CDFA0008420F /* SkStroke.cpp */, + 00BE43410EE9CDFA0008420F /* SkStrokerPriv.cpp */, + 00BE43420EE9CDFA0008420F /* SkStrokerPriv.h */, + 00BE43430EE9CDFA0008420F /* SkTemplatesPriv.h */, + 00BE43440EE9CDFA0008420F /* SkTSearch.cpp */, + 00BE43450EE9CDFA0008420F /* SkTSort.h */, + 00BE43460EE9CDFA0008420F /* SkTypeface.cpp */, + 00BE43470EE9CDFA0008420F /* SkUnPreMultiply.cpp */, + 00BE43490EE9CDFA0008420F /* SkWriter32.cpp */, + 00BE434A0EE9CDFA0008420F /* SkXfermode.cpp */, + 00BE434B0EE9CDFA0008420F /* Sk64.cpp */, + 00BE434C0EE9CDFA0008420F /* SkBuffer.cpp */, + 00BE434D0EE9CDFA0008420F /* SkChunkAlloc.cpp */, + 00BE434E0EE9CDFA0008420F /* SkCordic.cpp */, + 00BE434F0EE9CDFA0008420F /* SkCordic.h */, + 00BE43500EE9CDFA0008420F /* SkDebug.cpp */, + 00BE43510EE9CDFA0008420F /* SkDebug_stdio.cpp */, + 00BE43520EE9CDFA0008420F /* SkFloat.cpp */, + 00BE43530EE9CDFA0008420F /* SkFloat.h */, + 00BE43540EE9CDFA0008420F /* SkFloatBits.cpp */, + 00BE43550EE9CDFA0008420F /* SkInterpolator.cpp */, + 00BE43560EE9CDFA0008420F /* SkMath.cpp */, + 00BE43570EE9CDFA0008420F /* SkMatrix.cpp */, + 00BE43580EE9CDFA0008420F /* SkMemory_stdlib.cpp */, + 00BE43590EE9CDFA0008420F /* SkPageFlipper.cpp */, + 00BE435A0EE9CDFA0008420F /* SkPoint.cpp */, + 00BE435B0EE9CDFA0008420F /* SkRect.cpp */, + 00BE435C0EE9CDFA0008420F /* SkRegion.cpp */, + ); + name = core; + sourceTree = "<group>"; + }; + 00BE444E0EE9D1780008420F /* Products */ = { + isa = PBXGroup; + children = ( + 00BE44670EE9D1780008420F /* libgiflib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00BE44570EE9D1780008420F /* Products */ = { + isa = PBXGroup; + children = ( + 00BE446A0EE9D1780008420F /* libjpeg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00BE445A0EE9D1780008420F /* Products */ = { + isa = PBXGroup; + children = ( + 00BE446D0EE9D1780008420F /* liblibpng.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 00BE445D0EE9D1780008420F /* Products */ = { + isa = PBXGroup; + children = ( + 00BE44700EE9D1780008420F /* libzlib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + 08FB7794FE84155DC02AAC07 /* skia2 */ = { + isa = PBXGroup; + children = ( + 00AFCD780EF167A300BD2FF1 /* xml */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + 00BE42D90EE9CDFA0008420F /* core */, + 00BE42D20EE9CDFA0008420F /* port */, + 00BE42BC0EE9CDFA0008420F /* image */, + 00BE42A00EE9CDFA0008420F /* view */, + 00BE427F0EE9CDFA0008420F /* effects */, + 00BE444D0EE9D1780008420F /* giflib.xcodeproj */, + 00BE44560EE9D1780008420F /* jpeg.xcodeproj */, + 00BE44590EE9D1780008420F /* libpng.xcodeproj */, + 00BE445C0EE9D1780008420F /* zlib.xcodeproj */, + 00A567680EED77850096A2A1 /* freetype2.xcodeproj */, + 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */, + ); + name = skia2; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libskia2.a */, + ); + name = Products; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00BE43620EE9CDFA0008420F /* SkBlurMask.h in Headers */, + 00BE436E0EE9CDFA0008420F /* SkEmbossMask.h in Headers */, + 00BE436F0EE9CDFA0008420F /* SkEmbossMask_Table.h in Headers */, + 00BE43790EE9CDFA0008420F /* SkRadialGradient_Table.h in Headers */, + 00BE438E0EE9CDFA0008420F /* SkTagList.h in Headers */, + 00BE43930EE9CDFA0008420F /* SkViewPriv.h in Headers */, + 00BE43A60EE9CDFA0008420F /* SkImageRefPool.h in Headers */, + 00BE43AB0EE9CDFA0008420F /* SkScaledBitmapSampler.h in Headers */, + 00BE43B40EE9CDFA0008420F /* SkPathHeap.h in Headers */, + 00BE43B70EE9CDFA0008420F /* SkPictureFlat.h in Headers */, + 00BE43B90EE9CDFA0008420F /* SkPicturePlayback.h in Headers */, + 00BE43BB0EE9CDFA0008420F /* SkPictureRecord.h in Headers */, + 00BE43BD0EE9CDFA0008420F /* SkGL.h in Headers */, + 00BE43C00EE9CDFA0008420F /* SkGLDevice.h in Headers */, + 00BE43C20EE9CDFA0008420F /* SkGLDevice_FBO.h in Headers */, + 00BE43C40EE9CDFA0008420F /* SkGLDevice_SWLayer.h in Headers */, + 00BE43C60EE9CDFA0008420F /* SkGLTextCache.h in Headers */, + 00BE43C80EE9CDFA0008420F /* SkTextureCache.h in Headers */, + 00BE43CA0EE9CDFA0008420F /* SkAntiRun.h in Headers */, + 00BE43CB0EE9CDFA0008420F /* SkAutoKern.h in Headers */, + 00BE43CF0EE9CDFA0008420F /* SkBitmapProcShader.h in Headers */, + 00BE43D10EE9CDFA0008420F /* SkBitmapProcState.h in Headers */, + 00BE43D20EE9CDFA0008420F /* SkBitmapProcState_matrix.h in Headers */, + 00BE43D40EE9CDFA0008420F /* SkBitmapProcState_sample.h in Headers */, + 00BE43D60EE9CDFA0008420F /* SkBitmapSampler.h in Headers */, + 00BE43D70EE9CDFA0008420F /* SkBitmapSamplerTemplate.h in Headers */, + 00BE43D90EE9CDFA0008420F /* SkBitmapShader.h in Headers */, + 00BE43DA0EE9CDFA0008420F /* SkBitmapShader16BilerpTemplate.h in Headers */, + 00BE43DB0EE9CDFA0008420F /* SkBitmapShaderTemplate.h in Headers */, + 00BE43DC0EE9CDFA0008420F /* SkBlitBWMaskTemplate.h in Headers */, + 00BE43DD0EE9CDFA0008420F /* SkBlitRow.h in Headers */, + 00BE43E10EE9CDFA0008420F /* SkBlitter.h in Headers */, + 00BE43EC0EE9CDFA0008420F /* SkCoreBlitters.h in Headers */, + 00BE43F10EE9CDFA0008420F /* SkDrawProcs.h in Headers */, + 00BE43F30EE9CDFA0008420F /* SkEdge.h in Headers */, + 00BE43F50EE9CDFA0008420F /* SkFilterProc.h in Headers */, + 00BE43F70EE9CDFA0008420F /* SkFP.h in Headers */, + 00BE43F90EE9CDFA0008420F /* SkGeometry.h in Headers */, + 00BE43FC0EE9CDFA0008420F /* SkGlyphCache.h in Headers */, + 00BE440D0EE9CDFA0008420F /* SkScan.h in Headers */, + 00BE44120EE9CDFA0008420F /* SkScanPriv.h in Headers */, + 00BE44140EE9CDFA0008420F /* SkSpriteBlitter.h in Headers */, + 00BE44170EE9CDFA0008420F /* SkSpriteBlitterTemplate.h in Headers */, + 00BE441B0EE9CDFA0008420F /* SkStrokerPriv.h in Headers */, + 00BE441C0EE9CDFA0008420F /* SkTemplatesPriv.h in Headers */, + 00BE441E0EE9CDFA0008420F /* SkTSort.h in Headers */, + 00BE44280EE9CDFA0008420F /* SkCordic.h in Headers */, + 00BE442C0EE9CDFA0008420F /* SkFloat.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* skia2 */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "skia2" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 00BE44F10EE9D70D0008420F /* PBXTargetDependency */, + 00BE44F50EE9D70D0008420F /* PBXTargetDependency */, + 00BE44F70EE9D70D0008420F /* PBXTargetDependency */, + 003E929B0EED79240091D85B /* PBXTargetDependency */, + 003E92DA0EED7C3B0091D85B /* PBXTargetDependency */, + 00AFCE180EF16BBB00BD2FF1 /* PBXTargetDependency */, + ); + name = skia2; + productName = skia2; + productReference = D2AAC046055464E500DB518D /* libskia2.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "skia2" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* skia2 */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 00AFCE0E0EF16BA400BD2FF1 /* Products */; + ProjectRef = 00AFCE0D0EF16BA400BD2FF1 /* expat.xcodeproj */; + }, + { + ProductGroup = 00A567690EED77850096A2A1 /* Products */; + ProjectRef = 00A567680EED77850096A2A1 /* freetype2.xcodeproj */; + }, + { + ProductGroup = 00BE444E0EE9D1780008420F /* Products */; + ProjectRef = 00BE444D0EE9D1780008420F /* giflib.xcodeproj */; + }, + { + ProductGroup = 00BE44570EE9D1780008420F /* Products */; + ProjectRef = 00BE44560EE9D1780008420F /* jpeg.xcodeproj */; + }, + { + ProductGroup = 00BE445A0EE9D1780008420F /* Products */; + ProjectRef = 00BE44590EE9D1780008420F /* libpng.xcodeproj */; + }, + { + ProductGroup = 00BE445D0EE9D1780008420F /* Products */; + ProjectRef = 00BE445C0EE9D1780008420F /* zlib.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + D2AAC045055464E500DB518D /* skia2 */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 00A5676D0EED77850096A2A1 /* libfreetype.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libfreetype.a; + remoteRef = 00A5676C0EED77850096A2A1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00AFCE150EF16BA400BD2FF1 /* libexpat.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libexpat.a; + remoteRef = 00AFCE140EF16BA400BD2FF1 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00BE44670EE9D1780008420F /* libgiflib.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libgiflib.a; + remoteRef = 00BE44660EE9D1780008420F /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00BE446A0EE9D1780008420F /* libjpeg.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libjpeg.a; + remoteRef = 00BE44690EE9D1780008420F /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00BE446D0EE9D1780008420F /* liblibpng.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = liblibpng.a; + remoteRef = 00BE446C0EE9D1780008420F /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 00BE44700EE9D1780008420F /* libzlib.a */ = { + isa = PBXReferenceProxy; + fileType = archive.ar; + path = libzlib.a; + remoteRef = 00BE446F0EE9D1780008420F /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00BE435D0EE9CDFA0008420F /* Sk1DPathEffect.cpp in Sources */, + 00BE435E0EE9CDFA0008420F /* Sk2DPathEffect.cpp in Sources */, + 00BE435F0EE9CDFA0008420F /* SkAvoidXfermode.cpp in Sources */, + 00BE43600EE9CDFA0008420F /* SkBlurDrawLooper.cpp in Sources */, + 00BE43610EE9CDFA0008420F /* SkBlurMask.cpp in Sources */, + 00BE43630EE9CDFA0008420F /* SkBlurMaskFilter.cpp in Sources */, + 00BE43640EE9CDFA0008420F /* SkCamera.cpp in Sources */, + 00BE43650EE9CDFA0008420F /* SkColorFilters.cpp in Sources */, + 00BE43660EE9CDFA0008420F /* SkColorMatrix.cpp in Sources */, + 00BE43670EE9CDFA0008420F /* SkColorMatrixFilter.cpp in Sources */, + 00BE43680EE9CDFA0008420F /* SkCornerPathEffect.cpp in Sources */, + 00BE43690EE9CDFA0008420F /* SkCullPoints.cpp in Sources */, + 00BE436A0EE9CDFA0008420F /* SkDashPathEffect.cpp in Sources */, + 00BE436B0EE9CDFA0008420F /* SkDiscretePathEffect.cpp in Sources */, + 00BE436C0EE9CDFA0008420F /* SkDumpCanvas.cpp in Sources */, + 00BE436D0EE9CDFA0008420F /* SkEmbossMask.cpp in Sources */, + 00BE43700EE9CDFA0008420F /* SkEmbossMaskFilter.cpp in Sources */, + 00BE43710EE9CDFA0008420F /* SkGradientShader.cpp in Sources */, + 00BE43720EE9CDFA0008420F /* SkKernel33MaskFilter.cpp in Sources */, + 00BE43730EE9CDFA0008420F /* SkLayerDrawLooper.cpp in Sources */, + 00BE43740EE9CDFA0008420F /* SkLayerRasterizer.cpp in Sources */, + 00BE43750EE9CDFA0008420F /* SkNinePatch.cpp in Sources */, + 00BE43760EE9CDFA0008420F /* SkPaintFlagsDrawFilter.cpp in Sources */, + 00BE43770EE9CDFA0008420F /* SkPixelXorXfermode.cpp in Sources */, + 00BE43780EE9CDFA0008420F /* SkProxyCanvas.cpp in Sources */, + 00BE437A0EE9CDFA0008420F /* SkShaderExtras.cpp in Sources */, + 00BE437B0EE9CDFA0008420F /* SkTransparentShader.cpp in Sources */, + 00BE437C0EE9CDFA0008420F /* SkUnitMappers.cpp in Sources */, + 00BE437D0EE9CDFA0008420F /* SkBGViewArtist.cpp in Sources */, + 00BE437E0EE9CDFA0008420F /* SkBorderView.cpp in Sources */, + 00BE437F0EE9CDFA0008420F /* SkEvent.cpp in Sources */, + 00BE43800EE9CDFA0008420F /* SkEventSink.cpp in Sources */, + 00BE43810EE9CDFA0008420F /* SkImageView.cpp in Sources */, + 00BE43820EE9CDFA0008420F /* SkListView.cpp in Sources */, + 00BE43830EE9CDFA0008420F /* SkListWidget.cpp in Sources */, + 00BE43840EE9CDFA0008420F /* SkMetaData.cpp in Sources */, + 00BE43850EE9CDFA0008420F /* SkOSFile.cpp in Sources */, + 00BE43860EE9CDFA0008420F /* SkOSMenu.cpp in Sources */, + 00BE43870EE9CDFA0008420F /* SkOSSound.cpp in Sources */, + 00BE43880EE9CDFA0008420F /* SkParsePaint.cpp in Sources */, + 00BE43890EE9CDFA0008420F /* SkProgressBarView.cpp in Sources */, + 00BE438A0EE9CDFA0008420F /* SkProgressView.cpp in Sources */, + 00BE438B0EE9CDFA0008420F /* SkScrollBarView.cpp in Sources */, + 00BE438C0EE9CDFA0008420F /* SkStackViewLayout.cpp in Sources */, + 00BE438D0EE9CDFA0008420F /* SkTagList.cpp in Sources */, + 00BE438F0EE9CDFA0008420F /* SkTextBox.cpp in Sources */, + 00BE43900EE9CDFA0008420F /* SkView.cpp in Sources */, + 00BE43910EE9CDFA0008420F /* SkViewInflate.cpp in Sources */, + 00BE43920EE9CDFA0008420F /* SkViewPriv.cpp in Sources */, + 00BE43940EE9CDFA0008420F /* SkWidget.cpp in Sources */, + 00BE43950EE9CDFA0008420F /* SkWidgets.cpp in Sources */, + 00BE43960EE9CDFA0008420F /* SkWidgetViews.cpp in Sources */, + 00BE43970EE9CDFA0008420F /* SkWindow.cpp in Sources */, + 00BE43980EE9CDFA0008420F /* SkFDStream.cpp in Sources */, + 00BE43990EE9CDFA0008420F /* SkFlipPixelRef.cpp in Sources */, + 00BE439A0EE9CDFA0008420F /* SkImageDecoder.cpp in Sources */, + 00BE439C0EE9CDFA0008420F /* SkImageDecoder_libbmp.cpp in Sources */, + 00BE439E0EE9CDFA0008420F /* SkImageDecoder_libico.cpp in Sources */, + 00BE43A20EE9CDFA0008420F /* SkImageDecoder_wbmp.cpp in Sources */, + 00BE43A30EE9CDFA0008420F /* SkImageRef.cpp in Sources */, + 00BE43A40EE9CDFA0008420F /* SkImageRef_GlobalPool.cpp in Sources */, + 00BE43A50EE9CDFA0008420F /* SkImageRefPool.cpp in Sources */, + 00BE43A70EE9CDFA0008420F /* SkMMapStream.cpp in Sources */, + 00BE43A80EE9CDFA0008420F /* SkMovie.cpp in Sources */, + 00BE43AA0EE9CDFA0008420F /* SkScaledBitmapSampler.cpp in Sources */, + 00BE43AC0EE9CDFA0008420F /* SkStream.cpp in Sources */, + 00BE43AD0EE9CDFA0008420F /* SkFontHost_android.cpp in Sources */, + 00BE43AE0EE9CDFA0008420F /* SkFontHost_gamma.cpp in Sources */, + 00BE43AF0EE9CDFA0008420F /* SkGlobals_global.cpp in Sources */, + 00BE43B00EE9CDFA0008420F /* SkImageDecoder_Factory.cpp in Sources */, + 00BE43B10EE9CDFA0008420F /* SkThread_pthread.cpp in Sources */, + 00BE43B20EE9CDFA0008420F /* SkTime_Unix.cpp in Sources */, + 00BE43B30EE9CDFA0008420F /* SkPathHeap.cpp in Sources */, + 00BE43B50EE9CDFA0008420F /* SkPicture.cpp in Sources */, + 00BE43B60EE9CDFA0008420F /* SkPictureFlat.cpp in Sources */, + 00BE43B80EE9CDFA0008420F /* SkPicturePlayback.cpp in Sources */, + 00BE43BA0EE9CDFA0008420F /* SkPictureRecord.cpp in Sources */, + 00BE43BC0EE9CDFA0008420F /* SkGL.cpp in Sources */, + 00BE43BE0EE9CDFA0008420F /* SkGLCanvas.cpp in Sources */, + 00BE43BF0EE9CDFA0008420F /* SkGLDevice.cpp in Sources */, + 00BE43C10EE9CDFA0008420F /* SkGLDevice_FBO.cpp in Sources */, + 00BE43C30EE9CDFA0008420F /* SkGLDevice_SWLayer.cpp in Sources */, + 00BE43C50EE9CDFA0008420F /* SkGLTextCache.cpp in Sources */, + 00BE43C70EE9CDFA0008420F /* SkTextureCache.cpp in Sources */, + 00BE43C90EE9CDFA0008420F /* SkAlphaRuns.cpp in Sources */, + 00BE43CC0EE9CDFA0008420F /* SkBitmap.cpp in Sources */, + 00BE43CD0EE9CDFA0008420F /* SkBitmap_scroll.cpp in Sources */, + 00BE43CE0EE9CDFA0008420F /* SkBitmapProcShader.cpp in Sources */, + 00BE43D00EE9CDFA0008420F /* SkBitmapProcState.cpp in Sources */, + 00BE43D30EE9CDFA0008420F /* SkBitmapProcState_matrixProcs.cpp in Sources */, + 00BE43D50EE9CDFA0008420F /* SkBitmapSampler.cpp in Sources */, + 00BE43D80EE9CDFA0008420F /* SkBitmapShader.cpp in Sources */, + 00BE43DE0EE9CDFA0008420F /* SkBlitRow_D16.cpp in Sources */, + 00BE43DF0EE9CDFA0008420F /* SkBlitRow_D4444.cpp in Sources */, + 00BE43E00EE9CDFA0008420F /* SkBlitter.cpp in Sources */, + 00BE43E20EE9CDFA0008420F /* SkBlitter_4444.cpp in Sources */, + 00BE43E30EE9CDFA0008420F /* SkBlitter_A1.cpp in Sources */, + 00BE43E40EE9CDFA0008420F /* SkBlitter_A8.cpp in Sources */, + 00BE43E50EE9CDFA0008420F /* SkBlitter_ARGB32.cpp in Sources */, + 00BE43E60EE9CDFA0008420F /* SkBlitter_RGB16.cpp in Sources */, + 00BE43E70EE9CDFA0008420F /* SkBlitter_Sprite.cpp in Sources */, + 00BE43E80EE9CDFA0008420F /* SkCanvas.cpp in Sources */, + 00BE43E90EE9CDFA0008420F /* SkColor.cpp in Sources */, + 00BE43EA0EE9CDFA0008420F /* SkColorFilter.cpp in Sources */, + 00BE43EB0EE9CDFA0008420F /* SkColorTable.cpp in Sources */, + 00BE43ED0EE9CDFA0008420F /* SkDeque.cpp in Sources */, + 00BE43EE0EE9CDFA0008420F /* SkDevice.cpp in Sources */, + 00BE43EF0EE9CDFA0008420F /* SkDither.cpp in Sources */, + 00BE43F00EE9CDFA0008420F /* SkDraw.cpp in Sources */, + 00BE43F20EE9CDFA0008420F /* SkEdge.cpp in Sources */, + 00BE43F40EE9CDFA0008420F /* SkFilterProc.cpp in Sources */, + 00BE43F60EE9CDFA0008420F /* SkFlattenable.cpp in Sources */, + 00BE43F80EE9CDFA0008420F /* SkGeometry.cpp in Sources */, + 00BE43FA0EE9CDFA0008420F /* SkGlobals.cpp in Sources */, + 00BE43FB0EE9CDFA0008420F /* SkGlyphCache.cpp in Sources */, + 00BE43FD0EE9CDFA0008420F /* SkGraphics.cpp in Sources */, + 00BE43FE0EE9CDFA0008420F /* SkMask.cpp in Sources */, + 00BE43FF0EE9CDFA0008420F /* SkMaskFilter.cpp in Sources */, + 00BE44000EE9CDFA0008420F /* SkPackBits.cpp in Sources */, + 00BE44010EE9CDFA0008420F /* SkPaint.cpp in Sources */, + 00BE44020EE9CDFA0008420F /* SkPath.cpp in Sources */, + 00BE44030EE9CDFA0008420F /* SkPathEffect.cpp in Sources */, + 00BE44040EE9CDFA0008420F /* SkPathMeasure.cpp in Sources */, + 00BE44050EE9CDFA0008420F /* SkPixelRef.cpp in Sources */, + 00BE44060EE9CDFA0008420F /* SkProcSpriteBlitter.cpp in Sources */, + 00BE44070EE9CDFA0008420F /* SkPtrRecorder.cpp in Sources */, + 00BE44080EE9CDFA0008420F /* SkRasterizer.cpp in Sources */, + 00BE44090EE9CDFA0008420F /* SkRefCnt.cpp in Sources */, + 00BE440A0EE9CDFA0008420F /* SkRegion_path.cpp in Sources */, + 00BE440B0EE9CDFA0008420F /* SkScalerContext.cpp in Sources */, + 00BE440C0EE9CDFA0008420F /* SkScan.cpp in Sources */, + 00BE440E0EE9CDFA0008420F /* SkScan_Antihair.cpp in Sources */, + 00BE440F0EE9CDFA0008420F /* SkScan_AntiPath.cpp in Sources */, + 00BE44100EE9CDFA0008420F /* SkScan_Hairline.cpp in Sources */, + 00BE44110EE9CDFA0008420F /* SkScan_Path.cpp in Sources */, + 00BE44130EE9CDFA0008420F /* SkShader.cpp in Sources */, + 00BE44150EE9CDFA0008420F /* SkSpriteBlitter_ARGB32.cpp in Sources */, + 00BE44160EE9CDFA0008420F /* SkSpriteBlitter_RGB16.cpp in Sources */, + 00BE44190EE9CDFA0008420F /* SkStroke.cpp in Sources */, + 00BE441A0EE9CDFA0008420F /* SkStrokerPriv.cpp in Sources */, + 00BE441D0EE9CDFA0008420F /* SkTSearch.cpp in Sources */, + 00BE441F0EE9CDFA0008420F /* SkTypeface.cpp in Sources */, + 00BE44200EE9CDFA0008420F /* SkUnPreMultiply.cpp in Sources */, + 00BE44220EE9CDFA0008420F /* SkWriter32.cpp in Sources */, + 00BE44230EE9CDFA0008420F /* SkXfermode.cpp in Sources */, + 00BE44240EE9CDFA0008420F /* Sk64.cpp in Sources */, + 00BE44250EE9CDFA0008420F /* SkBuffer.cpp in Sources */, + 00BE44260EE9CDFA0008420F /* SkChunkAlloc.cpp in Sources */, + 00BE44270EE9CDFA0008420F /* SkCordic.cpp in Sources */, + 00BE44290EE9CDFA0008420F /* SkDebug.cpp in Sources */, + 00BE442A0EE9CDFA0008420F /* SkDebug_stdio.cpp in Sources */, + 00BE442B0EE9CDFA0008420F /* SkFloat.cpp in Sources */, + 00BE442D0EE9CDFA0008420F /* SkFloatBits.cpp in Sources */, + 00BE442E0EE9CDFA0008420F /* SkInterpolator.cpp in Sources */, + 00BE442F0EE9CDFA0008420F /* SkMath.cpp in Sources */, + 00BE44300EE9CDFA0008420F /* SkMatrix.cpp in Sources */, + 00BE44310EE9CDFA0008420F /* SkMemory_stdlib.cpp in Sources */, + 00BE44320EE9CDFA0008420F /* SkPageFlipper.cpp in Sources */, + 00BE44330EE9CDFA0008420F /* SkPoint.cpp in Sources */, + 00BE44340EE9CDFA0008420F /* SkRect.cpp in Sources */, + 00BE44350EE9CDFA0008420F /* SkRegion.cpp in Sources */, + 00BE44C90EE9D4FC0008420F /* SkOSFile_stdio.cpp in Sources */, + 00BE45070EE9D8120008420F /* bmpdecoderhelper.cpp in Sources */, + 00AFCD710EF1672C00BD2FF1 /* SkDOM.cpp in Sources */, + 00AFCD7C0EF167BC00BD2FF1 /* SkParse.cpp in Sources */, + 00AFCD7D0EF167BC00BD2FF1 /* SkParseColor.cpp in Sources */, + 00AFCD7E0EF167BC00BD2FF1 /* SkXMLParser.cpp in Sources */, + 00AFCD890EF1684200BD2FF1 /* SkBitmap_Mac.cpp in Sources */, + 00AFCD8B0EF1685100BD2FF1 /* SkOSWindow_Mac.cpp in Sources */, + 006B43FE0EF7526E00F15BC4 /* SkString.cpp in Sources */, + 006B43FF0EF7526E00F15BC4 /* SkUtils.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 003E929B0EED79240091D85B /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = freetype; + targetProxy = 003E929A0EED79240091D85B /* PBXContainerItemProxy */; + }; + 003E92DA0EED7C3B0091D85B /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = zlib; + targetProxy = 003E92D90EED7C3B0091D85B /* PBXContainerItemProxy */; + }; + 00AFCE180EF16BBB00BD2FF1 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = expat; + targetProxy = 00AFCE170EF16BBB00BD2FF1 /* PBXContainerItemProxy */; + }; + 00BE44F10EE9D70D0008420F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = jpeg; + targetProxy = 00BE44F00EE9D70D0008420F /* PBXContainerItemProxy */; + }; + 00BE44F50EE9D70D0008420F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = giflib; + targetProxy = 00BE44F40EE9D70D0008420F /* PBXContainerItemProxy */; + }; + 00BE44F70EE9D70D0008420F /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + name = libpng; + targetProxy = 00BE44F60EE9D70D0008420F /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin XCBuildConfiguration section */ + 00A9BB930EF6BFC400D8DC2B /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_MODEL_TUNING = ""; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_RELEASE, + SK_BUILD_FOR_MAC, + ); + GCC_STRICT_ALIASING = YES; + GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + VALID_ARCHS = "i386 x86_64"; + }; + name = Release; + }; + 00A9BB940EF6BFC400D8DC2B /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = skia2; + ZERO_LINK = YES; + }; + name = Release; + }; + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = skia2; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_ENABLE_CPP_EXCEPTIONS = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_OBJC_EXCEPTIONS = NO; + GCC_PREPROCESSOR_DEFINITIONS = ( + SK_BUILD_FOR_MAC, + SK_DEBUG, + ); + GCC_STRICT_ALIASING = YES; + GCC_WARN_ABOUT_MISSING_PROTOTYPES = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_SIGN_COMPARE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + PREBINDING = NO; + USER_HEADER_SEARCH_PATHS = "../include/**"; + VALID_ARCHS = "i386 x86_64"; + }; + name = Debug; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "skia2" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 00A9BB940EF6BFC400D8DC2B /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "skia2" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 00A9BB930EF6BFC400D8DC2B /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/svg.xcodeproj/project.pbxproj b/xcode/svg.xcodeproj/project.pbxproj new file mode 100644 index 0000000..c4374eb --- /dev/null +++ b/xcode/svg.xcodeproj/project.pbxproj @@ -0,0 +1,435 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 002843AB09DDC030002E9CB0 /* SkSVGCircle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437609DDC02F002E9CB0 /* SkSVGCircle.cpp */; }; + 002843AC09DDC030002E9CB0 /* SkSVGCircle.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437709DDC02F002E9CB0 /* SkSVGCircle.h */; }; + 002843AD09DDC030002E9CB0 /* SkSVGClipPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437809DDC02F002E9CB0 /* SkSVGClipPath.cpp */; }; + 002843AE09DDC030002E9CB0 /* SkSVGClipPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437909DDC02F002E9CB0 /* SkSVGClipPath.h */; }; + 002843AF09DDC030002E9CB0 /* SkSVGDefs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437A09DDC02F002E9CB0 /* SkSVGDefs.cpp */; }; + 002843B009DDC030002E9CB0 /* SkSVGDefs.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437B09DDC02F002E9CB0 /* SkSVGDefs.h */; }; + 002843B109DDC030002E9CB0 /* SkSVGElements.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437C09DDC02F002E9CB0 /* SkSVGElements.cpp */; }; + 002843B209DDC030002E9CB0 /* SkSVGElements.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437D09DDC02F002E9CB0 /* SkSVGElements.h */; }; + 002843B309DDC030002E9CB0 /* SkSVGEllipse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028437E09DDC02F002E9CB0 /* SkSVGEllipse.cpp */; }; + 002843B409DDC030002E9CB0 /* SkSVGEllipse.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028437F09DDC02F002E9CB0 /* SkSVGEllipse.h */; }; + 002843B509DDC030002E9CB0 /* SkSVGFeColorMatrix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438009DDC02F002E9CB0 /* SkSVGFeColorMatrix.cpp */; }; + 002843B609DDC030002E9CB0 /* SkSVGFeColorMatrix.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438109DDC02F002E9CB0 /* SkSVGFeColorMatrix.h */; }; + 002843B709DDC030002E9CB0 /* SkSVGFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438209DDC02F002E9CB0 /* SkSVGFilter.cpp */; }; + 002843B809DDC030002E9CB0 /* SkSVGFilter.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438309DDC02F002E9CB0 /* SkSVGFilter.h */; }; + 002843B909DDC030002E9CB0 /* SkSVGG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438409DDC02F002E9CB0 /* SkSVGG.cpp */; }; + 002843BA09DDC030002E9CB0 /* SkSVGG.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438509DDC02F002E9CB0 /* SkSVGG.h */; }; + 002843BB09DDC030002E9CB0 /* SkSVGGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438609DDC02F002E9CB0 /* SkSVGGradient.cpp */; }; + 002843BC09DDC030002E9CB0 /* SkSVGGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438709DDC02F002E9CB0 /* SkSVGGradient.h */; }; + 002843BD09DDC030002E9CB0 /* SkSVGGroup.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438809DDC02F002E9CB0 /* SkSVGGroup.cpp */; }; + 002843BE09DDC030002E9CB0 /* SkSVGGroup.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438909DDC02F002E9CB0 /* SkSVGGroup.h */; }; + 002843BF09DDC030002E9CB0 /* SkSVGImage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438A09DDC02F002E9CB0 /* SkSVGImage.cpp */; }; + 002843C009DDC030002E9CB0 /* SkSVGImage.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438B09DDC02F002E9CB0 /* SkSVGImage.h */; }; + 002843C109DDC030002E9CB0 /* SkSVGLine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438C09DDC02F002E9CB0 /* SkSVGLine.cpp */; }; + 002843C209DDC030002E9CB0 /* SkSVGLine.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438D09DDC02F002E9CB0 /* SkSVGLine.h */; }; + 002843C309DDC030002E9CB0 /* SkSVGLinearGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028438E09DDC02F002E9CB0 /* SkSVGLinearGradient.cpp */; }; + 002843C409DDC030002E9CB0 /* SkSVGLinearGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028438F09DDC02F002E9CB0 /* SkSVGLinearGradient.h */; }; + 002843C509DDC030002E9CB0 /* SkSVGMask.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439009DDC02F002E9CB0 /* SkSVGMask.cpp */; }; + 002843C609DDC030002E9CB0 /* SkSVGMask.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439109DDC02F002E9CB0 /* SkSVGMask.h */; }; + 002843C709DDC030002E9CB0 /* SkSVGMetadata.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439209DDC02F002E9CB0 /* SkSVGMetadata.cpp */; }; + 002843C809DDC030002E9CB0 /* SkSVGMetadata.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439309DDC02F002E9CB0 /* SkSVGMetadata.h */; }; + 002843C909DDC030002E9CB0 /* SkSVGPaintState.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439409DDC02F002E9CB0 /* SkSVGPaintState.cpp */; }; + 002843CA09DDC030002E9CB0 /* SkSVGParser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439509DDC02F002E9CB0 /* SkSVGParser.cpp */; }; + 002843CB09DDC030002E9CB0 /* SkSVGPath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439609DDC02F002E9CB0 /* SkSVGPath.cpp */; }; + 002843CC09DDC030002E9CB0 /* SkSVGPath.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439709DDC02F002E9CB0 /* SkSVGPath.h */; }; + 002843CD09DDC030002E9CB0 /* SkSVGPolygon.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439809DDC02F002E9CB0 /* SkSVGPolygon.cpp */; }; + 002843CE09DDC030002E9CB0 /* SkSVGPolygon.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439909DDC02F002E9CB0 /* SkSVGPolygon.h */; }; + 002843CF09DDC030002E9CB0 /* SkSVGPolyline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439A09DDC02F002E9CB0 /* SkSVGPolyline.cpp */; }; + 002843D009DDC030002E9CB0 /* SkSVGPolyline.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439B09DDC02F002E9CB0 /* SkSVGPolyline.h */; }; + 002843D109DDC030002E9CB0 /* SkSVGRadialGradient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439C09DDC02F002E9CB0 /* SkSVGRadialGradient.cpp */; }; + 002843D209DDC030002E9CB0 /* SkSVGRadialGradient.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439D09DDC02F002E9CB0 /* SkSVGRadialGradient.h */; }; + 002843D309DDC030002E9CB0 /* SkSVGRect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0028439E09DDC02F002E9CB0 /* SkSVGRect.cpp */; }; + 002843D409DDC030002E9CB0 /* SkSVGRect.h in Headers */ = {isa = PBXBuildFile; fileRef = 0028439F09DDC02F002E9CB0 /* SkSVGRect.h */; }; + 002843D509DDC030002E9CB0 /* SkSVGStop.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A009DDC02F002E9CB0 /* SkSVGStop.cpp */; }; + 002843D609DDC030002E9CB0 /* SkSVGStop.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A109DDC02F002E9CB0 /* SkSVGStop.h */; }; + 002843D709DDC030002E9CB0 /* SkSVGSVG.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A209DDC02F002E9CB0 /* SkSVGSVG.cpp */; }; + 002843D809DDC030002E9CB0 /* SkSVGSVG.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A309DDC02F002E9CB0 /* SkSVGSVG.h */; }; + 002843D909DDC030002E9CB0 /* SkSVGSymbol.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A409DDC02F002E9CB0 /* SkSVGSymbol.cpp */; }; + 002843DA09DDC030002E9CB0 /* SkSVGSymbol.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A509DDC02F002E9CB0 /* SkSVGSymbol.h */; }; + 002843DB09DDC030002E9CB0 /* SkSVGText.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A609DDC02F002E9CB0 /* SkSVGText.cpp */; }; + 002843DC09DDC030002E9CB0 /* SkSVGText.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A709DDC02F002E9CB0 /* SkSVGText.h */; }; + 002843DD09DDC030002E9CB0 /* SkSVGUse.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 002843A809DDC02F002E9CB0 /* SkSVGUse.cpp */; }; + 002843DE09DDC030002E9CB0 /* SkSVGUse.h in Headers */ = {isa = PBXBuildFile; fileRef = 002843A909DDC02F002E9CB0 /* SkSVGUse.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXBuildStyle section */ + 014CEA520018CE5811CA2923 /* Debug */ = { + isa = PBXBuildStyle; + buildSettings = { + }; + name = Debug; + }; + 014CEA530018CE5811CA2923 /* Release */ = { + isa = PBXBuildStyle; + buildSettings = { + }; + name = Release; + }; +/* End PBXBuildStyle section */ + +/* Begin PBXFileReference section */ + 0028437609DDC02F002E9CB0 /* SkSVGCircle.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGCircle.cpp; sourceTree = "<group>"; }; + 0028437709DDC02F002E9CB0 /* SkSVGCircle.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGCircle.h; sourceTree = "<group>"; }; + 0028437809DDC02F002E9CB0 /* SkSVGClipPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGClipPath.cpp; sourceTree = "<group>"; }; + 0028437909DDC02F002E9CB0 /* SkSVGClipPath.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGClipPath.h; sourceTree = "<group>"; }; + 0028437A09DDC02F002E9CB0 /* SkSVGDefs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGDefs.cpp; sourceTree = "<group>"; }; + 0028437B09DDC02F002E9CB0 /* SkSVGDefs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGDefs.h; sourceTree = "<group>"; }; + 0028437C09DDC02F002E9CB0 /* SkSVGElements.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGElements.cpp; sourceTree = "<group>"; }; + 0028437D09DDC02F002E9CB0 /* SkSVGElements.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGElements.h; sourceTree = "<group>"; }; + 0028437E09DDC02F002E9CB0 /* SkSVGEllipse.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGEllipse.cpp; sourceTree = "<group>"; }; + 0028437F09DDC02F002E9CB0 /* SkSVGEllipse.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGEllipse.h; sourceTree = "<group>"; }; + 0028438009DDC02F002E9CB0 /* SkSVGFeColorMatrix.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGFeColorMatrix.cpp; sourceTree = "<group>"; }; + 0028438109DDC02F002E9CB0 /* SkSVGFeColorMatrix.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGFeColorMatrix.h; sourceTree = "<group>"; }; + 0028438209DDC02F002E9CB0 /* SkSVGFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGFilter.cpp; sourceTree = "<group>"; }; + 0028438309DDC02F002E9CB0 /* SkSVGFilter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGFilter.h; sourceTree = "<group>"; }; + 0028438409DDC02F002E9CB0 /* SkSVGG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGG.cpp; sourceTree = "<group>"; }; + 0028438509DDC02F002E9CB0 /* SkSVGG.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGG.h; sourceTree = "<group>"; }; + 0028438609DDC02F002E9CB0 /* SkSVGGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGGradient.cpp; sourceTree = "<group>"; }; + 0028438709DDC02F002E9CB0 /* SkSVGGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGGradient.h; sourceTree = "<group>"; }; + 0028438809DDC02F002E9CB0 /* SkSVGGroup.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGGroup.cpp; sourceTree = "<group>"; }; + 0028438909DDC02F002E9CB0 /* SkSVGGroup.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGGroup.h; sourceTree = "<group>"; }; + 0028438A09DDC02F002E9CB0 /* SkSVGImage.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGImage.cpp; sourceTree = "<group>"; }; + 0028438B09DDC02F002E9CB0 /* SkSVGImage.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGImage.h; sourceTree = "<group>"; }; + 0028438C09DDC02F002E9CB0 /* SkSVGLine.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGLine.cpp; sourceTree = "<group>"; }; + 0028438D09DDC02F002E9CB0 /* SkSVGLine.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGLine.h; sourceTree = "<group>"; }; + 0028438E09DDC02F002E9CB0 /* SkSVGLinearGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGLinearGradient.cpp; sourceTree = "<group>"; }; + 0028438F09DDC02F002E9CB0 /* SkSVGLinearGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGLinearGradient.h; sourceTree = "<group>"; }; + 0028439009DDC02F002E9CB0 /* SkSVGMask.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGMask.cpp; sourceTree = "<group>"; }; + 0028439109DDC02F002E9CB0 /* SkSVGMask.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGMask.h; sourceTree = "<group>"; }; + 0028439209DDC02F002E9CB0 /* SkSVGMetadata.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGMetadata.cpp; sourceTree = "<group>"; }; + 0028439309DDC02F002E9CB0 /* SkSVGMetadata.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGMetadata.h; sourceTree = "<group>"; }; + 0028439409DDC02F002E9CB0 /* SkSVGPaintState.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPaintState.cpp; sourceTree = "<group>"; }; + 0028439509DDC02F002E9CB0 /* SkSVGParser.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGParser.cpp; sourceTree = "<group>"; }; + 0028439609DDC02F002E9CB0 /* SkSVGPath.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPath.cpp; sourceTree = "<group>"; }; + 0028439709DDC02F002E9CB0 /* SkSVGPath.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGPath.h; sourceTree = "<group>"; }; + 0028439809DDC02F002E9CB0 /* SkSVGPolygon.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPolygon.cpp; sourceTree = "<group>"; }; + 0028439909DDC02F002E9CB0 /* SkSVGPolygon.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGPolygon.h; sourceTree = "<group>"; }; + 0028439A09DDC02F002E9CB0 /* SkSVGPolyline.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGPolyline.cpp; sourceTree = "<group>"; }; + 0028439B09DDC02F002E9CB0 /* SkSVGPolyline.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGPolyline.h; sourceTree = "<group>"; }; + 0028439C09DDC02F002E9CB0 /* SkSVGRadialGradient.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGRadialGradient.cpp; sourceTree = "<group>"; }; + 0028439D09DDC02F002E9CB0 /* SkSVGRadialGradient.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGRadialGradient.h; sourceTree = "<group>"; }; + 0028439E09DDC02F002E9CB0 /* SkSVGRect.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGRect.cpp; sourceTree = "<group>"; }; + 0028439F09DDC02F002E9CB0 /* SkSVGRect.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGRect.h; sourceTree = "<group>"; }; + 002843A009DDC02F002E9CB0 /* SkSVGStop.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGStop.cpp; sourceTree = "<group>"; }; + 002843A109DDC02F002E9CB0 /* SkSVGStop.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGStop.h; sourceTree = "<group>"; }; + 002843A209DDC02F002E9CB0 /* SkSVGSVG.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGSVG.cpp; sourceTree = "<group>"; }; + 002843A309DDC02F002E9CB0 /* SkSVGSVG.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGSVG.h; sourceTree = "<group>"; }; + 002843A409DDC02F002E9CB0 /* SkSVGSymbol.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGSymbol.cpp; sourceTree = "<group>"; }; + 002843A509DDC02F002E9CB0 /* SkSVGSymbol.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGSymbol.h; sourceTree = "<group>"; }; + 002843A609DDC02F002E9CB0 /* SkSVGText.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGText.cpp; sourceTree = "<group>"; }; + 002843A709DDC02F002E9CB0 /* SkSVGText.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGText.h; sourceTree = "<group>"; }; + 002843A809DDC02F002E9CB0 /* SkSVGUse.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = SkSVGUse.cpp; sourceTree = "<group>"; }; + 002843A909DDC02F002E9CB0 /* SkSVGUse.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = SkSVGUse.h; sourceTree = "<group>"; }; + D2AAC046055464E500DB518D /* libsvg.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libsvg.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 0028437409DDC02F002E9CB0 /* svg */ = { + isa = PBXGroup; + children = ( + 0028437609DDC02F002E9CB0 /* SkSVGCircle.cpp */, + 0028437709DDC02F002E9CB0 /* SkSVGCircle.h */, + 0028437809DDC02F002E9CB0 /* SkSVGClipPath.cpp */, + 0028437909DDC02F002E9CB0 /* SkSVGClipPath.h */, + 0028437A09DDC02F002E9CB0 /* SkSVGDefs.cpp */, + 0028437B09DDC02F002E9CB0 /* SkSVGDefs.h */, + 0028437C09DDC02F002E9CB0 /* SkSVGElements.cpp */, + 0028437D09DDC02F002E9CB0 /* SkSVGElements.h */, + 0028437E09DDC02F002E9CB0 /* SkSVGEllipse.cpp */, + 0028437F09DDC02F002E9CB0 /* SkSVGEllipse.h */, + 0028438009DDC02F002E9CB0 /* SkSVGFeColorMatrix.cpp */, + 0028438109DDC02F002E9CB0 /* SkSVGFeColorMatrix.h */, + 0028438209DDC02F002E9CB0 /* SkSVGFilter.cpp */, + 0028438309DDC02F002E9CB0 /* SkSVGFilter.h */, + 0028438409DDC02F002E9CB0 /* SkSVGG.cpp */, + 0028438509DDC02F002E9CB0 /* SkSVGG.h */, + 0028438609DDC02F002E9CB0 /* SkSVGGradient.cpp */, + 0028438709DDC02F002E9CB0 /* SkSVGGradient.h */, + 0028438809DDC02F002E9CB0 /* SkSVGGroup.cpp */, + 0028438909DDC02F002E9CB0 /* SkSVGGroup.h */, + 0028438A09DDC02F002E9CB0 /* SkSVGImage.cpp */, + 0028438B09DDC02F002E9CB0 /* SkSVGImage.h */, + 0028438C09DDC02F002E9CB0 /* SkSVGLine.cpp */, + 0028438D09DDC02F002E9CB0 /* SkSVGLine.h */, + 0028438E09DDC02F002E9CB0 /* SkSVGLinearGradient.cpp */, + 0028438F09DDC02F002E9CB0 /* SkSVGLinearGradient.h */, + 0028439009DDC02F002E9CB0 /* SkSVGMask.cpp */, + 0028439109DDC02F002E9CB0 /* SkSVGMask.h */, + 0028439209DDC02F002E9CB0 /* SkSVGMetadata.cpp */, + 0028439309DDC02F002E9CB0 /* SkSVGMetadata.h */, + 0028439409DDC02F002E9CB0 /* SkSVGPaintState.cpp */, + 0028439509DDC02F002E9CB0 /* SkSVGParser.cpp */, + 0028439609DDC02F002E9CB0 /* SkSVGPath.cpp */, + 0028439709DDC02F002E9CB0 /* SkSVGPath.h */, + 0028439809DDC02F002E9CB0 /* SkSVGPolygon.cpp */, + 0028439909DDC02F002E9CB0 /* SkSVGPolygon.h */, + 0028439A09DDC02F002E9CB0 /* SkSVGPolyline.cpp */, + 0028439B09DDC02F002E9CB0 /* SkSVGPolyline.h */, + 0028439C09DDC02F002E9CB0 /* SkSVGRadialGradient.cpp */, + 0028439D09DDC02F002E9CB0 /* SkSVGRadialGradient.h */, + 0028439E09DDC02F002E9CB0 /* SkSVGRect.cpp */, + 0028439F09DDC02F002E9CB0 /* SkSVGRect.h */, + 002843A009DDC02F002E9CB0 /* SkSVGStop.cpp */, + 002843A109DDC02F002E9CB0 /* SkSVGStop.h */, + 002843A209DDC02F002E9CB0 /* SkSVGSVG.cpp */, + 002843A309DDC02F002E9CB0 /* SkSVGSVG.h */, + 002843A409DDC02F002E9CB0 /* SkSVGSymbol.cpp */, + 002843A509DDC02F002E9CB0 /* SkSVGSymbol.h */, + 002843A609DDC02F002E9CB0 /* SkSVGText.cpp */, + 002843A709DDC02F002E9CB0 /* SkSVGText.h */, + 002843A809DDC02F002E9CB0 /* SkSVGUse.cpp */, + 002843A909DDC02F002E9CB0 /* SkSVGUse.h */, + ); + name = svg; + path = ../../libs/graphics/svg; + sourceTree = SOURCE_ROOT; + }; + 08FB7794FE84155DC02AAC07 /* svg */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = svg; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 0028437409DDC02F002E9CB0 /* svg */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libsvg.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 002843AC09DDC030002E9CB0 /* SkSVGCircle.h in Headers */, + 002843AE09DDC030002E9CB0 /* SkSVGClipPath.h in Headers */, + 002843B009DDC030002E9CB0 /* SkSVGDefs.h in Headers */, + 002843B209DDC030002E9CB0 /* SkSVGElements.h in Headers */, + 002843B409DDC030002E9CB0 /* SkSVGEllipse.h in Headers */, + 002843B609DDC030002E9CB0 /* SkSVGFeColorMatrix.h in Headers */, + 002843B809DDC030002E9CB0 /* SkSVGFilter.h in Headers */, + 002843BA09DDC030002E9CB0 /* SkSVGG.h in Headers */, + 002843BC09DDC030002E9CB0 /* SkSVGGradient.h in Headers */, + 002843BE09DDC030002E9CB0 /* SkSVGGroup.h in Headers */, + 002843C009DDC030002E9CB0 /* SkSVGImage.h in Headers */, + 002843C209DDC030002E9CB0 /* SkSVGLine.h in Headers */, + 002843C409DDC030002E9CB0 /* SkSVGLinearGradient.h in Headers */, + 002843C609DDC030002E9CB0 /* SkSVGMask.h in Headers */, + 002843C809DDC030002E9CB0 /* SkSVGMetadata.h in Headers */, + 002843CC09DDC030002E9CB0 /* SkSVGPath.h in Headers */, + 002843CE09DDC030002E9CB0 /* SkSVGPolygon.h in Headers */, + 002843D009DDC030002E9CB0 /* SkSVGPolyline.h in Headers */, + 002843D209DDC030002E9CB0 /* SkSVGRadialGradient.h in Headers */, + 002843D409DDC030002E9CB0 /* SkSVGRect.h in Headers */, + 002843D609DDC030002E9CB0 /* SkSVGStop.h in Headers */, + 002843D809DDC030002E9CB0 /* SkSVGSVG.h in Headers */, + 002843DA09DDC030002E9CB0 /* SkSVGSymbol.h in Headers */, + 002843DC09DDC030002E9CB0 /* SkSVGText.h in Headers */, + 002843DE09DDC030002E9CB0 /* SkSVGUse.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* svg */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "svg" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + buildSettings = { + }; + dependencies = ( + ); + name = svg; + productName = svg; + productReference = D2AAC046055464E500DB518D /* libsvg.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "svg" */; + buildSettings = { + }; + buildStyles = ( + 014CEA520018CE5811CA2923 /* Debug */, + 014CEA530018CE5811CA2923 /* Release */, + ); + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* svg */; + projectDirPath = ""; + targets = ( + D2AAC045055464E500DB518D /* svg */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 002843AB09DDC030002E9CB0 /* SkSVGCircle.cpp in Sources */, + 002843AD09DDC030002E9CB0 /* SkSVGClipPath.cpp in Sources */, + 002843AF09DDC030002E9CB0 /* SkSVGDefs.cpp in Sources */, + 002843B109DDC030002E9CB0 /* SkSVGElements.cpp in Sources */, + 002843B309DDC030002E9CB0 /* SkSVGEllipse.cpp in Sources */, + 002843B509DDC030002E9CB0 /* SkSVGFeColorMatrix.cpp in Sources */, + 002843B709DDC030002E9CB0 /* SkSVGFilter.cpp in Sources */, + 002843B909DDC030002E9CB0 /* SkSVGG.cpp in Sources */, + 002843BB09DDC030002E9CB0 /* SkSVGGradient.cpp in Sources */, + 002843BD09DDC030002E9CB0 /* SkSVGGroup.cpp in Sources */, + 002843BF09DDC030002E9CB0 /* SkSVGImage.cpp in Sources */, + 002843C109DDC030002E9CB0 /* SkSVGLine.cpp in Sources */, + 002843C309DDC030002E9CB0 /* SkSVGLinearGradient.cpp in Sources */, + 002843C509DDC030002E9CB0 /* SkSVGMask.cpp in Sources */, + 002843C709DDC030002E9CB0 /* SkSVGMetadata.cpp in Sources */, + 002843C909DDC030002E9CB0 /* SkSVGPaintState.cpp in Sources */, + 002843CA09DDC030002E9CB0 /* SkSVGParser.cpp in Sources */, + 002843CB09DDC030002E9CB0 /* SkSVGPath.cpp in Sources */, + 002843CD09DDC030002E9CB0 /* SkSVGPolygon.cpp in Sources */, + 002843CF09DDC030002E9CB0 /* SkSVGPolyline.cpp in Sources */, + 002843D109DDC030002E9CB0 /* SkSVGRadialGradient.cpp in Sources */, + 002843D309DDC030002E9CB0 /* SkSVGRect.cpp in Sources */, + 002843D509DDC030002E9CB0 /* SkSVGStop.cpp in Sources */, + 002843D709DDC030002E9CB0 /* SkSVGSVG.cpp in Sources */, + 002843D909DDC030002E9CB0 /* SkSVGSymbol.cpp in Sources */, + 002843DB09DDC030002E9CB0 /* SkSVGText.cpp in Sources */, + 002843DD09DDC030002E9CB0 /* SkSVGUse.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = svg; + ZERO_LINK = YES; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + ); + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = svg; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + USER_HEADER_SEARCH_PATHS = "../../include/graphics ../../include/corecg"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "svg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "svg" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/views.xcodeproj/project.pbxproj b/xcode/views.xcodeproj/project.pbxproj new file mode 100644 index 0000000..05d65d3 --- /dev/null +++ b/xcode/views.xcodeproj/project.pbxproj @@ -0,0 +1,324 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7E1C20EDCAB1500F77EA2 /* SkEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BC0EDCAB1500F77EA2 /* SkEvent.cpp */; }; + 00B7E1C30EDCAB1500F77EA2 /* SkEventSink.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BD0EDCAB1500F77EA2 /* SkEventSink.cpp */; }; + 00B7E1C40EDCAB1500F77EA2 /* SkMetaData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BE0EDCAB1500F77EA2 /* SkMetaData.cpp */; }; + 00B7E1C50EDCAB1500F77EA2 /* SkTagList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1BF0EDCAB1500F77EA2 /* SkTagList.cpp */; }; + 00B7E1C60EDCAB1500F77EA2 /* SkTagList.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1C00EDCAB1500F77EA2 /* SkTagList.h */; }; + 00B7E1C70EDCAB1500F77EA2 /* SkTextBox.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1C10EDCAB1500F77EA2 /* SkTextBox.cpp */; }; + 00B7E1DF0EDCABAC00F77EA2 /* SkBGViewArtist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CA0EDCABAC00F77EA2 /* SkBGViewArtist.cpp */; }; + 00B7E1E00EDCABAC00F77EA2 /* SkBorderView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CB0EDCABAC00F77EA2 /* SkBorderView.cpp */; }; + 00B7E1E10EDCABAC00F77EA2 /* SkImageView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CC0EDCABAC00F77EA2 /* SkImageView.cpp */; }; + 00B7E1E20EDCABAC00F77EA2 /* SkListView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CD0EDCABAC00F77EA2 /* SkListView.cpp */; }; + 00B7E1E30EDCABAC00F77EA2 /* SkListWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CE0EDCABAC00F77EA2 /* SkListWidget.cpp */; }; + 00B7E1E40EDCABAC00F77EA2 /* SkOSFile.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1CF0EDCABAC00F77EA2 /* SkOSFile.cpp */; }; + 00B7E1E50EDCABAC00F77EA2 /* SkOSMenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D00EDCABAC00F77EA2 /* SkOSMenu.cpp */; }; + 00B7E1E60EDCABAC00F77EA2 /* SkOSSound.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D10EDCABAC00F77EA2 /* SkOSSound.cpp */; }; + 00B7E1E70EDCABAC00F77EA2 /* SkParsePaint.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D20EDCABAC00F77EA2 /* SkParsePaint.cpp */; }; + 00B7E1E80EDCABAC00F77EA2 /* SkProgressBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D30EDCABAC00F77EA2 /* SkProgressBarView.cpp */; }; + 00B7E1E90EDCABAC00F77EA2 /* SkProgressView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D40EDCABAC00F77EA2 /* SkProgressView.cpp */; }; + 00B7E1EA0EDCABAC00F77EA2 /* SkScrollBarView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D50EDCABAC00F77EA2 /* SkScrollBarView.cpp */; }; + 00B7E1EB0EDCABAC00F77EA2 /* SkStackViewLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D60EDCABAC00F77EA2 /* SkStackViewLayout.cpp */; }; + 00B7E1EC0EDCABAC00F77EA2 /* SkView.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D70EDCABAC00F77EA2 /* SkView.cpp */; }; + 00B7E1ED0EDCABAC00F77EA2 /* SkViewInflate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D80EDCABAC00F77EA2 /* SkViewInflate.cpp */; }; + 00B7E1EE0EDCABAC00F77EA2 /* SkViewPriv.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1D90EDCABAC00F77EA2 /* SkViewPriv.cpp */; }; + 00B7E1EF0EDCABAC00F77EA2 /* SkViewPriv.h in Headers */ = {isa = PBXBuildFile; fileRef = 00B7E1DA0EDCABAC00F77EA2 /* SkViewPriv.h */; }; + 00B7E1F00EDCABAC00F77EA2 /* SkWidget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DB0EDCABAC00F77EA2 /* SkWidget.cpp */; }; + 00B7E1F10EDCABAC00F77EA2 /* SkWidgets.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DC0EDCABAC00F77EA2 /* SkWidgets.cpp */; }; + 00B7E1F20EDCABAC00F77EA2 /* SkWidgetViews.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DD0EDCABAC00F77EA2 /* SkWidgetViews.cpp */; }; + 00B7E1F30EDCABAC00F77EA2 /* SkWindow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E1DE0EDCABAC00F77EA2 /* SkWindow.cpp */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7E1BC0EDCAB1500F77EA2 /* SkEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEvent.cpp; path = ../libsgl/views/SkEvent.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1BD0EDCAB1500F77EA2 /* SkEventSink.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkEventSink.cpp; path = ../libsgl/views/SkEventSink.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1BE0EDCAB1500F77EA2 /* SkMetaData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkMetaData.cpp; path = ../libsgl/views/SkMetaData.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1BF0EDCAB1500F77EA2 /* SkTagList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTagList.cpp; path = ../libsgl/views/SkTagList.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1C00EDCAB1500F77EA2 /* SkTagList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkTagList.h; path = ../libsgl/views/SkTagList.h; sourceTree = SOURCE_ROOT; }; + 00B7E1C10EDCAB1500F77EA2 /* SkTextBox.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkTextBox.cpp; path = ../libsgl/views/SkTextBox.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1CA0EDCABAC00F77EA2 /* SkBGViewArtist.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBGViewArtist.cpp; path = ../libsgl/views/SkBGViewArtist.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1CB0EDCABAC00F77EA2 /* SkBorderView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkBorderView.cpp; path = ../libsgl/views/SkBorderView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1CC0EDCABAC00F77EA2 /* SkImageView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkImageView.cpp; path = ../libsgl/views/SkImageView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1CD0EDCABAC00F77EA2 /* SkListView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListView.cpp; path = ../libsgl/views/SkListView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1CE0EDCABAC00F77EA2 /* SkListWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkListWidget.cpp; path = ../libsgl/views/SkListWidget.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1CF0EDCABAC00F77EA2 /* SkOSFile.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSFile.cpp; path = ../libsgl/views/SkOSFile.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D00EDCABAC00F77EA2 /* SkOSMenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSMenu.cpp; path = ../libsgl/views/SkOSMenu.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D10EDCABAC00F77EA2 /* SkOSSound.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkOSSound.cpp; path = ../libsgl/views/SkOSSound.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D20EDCABAC00F77EA2 /* SkParsePaint.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkParsePaint.cpp; path = ../libsgl/views/SkParsePaint.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D30EDCABAC00F77EA2 /* SkProgressBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressBarView.cpp; path = ../libsgl/views/SkProgressBarView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D40EDCABAC00F77EA2 /* SkProgressView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkProgressView.cpp; path = ../libsgl/views/SkProgressView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D50EDCABAC00F77EA2 /* SkScrollBarView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkScrollBarView.cpp; path = ../libsgl/views/SkScrollBarView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D60EDCABAC00F77EA2 /* SkStackViewLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkStackViewLayout.cpp; path = ../libsgl/views/SkStackViewLayout.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D70EDCABAC00F77EA2 /* SkView.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkView.cpp; path = ../libsgl/views/SkView.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D80EDCABAC00F77EA2 /* SkViewInflate.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewInflate.cpp; path = ../libsgl/views/SkViewInflate.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1D90EDCABAC00F77EA2 /* SkViewPriv.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkViewPriv.cpp; path = ../libsgl/views/SkViewPriv.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1DA0EDCABAC00F77EA2 /* SkViewPriv.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SkViewPriv.h; path = ../libsgl/views/SkViewPriv.h; sourceTree = SOURCE_ROOT; }; + 00B7E1DB0EDCABAC00F77EA2 /* SkWidget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidget.cpp; path = ../libsgl/views/SkWidget.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1DC0EDCABAC00F77EA2 /* SkWidgets.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgets.cpp; path = ../libsgl/views/SkWidgets.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1DD0EDCABAC00F77EA2 /* SkWidgetViews.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWidgetViews.cpp; path = ../libsgl/views/SkWidgetViews.cpp; sourceTree = SOURCE_ROOT; }; + 00B7E1DE0EDCABAC00F77EA2 /* SkWindow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SkWindow.cpp; path = ../libsgl/views/SkWindow.cpp; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libviews.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libviews.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* views */ = { + isa = PBXGroup; + children = ( + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = views; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7E1CA0EDCABAC00F77EA2 /* SkBGViewArtist.cpp */, + 00B7E1CB0EDCABAC00F77EA2 /* SkBorderView.cpp */, + 00B7E1CC0EDCABAC00F77EA2 /* SkImageView.cpp */, + 00B7E1CD0EDCABAC00F77EA2 /* SkListView.cpp */, + 00B7E1CE0EDCABAC00F77EA2 /* SkListWidget.cpp */, + 00B7E1CF0EDCABAC00F77EA2 /* SkOSFile.cpp */, + 00B7E1D00EDCABAC00F77EA2 /* SkOSMenu.cpp */, + 00B7E1D10EDCABAC00F77EA2 /* SkOSSound.cpp */, + 00B7E1D20EDCABAC00F77EA2 /* SkParsePaint.cpp */, + 00B7E1D30EDCABAC00F77EA2 /* SkProgressBarView.cpp */, + 00B7E1D40EDCABAC00F77EA2 /* SkProgressView.cpp */, + 00B7E1D50EDCABAC00F77EA2 /* SkScrollBarView.cpp */, + 00B7E1D60EDCABAC00F77EA2 /* SkStackViewLayout.cpp */, + 00B7E1D70EDCABAC00F77EA2 /* SkView.cpp */, + 00B7E1D80EDCABAC00F77EA2 /* SkViewInflate.cpp */, + 00B7E1D90EDCABAC00F77EA2 /* SkViewPriv.cpp */, + 00B7E1DA0EDCABAC00F77EA2 /* SkViewPriv.h */, + 00B7E1DB0EDCABAC00F77EA2 /* SkWidget.cpp */, + 00B7E1DC0EDCABAC00F77EA2 /* SkWidgets.cpp */, + 00B7E1DD0EDCABAC00F77EA2 /* SkWidgetViews.cpp */, + 00B7E1DE0EDCABAC00F77EA2 /* SkWindow.cpp */, + 00B7E1BC0EDCAB1500F77EA2 /* SkEvent.cpp */, + 00B7E1BD0EDCAB1500F77EA2 /* SkEventSink.cpp */, + 00B7E1BE0EDCAB1500F77EA2 /* SkMetaData.cpp */, + 00B7E1BF0EDCAB1500F77EA2 /* SkTagList.cpp */, + 00B7E1C00EDCAB1500F77EA2 /* SkTagList.h */, + 00B7E1C10EDCAB1500F77EA2 /* SkTextBox.cpp */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libviews.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E1C60EDCAB1500F77EA2 /* SkTagList.h in Headers */, + 00B7E1EF0EDCABAC00F77EA2 /* SkViewPriv.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* views */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "views" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = views; + productName = views; + productReference = D2AAC046055464E500DB518D /* libviews.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "views" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* views */; + projectDirPath = ""; + projectRoot = ..; + targets = ( + D2AAC045055464E500DB518D /* views */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E1C20EDCAB1500F77EA2 /* SkEvent.cpp in Sources */, + 00B7E1C30EDCAB1500F77EA2 /* SkEventSink.cpp in Sources */, + 00B7E1C40EDCAB1500F77EA2 /* SkMetaData.cpp in Sources */, + 00B7E1C50EDCAB1500F77EA2 /* SkTagList.cpp in Sources */, + 00B7E1C70EDCAB1500F77EA2 /* SkTextBox.cpp in Sources */, + 00B7E1DF0EDCABAC00F77EA2 /* SkBGViewArtist.cpp in Sources */, + 00B7E1E00EDCABAC00F77EA2 /* SkBorderView.cpp in Sources */, + 00B7E1E10EDCABAC00F77EA2 /* SkImageView.cpp in Sources */, + 00B7E1E20EDCABAC00F77EA2 /* SkListView.cpp in Sources */, + 00B7E1E30EDCABAC00F77EA2 /* SkListWidget.cpp in Sources */, + 00B7E1E40EDCABAC00F77EA2 /* SkOSFile.cpp in Sources */, + 00B7E1E50EDCABAC00F77EA2 /* SkOSMenu.cpp in Sources */, + 00B7E1E60EDCABAC00F77EA2 /* SkOSSound.cpp in Sources */, + 00B7E1E70EDCABAC00F77EA2 /* SkParsePaint.cpp in Sources */, + 00B7E1E80EDCABAC00F77EA2 /* SkProgressBarView.cpp in Sources */, + 00B7E1E90EDCABAC00F77EA2 /* SkProgressView.cpp in Sources */, + 00B7E1EA0EDCABAC00F77EA2 /* SkScrollBarView.cpp in Sources */, + 00B7E1EB0EDCABAC00F77EA2 /* SkStackViewLayout.cpp in Sources */, + 00B7E1EC0EDCABAC00F77EA2 /* SkView.cpp in Sources */, + 00B7E1ED0EDCABAC00F77EA2 /* SkViewInflate.cpp in Sources */, + 00B7E1EE0EDCABAC00F77EA2 /* SkViewPriv.cpp in Sources */, + 00B7E1F00EDCABAC00F77EA2 /* SkWidget.cpp in Sources */, + 00B7E1F10EDCABAC00F77EA2 /* SkWidgets.cpp in Sources */, + 00B7E1F20EDCABAC00F77EA2 /* SkWidgetViews.cpp in Sources */, + 00B7E1F30EDCABAC00F77EA2 /* SkWindow.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1DEB91EC08733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = views; + ZERO_LINK = NO; + }; + name = Debug; + }; + 1DEB91ED08733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + INSTALL_PATH = /usr/local/lib; + PRODUCT_NAME = views; + ZERO_LINK = NO; + }; + name = Release; + }; + 1DEB91F008733DB70010E9CD /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = ""; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/**"; + }; + name = Debug; + }; + 1DEB91F108733DB70010E9CD /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = YES; + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + HEADER_SEARCH_PATHS = "$(HEADER_SEARCH_PATHS)"; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + SDKROOT = ""; + SHARED_PRECOMPS_DIR = ""; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = "../libsgl/sgl ../include/**"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1DEB91EB08733DB70010E9CD /* Build configuration list for PBXNativeTarget "views" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91EC08733DB70010E9CD /* Debug */, + 1DEB91ED08733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 1DEB91EF08733DB70010E9CD /* Build configuration list for PBXProject "views" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1DEB91F008733DB70010E9CD /* Debug */, + 1DEB91F108733DB70010E9CD /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} diff --git a/xcode/zlib.xcodeproj/project.pbxproj b/xcode/zlib.xcodeproj/project.pbxproj new file mode 100644 index 0000000..b7f96b2 --- /dev/null +++ b/xcode/zlib.xcodeproj/project.pbxproj @@ -0,0 +1,269 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 00B7E21D0EDCAC9E00F77EA2 /* adler32.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2120EDCAC9E00F77EA2 /* adler32.c */; }; + 00B7E21E0EDCAC9E00F77EA2 /* compress.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2130EDCAC9E00F77EA2 /* compress.c */; }; + 00B7E21F0EDCAC9E00F77EA2 /* crc32.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2140EDCAC9E00F77EA2 /* crc32.c */; }; + 00B7E2200EDCAC9E00F77EA2 /* deflate.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2150EDCAC9E00F77EA2 /* deflate.c */; }; + 00B7E2210EDCAC9E00F77EA2 /* infback.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2160EDCAC9E00F77EA2 /* infback.c */; }; + 00B7E2220EDCAC9E00F77EA2 /* inffast.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2170EDCAC9E00F77EA2 /* inffast.c */; }; + 00B7E2230EDCAC9E00F77EA2 /* inflate.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2180EDCAC9E00F77EA2 /* inflate.c */; }; + 00B7E2240EDCAC9E00F77EA2 /* inftrees.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E2190EDCAC9E00F77EA2 /* inftrees.c */; }; + 00B7E2250EDCAC9E00F77EA2 /* trees.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E21A0EDCAC9E00F77EA2 /* trees.c */; }; + 00B7E2260EDCAC9E00F77EA2 /* uncompr.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E21B0EDCAC9E00F77EA2 /* uncompr.c */; }; + 00B7E2270EDCAC9E00F77EA2 /* zutil.c in Sources */ = {isa = PBXBuildFile; fileRef = 00B7E21C0EDCAC9E00F77EA2 /* zutil.c */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 00B7E2120EDCAC9E00F77EA2 /* adler32.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = adler32.c; path = ../../zlib/adler32.c; sourceTree = SOURCE_ROOT; }; + 00B7E2130EDCAC9E00F77EA2 /* compress.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = compress.c; path = ../../zlib/compress.c; sourceTree = SOURCE_ROOT; }; + 00B7E2140EDCAC9E00F77EA2 /* crc32.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = crc32.c; path = ../../zlib/crc32.c; sourceTree = SOURCE_ROOT; }; + 00B7E2150EDCAC9E00F77EA2 /* deflate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = deflate.c; path = ../../zlib/deflate.c; sourceTree = SOURCE_ROOT; }; + 00B7E2160EDCAC9E00F77EA2 /* infback.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = infback.c; path = ../../zlib/infback.c; sourceTree = SOURCE_ROOT; }; + 00B7E2170EDCAC9E00F77EA2 /* inffast.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = inffast.c; path = ../../zlib/inffast.c; sourceTree = SOURCE_ROOT; }; + 00B7E2180EDCAC9E00F77EA2 /* inflate.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = inflate.c; path = ../../zlib/inflate.c; sourceTree = SOURCE_ROOT; }; + 00B7E2190EDCAC9E00F77EA2 /* inftrees.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = inftrees.c; path = ../../zlib/inftrees.c; sourceTree = SOURCE_ROOT; }; + 00B7E21A0EDCAC9E00F77EA2 /* trees.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = trees.c; path = ../../zlib/trees.c; sourceTree = SOURCE_ROOT; }; + 00B7E21B0EDCAC9E00F77EA2 /* uncompr.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = uncompr.c; path = ../../zlib/uncompr.c; sourceTree = SOURCE_ROOT; }; + 00B7E21C0EDCAC9E00F77EA2 /* zutil.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = zutil.c; path = ../../zlib/zutil.c; sourceTree = SOURCE_ROOT; }; + D2AAC046055464E500DB518D /* libzlib.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libzlib.a; sourceTree = BUILT_PRODUCTS_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + D289987405E68DCB004EDB86 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 08FB7794FE84155DC02AAC07 /* zlib */ = { + isa = PBXGroup; + children = ( + FE08AA1A0944F1FE0057213F /* Include */, + 08FB7795FE84155DC02AAC07 /* Source */, + C6A0FF2B0290797F04C91782 /* Documentation */, + 1AB674ADFE9D54B511CA2CBB /* Products */, + ); + name = zlib; + sourceTree = "<group>"; + }; + 08FB7795FE84155DC02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 00B7E2120EDCAC9E00F77EA2 /* adler32.c */, + 00B7E2130EDCAC9E00F77EA2 /* compress.c */, + 00B7E2140EDCAC9E00F77EA2 /* crc32.c */, + 00B7E2150EDCAC9E00F77EA2 /* deflate.c */, + 00B7E2160EDCAC9E00F77EA2 /* infback.c */, + 00B7E2170EDCAC9E00F77EA2 /* inffast.c */, + 00B7E2180EDCAC9E00F77EA2 /* inflate.c */, + 00B7E2190EDCAC9E00F77EA2 /* inftrees.c */, + 00B7E21A0EDCAC9E00F77EA2 /* trees.c */, + 00B7E21B0EDCAC9E00F77EA2 /* uncompr.c */, + 00B7E21C0EDCAC9E00F77EA2 /* zutil.c */, + ); + name = Source; + sourceTree = "<group>"; + }; + 1AB674ADFE9D54B511CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + D2AAC046055464E500DB518D /* libzlib.a */, + ); + name = Products; + sourceTree = "<group>"; + }; + C6A0FF2B0290797F04C91782 /* Documentation */ = { + isa = PBXGroup; + children = ( + ); + name = Documentation; + sourceTree = "<group>"; + }; + FE08AA1A0944F1FE0057213F /* Include */ = { + isa = PBXGroup; + children = ( + ); + name = Include; + sourceTree = "<group>"; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + D2AAC043055464E500DB518D /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + D2AAC045055464E500DB518D /* zlib */ = { + isa = PBXNativeTarget; + buildConfigurationList = FE5F4830094784880095980F /* Build configuration list for PBXNativeTarget "zlib" */; + buildPhases = ( + D2AAC043055464E500DB518D /* Headers */, + D2AAC044055464E500DB518D /* Sources */, + D289987405E68DCB004EDB86 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = zlib; + productName = zlib; + productReference = D2AAC046055464E500DB518D /* libzlib.a */; + productType = "com.apple.product-type.library.static"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 08FB7793FE84155DC02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = FE5F4834094784880095980F /* Build configuration list for PBXProject "zlib" */; + compatibilityVersion = "Xcode 2.4"; + hasScannedForEncodings = 1; + mainGroup = 08FB7794FE84155DC02AAC07 /* zlib */; + projectDirPath = ""; + projectRoot = ..; + targets = ( + D2AAC045055464E500DB518D /* zlib */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXSourcesBuildPhase section */ + D2AAC044055464E500DB518D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 00B7E21D0EDCAC9E00F77EA2 /* adler32.c in Sources */, + 00B7E21E0EDCAC9E00F77EA2 /* compress.c in Sources */, + 00B7E21F0EDCAC9E00F77EA2 /* crc32.c in Sources */, + 00B7E2200EDCAC9E00F77EA2 /* deflate.c in Sources */, + 00B7E2210EDCAC9E00F77EA2 /* infback.c in Sources */, + 00B7E2220EDCAC9E00F77EA2 /* inffast.c in Sources */, + 00B7E2230EDCAC9E00F77EA2 /* inflate.c in Sources */, + 00B7E2240EDCAC9E00F77EA2 /* inftrees.c in Sources */, + 00B7E2250EDCAC9E00F77EA2 /* trees.c in Sources */, + 00B7E2260EDCAC9E00F77EA2 /* uncompr.c in Sources */, + 00B7E2270EDCAC9E00F77EA2 /* zutil.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + FE5F4831094784880095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = zlib; + ZERO_LINK = YES; + }; + name = Debug; + }; + FE5F4832094784880095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = YES; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G5; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + INSTALL_PATH = /usr/local/lib; + LIBRARY_STYLE = STATIC; + PREBINDING = NO; + PRODUCT_NAME = zlib; + ZERO_LINK = NO; + }; + name = Release; + }; + FE5F4835094784880095980F /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = ../../zlib; + }; + name = Debug; + }; + FE5F4836094784880095980F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + GCC_CW_ASM_SYNTAX = NO; + GCC_ENABLE_CPP_RTTI = NO; + GCC_ENABLE_PASCAL_STRINGS = NO; + GCC_ENABLE_SYMBOL_SEPARATION = NO; + GCC_PREPROCESSOR_DEFINITIONS = SK_RELEASE; + GCC_USE_GCC3_PFE_SUPPORT = NO; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + LINK_WITH_STANDARD_LIBRARIES = NO; + PREBINDING = NO; + PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO; + STRIP_INSTALLED_PRODUCT = NO; + USER_HEADER_SEARCH_PATHS = ../../zlib; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + FE5F4830094784880095980F /* Build configuration list for PBXNativeTarget "zlib" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F4831094784880095980F /* Debug */, + FE5F4832094784880095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + FE5F4834094784880095980F /* Build configuration list for PBXProject "zlib" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + FE5F4835094784880095980F /* Debug */, + FE5F4836094784880095980F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = 08FB7793FE84155DC02AAC07 /* Project object */; +} |
