Add 'P' to SampleApp to cycle through pixel geometries.

samplecode/SampleApp.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SampleApp.h"
 
 #include "OverView.h"
@@ skipping 450 matching lines @@
     const char* label;
 };
 static HintingState gHintingStates[] = {
     {SkPaint::kNo_Hinting, "Mixed", nullptr },
     {SkPaint::kNo_Hinting, "None", "H0 " },
     {SkPaint::kSlight_Hinting, "Slight", "Hs " },
     {SkPaint::kNormal_Hinting, "Normal", "Hn " },
     {SkPaint::kFull_Hinting, "Full", "Hf " },
 };
 
+struct PixelGeometryState {
+    SkPixelGeometry pixelGeometry;
+    const char* name;
+    const char* label;
+};
+static PixelGeometryState gPixelGeometryStates[] = {
+    {SkPixelGeometry::kUnknown_SkPixelGeometry, "Mixed", nullptr },
+    {SkPixelGeometry::kUnknown_SkPixelGeometry, "Flat",  "{Flat} "  },

[reed1, 2016/03/31 11:04:13]

I presume Flat means ... unknown?

[bungeman-skia, 2016/03/31 14:15:27]

Right here I'm not stating that the created surface should have some unknown
pixel geometry or that the eventual display's pixel geometry is unknown, but
stating that I'm creating a surface where the pixel geometry is explicitly flat.
Using the term "Flat" here in the UI is stating that the surface's pixel
geometry is flat, it most assuredly is not "unknown". Indeed, the "Mixed"
actually means something more like unknown, since the pixelGeometry in the above
PixelGeometryState is just a dummy, it isn't used (the legacy default is what is
used).
 
From the user's perspective, it's kUnknown that's misnamed. SkPixelGeometry is
used to specify the pixel geometry of the SkSurface, it doesn't need to reflect
the user's knowledge of where the SkSurface will eventually end up. In other
words, by specifying the SkPixelGeometry on a surface the user is definitively
configuring the surface, in which case stating 'I don't know what you should be'
isn't very clear. 'kFlat_SkPixelGeometry' or even 'kNone_SkPixelGeometry' would
be better names.  If some user doesn't know the pixel geometry of the eventual
display device then of course they should explicitly state 'flat' as opposed to
just 'unknown'.

The naming of this is somewhat a matter of perspective. The use of 'kUnknown'
reflects what the names would be if one were to query a device for its pixel
geometry. (Though in this case 'kUnknown' would probably better be called
'kOther'.) Since in Skia these enum names are only ever used to create a surface
(not query a device) I believe they should have the perspective of telling the
surface what its pixel geometry is.

+    {SkPixelGeometry::kRGB_H_SkPixelGeometry,   "RGB H", "{RGB H} " },
+    {SkPixelGeometry::kBGR_H_SkPixelGeometry,   "BGR H", "{BGR H} " },
+    {SkPixelGeometry::kRGB_V_SkPixelGeometry,   "RGB_V", "{RGB V} " },
+    {SkPixelGeometry::kBGR_V_SkPixelGeometry,   "BGR_V", "{BGR V} " },
+};
+
 struct FilterQualityState {
     SkFilterQuality fQuality;
     const char*     fName;
     const char*     fLabel;
 };
 static FilterQualityState gFilterQualityStates[] = {
     { kNone_SkFilterQuality,   "Mixed",    nullptr    },
     { kNone_SkFilterQuality,   "None",     "F0 "   },
     { kLow_SkFilterQuality,    "Low",      "F1 "   },
     { kMedium_SkFilterQuality, "Medium",   "F2 "   },
@@ skipping 364 matching lines @@
 
     static SkTaskGroup::Enabler enabled(-1);
     gSampleWindow = this;
 
     fDeviceType = kRaster_DeviceType;
 #if SK_SUPPORT_GPU
     if (FLAGS_gpu) {
         fDeviceType = kGPU_DeviceType;
     }
 #endif
-        
+
 #if DEFAULT_TO_GPU
     fDeviceType = kGPU_DeviceType;
 #endif
 #if SK_ANGLE && DEFAULT_TO_ANGLE
     fDeviceType = kANGLE_DeviceType;
 #endif
 #if SK_COMMAND_BUFFER && DEFAULT_TO_COMMAND_BUFFER
     fDeviceType = kCommandBuffer_DeviceType;
 #endif
 
     fUseClip = false;
     fUsePicture = false;
     fAnimating = false;
     fRotate = false;
     fPerspAnim = false;
     fRequestGrabImage = false;
     fTilingMode = kNo_Tiling;
     fMeasureFPS = false;
     fLCDState = SkOSMenu::kMixedState;
     fAAState = SkOSMenu::kMixedState;
     fSubpixelState = SkOSMenu::kMixedState;
     fHintingState = 0;
+    fPixelGeometryIndex = 0;
     fFilterQualityIndex = 0;
     fFlipAxis = 0;
 
     fMouseX = fMouseY = 0;
     fFatBitsScale = 8;
     fTypeface = SkTypeface::CreateFromTypeface(nullptr, SkTypeface::kBold);
     fShowZoomer = false;
 
     fZoomLevel = 0;
     fZoomScale = SK_Scalar1;
@@ skipping 40 matching lines @@
     fAppMenu->assignKeyEquivalentToItem(itemID, 's');
     itemID = fAppMenu->appendList("Hinting", "Hinting", sinkID, fHintingState,
                                   gHintingStates[0].name,
                                   gHintingStates[1].name,
                                   gHintingStates[2].name,
                                   gHintingStates[3].name,
                                   gHintingStates[4].name,
                                   nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'h');
 
+    itemID = fAppMenu->appendList("Pixel Geometry", "Pixel Geometry", sinkID, fPixelGeometryIndex,
+                                  gPixelGeometryStates[0].name,
+                                  gPixelGeometryStates[1].name,
+                                  gPixelGeometryStates[2].name,
+                                  gPixelGeometryStates[3].name,
+                                  gPixelGeometryStates[4].name,
+                                  gPixelGeometryStates[5].name,
+                                  nullptr);
+    fAppMenu->assignKeyEquivalentToItem(itemID, 'P');
+
     itemID =fAppMenu->appendList("Tiling", "Tiling", sinkID, fTilingMode,
                                  gTilingInfo[kNo_Tiling].label,
                                  gTilingInfo[kAbs_128x128_Tiling].label,
                                  gTilingInfo[kAbs_256x256_Tiling].label,
                                  gTilingInfo[kRel_4x4_Tiling].label,
                                  gTilingInfo[kRel_1x16_Tiling].label,
                                  gTilingInfo[kRel_16x1_Tiling].label,
                                  nullptr);
     fAppMenu->assignKeyEquivalentToItem(itemID, 't');
 
@@ skipping 656 matching lines @@
         SkOSMenu::FindTriState(evt, "Subpixel", &fSubpixelState) ||
         SkOSMenu::FindListIndex(evt, "Hinting", &fHintingState) ||
         SkOSMenu::FindSwitchState(evt, "Clip", &fUseClip) ||
         SkOSMenu::FindSwitchState(evt, "Zoomer", &fShowZoomer) ||
         SkOSMenu::FindSwitchState(evt, "Magnify", &fMagnify))
     {
         this->inval(nullptr);
         this->updateTitle();
         return true;
     }
