SampleApp.cpp revision 3c4d032aeb2831a64fd6eff570667d590e3ed209
1/* 2 * Copyright 2011 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7#include "SampleApp.h" 8 9#include "SkData.h" 10#include "SkCanvas.h" 11#include "SkDevice.h" 12#include "SkGpuDevice.h" 13#include "SkGraphics.h" 14#include "SkImageEncoder.h" 15#include "SkPaint.h" 16#include "SkPicture.h" 17#include "SkStream.h" 18#include "SkTime.h" 19#include "SkWindow.h" 20 21#include "SampleCode.h" 22#include "GrContext.h" 23#include "SkTypeface.h" 24 25#include "gl/GrGLInterface.h" 26#include "GrRenderTarget.h" 27 28#include "SkPDFDevice.h" 29#include "SkPDFDocument.h" 30#include "SkStream.h" 31 32#define TEST_GPIPE 33 34#ifdef TEST_GPIPE 35#define PIPE_FILEx 36#ifdef PIPE_FILE 37#define FILE_PATH "/path/to/drawing.data" 38#endif 39 40#define PIPE_NETx 41#ifdef PIPE_NET 42#include "SkSockets.h" 43SkTCPServer gServer; 44#endif 45 46#define DEBUGGERx 47#ifdef DEBUGGER 48extern SkView* create_debugger(const char* data, size_t size); 49extern bool is_debugger(SkView* view); 50SkTDArray<char> gTempDataStore; 51#endif 52 53#endif 54 55#define USE_ARROWS_FOR_ZOOM true 56 57#if SK_ANGLE 58//#define DEFAULT_TO_ANGLE 1 59#else 60//#define DEFAULT_TO_GPU 1 61#endif 62 63extern SkView* create_overview(int, const SkViewFactory*[]); 64extern bool is_overview(SkView* view); 65extern SkView* create_transition(SkView*, SkView*, int); 66extern bool is_transition(SkView* view); 67 68 69#define ANIMATING_EVENTTYPE "nextSample" 70#define ANIMATING_DELAY 750 71 72#ifdef SK_DEBUG 73 #define FPS_REPEAT_MULTIPLIER 1 74#else 75 #define FPS_REPEAT_MULTIPLIER 10 76#endif 77#define FPS_REPEAT_COUNT (10 * FPS_REPEAT_MULTIPLIER) 78 79static SampleWindow* gSampleWindow; 80 81static void postEventToSink(SkEvent* evt, SkEventSink* sink) { 82 evt->setTargetID(sink->getSinkID())->post(); 83} 84 85/////////////////////////////////////////////////////////////////////////////// 86 87static const char* skip_until(const char* str, const char* skip) { 88 if (!str) { 89 return NULL; 90 } 91 return strstr(str, skip); 92} 93 94static const char* skip_past(const char* str, const char* skip) { 95 const char* found = skip_until(str, skip); 96 if (!found) { 97 return NULL; 98 } 99 return found + strlen(skip); 100} 101 102static const char* gPrefFileName = "sampleapp_prefs.txt"; 103 104static bool readTitleFromPrefs(SkString* title) { 105 SkFILEStream stream(gPrefFileName); 106 if (!stream.isValid()) { 107 return false; 108 } 109 110 int len = stream.getLength(); 111 SkString data(len); 112 stream.read(data.writable_str(), len); 113 const char* s = data.c_str(); 114 115 s = skip_past(s, "curr-slide-title"); 116 s = skip_past(s, "="); 117 s = skip_past(s, "\""); 118 const char* stop = skip_until(s, "\""); 119 if (stop > s) { 120 title->set(s, stop - s); 121 return true; 122 } 123 return false; 124} 125 126static void writeTitleToPrefs(const char* title) { 127 SkFILEWStream stream(gPrefFileName); 128 SkString data; 129 data.printf("curr-slide-title = \"%s\"\n", title); 130 stream.write(data.c_str(), data.size()); 131} 132 133/////////////////////////////////////////////////////////////////////////////// 134 135class SampleWindow::DefaultDeviceManager : public SampleWindow::DeviceManager { 136public: 137 138 DefaultDeviceManager() 139 : fCurContext(NULL) 140 , fCurIntf(NULL) 141 , fCurRenderTarget(NULL) 142 , fBackend(kNone_BackEndType) { 143 } 144 145 virtual ~DefaultDeviceManager() { 146 SkSafeUnref(fCurContext); 147 SkSafeUnref(fCurIntf); 148 SkSafeUnref(fCurRenderTarget); 149 } 150 151 virtual void setUpBackend(SampleWindow* win) { 152 SkASSERT(kNone_BackEndType == fBackend); 153 154 fBackend = kNone_BackEndType; 155 156 switch (win->getDeviceType()) { 157 case kRaster_DeviceType: 158 // fallthrough 159 case kPicture_DeviceType: 160 // fallthrough 161 case kGPU_DeviceType: 162 // fallthrough 163 case kNullGPU_DeviceType: 164 // all these guys use the native backend 165 fBackend = kNativeGL_BackEndType; 166 break; 167#if SK_ANGLE 168 case kANGLE_DeviceType: 169 // ANGLE is really the only odd man out 170 fBackend = kANGLE_BackEndType; 171 break; 172#endif 173 default: 174 SkASSERT(false); 175 break; 176 } 177 178 bool result = win->attach(fBackend); 179 if (!result) { 180 SkDebugf("Failed to initialize GL"); 181 return; 182 } 183 184 SkASSERT(NULL == fCurIntf); 185 switch (win->getDeviceType()) { 186 case kRaster_DeviceType: 187 // fallthrough 188 case kPicture_DeviceType: 189 // fallthrough 190 case kGPU_DeviceType: 191 // all these guys use the native interface 192 fCurIntf = GrGLCreateNativeInterface(); 193 break; 194#if SK_ANGLE 195 case kANGLE_DeviceType: 196 fCurIntf = GrGLCreateANGLEInterface(); 197 break; 198#endif 199 case kNullGPU_DeviceType: 200 fCurIntf = GrGLCreateNullInterface(); 201 break; 202 default: 203 SkASSERT(false); 204 break; 205 } 206 207 SkASSERT(NULL == fCurContext); 208 fCurContext = GrContext::Create(kOpenGL_Shaders_GrEngine, 209 (GrPlatform3DContext) fCurIntf); 210 211 if (NULL == fCurContext || NULL == fCurIntf) { 212 // We need some context and interface to see results 213 SkSafeUnref(fCurContext); 214 SkSafeUnref(fCurIntf); 215 SkDebugf("Failed to setup 3D"); 216 217 win->detach(); 218 } 219 220 // call windowSizeChanged to create the render target 221 windowSizeChanged(win); 222 } 223 224 virtual void tearDownBackend(SampleWindow *win) { 225 win->detach(); 226 fBackend = kNone_BackEndType; 227 228 SkSafeUnref(fCurContext); 229 fCurContext = NULL; 230 231 SkSafeUnref(fCurIntf); 232 fCurIntf = NULL; 233 234 SkSafeUnref(fCurRenderTarget); 235 fCurRenderTarget = NULL; 236 } 237 238 virtual bool prepareCanvas(SampleWindow::DeviceType dType, 239 SkCanvas* canvas, 240 SampleWindow* win) { 241 switch (dType) { 242 case kRaster_DeviceType: 243 // fallthrough 244 case kPicture_DeviceType: 245 // fallthrough 246#if SK_ANGLE 247 case kANGLE_DeviceType: 248#endif 249 break; 250 case kGPU_DeviceType: 251 case kNullGPU_DeviceType: 252 if (fCurContext) { 253 canvas->setDevice(new SkGpuDevice(fCurContext, 254 fCurRenderTarget))->unref(); 255 } else { 256 return false; 257 } 258 break; 259 default: 260 SkASSERT(false); 261 return false; 262 } 263 return true; 264 } 265 266 virtual void publishCanvas(SampleWindow::DeviceType dType, 267 SkCanvas* canvas, 268 SampleWindow* win) { 269 if (fCurContext) { 270 // in case we have queued drawing calls 271 fCurContext->flush(); 272 273 if (kGPU_DeviceType != dType && kNullGPU_DeviceType != dType) { 274 // need to send the raster bits to the (gpu) window 275 fCurContext->setRenderTarget(fCurRenderTarget); 276 const SkBitmap& bm = win->getBitmap(); 277 fCurRenderTarget->writePixels(0, 0, bm.width(), bm.height(), 278 kSkia8888_PM_GrPixelConfig, 279 bm.getPixels(), 280 bm.rowBytes()); 281 } 282 } 283 284 win->present(); 285 } 286 287 virtual void windowSizeChanged(SampleWindow* win) { 288 289 if (fCurContext) { 290 win->attach(fBackend); 291 292 GrPlatformRenderTargetDesc desc; 293 desc.fWidth = SkScalarRound(win->width()); 294 desc.fHeight = SkScalarRound(win->height()); 295 desc.fConfig = kSkia8888_PM_GrPixelConfig; 296 GR_GL_GetIntegerv(fCurIntf, GR_GL_SAMPLES, &desc.fSampleCnt); 297 GR_GL_GetIntegerv(fCurIntf, GR_GL_STENCIL_BITS, &desc.fStencilBits); 298 GrGLint buffer; 299 GR_GL_GetIntegerv(fCurIntf, GR_GL_FRAMEBUFFER_BINDING, &buffer); 300 desc.fRenderTargetHandle = buffer; 301 302 SkSafeUnref(fCurRenderTarget); 303 fCurRenderTarget = fCurContext->createPlatformRenderTarget(desc); 304 } 305 } 306 307 virtual GrContext* getGrContext() { 308 return fCurContext; 309 } 310private: 311 GrContext* fCurContext; 312 const GrGLInterface* fCurIntf; 313 GrRenderTarget* fCurRenderTarget; 314 315 SkOSWindow::SkBackEndTypes fBackend; 316 317 typedef SampleWindow::DeviceManager INHERITED; 318}; 319 320/////////////// 321static const char view_inval_msg[] = "view-inval-msg"; 322 323void SampleWindow::postInvalDelay() { 324 (new SkEvent(view_inval_msg, this->getSinkID()))->postDelay(1); 325} 326 327static bool isInvalEvent(const SkEvent& evt) { 328 return evt.isType(view_inval_msg); 329} 330////////////////// 331 332SkFuncViewFactory::SkFuncViewFactory(SkViewCreateFunc func) 333 : fCreateFunc(func) { 334} 335 336SkView* SkFuncViewFactory::operator() () const { 337 return (*fCreateFunc)(); 338} 339 340#include "GMSampleView.h" 341 342SkGMSampleViewFactory::SkGMSampleViewFactory(GMFactoryFunc func) 343 : fFunc(func) { 344} 345 346SkView* SkGMSampleViewFactory::operator() () const { 347 return new GMSampleView(fFunc(NULL)); 348} 349 350SkViewRegister* SkViewRegister::gHead; 351SkViewRegister::SkViewRegister(SkViewFactory* fact) : fFact(fact) { 352 fFact->ref(); 353 fChain = gHead; 354 gHead = this; 355} 356 357SkViewRegister::SkViewRegister(SkViewCreateFunc func) { 358 fFact = new SkFuncViewFactory(func); 359 fChain = gHead; 360 gHead = this; 361} 362 363SkViewRegister::SkViewRegister(GMFactoryFunc func) { 364 fFact = new SkGMSampleViewFactory(func); 365 fChain = gHead; 366 gHead = this; 367} 368 369class AutoUnrefArray { 370public: 371 AutoUnrefArray() {} 372 ~AutoUnrefArray() { 373 int count = fObjs.count(); 374 for (int i = 0; i < count; ++i) { 375 fObjs[i]->unref(); 376 } 377 } 378 SkRefCnt*& push_back() { return *fObjs.append(); } 379 380private: 381 SkTDArray<SkRefCnt*> fObjs; 382}; 383 384// registers GMs as Samples 385// This can't be performed during static initialization because it could be 386// run before GMRegistry has been fully built. 387void SkGMRegistyToSampleRegistry() { 388 static bool gOnce; 389 static AutoUnrefArray fRegisters; 390 391 if (!gOnce) { 392 const skiagm::GMRegistry* gmreg = skiagm::GMRegistry::Head(); 393 while (gmreg) { 394 fRegisters.push_back() = new SkViewRegister(gmreg->factory()); 395 gmreg = gmreg->next(); 396 } 397 gOnce = true; 398 } 399} 400 401#if 0 402#include <CoreFoundation/CoreFoundation.h> 403#include <CoreFoundation/CFURLAccess.h> 404 405static void testpdf() { 406 CFStringRef path = CFStringCreateWithCString(NULL, "/test.pdf", 407 kCFStringEncodingUTF8); 408 CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path, 409 kCFURLPOSIXPathStyle, 410 false); 411 CFRelease(path); 412 CGRect box = CGRectMake(0, 0, 8*72, 10*72); 413 CGContextRef cg = CGPDFContextCreateWithURL(url, &box, NULL); 414 CFRelease(url); 415 416 CGContextBeginPage(cg, &box); 417 CGRect r = CGRectMake(10, 10, 40 + 0.5, 50 + 0.5); 418 CGContextFillEllipseInRect(cg, r); 419 CGContextEndPage(cg); 420 CGContextRelease(cg); 421 422 if (false) { 423 SkBitmap bm; 424 bm.setConfig(SkBitmap::kA8_Config, 64, 64); 425 bm.allocPixels(); 426 bm.eraseColor(0); 427 428 SkCanvas canvas(bm); 429 430 } 431} 432#endif 433 434////////////////////////////////////////////////////////////////////////////// 435 436enum FlipAxisEnum { 437 kFlipAxis_X = (1 << 0), 438 kFlipAxis_Y = (1 << 1) 439}; 440 441#include "SkDrawFilter.h" 442 443class FlagsDrawFilter : public SkDrawFilter { 444public: 445 FlagsDrawFilter(SkOSMenu::TriState lcd, SkOSMenu::TriState aa, SkOSMenu::TriState filter, 446 SkOSMenu::TriState hinting) : 447 fLCDState(lcd), fAAState(aa), fFilterState(filter), fHintingState(hinting) {} 448 449 virtual void filter(SkPaint* paint, Type t) { 450 if (kText_Type == t && SkOSMenu::kMixedState != fLCDState) { 451 paint->setLCDRenderText(SkOSMenu::kOnState == fLCDState); 452 } 453 if (SkOSMenu::kMixedState != fAAState) { 454 paint->setAntiAlias(SkOSMenu::kOnState == fAAState); 455 } 456 if (SkOSMenu::kMixedState != fFilterState) { 457 paint->setFilterBitmap(SkOSMenu::kOnState == fFilterState); 458 } 459 if (SkOSMenu::kMixedState != fHintingState) { 460 paint->setHinting(SkOSMenu::kOnState == fHintingState ? 461 SkPaint::kNormal_Hinting : 462 SkPaint::kSlight_Hinting); 463 } 464 } 465 466private: 467 SkOSMenu::TriState fLCDState; 468 SkOSMenu::TriState fAAState; 469 SkOSMenu::TriState fFilterState; 470 SkOSMenu::TriState fHintingState; 471}; 472 473////////////////////////////////////////////////////////////////////////////// 474 475#define MAX_ZOOM_LEVEL 8 476#define MIN_ZOOM_LEVEL -8 477 478static const char gCharEvtName[] = "SampleCode_Char_Event"; 479static const char gKeyEvtName[] = "SampleCode_Key_Event"; 480static const char gTitleEvtName[] = "SampleCode_Title_Event"; 481static const char gPrefSizeEvtName[] = "SampleCode_PrefSize_Event"; 482static const char gFastTextEvtName[] = "SampleCode_FastText_Event"; 483static const char gUpdateWindowTitleEvtName[] = "SampleCode_UpdateWindowTitle"; 484 485bool SampleCode::CharQ(const SkEvent& evt, SkUnichar* outUni) { 486 if (evt.isType(gCharEvtName, sizeof(gCharEvtName) - 1)) { 487 if (outUni) { 488 *outUni = evt.getFast32(); 489 } 490 return true; 491 } 492 return false; 493} 494 495bool SampleCode::KeyQ(const SkEvent& evt, SkKey* outKey) { 496 if (evt.isType(gKeyEvtName, sizeof(gKeyEvtName) - 1)) { 497 if (outKey) { 498 *outKey = (SkKey)evt.getFast32(); 499 } 500 return true; 501 } 502 return false; 503} 504 505bool SampleCode::TitleQ(const SkEvent& evt) { 506 return evt.isType(gTitleEvtName, sizeof(gTitleEvtName) - 1); 507} 508 509void SampleCode::TitleR(SkEvent* evt, const char title[]) { 510 SkASSERT(evt && TitleQ(*evt)); 511 evt->setString(gTitleEvtName, title); 512} 513 514bool SampleCode::RequestTitle(SkView* view, SkString* title) { 515 SkEvent evt(gTitleEvtName); 516 if (view->doQuery(&evt)) { 517 title->set(evt.findString(gTitleEvtName)); 518 return true; 519 } 520 return false; 521} 522 523bool SampleCode::PrefSizeQ(const SkEvent& evt) { 524 return evt.isType(gPrefSizeEvtName, sizeof(gPrefSizeEvtName) - 1); 525} 526 527void SampleCode::PrefSizeR(SkEvent* evt, SkScalar width, SkScalar height) { 528 SkASSERT(evt && PrefSizeQ(*evt)); 529 SkScalar size[2]; 530 size[0] = width; 531 size[1] = height; 532 evt->setScalars(gPrefSizeEvtName, 2, size); 533} 534 535bool SampleCode::FastTextQ(const SkEvent& evt) { 536 return evt.isType(gFastTextEvtName, sizeof(gFastTextEvtName) - 1); 537} 538 539/////////////////////////////////////////////////////////////////////////////// 540 541static SkMSec gAnimTime; 542static SkMSec gAnimTimePrev; 543 544SkMSec SampleCode::GetAnimTime() { return gAnimTime; } 545SkMSec SampleCode::GetAnimTimeDelta() { return gAnimTime - gAnimTimePrev; } 546SkScalar SampleCode::GetAnimSecondsDelta() { 547 return SkDoubleToScalar(GetAnimTimeDelta() / 1000.0); 548} 549 550SkScalar SampleCode::GetAnimScalar(SkScalar speed, SkScalar period) { 551 // since gAnimTime can be up to 32 bits, we can't convert it to a float 552 // or we'll lose the low bits. Hence we use doubles for the intermediate 553 // calculations 554 double seconds = (double)gAnimTime / 1000.0; 555 double value = SkScalarToDouble(speed) * seconds; 556 if (period) { 557 value = ::fmod(value, SkScalarToDouble(period)); 558 } 559 return SkDoubleToScalar(value); 560} 561 562SkScalar SampleCode::GetAnimSinScalar(SkScalar amplitude, 563 SkScalar periodInSec, 564 SkScalar phaseInSec) { 565 if (!periodInSec) { 566 return 0; 567 } 568 double t = (double)gAnimTime / 1000.0 + phaseInSec; 569 t *= SkScalarToFloat(2 * SK_ScalarPI) / periodInSec; 570 amplitude = SK_ScalarHalf * amplitude; 571 return SkScalarMul(amplitude, SkDoubleToScalar(sin(t))) + amplitude; 572} 573 574GrContext* SampleCode::GetGr() { 575 return gSampleWindow ? gSampleWindow->getGrContext() : NULL; 576} 577 578// some GMs rely on having a skiagm::GetGr function defined 579namespace skiagm { 580 GrContext* GetGr() { return SampleCode::GetGr(); } 581} 582 583////////////////////////////////////////////////////////////////////////////// 584 585static SkView* curr_view(SkWindow* wind) { 586 SkView::F2BIter iter(wind); 587 return iter.next(); 588} 589 590static bool curr_title(SkWindow* wind, SkString* title) { 591 SkView* view = curr_view(wind); 592 if (view) { 593 SkEvent evt(gTitleEvtName); 594 if (view->doQuery(&evt)) { 595 title->set(evt.findString(gTitleEvtName)); 596 return true; 597 } 598 } 599 return false; 600} 601 602void SampleWindow::setZoomCenter(float x, float y) 603{ 604 fZoomCenterX = SkFloatToScalar(x); 605 fZoomCenterY = SkFloatToScalar(y); 606} 607 608bool SampleWindow::zoomIn() 609{ 610 // Arbitrarily decided 611 if (fFatBitsScale == 25) return false; 612 fFatBitsScale++; 613 this->inval(NULL); 614 return true; 615} 616 617bool SampleWindow::zoomOut() 618{ 619 if (fFatBitsScale == 1) return false; 620 fFatBitsScale--; 621 this->inval(NULL); 622 return true; 623} 624 625void SampleWindow::updatePointer(int x, int y) 626{ 627 fMouseX = x; 628 fMouseY = y; 629 if (fShowZoomer) { 630 this->inval(NULL); 631 } 632} 633 634static inline SampleWindow::DeviceType cycle_devicetype(SampleWindow::DeviceType ct) { 635 static const SampleWindow::DeviceType gCT[] = { 636 SampleWindow::kPicture_DeviceType, 637 SampleWindow::kGPU_DeviceType, 638#if SK_ANGLE 639 SampleWindow::kANGLE_DeviceType, 640#endif 641 SampleWindow::kRaster_DeviceType, // skip the null gpu device in normal cycling 642 SampleWindow::kRaster_DeviceType 643 }; 644 return gCT[ct]; 645} 646 647static void usage(const char * argv0) { 648 SkDebugf("%s [--slide sampleName] [-i resourcePath]\n", argv0); 649 SkDebugf(" sampleName: sample at which to start.\n"); 650 SkDebugf(" resourcePath: directory that stores image resources.\n"); 651} 652 653SampleWindow::SampleWindow(void* hwnd, int argc, char** argv, DeviceManager* devManager) : INHERITED(hwnd) { 654 655 SkGMRegistyToSampleRegistry(); 656 { 657 const SkViewRegister* reg = SkViewRegister::Head(); 658 while (reg) { 659 *fSamples.append() = reg->factory(); 660 reg = reg->next(); 661 } 662 } 663 664 const char* resourcePath = NULL; 665 fCurrIndex = -1; 666 667 const char* const commandName = argv[0]; 668 char* const* stop = argv + argc; 669 for (++argv; argv < stop; ++argv) { 670 if (strcmp(*argv, "-i") == 0) { 671 argv++; 672 if (argv < stop && **argv) { 673 resourcePath = *argv; 674 } 675 } else if (strcmp(*argv, "--slide") == 0) { 676 argv++; 677 if (argv < stop && **argv) { 678 fCurrIndex = findByTitle(*argv); 679 if (fCurrIndex < 0) { 680 fprintf(stderr, "Unknown sample \"%s\"\n", *argv); 681 } 682 } 683 } 684 else { 685 usage(commandName); 686 } 687 } 688 689 if (fCurrIndex < 0) { 690 SkString title; 691 if (readTitleFromPrefs(&title)) { 692 fCurrIndex = findByTitle(title.c_str()); 693 } 694 } 695 696 if (fCurrIndex < 0) { 697 fCurrIndex = 0; 698 } 699 700 gSampleWindow = this; 701 702#ifdef PIPE_FILE 703 //Clear existing file or create file if it doesn't exist 704 FILE* f = fopen(FILE_PATH, "wb"); 705 fclose(f); 706#endif 707 708 fPicture = NULL; 709 710 fDeviceType = kRaster_DeviceType; 711 712#if DEFAULT_TO_GPU 713 fDeviceType = kGPU_DeviceType; 714#endif 715#if SK_ANGLE && DEFAULT_TO_ANGLE 716 fDeviceType = kANGLE_DeviceType; 717#endif 718 719 fUseClip = false; 720 fNClip = false; 721 fAnimating = false; 722 fRotate = false; 723 fPerspAnim = false; 724 fPerspAnimTime = 0; 725 fScale = false; 726 fRequestGrabImage = false; 727 fUsePipe = false; 728 fMeasureFPS = false; 729 fLCDState = SkOSMenu::kMixedState; 730 fAAState = SkOSMenu::kMixedState; 731 fFilterState = SkOSMenu::kMixedState; 732 fHintingState = SkOSMenu::kMixedState; 733 fFlipAxis = 0; 734 fScrollTestX = fScrollTestY = 0; 735 736 fMouseX = fMouseY = 0; 737 fFatBitsScale = 8; 738 fTypeface = SkTypeface::CreateFromTypeface(NULL, SkTypeface::kBold); 739 fShowZoomer = false; 740 741 fZoomLevel = 0; 742 fZoomScale = SK_Scalar1; 743 744 fMagnify = false; 745 fDebugger = false; 746 747 fSaveToPdf = false; 748 fPdfCanvas = NULL; 749 750 fTransitionNext = 6; 751 fTransitionPrev = 2; 752 753 int sinkID = this->getSinkID(); 754 fAppMenu.setTitle("Global Settings"); 755 int itemID; 756 757 itemID =fAppMenu.appendList("Device Type", "Device Type", sinkID, 0, 758 "Raster", "Picture", "OpenGL", 759#if SK_ANGLE 760 "ANGLE", 761#endif 762 NULL); 763 fAppMenu.assignKeyEquivalentToItem(itemID, 'd'); 764 itemID = fAppMenu.appendTriState("AA", "AA", sinkID, fAAState); 765 fAppMenu.assignKeyEquivalentToItem(itemID, 'b'); 766 itemID = fAppMenu.appendTriState("LCD", "LCD", sinkID, fLCDState); 767 fAppMenu.assignKeyEquivalentToItem(itemID, 'l'); 768 itemID = fAppMenu.appendTriState("Filter", "Filter", sinkID, fFilterState); 769 fAppMenu.assignKeyEquivalentToItem(itemID, 'n'); 770 itemID = fAppMenu.appendTriState("Hinting", "Hinting", sinkID, fHintingState); 771 fAppMenu.assignKeyEquivalentToItem(itemID, 'h'); 772 fUsePipeMenuItemID = fAppMenu.appendSwitch("Pipe", "Pipe" , sinkID, fUsePipe); 773 fAppMenu.assignKeyEquivalentToItem(fUsePipeMenuItemID, 'p'); 774#ifdef DEBUGGER 775 itemID = fAppMenu.appendSwitch("Debugger", "Debugger", sinkID, fDebugger); 776 fAppMenu.assignKeyEquivalentToItem(itemID, 'q'); 777#endif 778 itemID = fAppMenu.appendSwitch("Slide Show", "Slide Show" , sinkID, false); 779 fAppMenu.assignKeyEquivalentToItem(itemID, 'a'); 780 itemID = fAppMenu.appendSwitch("Clip", "Clip" , sinkID, fUseClip); 781 fAppMenu.assignKeyEquivalentToItem(itemID, 'c'); 782 itemID = fAppMenu.appendSwitch("Flip X", "Flip X" , sinkID, false); 783 fAppMenu.assignKeyEquivalentToItem(itemID, 'x'); 784 itemID = fAppMenu.appendSwitch("Flip Y", "Flip Y" , sinkID, false); 785 fAppMenu.assignKeyEquivalentToItem(itemID, 'y'); 786 itemID = fAppMenu.appendSwitch("Zoomer", "Zoomer" , sinkID, fShowZoomer); 787 fAppMenu.assignKeyEquivalentToItem(itemID, 'z'); 788 itemID = fAppMenu.appendSwitch("Magnify", "Magnify" , sinkID, fMagnify); 789 fAppMenu.assignKeyEquivalentToItem(itemID, 'm'); 790 itemID =fAppMenu.appendList("Transition-Next", "Transition-Next", sinkID, 791 fTransitionNext, "Up", "Up and Right", "Right", 792 "Down and Right", "Down", "Down and Left", 793 "Left", "Up and Left", NULL); 794 fAppMenu.assignKeyEquivalentToItem(itemID, 'j'); 795 itemID =fAppMenu.appendList("Transition-Prev", "Transition-Prev", sinkID, 796 fTransitionPrev, "Up", "Up and Right", "Right", 797 "Down and Right", "Down", "Down and Left", 798 "Left", "Up and Left", NULL); 799 fAppMenu.assignKeyEquivalentToItem(itemID, 'k'); 800 itemID = fAppMenu.appendAction("Save to PDF", sinkID); 801 fAppMenu.assignKeyEquivalentToItem(itemID, 'e'); 802 803 this->addMenu(&fAppMenu); 804 this->addMenu(&fSlideMenu); 805 806// this->setConfig(SkBitmap::kRGB_565_Config); 807 this->setConfig(SkBitmap::kARGB_8888_Config); 808 this->setVisibleP(true); 809 this->setClipToBounds(false); 810 811 skiagm::GM::SetResourcePath(resourcePath); 812 813 this->loadView((*fSamples[fCurrIndex])()); 814 815 fPDFData = NULL; 816 817 if (NULL == devManager) { 818 fDevManager = new DefaultDeviceManager(); 819 } else { 820 devManager->ref(); 821 fDevManager = devManager; 822 } 823 fDevManager->setUpBackend(this); 824 825 // If another constructor set our dimensions, ensure that our 826 // onSizeChange gets called. 827 if (this->height() && this->width()) { 828 this->onSizeChange(); 829 } 830 831 // can't call this synchronously, since it may require a subclass to 832 // to implement, or the caller may need us to have returned from the 833 // constructor first. Hence we post an event to ourselves. 834// this->updateTitle(); 835 postEventToSink(new SkEvent(gUpdateWindowTitleEvtName), this); 836} 837 838SampleWindow::~SampleWindow() { 839 delete fPicture; 840 delete fPdfCanvas; 841 fTypeface->unref(); 842 843 SkSafeUnref(fDevManager); 844} 845 846int SampleWindow::findByTitle(const char title[]) { 847 int i, count = fSamples.count(); 848 for (i = 0; i < count; i++) { 849 if (getSampleTitle(i).equals(title)) { 850 return i; 851 } 852 } 853 return -1; 854} 855 856static SkBitmap capture_bitmap(SkCanvas* canvas) { 857 SkBitmap bm; 858 const SkBitmap& src = canvas->getDevice()->accessBitmap(false); 859 src.copyTo(&bm, src.config()); 860 return bm; 861} 862 863static bool bitmap_diff(SkCanvas* canvas, const SkBitmap& orig, 864 SkBitmap* diff) { 865 const SkBitmap& src = canvas->getDevice()->accessBitmap(false); 866 867 SkAutoLockPixels alp0(src); 868 SkAutoLockPixels alp1(orig); 869 for (int y = 0; y < src.height(); y++) { 870 const void* srcP = src.getAddr(0, y); 871 const void* origP = orig.getAddr(0, y); 872 size_t bytes = src.width() * src.bytesPerPixel(); 873 if (memcmp(srcP, origP, bytes)) { 874 SkDebugf("---------- difference on line %d\n", y); 875 return true; 876 } 877 } 878 return false; 879} 880 881static void drawText(SkCanvas* canvas, SkString string, SkScalar left, SkScalar top, SkPaint& paint) 882{ 883 SkColor desiredColor = paint.getColor(); 884 paint.setColor(SK_ColorWHITE); 885 const char* c_str = string.c_str(); 886 size_t size = string.size(); 887 SkRect bounds; 888 paint.measureText(c_str, size, &bounds); 889 bounds.offset(left, top); 890 SkScalar inset = SkIntToScalar(-2); 891 bounds.inset(inset, inset); 892 canvas->drawRect(bounds, paint); 893 if (desiredColor != SK_ColorBLACK) { 894 paint.setColor(SK_ColorBLACK); 895 canvas->drawText(c_str, size, left + SK_Scalar1, top + SK_Scalar1, paint); 896 } 897 paint.setColor(desiredColor); 898 canvas->drawText(c_str, size, left, top, paint); 899} 900 901#define XCLIP_N 8 902#define YCLIP_N 8 903 904void SampleWindow::draw(SkCanvas* canvas) { 905 if (!fDevManager->prepareCanvas(fDeviceType, canvas, this)) { 906 return; 907 } 908 // update the animation time 909 if (!gAnimTimePrev && !gAnimTime) { 910 // first time make delta be 0 911 gAnimTime = SkTime::GetMSecs(); 912 gAnimTimePrev = gAnimTime; 913 } else { 914 gAnimTimePrev = gAnimTime; 915 gAnimTime = SkTime::GetMSecs(); 916 } 917 918 const SkMatrix& localM = fGesture.localM(); 919 if (localM.getType() & SkMatrix::kScale_Mask) { 920 canvas->setExternalMatrix(&localM); 921 } 922 if (fGesture.isActive()) { 923 this->updateMatrix(); 924 } 925 926 if (fNClip) { 927 this->INHERITED::draw(canvas); 928 SkBitmap orig = capture_bitmap(canvas); 929 930 const SkScalar w = this->width(); 931 const SkScalar h = this->height(); 932 const SkScalar cw = w / XCLIP_N; 933 const SkScalar ch = h / YCLIP_N; 934 for (int y = 0; y < YCLIP_N; y++) { 935 SkRect r; 936 r.fTop = y * ch; 937 r.fBottom = (y + 1) * ch; 938 if (y == YCLIP_N - 1) { 939 r.fBottom = h; 940 } 941 for (int x = 0; x < XCLIP_N; x++) { 942 SkAutoCanvasRestore acr(canvas, true); 943 r.fLeft = x * cw; 944 r.fRight = (x + 1) * cw; 945 if (x == XCLIP_N - 1) { 946 r.fRight = w; 947 } 948 canvas->clipRect(r); 949 this->INHERITED::draw(canvas); 950 } 951 } 952 953 SkBitmap diff; 954 if (bitmap_diff(canvas, orig, &diff)) { 955 } 956 } else { 957 this->INHERITED::draw(canvas); 958 } 959 if (fShowZoomer && !fSaveToPdf) { 960 showZoomer(canvas); 961 } 962 if (fMagnify && !fSaveToPdf) { 963 magnify(canvas); 964 } 965 966 // do this last 967 fDevManager->publishCanvas(fDeviceType, canvas, this); 968} 969 970static float clipW = 200; 971static float clipH = 200; 972void SampleWindow::magnify(SkCanvas* canvas) { 973 SkRect r; 974 int count = canvas->save(); 975 976 SkMatrix m = canvas->getTotalMatrix(); 977 m.invert(&m); 978 SkPoint offset, center; 979 SkScalar mouseX = fMouseX * SK_Scalar1; 980 SkScalar mouseY = fMouseY * SK_Scalar1; 981 m.mapXY(mouseX - clipW/2, mouseY - clipH/2, &offset); 982 m.mapXY(mouseX, mouseY, ¢er); 983 984 r.set(0, 0, clipW * m.getScaleX(), clipH * m.getScaleX()); 985 r.offset(offset.fX, offset.fY); 986 987 SkPaint paint; 988 paint.setColor(0xFF66AAEE); 989 paint.setStyle(SkPaint::kStroke_Style); 990 paint.setStrokeWidth(10.f * m.getScaleX()); 991 //lense offset 992 //canvas->translate(0, -250); 993 canvas->drawRect(r, paint); 994 canvas->clipRect(r); 995 996 m = canvas->getTotalMatrix(); 997 m.setTranslate(-center.fX, -center.fY); 998 m.postScale(0.5f * fFatBitsScale, 0.5f * fFatBitsScale); 999 m.postTranslate(center.fX, center.fY); 1000 canvas->concat(m); 1001 1002 this->INHERITED::draw(canvas); 1003 1004 canvas->restoreToCount(count); 1005} 1006 1007void SampleWindow::showZoomer(SkCanvas* canvas) { 1008 int count = canvas->save(); 1009 canvas->resetMatrix(); 1010 // Ensure the mouse position is on screen. 1011 int width = SkScalarRound(this->width()); 1012 int height = SkScalarRound(this->height()); 1013 if (fMouseX >= width) fMouseX = width - 1; 1014 else if (fMouseX < 0) fMouseX = 0; 1015 if (fMouseY >= height) fMouseY = height - 1; 1016 else if (fMouseY < 0) fMouseY = 0; 1017 1018 SkBitmap bitmap = capture_bitmap(canvas); 1019 bitmap.lockPixels(); 1020 1021 // Find the size of the zoomed in view, forced to be odd, so the examined pixel is in the middle. 1022 int zoomedWidth = (width >> 1) | 1; 1023 int zoomedHeight = (height >> 1) | 1; 1024 SkIRect src; 1025 src.set(0, 0, zoomedWidth / fFatBitsScale, zoomedHeight / fFatBitsScale); 1026 src.offset(fMouseX - (src.width()>>1), fMouseY - (src.height()>>1)); 1027 SkRect dest; 1028 dest.set(0, 0, SkIntToScalar(zoomedWidth), SkIntToScalar(zoomedHeight)); 1029 dest.offset(SkIntToScalar(width - zoomedWidth), SkIntToScalar(height - zoomedHeight)); 1030 SkPaint paint; 1031 // Clear the background behind our zoomed in view 1032 paint.setColor(SK_ColorWHITE); 1033 canvas->drawRect(dest, paint); 1034 canvas->drawBitmapRect(bitmap, &src, dest); 1035 paint.setColor(SK_ColorBLACK); 1036 paint.setStyle(SkPaint::kStroke_Style); 1037 // Draw a border around the pixel in the middle 1038 SkRect originalPixel; 1039 originalPixel.set(SkIntToScalar(fMouseX), SkIntToScalar(fMouseY), SkIntToScalar(fMouseX + 1), SkIntToScalar(fMouseY + 1)); 1040 SkMatrix matrix; 1041 SkRect scalarSrc; 1042 scalarSrc.set(src); 1043 SkColor color = bitmap.getColor(fMouseX, fMouseY); 1044 if (matrix.setRectToRect(scalarSrc, dest, SkMatrix::kFill_ScaleToFit)) { 1045 SkRect pixel; 1046 matrix.mapRect(&pixel, originalPixel); 1047 // TODO Perhaps measure the values and make the outline white if it's "dark" 1048 if (color == SK_ColorBLACK) { 1049 paint.setColor(SK_ColorWHITE); 1050 } 1051 canvas->drawRect(pixel, paint); 1052 } 1053 paint.setColor(SK_ColorBLACK); 1054 // Draw a border around the destination rectangle 1055 canvas->drawRect(dest, paint); 1056 paint.setStyle(SkPaint::kStrokeAndFill_Style); 1057 // Identify the pixel and its color on screen 1058 paint.setTypeface(fTypeface); 1059 paint.setAntiAlias(true); 1060 SkScalar lineHeight = paint.getFontMetrics(NULL); 1061 SkString string; 1062 string.appendf("(%i, %i)", fMouseX, fMouseY); 1063 SkScalar left = dest.fLeft + SkIntToScalar(3); 1064 SkScalar i = SK_Scalar1; 1065 drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint); 1066 // Alpha 1067 i += SK_Scalar1; 1068 string.reset(); 1069 string.appendf("A: %X", SkColorGetA(color)); 1070 drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint); 1071 // Red 1072 i += SK_Scalar1; 1073 string.reset(); 1074 string.appendf("R: %X", SkColorGetR(color)); 1075 paint.setColor(SK_ColorRED); 1076 drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint); 1077 // Green 1078 i += SK_Scalar1; 1079 string.reset(); 1080 string.appendf("G: %X", SkColorGetG(color)); 1081 paint.setColor(SK_ColorGREEN); 1082 drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint); 1083 // Blue 1084 i += SK_Scalar1; 1085 string.reset(); 1086 string.appendf("B: %X", SkColorGetB(color)); 1087 paint.setColor(SK_ColorBLUE); 1088 drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint); 1089 canvas->restoreToCount(count); 1090} 1091 1092void SampleWindow::onDraw(SkCanvas* canvas) { 1093} 1094 1095#include "SkColorPriv.h" 1096 1097static void reverseRedAndBlue(const SkBitmap& bm) { 1098 SkASSERT(bm.config() == SkBitmap::kARGB_8888_Config); 1099 uint8_t* p = (uint8_t*)bm.getPixels(); 1100 uint8_t* stop = p + bm.getSize(); 1101 while (p < stop) { 1102 // swap red/blue (to go from ARGB(int) to RGBA(memory) and premultiply 1103 unsigned scale = SkAlpha255To256(p[3]); 1104 unsigned r = p[2]; 1105 unsigned b = p[0]; 1106 p[0] = SkAlphaMul(r, scale); 1107 p[1] = SkAlphaMul(p[1], scale); 1108 p[2] = SkAlphaMul(b, scale); 1109 p += 4; 1110 } 1111} 1112 1113void SampleWindow::saveToPdf() 1114{ 1115 fSaveToPdf = true; 1116 this->inval(NULL); 1117} 1118 1119SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) { 1120 if (fSaveToPdf) { 1121 const SkBitmap& bmp = canvas->getDevice()->accessBitmap(false); 1122 SkISize size = SkISize::Make(bmp.width(), bmp.height()); 1123 SkPDFDevice* pdfDevice = new SkPDFDevice(size, size, 1124 canvas->getTotalMatrix()); 1125 fPdfCanvas = new SkCanvas(pdfDevice); 1126 pdfDevice->unref(); 1127 canvas = fPdfCanvas; 1128 } else { 1129 switch (fDeviceType) { 1130 case kRaster_DeviceType: 1131 // fallthrough 1132 case kGPU_DeviceType: 1133 // fallthrough 1134#if SK_ANGLE 1135 case kANGLE_DeviceType: 1136#endif 1137 canvas = this->INHERITED::beforeChildren(canvas); 1138 break; 1139 case kPicture_DeviceType: 1140 fPicture = new SkPicture; 1141 canvas = fPicture->beginRecording(9999, 9999); 1142 break; 1143 case kNullGPU_DeviceType: 1144 break; 1145 default: 1146 SkASSERT(false); 1147 break; 1148 } 1149 } 1150 1151 if (fUseClip) { 1152 canvas->drawColor(0xFFFF88FF); 1153 canvas->clipPath(fClipPath, SkRegion::kIntersect_Op, true); 1154 } 1155 1156 return canvas; 1157} 1158 1159static void paint_rgn(const SkBitmap& bm, const SkIRect& r, 1160 const SkRegion& rgn) { 1161 SkCanvas canvas(bm); 1162 SkRegion inval(rgn); 1163 1164 inval.translate(r.fLeft, r.fTop); 1165 canvas.clipRegion(inval); 1166 canvas.drawColor(0xFFFF8080); 1167} 1168#include "SkData.h" 1169void SampleWindow::afterChildren(SkCanvas* orig) { 1170 if (fSaveToPdf) { 1171 fSaveToPdf = false; 1172 if (fShowZoomer) { 1173 showZoomer(fPdfCanvas); 1174 } 1175 SkString name; 1176 name.printf("%s.pdf", this->getTitle()); 1177 SkPDFDocument doc; 1178 SkPDFDevice* device = static_cast<SkPDFDevice*>(fPdfCanvas->getDevice()); 1179 doc.appendPage(device); 1180#ifdef SK_BUILD_FOR_ANDROID 1181 name.prepend("/sdcard/"); 1182#endif 1183 1184#ifdef SK_BUILD_FOR_IOS 1185 SkDynamicMemoryWStream mstream; 1186 doc.emitPDF(&mstream); 1187 fPDFData = mstream.copyToData(); 1188#endif 1189 SkFILEWStream stream(name.c_str()); 1190 if (stream.isValid()) { 1191 doc.emitPDF(&stream); 1192 const char* desc = "File saved from Skia SampleApp"; 1193 this->onPDFSaved(this->getTitle(), desc, name.c_str()); 1194 } 1195 1196 delete fPdfCanvas; 1197 fPdfCanvas = NULL; 1198 1199 // We took over the draw calls in order to create the PDF, so we need 1200 // to redraw. 1201 this->inval(NULL); 1202 return; 1203 } 1204 1205 if (fRequestGrabImage) { 1206 fRequestGrabImage = false; 1207 1208 SkDevice* device = orig->getDevice(); 1209 SkBitmap bmp; 1210 if (device->accessBitmap(false).copyTo(&bmp, SkBitmap::kARGB_8888_Config)) { 1211 static int gSampleGrabCounter; 1212 SkString name; 1213 name.printf("sample_grab_%d", gSampleGrabCounter++); 1214 SkImageEncoder::EncodeFile(name.c_str(), bmp, 1215 SkImageEncoder::kPNG_Type, 100); 1216 } 1217 } 1218 1219 if (kPicture_DeviceType == fDeviceType) { 1220 if (true) { 1221 SkPicture* pict = new SkPicture(*fPicture); 1222 fPicture->unref(); 1223 this->installDrawFilter(orig); 1224 orig->drawPicture(*pict); 1225 pict->unref(); 1226 } else if (true) { 1227 SkDynamicMemoryWStream ostream; 1228 fPicture->serialize(&ostream); 1229 fPicture->unref(); 1230 1231 SkAutoDataUnref data(ostream.copyToData()); 1232 SkMemoryStream istream(data.data(), data.size()); 1233 SkPicture pict(&istream); 1234 orig->drawPicture(pict); 1235 } else { 1236 fPicture->draw(orig); 1237 fPicture->unref(); 1238 } 1239 fPicture = NULL; 1240 } 1241 1242 // Do this after presentGL and other finishing, rather than in afterChild 1243 if (fMeasureFPS && fMeasureFPS_Time) { 1244 fMeasureFPS_Time = SkTime::GetMSecs() - fMeasureFPS_Time; 1245 this->updateTitle(); 1246 this->postInvalDelay(); 1247 } 1248 1249 // if ((fScrollTestX | fScrollTestY) != 0) 1250 if (false) { 1251 const SkBitmap& bm = orig->getDevice()->accessBitmap(true); 1252 int dx = fScrollTestX * 7; 1253 int dy = fScrollTestY * 7; 1254 SkIRect r; 1255 SkRegion inval; 1256 1257 r.set(50, 50, 50+100, 50+100); 1258 bm.scrollRect(&r, dx, dy, &inval); 1259 paint_rgn(bm, r, inval); 1260 } 1261#ifdef DEBUGGER 1262 SkView* curr = curr_view(this); 1263 if (fDebugger && !is_debugger(curr) && !is_transition(curr) && !is_overview(curr)) { 1264 //Stop Pipe when fDebugger is active 1265 fUsePipe = false; 1266 (void)SampleView::SetUsePipe(curr, false); 1267 fAppMenu.getItemByID(fUsePipeMenuItemID)->setBool(fUsePipe); 1268 this->onUpdateMenu(&fAppMenu); 1269 1270 //Reset any transformations 1271 fGesture.stop(); 1272 fGesture.reset(); 1273 1274 this->loadView(create_debugger(gTempDataStore.begin(), 1275 gTempDataStore.count())); 1276 } 1277#endif 1278} 1279 1280void SampleWindow::beforeChild(SkView* child, SkCanvas* canvas) { 1281 if (fScale) { 1282 SkScalar scale = SK_Scalar1 * 7 / 10; 1283 SkScalar cx = this->width() / 2; 1284 SkScalar cy = this->height() / 2; 1285 canvas->translate(cx, cy); 1286 canvas->scale(scale, scale); 1287 canvas->translate(-cx, -cy); 1288 } 1289 if (fRotate) { 1290 SkScalar cx = this->width() / 2; 1291 SkScalar cy = this->height() / 2; 1292 canvas->translate(cx, cy); 1293 canvas->rotate(SkIntToScalar(30)); 1294 canvas->translate(-cx, -cy); 1295 } 1296 if (fPerspAnim) { 1297 fPerspAnimTime += SampleCode::GetAnimSecondsDelta(); 1298 1299 static const SkScalar gAnimPeriod = 10 * SK_Scalar1; 1300 static const SkScalar gAnimMag = SK_Scalar1 / 1000; 1301 SkScalar t = SkScalarMod(fPerspAnimTime, gAnimPeriod); 1302 if (SkScalarFloorToInt(SkScalarDiv(fPerspAnimTime, gAnimPeriod)) & 0x1) { 1303 t = gAnimPeriod - t; 1304 } 1305 t = 2 * t - gAnimPeriod; 1306 t = SkScalarMul(SkScalarDiv(t, gAnimPeriod), gAnimMag); 1307 SkMatrix m; 1308 m.reset(); 1309 m.setPerspY(t); 1310 canvas->concat(m); 1311 } 1312 1313 this->installDrawFilter(canvas); 1314 1315 if (fMeasureFPS) { 1316 fMeasureFPS_Time = 0; // 0 means the child is not aware of repeat-draw 1317 if (SampleView::SetRepeatDraw(child, FPS_REPEAT_COUNT)) { 1318 fMeasureFPS_Time = SkTime::GetMSecs(); 1319 } 1320 } else { 1321 (void)SampleView::SetRepeatDraw(child, 1); 1322 } 1323 if (fPerspAnim) { 1324 this->inval(NULL); 1325 } 1326 //(void)SampleView::SetUsePipe(child, fUsePipe); 1327} 1328 1329void SampleWindow::afterChild(SkView* child, SkCanvas* canvas) { 1330 canvas->setDrawFilter(NULL); 1331} 1332 1333static SkBitmap::Config gConfigCycle[] = { 1334 SkBitmap::kNo_Config, // none -> none 1335 SkBitmap::kNo_Config, // a1 -> none 1336 SkBitmap::kNo_Config, // a8 -> none 1337 SkBitmap::kNo_Config, // index8 -> none 1338 SkBitmap::kARGB_4444_Config, // 565 -> 4444 1339 SkBitmap::kARGB_8888_Config, // 4444 -> 8888 1340 SkBitmap::kRGB_565_Config // 8888 -> 565 1341}; 1342 1343static SkBitmap::Config cycle_configs(SkBitmap::Config c) { 1344 return gConfigCycle[c]; 1345} 1346 1347void SampleWindow::changeZoomLevel(float delta) { 1348 fZoomLevel += SkFloatToScalar(delta); 1349 if (fZoomLevel > 0) { 1350 fZoomLevel = SkMinScalar(fZoomLevel, MAX_ZOOM_LEVEL); 1351 fZoomScale = fZoomLevel + SK_Scalar1; 1352 } else if (fZoomLevel < 0) { 1353 fZoomLevel = SkMaxScalar(fZoomLevel, MIN_ZOOM_LEVEL); 1354 fZoomScale = SK_Scalar1 / (SK_Scalar1 - fZoomLevel); 1355 } else { 1356 fZoomScale = SK_Scalar1; 1357 } 1358 this->updateMatrix(); 1359} 1360 1361void SampleWindow::updateMatrix(){ 1362 SkMatrix m; 1363 m.reset(); 1364 if (fZoomLevel) { 1365 SkPoint center; 1366 //m = this->getLocalMatrix();//.invert(&m); 1367 m.mapXY(fZoomCenterX, fZoomCenterY, ¢er); 1368 SkScalar cx = center.fX; 1369 SkScalar cy = center.fY; 1370 1371 m.setTranslate(-cx, -cy); 1372 m.postScale(fZoomScale, fZoomScale); 1373 m.postTranslate(cx, cy); 1374 } 1375 1376 if (fFlipAxis) { 1377 m.preTranslate(fZoomCenterX, fZoomCenterY); 1378 if (fFlipAxis & kFlipAxis_X) { 1379 m.preScale(-SK_Scalar1, SK_Scalar1); 1380 } 1381 if (fFlipAxis & kFlipAxis_Y) { 1382 m.preScale(SK_Scalar1, -SK_Scalar1); 1383 } 1384 m.preTranslate(-fZoomCenterX, -fZoomCenterY); 1385 //canvas->concat(m); 1386 } 1387 // Apply any gesture matrix 1388 m.preConcat(fGesture.localM()); 1389 m.preConcat(fGesture.globalM()); 1390 1391 this->setLocalMatrix(m); 1392 1393 this->updateTitle(); 1394 this->inval(NULL); 1395} 1396bool SampleWindow::previousSample() { 1397 fCurrIndex = (fCurrIndex - 1 + fSamples.count()) % fSamples.count(); 1398 this->loadView(create_transition(curr_view(this), (*fSamples[fCurrIndex])(), 1399 fTransitionPrev)); 1400 return true; 1401} 1402 1403bool SampleWindow::nextSample() { 1404 fCurrIndex = (fCurrIndex + 1) % fSamples.count(); 1405 this->loadView(create_transition(curr_view(this), (*fSamples[fCurrIndex])(), 1406 fTransitionNext)); 1407 return true; 1408} 1409 1410bool SampleWindow::goToSample(int i) { 1411 fCurrIndex = (i) % fSamples.count(); 1412 this->loadView(create_transition(curr_view(this),(*fSamples[fCurrIndex])(), 6)); 1413 return true; 1414} 1415 1416SkString SampleWindow::getSampleTitle(int i) { 1417 SkView* view = (*fSamples[i])(); 1418 SkString title; 1419 SampleCode::RequestTitle(view, &title); 1420 view->unref(); 1421 return title; 1422} 1423 1424int SampleWindow::sampleCount() { 1425 return fSamples.count(); 1426} 1427 1428void SampleWindow::showOverview() { 1429 this->loadView(create_transition(curr_view(this), 1430 create_overview(fSamples.count(), fSamples.begin()), 1431 4)); 1432} 1433 1434void SampleWindow::installDrawFilter(SkCanvas* canvas) { 1435 canvas->setDrawFilter(new FlagsDrawFilter(fLCDState, fAAState, 1436 fFilterState, fHintingState))->unref(); 1437} 1438 1439void SampleWindow::postAnimatingEvent() { 1440 if (fAnimating) { 1441 (new SkEvent(ANIMATING_EVENTTYPE, this->getSinkID()))->postDelay(ANIMATING_DELAY); 1442 } 1443} 1444 1445bool SampleWindow::onEvent(const SkEvent& evt) { 1446 if (evt.isType(gUpdateWindowTitleEvtName)) { 1447 this->updateTitle(); 1448 return true; 1449 } 1450 if (evt.isType(ANIMATING_EVENTTYPE)) { 1451 if (fAnimating) { 1452 this->nextSample(); 1453 this->postAnimatingEvent(); 1454 } 1455 return true; 1456 } 1457 if (evt.isType("replace-transition-view")) { 1458 this->loadView((SkView*)SkEventSink::FindSink(evt.getFast32())); 1459 return true; 1460 } 1461 if (evt.isType("set-curr-index")) { 1462 this->goToSample(evt.getFast32()); 1463 return true; 1464 } 1465 if (isInvalEvent(evt)) { 1466 this->inval(NULL); 1467 return true; 1468 } 1469 int selected = -1; 1470 if (SkOSMenu::FindListIndex(evt, "Device Type", &selected)) { 1471 this->setDeviceType((DeviceType)selected); 1472 return true; 1473 } 1474 if (SkOSMenu::FindSwitchState(evt, "Pipe", &fUsePipe)) { 1475#ifdef PIPE_NET 1476 if (!fUsePipe) 1477 gServer.disconnectAll(); 1478#endif 1479 (void)SampleView::SetUsePipe(curr_view(this), fUsePipe); 1480 this->updateTitle(); 1481 this->inval(NULL); 1482 return true; 1483 } 1484 if (SkOSMenu::FindSwitchState(evt, "Slide Show", NULL)) { 1485 this->toggleSlideshow(); 1486 return true; 1487 } 1488 if (SkOSMenu::FindTriState(evt, "AA", &fAAState) || 1489 SkOSMenu::FindTriState(evt, "LCD", &fLCDState) || 1490 SkOSMenu::FindTriState(evt, "Filter", &fFilterState) || 1491 SkOSMenu::FindTriState(evt, "Hinting", &fHintingState) || 1492 SkOSMenu::FindSwitchState(evt, "Clip", &fUseClip) || 1493 SkOSMenu::FindSwitchState(evt, "Zoomer", &fShowZoomer) || 1494 SkOSMenu::FindSwitchState(evt, "Magnify", &fMagnify) || 1495 SkOSMenu::FindListIndex(evt, "Transition-Next", &fTransitionNext) || 1496 SkOSMenu::FindListIndex(evt, "Transition-Prev", &fTransitionPrev)) { 1497 this->inval(NULL); 1498 this->updateTitle(); 1499 return true; 1500 } 1501 if (SkOSMenu::FindSwitchState(evt, "Flip X", NULL)) { 1502 fFlipAxis ^= kFlipAxis_X; 1503 this->updateMatrix(); 1504 return true; 1505 } 1506 if (SkOSMenu::FindSwitchState(evt, "Flip Y", NULL)) { 1507 fFlipAxis ^= kFlipAxis_Y; 1508 this->updateMatrix(); 1509 return true; 1510 } 1511 if (SkOSMenu::FindAction(evt,"Save to PDF")) { 1512 this->saveToPdf(); 1513 return true; 1514 } 1515#ifdef DEBUGGER 1516 if (SkOSMenu::FindSwitchState(evt, "Debugger", &fDebugger)) { 1517 if (fDebugger) { 1518 fUsePipe = true; 1519 (void)SampleView::SetUsePipe(curr_view(this), true); 1520 } else { 1521 this->loadView(fSamples[fCurrIndex]()); 1522 } 1523 this->inval(NULL); 1524 return true; 1525 } 1526#endif 1527 return this->INHERITED::onEvent(evt); 1528} 1529 1530bool SampleWindow::onQuery(SkEvent* query) { 1531 if (query->isType("get-slide-count")) { 1532 query->setFast32(fSamples.count()); 1533 return true; 1534 } 1535 if (query->isType("get-slide-title")) { 1536 SkView* view = (*fSamples[query->getFast32()])(); 1537 SkEvent evt(gTitleEvtName); 1538 if (view->doQuery(&evt)) { 1539 query->setString("title", evt.findString(gTitleEvtName)); 1540 } 1541 SkSafeUnref(view); 1542 return true; 1543 } 1544 if (query->isType("use-fast-text")) { 1545 SkEvent evt(gFastTextEvtName); 1546 return curr_view(this)->doQuery(&evt); 1547 } 1548 if (query->isType("ignore-window-bitmap")) { 1549 query->setFast32(this->getGrContext() != NULL); 1550 return true; 1551 } 1552 return this->INHERITED::onQuery(query); 1553} 1554 1555static void cleanup_for_filename(SkString* name) { 1556 char* str = name->writable_str(); 1557 for (size_t i = 0; i < name->size(); i++) { 1558 switch (str[i]) { 1559 case ':': str[i] = '-'; break; 1560 case '/': str[i] = '-'; break; 1561 case ' ': str[i] = '_'; break; 1562 default: break; 1563 } 1564 } 1565} 1566 1567bool SampleWindow::onHandleChar(SkUnichar uni) { 1568 { 1569 SkView* view = curr_view(this); 1570 if (view) { 1571 SkEvent evt(gCharEvtName); 1572 evt.setFast32(uni); 1573 if (view->doQuery(&evt)) { 1574 return true; 1575 } 1576 } 1577 } 1578 1579 int dx = 0xFF; 1580 int dy = 0xFF; 1581 1582 switch (uni) { 1583 case '5': dx = 0; dy = 0; break; 1584 case '8': dx = 0; dy = -1; break; 1585 case '6': dx = 1; dy = 0; break; 1586 case '2': dx = 0; dy = 1; break; 1587 case '4': dx = -1; dy = 0; break; 1588 case '7': dx = -1; dy = -1; break; 1589 case '9': dx = 1; dy = -1; break; 1590 case '3': dx = 1; dy = 1; break; 1591 case '1': dx = -1; dy = 1; break; 1592 1593 default: 1594 break; 1595 } 1596 1597 if (0xFF != dx && 0xFF != dy) { 1598 if ((dx | dy) == 0) { 1599 fScrollTestX = fScrollTestY = 0; 1600 } else { 1601 fScrollTestX += dx; 1602 fScrollTestY += dy; 1603 } 1604 this->inval(NULL); 1605 return true; 1606 } 1607 1608 switch (uni) { 1609 case 'f': 1610 // only 1611 toggleFPS(); 1612 break; 1613 case 'g': 1614 fRequestGrabImage = true; 1615 this->inval(NULL); 1616 break; 1617 case 'i': 1618 this->zoomIn(); 1619 break; 1620 case 'o': 1621 this->zoomOut(); 1622 break; 1623 case 'r': 1624 fRotate = !fRotate; 1625 this->inval(NULL); 1626 this->updateTitle(); 1627 return true; 1628 case 'k': 1629 fPerspAnim = !fPerspAnim; 1630 this->inval(NULL); 1631 this->updateTitle(); 1632 return true; 1633 case '\\': 1634 this->setDeviceType(kNullGPU_DeviceType); 1635 this->inval(NULL); 1636 this->updateTitle(); 1637 return true; 1638 case 'p': 1639 { 1640 GrContext* grContext = this->getGrContext(); 1641 if (grContext) { 1642 size_t cacheBytes = grContext->getGpuTextureCacheBytes(); 1643 grContext->freeGpuResources(); 1644 SkDebugf("Purged %d bytes from the GPU resource cache.\n", 1645 cacheBytes); 1646 } 1647 } 1648 return true; 1649 case 's': 1650 fScale = !fScale; 1651 this->inval(NULL); 1652 this->updateTitle(); 1653 return true; 1654 default: 1655 break; 1656 } 1657 1658 if (fAppMenu.handleKeyEquivalent(uni)|| fSlideMenu.handleKeyEquivalent(uni)) { 1659 this->onUpdateMenu(&fAppMenu); 1660 this->onUpdateMenu(&fSlideMenu); 1661 return true; 1662 } 1663 return this->INHERITED::onHandleChar(uni); 1664} 1665 1666void SampleWindow::setDeviceType(DeviceType type) { 1667 if (type == fDeviceType) 1668 return; 1669 1670 fDevManager->tearDownBackend(this); 1671 1672 fDeviceType = type; 1673 1674 fDevManager->setUpBackend(this); 1675 1676 this->updateTitle(); 1677 this->inval(NULL); 1678} 1679 1680void SampleWindow::toggleSlideshow() { 1681 fAnimating = !fAnimating; 1682 this->postAnimatingEvent(); 1683 this->updateTitle(); 1684} 1685 1686void SampleWindow::toggleRendering() { 1687 this->setDeviceType(cycle_devicetype(fDeviceType)); 1688 this->updateTitle(); 1689 this->inval(NULL); 1690} 1691 1692void SampleWindow::toggleFPS() { 1693 fMeasureFPS = !fMeasureFPS; 1694 this->updateTitle(); 1695 this->inval(NULL); 1696} 1697 1698#include "SkDumpCanvas.h" 1699 1700bool SampleWindow::onHandleKey(SkKey key) { 1701 { 1702 SkView* view = curr_view(this); 1703 if (view) { 1704 SkEvent evt(gKeyEvtName); 1705 evt.setFast32(key); 1706 if (view->doQuery(&evt)) { 1707 return true; 1708 } 1709 } 1710 } 1711 switch (key) { 1712 case kRight_SkKey: 1713 if (this->nextSample()) { 1714 return true; 1715 } 1716 break; 1717 case kLeft_SkKey: 1718 toggleRendering(); 1719 return true; 1720 case kUp_SkKey: 1721 if (USE_ARROWS_FOR_ZOOM) { 1722 this->changeZoomLevel(1.f); 1723 } else { 1724 fNClip = !fNClip; 1725 this->inval(NULL); 1726 this->updateTitle(); 1727 } 1728 return true; 1729 case kDown_SkKey: 1730 if (USE_ARROWS_FOR_ZOOM) { 1731 this->changeZoomLevel(-1.f); 1732 } else { 1733 this->setConfig(cycle_configs(this->getBitmap().config())); 1734 this->updateTitle(); 1735 } 1736 return true; 1737 case kOK_SkKey: { 1738 SkString title; 1739 if (curr_title(this, &title)) { 1740 writeTitleToPrefs(title.c_str()); 1741 } 1742 return true; 1743 } 1744 case kBack_SkKey: 1745 this->showOverview(); 1746 return true; 1747 default: 1748 break; 1749 } 1750 return this->INHERITED::onHandleKey(key); 1751} 1752 1753/////////////////////////////////////////////////////////////////////////////// 1754 1755static const char gGestureClickType[] = "GestureClickType"; 1756 1757bool SampleWindow::onDispatchClick(int x, int y, Click::State state, 1758 void* owner) { 1759 if (Click::kMoved_State == state) { 1760 updatePointer(x, y); 1761 } 1762 int w = SkScalarRound(this->width()); 1763 int h = SkScalarRound(this->height()); 1764 1765 // check for the resize-box 1766 if (w - x < 16 && h - y < 16) { 1767 return false; // let the OS handle the click 1768 } 1769 else if (fMagnify) { 1770 //it's only necessary to update the drawing if there's a click 1771 this->inval(NULL); 1772 return false; //prevent dragging while magnify is enabled 1773 } 1774 else { 1775 return this->INHERITED::onDispatchClick(x, y, state, owner); 1776 } 1777} 1778 1779class GestureClick : public SkView::Click { 1780public: 1781 GestureClick(SkView* target) : SkView::Click(target) { 1782 this->setType(gGestureClickType); 1783 } 1784 1785 static bool IsGesture(Click* click) { 1786 return click->isType(gGestureClickType); 1787 } 1788}; 1789 1790SkView::Click* SampleWindow::onFindClickHandler(SkScalar x, SkScalar y) { 1791 return new GestureClick(this); 1792} 1793 1794bool SampleWindow::onClick(Click* click) { 1795 if (GestureClick::IsGesture(click)) { 1796 float x = static_cast<float>(click->fICurr.fX); 1797 float y = static_cast<float>(click->fICurr.fY); 1798 1799 switch (click->fState) { 1800 case SkView::Click::kDown_State: 1801 fGesture.touchBegin(click->fOwner, x, y); 1802 break; 1803 case SkView::Click::kMoved_State: 1804 fGesture.touchMoved(click->fOwner, x, y); 1805 this->updateMatrix(); 1806 break; 1807 case SkView::Click::kUp_State: 1808 fGesture.touchEnd(click->fOwner); 1809 this->updateMatrix(); 1810 break; 1811 } 1812 return true; 1813 } 1814 return false; 1815} 1816 1817/////////////////////////////////////////////////////////////////////////////// 1818 1819void SampleWindow::loadView(SkView* view) { 1820 SkView::F2BIter iter(this); 1821 SkView* prev = iter.next(); 1822 if (prev) { 1823 prev->detachFromParent(); 1824 } 1825 1826 view->setVisibleP(true); 1827 view->setClipToBounds(false); 1828 this->attachChildToFront(view)->unref(); 1829 view->setSize(this->width(), this->height()); 1830 1831 //repopulate the slide menu when a view is loaded 1832 fSlideMenu.reset(); 1833#ifdef DEBUGGER 1834 if (!is_debugger(view) && !is_overview(view) && !is_transition(view) && fDebugger) { 1835 //Force Pipe to be on if using debugger 1836 fUsePipe = true; 1837 } 1838#endif 1839 (void)SampleView::SetUsePipe(view, fUsePipe); 1840 if (SampleView::IsSampleView(view)) 1841 ((SampleView*)view)->requestMenu(&fSlideMenu); 1842 this->onUpdateMenu(&fSlideMenu); 1843 this->updateTitle(); 1844} 1845 1846static const char* gConfigNames[] = { 1847 "unknown config", 1848 "A1", 1849 "A8", 1850 "Index8", 1851 "565", 1852 "4444", 1853 "8888" 1854}; 1855 1856static const char* configToString(SkBitmap::Config c) { 1857 return gConfigNames[c]; 1858} 1859 1860static const char* gDeviceTypePrefix[] = { 1861 "raster: ", 1862 "picture: ", 1863 "opengl: ", 1864#if SK_ANGLE 1865 "angle: ", 1866#endif 1867 "null-gl: " 1868}; 1869 1870static const char* trystate_str(SkOSMenu::TriState state, 1871 const char trueStr[], const char falseStr[]) { 1872 if (SkOSMenu::kOnState == state) { 1873 return trueStr; 1874 } else if (SkOSMenu::kOffState == state) { 1875 return falseStr; 1876 } 1877 return NULL; 1878} 1879 1880void SampleWindow::updateTitle() { 1881 SkView* view = curr_view(this); 1882 1883 SkString title; 1884 if (!curr_title(this, &title)) { 1885 title.set("<unknown>"); 1886 } 1887 1888 title.prepend(gDeviceTypePrefix[fDeviceType]); 1889 1890 title.prepend(" "); 1891 title.prepend(configToString(this->getBitmap().config())); 1892 1893 if (fAnimating) { 1894 title.prepend("<A> "); 1895 } 1896 if (fScale) { 1897 title.prepend("<S> "); 1898 } 1899 if (fRotate) { 1900 title.prepend("<R> "); 1901 } 1902 if (fNClip) { 1903 title.prepend("<C> "); 1904 } 1905 if (fPerspAnim) { 1906 title.prepend("<K> "); 1907 } 1908 1909 title.prepend(trystate_str(fLCDState, "LCD ", "lcd ")); 1910 title.prepend(trystate_str(fAAState, "AA ", "aa ")); 1911 title.prepend(trystate_str(fFilterState, "H ", "h ")); 1912 title.prepend(fFlipAxis & kFlipAxis_X ? "X " : NULL); 1913 title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : NULL); 1914 1915 if (fZoomLevel) { 1916 title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel)); 1917 } 1918 1919 if (fMeasureFPS) { 1920 title.appendf(" %6.1f ms", fMeasureFPS_Time / (float)FPS_REPEAT_MULTIPLIER); 1921 } 1922 if (fUsePipe && SampleView::IsSampleView(view)) { 1923 title.prepend("<P> "); 1924 } 1925 if (SampleView::IsSampleView(view)) { 1926 title.prepend("! "); 1927 } 1928 1929 this->setTitle(title.c_str()); 1930} 1931 1932void SampleWindow::onSizeChange() { 1933 this->INHERITED::onSizeChange(); 1934 1935 SkView::F2BIter iter(this); 1936 SkView* view = iter.next(); 1937 view->setSize(this->width(), this->height()); 1938 1939 // rebuild our clippath 1940 { 1941 const SkScalar W = this->width(); 1942 const SkScalar H = this->height(); 1943 1944 fClipPath.reset(); 1945#if 0 1946 for (SkScalar y = SK_Scalar1; y < H; y += SkIntToScalar(32)) { 1947 SkRect r; 1948 r.set(SK_Scalar1, y, SkIntToScalar(30), y + SkIntToScalar(30)); 1949 for (; r.fLeft < W; r.offset(SkIntToScalar(32), 0)) 1950 fClipPath.addRect(r); 1951 } 1952#else 1953 SkRect r; 1954 r.set(0, 0, W, H); 1955 fClipPath.addRect(r, SkPath::kCCW_Direction); 1956 r.set(W/4, H/4, W*3/4, H*3/4); 1957 fClipPath.addRect(r, SkPath::kCW_Direction); 1958#endif 1959 } 1960 1961 fZoomCenterX = SkScalarHalf(this->width()); 1962 fZoomCenterY = SkScalarHalf(this->height()); 1963 1964#ifdef SK_BUILD_FOR_ANDROID 1965 // FIXME: The first draw after a size change does not work on Android, so 1966 // we post an invalidate. 1967 this->postInvalDelay(); 1968#endif 1969 this->updateTitle(); // to refresh our config 1970 fDevManager->windowSizeChanged(this); 1971} 1972 1973/////////////////////////////////////////////////////////////////////////////// 1974 1975static const char is_sample_view_tag[] = "sample-is-sample-view"; 1976static const char repeat_count_tag[] = "sample-set-repeat-count"; 1977static const char set_use_pipe_tag[] = "sample-set-use-pipe"; 1978 1979bool SampleView::IsSampleView(SkView* view) { 1980 SkEvent evt(is_sample_view_tag); 1981 return view->doQuery(&evt); 1982} 1983 1984bool SampleView::SetRepeatDraw(SkView* view, int count) { 1985 SkEvent evt(repeat_count_tag); 1986 evt.setFast32(count); 1987 return view->doEvent(evt); 1988} 1989 1990bool SampleView::SetUsePipe(SkView* view, bool pred) { 1991 SkEvent evt(set_use_pipe_tag); 1992 evt.setFast32(pred); 1993 return view->doEvent(evt); 1994} 1995 1996bool SampleView::onEvent(const SkEvent& evt) { 1997 if (evt.isType(repeat_count_tag)) { 1998 fRepeatCount = evt.getFast32(); 1999 return true; 2000 } 2001 if (evt.isType(set_use_pipe_tag)) { 2002 fUsePipe = !!evt.getFast32(); 2003 return true; 2004 } 2005 return this->INHERITED::onEvent(evt); 2006} 2007 2008bool SampleView::onQuery(SkEvent* evt) { 2009 if (evt->isType(is_sample_view_tag)) { 2010 return true; 2011 } 2012 return this->INHERITED::onQuery(evt); 2013} 2014 2015#ifdef TEST_GPIPE 2016 #include "SkGPipe.h" 2017 2018class SimplePC : public SkGPipeController { 2019public: 2020 SimplePC(SkCanvas* target); 2021 ~SimplePC(); 2022 2023 /** 2024 * User this method to halt/restart pipe 2025 */ 2026 void setWriteToPipe(bool writeToPipe) { fWriteToPipe = writeToPipe; } 2027 virtual void* requestBlock(size_t minRequest, size_t* actual); 2028 virtual void notifyWritten(size_t bytes); 2029 2030private: 2031 SkGPipeReader fReader; 2032 void* fBlock; 2033 size_t fBlockSize; 2034 size_t fBytesWritten; 2035 int fAtomsWritten; 2036 SkGPipeReader::Status fStatus; 2037 bool fWriteToPipe; 2038 2039 size_t fTotalWritten; 2040}; 2041 2042SimplePC::SimplePC(SkCanvas* target) : fReader(target) { 2043 fBlock = NULL; 2044 fBlockSize = fBytesWritten = 0; 2045 fStatus = SkGPipeReader::kDone_Status; 2046 fTotalWritten = 0; 2047 fAtomsWritten = 0; 2048 fWriteToPipe = true; 2049} 2050 2051SimplePC::~SimplePC() { 2052// SkASSERT(SkGPipeReader::kDone_Status == fStatus); 2053 if (fTotalWritten) { 2054 if (fWriteToPipe) { 2055 SkDebugf("--- %d bytes %d atoms, status %d\n", fTotalWritten, 2056 fAtomsWritten, fStatus); 2057#ifdef PIPE_FILE 2058 //File is open in append mode 2059 FILE* f = fopen(FILE_PATH, "ab"); 2060 SkASSERT(f != NULL); 2061 fwrite((const char*)fBlock + fBytesWritten, 1, bytes, f); 2062 fclose(f); 2063#endif 2064#ifdef PIPE_NET 2065 if (fAtomsWritten > 1 && fTotalWritten > 4) { //ignore done 2066 gServer.acceptConnections(); 2067 gServer.writePacket(fBlock, fTotalWritten); 2068 } 2069#endif 2070#ifdef DEBUGGER 2071 gTempDataStore.reset(); 2072 gTempDataStore.append(fTotalWritten, (const char*)fBlock); 2073#endif 2074 } 2075 } 2076 sk_free(fBlock); 2077} 2078 2079void* SimplePC::requestBlock(size_t minRequest, size_t* actual) { 2080 sk_free(fBlock); 2081 2082 fBlockSize = minRequest * 4; 2083 fBlock = sk_malloc_throw(fBlockSize); 2084 fBytesWritten = 0; 2085 *actual = fBlockSize; 2086 return fBlock; 2087} 2088 2089void SimplePC::notifyWritten(size_t bytes) { 2090 SkASSERT(fBytesWritten + bytes <= fBlockSize); 2091 fStatus = fReader.playback((const char*)fBlock + fBytesWritten, bytes); 2092 SkASSERT(SkGPipeReader::kError_Status != fStatus); 2093 fBytesWritten += bytes; 2094 fTotalWritten += bytes; 2095 2096 fAtomsWritten += 1; 2097} 2098 2099#endif 2100 2101void SampleView::draw(SkCanvas* canvas) { 2102#ifdef TEST_GPIPE 2103 if (fUsePipe) { 2104 SkGPipeWriter writer; 2105 SimplePC controller(canvas); 2106 uint32_t flags = SkGPipeWriter::kCrossProcess_Flag; 2107 canvas = writer.startRecording(&controller, flags); 2108 //Must draw before controller goes out of scope and sends data 2109 this->INHERITED::draw(canvas); 2110 //explicitly end recording to ensure writer is flushed before the memory 2111 //is freed in the deconstructor of the controller 2112 writer.endRecording(); 2113 controller.setWriteToPipe(fUsePipe); 2114 } 2115 else 2116 this->INHERITED::draw(canvas); 2117#else 2118 this->INHERITED::draw(canvas); 2119#endif 2120} 2121void SampleView::onDraw(SkCanvas* canvas) { 2122 this->onDrawBackground(canvas); 2123 2124 for (int i = 0; i < fRepeatCount; i++) { 2125 SkAutoCanvasRestore acr(canvas, true); 2126 this->onDrawContent(canvas); 2127 } 2128} 2129 2130void SampleView::onDrawBackground(SkCanvas* canvas) { 2131 canvas->drawColor(fBGColor); 2132} 2133 2134/////////////////////////////////////////////////////////////////////////////// 2135 2136template <typename T> void SkTBSort(T array[], int count) { 2137 for (int i = 1; i < count - 1; i++) { 2138 bool didSwap = false; 2139 for (int j = count - 1; j > i; --j) { 2140 if (array[j] < array[j-1]) { 2141 T tmp(array[j-1]); 2142 array[j-1] = array[j]; 2143 array[j] = tmp; 2144 didSwap = true; 2145 } 2146 } 2147 if (!didSwap) { 2148 break; 2149 } 2150 } 2151 2152 for (int k = 0; k < count - 1; k++) { 2153 SkASSERT(!(array[k+1] < array[k])); 2154 } 2155} 2156 2157#include "SkRandom.h" 2158 2159static void rand_rect(SkIRect* rect, SkRandom& rand) { 2160 int bits = 8; 2161 int shift = 32 - bits; 2162 rect->set(rand.nextU() >> shift, rand.nextU() >> shift, 2163 rand.nextU() >> shift, rand.nextU() >> shift); 2164 rect->sort(); 2165} 2166 2167static void dumpRect(const SkIRect& r) { 2168 SkDebugf(" { %d, %d, %d, %d },\n", 2169 r.fLeft, r.fTop, 2170 r.fRight, r.fBottom); 2171} 2172 2173static void test_rects(const SkIRect rect[], int count) { 2174 SkRegion rgn0, rgn1; 2175 2176 for (int i = 0; i < count; i++) { 2177 rgn0.op(rect[i], SkRegion::kUnion_Op); 2178 // dumpRect(rect[i]); 2179 } 2180 rgn1.setRects(rect, count); 2181 2182 if (rgn0 != rgn1) { 2183 SkDebugf("\n"); 2184 for (int i = 0; i < count; i++) { 2185 dumpRect(rect[i]); 2186 } 2187 SkDebugf("\n"); 2188 } 2189} 2190 2191static void test() { 2192 size_t i; 2193 2194 const SkIRect r0[] = { 2195 { 0, 0, 1, 1 }, 2196 { 2, 2, 3, 3 }, 2197 }; 2198 const SkIRect r1[] = { 2199 { 0, 0, 1, 3 }, 2200 { 1, 1, 2, 2 }, 2201 { 2, 0, 3, 3 }, 2202 }; 2203 const SkIRect r2[] = { 2204 { 0, 0, 1, 2 }, 2205 { 2, 1, 3, 3 }, 2206 { 4, 0, 5, 1 }, 2207 { 6, 0, 7, 4 }, 2208 }; 2209 2210 static const struct { 2211 const SkIRect* fRects; 2212 int fCount; 2213 } gRecs[] = { 2214 { r0, SK_ARRAY_COUNT(r0) }, 2215 { r1, SK_ARRAY_COUNT(r1) }, 2216 { r2, SK_ARRAY_COUNT(r2) }, 2217 }; 2218 2219 for (i = 0; i < SK_ARRAY_COUNT(gRecs); i++) { 2220 test_rects(gRecs[i].fRects, gRecs[i].fCount); 2221 } 2222 2223 SkRandom rand; 2224 for (i = 0; i < 10000; i++) { 2225 SkRegion rgn0, rgn1; 2226 2227 const int N = 8; 2228 SkIRect rect[N]; 2229 for (int j = 0; j < N; j++) { 2230 rand_rect(&rect[j], rand); 2231 } 2232 test_rects(rect, N); 2233 } 2234} 2235 2236SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) { 2237// test(); 2238 return new SampleWindow(hwnd, argc, argv, NULL); 2239} 2240 2241void get_preferred_size(int* x, int* y, int* width, int* height) { 2242 *x = 10; 2243 *y = 50; 2244 *width = 640; 2245 *height = 480; 2246} 2247 2248void application_init() { 2249// setenv("ANDROID_ROOT", "../../../data", 0); 2250#ifdef SK_BUILD_FOR_MAC 2251 setenv("ANDROID_ROOT", "/android/device/data", 0); 2252#endif 2253 SkGraphics::Init(); 2254 SkEvent::Init(); 2255} 2256 2257void application_term() { 2258 SkEvent::Term(); 2259 SkGraphics::Term(); 2260} 2261