1
2 /*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8 #include "SampleCode.h"
9 #include "SkView.h"
10 #include "SkCanvas.h"
11 #include "Sk64.h"
12 #include "SkGradientShader.h"
13 #include "SkGraphics.h"
14 #include "SkImageDecoder.h"
15 #include "SkKernel33MaskFilter.h"
16 #include "SkPath.h"
17 #include "SkRandom.h"
18 #include "SkRegion.h"
19 #include "SkShader.h"
20 #include "SkUtils.h"
21 #include "SkColorPriv.h"
22 #include "SkColorFilter.h"
23 #include "SkTime.h"
24 #include "SkTypeface.h"
25 #include "SkXfermode.h"
26
27 #include "SkStream.h"
28 #include "SkXMLParser.h"
29
30 static const int gKernel[3][3] = {
31 // { -1, -2, -1 }, { -2, 12, -2 }, { -1, -2, -1 }
32 { 1, 2, 1 }, { 2, 64-12, 2 }, { 1, 2, 1 }
33 };
34 static const int gShift = 6;
35
36 class ReduceNoise : public SkKernel33ProcMaskFilter {
37 public:
ReduceNoise(int percent256)38 ReduceNoise(int percent256) : SkKernel33ProcMaskFilter(percent256) {}
computeValue(uint8_t * const * srcRows)39 virtual uint8_t computeValue(uint8_t* const* srcRows)
40 {
41 int c = srcRows[1][1];
42 int min = 255, max = 0;
43 for (int i = 0; i < 3; i++)
44 for (int j = 0; j < 3; j++)
45 if (i != 1 || j != 1)
46 {
47 int v = srcRows[i][j];
48 if (max < v)
49 max = v;
50 if (min > v)
51 min = v;
52 }
53 if (c > max) c = max;
54 // if (c < min) c = min;
55 return c;
56 }
getFactory()57 virtual Factory getFactory() { return Create; }
58 private:
ReduceNoise(SkFlattenableReadBuffer & rb)59 ReduceNoise(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
Create(SkFlattenableReadBuffer & rb)60 static SkFlattenable* Create(SkFlattenableReadBuffer& rb) {
61 return new ReduceNoise(rb);
62 }
63 };
64
65 class Darken : public SkKernel33ProcMaskFilter {
66 public:
Darken(int percent256)67 Darken(int percent256) : SkKernel33ProcMaskFilter(percent256) {}
computeValue(uint8_t * const * srcRows)68 virtual uint8_t computeValue(uint8_t* const* srcRows)
69 {
70 int c = srcRows[1][1];
71 float f = c / 255.f;
72
73 if (c >= 0) {
74 f = sqrtf(f);
75 } else {
76 f *= f;
77 }
78 SkASSERT(f >= 0 && f <= 1);
79 return (int)(f * 255);
80 }
getFactory()81 virtual Factory getFactory() { return Create; }
82 private:
Darken(SkFlattenableReadBuffer & rb)83 Darken(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
Create(SkFlattenableReadBuffer & rb)84 static SkFlattenable* Create(SkFlattenableReadBuffer& rb) {
85 return new Darken(rb);
86 }
87 };
88
makemf()89 static SkMaskFilter* makemf() { return new Darken(0x30); }
90
test_breakText()91 static void test_breakText() {
92 SkPaint paint;
93 const char* text = "sdfkljAKLDFJKEWkldfjlk#$%&sdfs.dsj";
94 size_t length = strlen(text);
95 SkScalar width = paint.measureText(text, length);
96
97 SkScalar mm = 0;
98 SkScalar nn = 0;
99 for (SkScalar w = 0; w <= width; w += SK_Scalar1) {
100 SkScalar m;
101 size_t n = paint.breakText(text, length, w, &m,
102 SkPaint::kBackward_TextBufferDirection);
103
104 SkASSERT(n <= length);
105 SkASSERT(m <= width);
106
107 if (n == 0) {
108 SkASSERT(m == 0);
109 } else {
110 // now assert that we're monotonic
111 if (n == nn) {
112 SkASSERT(m == mm);
113 } else {
114 SkASSERT(n > nn);
115 SkASSERT(m > mm);
116 }
117 }
118 nn = SkIntToScalar(n);
119 mm = m;
120 }
121
122 SkDEBUGCODE(size_t length2 =) paint.breakText(text, length, width, &mm);
123 SkASSERT(length2 == length);
124 SkASSERT(mm == width);
125 }
126
127 static SkRandom gRand;
128
129 class SkPowerMode : public SkXfermode {
130 public:
SkPowerMode(SkScalar exponent)131 SkPowerMode(SkScalar exponent) { this->init(exponent); }
132
133 virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
134 const SkAlpha aa[]);
135
136 typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);
137
138 // overrides for SkFlattenable
getFactory()139 virtual Factory getFactory() { return Create; }
flatten(SkFlattenableWriteBuffer & b)140 virtual void flatten(SkFlattenableWriteBuffer& b) {
141 // this->INHERITED::flatten(b); How can we know if this is legal????
142 b.write32(SkScalarToFixed(fExp));
143 }
144
145 private:
146 SkScalar fExp; // user's value
147 uint8_t fTable[256]; // cache
148
149 void init(SkScalar exponent);
SkPowerMode(SkFlattenableReadBuffer & b)150 SkPowerMode(SkFlattenableReadBuffer& b) : SkXfermode(b) {
151 // read the exponent
152 this->init(SkFixedToScalar(b.readS32()));
153 }
Create(SkFlattenableReadBuffer & b)154 static SkFlattenable* Create(SkFlattenableReadBuffer& b) {
155 return SkNEW_ARGS(SkPowerMode, (b));
156 }
157
158 typedef SkXfermode INHERITED;
159 };
160
init(SkScalar e)161 void SkPowerMode::init(SkScalar e) {
162 fExp = e;
163 float ee = SkScalarToFloat(e);
164
165 printf("------ %g\n", ee);
166 for (int i = 0; i < 256; i++) {
167 float x = i / 255.f;
168 // printf(" %d %g", i, x);
169 x = powf(x, ee);
170 // printf(" %g", x);
171 int xx = SkScalarRound(SkFloatToScalar(x * 255));
172 // printf(" %d\n", xx);
173 fTable[i] = SkToU8(xx);
174 }
175 }
176
xfer16(uint16_t dst[],const SkPMColor src[],int count,const SkAlpha aa[])177 void SkPowerMode::xfer16(uint16_t dst[], const SkPMColor src[], int count,
178 const SkAlpha aa[]) {
179 for (int i = 0; i < count; i++) {
180 SkPMColor c = src[i];
181 int r = SkGetPackedR32(c);
182 int g = SkGetPackedG32(c);
183 int b = SkGetPackedB32(c);
184 r = fTable[r];
185 g = fTable[g];
186 b = fTable[b];
187 dst[i] = SkPack888ToRGB16(r, g, b);
188 }
189 }
190
191 static const struct {
192 const char* fName;
193 uint32_t fFlags;
194 bool fFlushCache;
195 } gHints[] = {
196 { "Linear", SkPaint::kLinearText_Flag, false },
197 { "Normal", 0, true },
198 { "Subpixel", SkPaint::kSubpixelText_Flag, true }
199 };
200
count_char_points(const SkPaint & paint,char c)201 static int count_char_points(const SkPaint& paint, char c) {
202 SkPath path;
203
204 paint.getTextPath(&c, 1, 0, 0, &path);
205 return path.getPoints(NULL, 0);
206 }
207
208 static int gOld, gNew, gCount;
209
dump(int c,int oldc,int newc)210 static void dump(int c, int oldc, int newc) {
211 if (oldc != newc) {
212 gOld += oldc;
213 gNew += newc;
214 gCount += 1;
215 printf("char %c: old = %3d, new = %3d, reduction %g%%\n", c, oldc, newc, 100. * (oldc - newc) / oldc);
216 }
217 }
218
tab(int n)219 static void tab(int n) {
220 // printf("[%d] ", n); return;
221 SkASSERT(n >= 0);
222 for (int i = 0; i < n; i++)
223 printf(" ");
224 }
225
draw_rgn(const SkRegion & rgn,SkCanvas * canvas,const SkPaint & paint)226 static void draw_rgn(const SkRegion& rgn, SkCanvas* canvas, const SkPaint& paint) {
227 SkRect r;
228 SkRegion::Iterator iter(rgn);
229
230 for (; !iter.done(); iter.next()) {
231 r.set(iter.rect());
232 canvas->drawRect(r, paint);
233 }
234 }
235
test_break(SkCanvas * canvas,const char text[],size_t length,SkScalar x,SkScalar y,const SkPaint & paint,SkScalar clickX)236 static void test_break(SkCanvas* canvas, const char text[], size_t length,
237 SkScalar x, SkScalar y, const SkPaint& paint,
238 SkScalar clickX) {
239 SkPaint linePaint;
240
241 linePaint.setAntiAlias(true);
242
243 SkScalar measured;
244
245 if (paint.breakText(text, length, clickX - x, &measured,
246 SkPaint::kForward_TextBufferDirection)) {
247 linePaint.setColor(SK_ColorRED);
248 canvas->drawLine(x, y, x + measured, y, linePaint);
249 }
250
251 x += paint.measureText(text, length);
252 if (paint.breakText(text, length, x - clickX, &measured,
253 SkPaint::kBackward_TextBufferDirection)) {
254 linePaint.setColor(SK_ColorBLUE);
255 canvas->drawLine(x - measured, y, x, y, linePaint);
256 }
257 }
258
DrawTheText(SkCanvas * canvas,const char text[],size_t length,SkScalar x,SkScalar y,const SkPaint & paint,SkScalar clickX,SkMaskFilter * mf)259 static void DrawTheText(SkCanvas* canvas, const char text[], size_t length,
260 SkScalar x, SkScalar y, const SkPaint& paint,
261 SkScalar clickX, SkMaskFilter* mf) {
262 SkPaint p(paint);
263
264 #if 0
265 canvas->drawText(text, length, x, y, paint);
266 #else
267 {
268 SkPoint pts[1000];
269 SkScalar xpos = x;
270 SkASSERT(length <= SK_ARRAY_COUNT(pts));
271 for (size_t i = 0; i < length; i++) {
272 pts[i].set(xpos, y), xpos += paint.getTextSize();
273 }
274 canvas->drawPosText(text, length, pts, paint);
275 }
276 #endif
277
278 p.setSubpixelText(true);
279 x += SkIntToScalar(180);
280 canvas->drawText(text, length, x, y, p);
281
282 #ifdef SK_DEBUG
283 if (true) {
284 // p.setMaskFilter(mf);
285 p.setSubpixelText(false);
286 p.setLinearText(true);
287 x += SkIntToScalar(180);
288 canvas->drawText(text, length, x, y, p);
289 }
290 #endif
291 }
292
293 class TextSpeedView : public SampleView {
294 public:
TextSpeedView()295 TextSpeedView() {
296 fMF = makemf();
297
298 fHints = 0;
299 fClickX = 0;
300
301 test_breakText();
302 }
303
~TextSpeedView()304 virtual ~TextSpeedView() {
305 SkSafeUnref(fMF);
306 }
307
308 protected:
309 // overrides from SkEventSink
onQuery(SkEvent * evt)310 virtual bool onQuery(SkEvent* evt) {
311 if (SampleCode::TitleQ(*evt)) {
312 SampleCode::TitleR(evt, "Text");
313 return true;
314 }
315 return this->INHERITED::onQuery(evt);
316 }
317
make_textstrip(SkBitmap * bm)318 static void make_textstrip(SkBitmap* bm) {
319 bm->setConfig(SkBitmap::kRGB_565_Config, 200, 18);
320 bm->allocPixels();
321 bm->eraseColor(SK_ColorWHITE);
322
323 SkCanvas canvas(*bm);
324 SkPaint paint;
325 const char* s = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit";
326
327 paint.setFlags(paint.getFlags() | SkPaint::kAntiAlias_Flag
328 | SkPaint::kDevKernText_Flag);
329 paint.setTextSize(SkIntToScalar(14));
330 canvas.drawText(s, strlen(s), SkIntToScalar(8), SkIntToScalar(14), paint);
331 }
332
fill_pts(SkPoint pts[],size_t n,SkRandom * rand)333 static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand) {
334 for (size_t i = 0; i < n; i++)
335 pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480);
336 }
337
onDrawContent(SkCanvas * canvas)338 virtual void onDrawContent(SkCanvas* canvas) {
339 SkAutoCanvasRestore restore(canvas, false);
340 {
341 SkRect r;
342 r.set(0, 0, SkIntToScalar(1000), SkIntToScalar(20));
343 // canvas->saveLayer(&r, NULL, SkCanvas::kHasAlphaLayer_SaveFlag);
344 }
345
346 SkPaint paint;
347 // const uint16_t glyphs[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 };
348 int index = fHints % SK_ARRAY_COUNT(gHints);
349 index = 1;
350 // const char* style = gHints[index].fName;
351
352 // canvas->translate(0, SkIntToScalar(50));
353
354 // canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint);
355
356 SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromFile("/skimages/samplefont.ttf")));
357 paint.setAntiAlias(true);
358 paint.setFlags(paint.getFlags() | gHints[index].fFlags);
359
360 SkRect clip;
361 clip.set(SkIntToScalar(25), SkIntToScalar(34), SkIntToScalar(88), SkIntToScalar(155));
362
363 const char* text = "Hamburgefons";
364 size_t length = strlen(text);
365
366 SkScalar y = SkIntToScalar(0);
367 for (int i = 9; i <= 24; i++) {
368 paint.setTextSize(SkIntToScalar(i) /*+ (gRand.nextU() & 0xFFFF)*/);
369 for (SkScalar dx = 0; dx <= SkIntToScalar(3)/4;
370 dx += SkIntToScalar(1) /* /4 */) {
371 y += paint.getFontSpacing();
372 DrawTheText(canvas, text, length, SkIntToScalar(20) + dx, y,
373 paint, fClickX, fMF);
374 }
375 }
376 if (gHints[index].fFlushCache) {
377 // SkGraphics::SetFontCacheUsed(0);
378 }
379 }
380
onFindClickHandler(SkScalar x,SkScalar y)381 virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y) {
382 fClickX = x;
383 this->inval(NULL);
384 return this->INHERITED::onFindClickHandler(x, y);
385 }
386
onClick(Click * click)387 virtual bool onClick(Click* click) {
388 return this->INHERITED::onClick(click);
389 }
390
391 private:
392 int fHints;
393 SkScalar fClickX;
394 SkMaskFilter* fMF;
395
396 typedef SampleView INHERITED;
397 };
398
399 //////////////////////////////////////////////////////////////////////////////
400
MyFactory()401 static SkView* MyFactory() { return new TextSpeedView; }
402 static SkViewRegister reg(MyFactory);
403
404