+    if (SkOSMenu::FindListIndex(evt, "Pixel Geometry", &fPixelGeometryIndex)) {
+        this->setPixelGeometry(fPixelGeometryIndex);
+        return true;
+    }
     if (SkOSMenu::FindListIndex(evt, "Tiling", &fTilingMode)) {
         if (SampleView::IsSampleView(curr_view(this))) {
             ((SampleView*)curr_view(this))->onTileSizeChanged(this->tileSize());
         }
         this->inval(nullptr);
         this->updateTitle();
         return true;
     }
     if (SkOSMenu::FindSwitchState(evt, "Flip X", nullptr)) {
         fFlipAxis ^= kFlipAxis_X;
@@ skipping 161 matching lines @@
         this->onUpdateMenu(fAppMenu);
         this->onUpdateMenu(fSlideMenu);
         return true;
     }
     return this->INHERITED::onHandleChar(uni);
 }
 
 void SampleWindow::setDeviceType(DeviceType type) {
     if (type == fDeviceType)
         return;
-    
+
     fDevManager->tearDownBackend(this);
-    
     fDeviceType = type;
-    
     fDevManager->setUpBackend(this, fMSAASampleCount);
-    
+
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::setDeviceColorType(SkColorType ct, SkColorProfileType pt) {
     this->setColorType(ct, pt);
 
     fDevManager->tearDownBackend(this);
-    
     fDevManager->setUpBackend(this, fMSAASampleCount);
-    
+
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleSlideshow() {
     fAnimating = !fAnimating;
     this->postAnimatingEvent();
     this->updateTitle();
 }
 
@@ skipping 15 matching lines @@
     fDevManager->setUpBackend(this, fMSAASampleCount);
 
     SkSurfaceProps props = this->getSurfaceProps();
     uint32_t flags = props.flags() ^ SkSurfaceProps::kUseDeviceIndependentFonts_Flag;
     this->setSurfaceProps(SkSurfaceProps(flags, props.pixelGeometry()));
 
     this->updateTitle();
     this->inval(nullptr);
 }
 
+void SampleWindow::setPixelGeometry(int pixelGeometryIndex) {
+    // reset backend
+    fDevManager->tearDownBackend(this);
+    fDevManager->setUpBackend(this, fMSAASampleCount);
+
+    const SkSurfaceProps& oldProps = this->getSurfaceProps();
+    SkSurfaceProps newProps(oldProps.flags(), SkSurfaceProps::kLegacyFontHost_InitType);
+    if (pixelGeometryIndex > 0) {
+        newProps = SkSurfaceProps(oldProps.flags(),
+                                  gPixelGeometryStates[pixelGeometryIndex].pixelGeometry);
+    }
+    this->setSurfaceProps(newProps);
+
+    this->updateTitle();
+    this->inval(nullptr);
+}
+
 #include "SkDumpCanvas.h"
 
 bool SampleWindow::onHandleKey(SkKey key) {
     {
         SkView* view = curr_view(this);
         if (view) {
             SkEvent evt(gKeyEvtName);
             evt.setFast32(key);
             if (view->doQuery(&evt)) {
                 return true;
@@ skipping 206 matching lines @@
         title.prepend("<P> ");
     }
 
     title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
     title.prepend(trystate_str(fAAState, "AA ", "aa "));
     title.prepend(gFilterQualityStates[fFilterQualityIndex].fLabel);
     title.prepend(trystate_str(fSubpixelState, "S ", "s "));
     title.prepend(fFlipAxis & kFlipAxis_X ? "X " : nullptr);
     title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : nullptr);
     title.prepend(gHintingStates[fHintingState].label);
+    title.prepend(gPixelGeometryStates[fPixelGeometryIndex].label);
 
     if (fOffset.fX || fOffset.fY) {
         title.prependf("(%.2f, %.2f) ", SkScalarToFloat(fOffset.fX), SkScalarToFloat(fOffset.fY));
     }
     if (fZoomLevel) {
         title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
     }
 
     if (fMeasureFPS) {
         title.appendf(" %8.4f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
@@ skipping 246 matching lines @@
 #ifdef SK_BUILD_FOR_MAC
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
 }