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