remove cruft from SkTypes.h, including SkBool

src/views/SkView.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 "SkView.h"
 #include "SkCanvas.h"
 
+static inline uint32_t SkSetClearShift(uint32_t bits, bool cond, unsigned shift) {
+    SkASSERT((int)cond == 0 || (int)cond == 1);
+    return (bits & ~(1 << shift)) | ((int)cond << shift);
+}
+
 ////////////////////////////////////////////////////////////////////////
 
-SkView::SkView(uint32_t flags) : fFlags(SkToU8(flags))
-{
+SkView::SkView(uint32_t flags) : fFlags(SkToU8(flags)) {
     fWidth = fHeight = 0;
     fLoc.set(0, 0);
     fParent = fFirstChild = fNextSibling = fPrevSibling = nullptr;
     fMatrix.setIdentity();
     fContainsFocus = 0;
 }
 
-SkView::~SkView()
-{
+SkView::~SkView() {
     this->detachAllChildren();
 }
 
-void SkView::setFlags(uint32_t flags)
-{
+void SkView::setFlags(uint32_t flags) {
     SkASSERT((flags & ~kAllFlagMasks) == 0);
 
     uint32_t diff = fFlags ^ flags;
 
     if (diff & kVisible_Mask)
         this->inval(nullptr);
 
     fFlags = SkToU8(flags);
 
-    if (diff & kVisible_Mask)
-    {
+    if (diff & kVisible_Mask) {
         this->inval(nullptr);
     }
 }
 
-void SkView::setVisibleP(bool pred)
-{
+void SkView::setVisibleP(bool pred) {
     this->setFlags(SkSetClearShift(fFlags, pred, kVisible_Shift));
 }
 
-void SkView::setEnabledP(bool pred)
-{
+void SkView::setEnabledP(bool pred) {
     this->setFlags(SkSetClearShift(fFlags, pred, kEnabled_Shift));
 }
 
-void SkView::setFocusableP(bool pred)
-{
+void SkView::setFocusableP(bool pred) {
     this->setFlags(SkSetClearShift(fFlags, pred, kFocusable_Shift));
 }
 
 void SkView::setClipToBounds(bool pred) {
     this->setFlags(SkSetClearShift(fFlags, !pred, kNoClip_Shift));
 }
 
-void SkView::setSize(SkScalar width, SkScalar height)
-{
+void SkView::setSize(SkScalar width, SkScalar height) {
     width = SkMaxScalar(0, width);
     height = SkMaxScalar(0, height);
 
     if (fWidth != width || fHeight != height)
     {
         this->inval(nullptr);
         fWidth = width;
         fHeight = height;
         this->inval(nullptr);
         this->onSizeChange();
         this->invokeLayout();
     }
 }
 
-void SkView::setLoc(SkScalar x, SkScalar y)
-{
-    if (fLoc.fX != x || fLoc.fY != y)
-    {
+void SkView::setLoc(SkScalar x, SkScalar y) {
+    if (fLoc.fX != x || fLoc.fY != y) {
         this->inval(nullptr);
         fLoc.set(x, y);
         this->inval(nullptr);
     }
 }
 
-void SkView::offset(SkScalar dx, SkScalar dy)
-{
+void SkView::offset(SkScalar dx, SkScalar dy) {
     if (dx || dy)
         this->setLoc(fLoc.fX + dx, fLoc.fY + dy);
 }
 
-void SkView::setLocalMatrix(const SkMatrix& matrix)
-{
+void SkView::setLocalMatrix(const SkMatrix& matrix) {
     this->inval(nullptr);
     fMatrix = matrix;
     this->inval(nullptr);
 }
 
-void SkView::draw(SkCanvas* canvas)
-{
-    if (fWidth && fHeight && this->isVisible())
-    {
+void SkView::draw(SkCanvas* canvas) {
+    if (fWidth && fHeight && this->isVisible()) {
         SkRect    r;
         r.set(fLoc.fX, fLoc.fY, fLoc.fX + fWidth, fLoc.fY + fHeight);
-        if (this->isClipToBounds() &&
-            canvas->quickReject(r)) {
-                return;
+        if (this->isClipToBounds() && canvas->quickReject(r)) {
+            return;
         }
 
         SkAutoCanvasRestore    as(canvas, true);
 
         if (this->isClipToBounds()) {
             canvas->clipRect(r);
         }
 
         canvas->translate(fLoc.fX, fLoc.fY);
         canvas->concat(fMatrix);
@@ skipping 50 matching lines @@
 
         if (rect) {
             rect->offset(view->fLoc.fX, view->fLoc.fY);
         }
         view = parent;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
-bool SkView::setFocusView(SkView* fv)
-{
+bool SkView::setFocusView(SkView* fv) {
     SkView* view = this;
 
     do {
-        if (view->onSetFocusView(fv))
+        if (view->onSetFocusView(fv)) {
             return true;
+        }
     } while ((view = view->fParent) != nullptr);
     return false;
 }
 
-SkView* SkView::getFocusView() const
-{
-    SkView*            focus = nullptr;
-    const SkView*    view = this;
+SkView* SkView::getFocusView() const {
+    SkView*         focus = nullptr;
+    const SkView*   view = this;
     do {
-        if (view->onGetFocusView(&focus))
+        if (view->onGetFocusView(&focus)) {
             break;
+        }
     } while ((view = view->fParent) != nullptr);
     return focus;
 }
 
-bool SkView::hasFocus() const
-{
+bool SkView::hasFocus() const {
     return this == this->getFocusView();
 }
 
-bool SkView::acceptFocus()
-{
+bool SkView::acceptFocus() {
     return this->isFocusable() && this->setFocusView(this);
 }
 
 /*
     Try to give focus to this view, or its children
 */
-SkView* SkView::acceptFocus(FocusDirection dir)
-{
-    if (dir == kNext_FocusDirection)
-    {
-        if (this->acceptFocus())
+SkView* SkView::acceptFocus(FocusDirection dir) {
+    if (dir == kNext_FocusDirection) {
+        if (this->acceptFocus()) {
             return this;
-
+        }
         B2FIter    iter(this);
         SkView*    child, *focus;
-        while ((child = iter.next()) != nullptr)
-            if ((focus = child->acceptFocus(dir)) != nullptr)
+        while ((child = iter.next()) != nullptr) {
+            if ((focus = child->acceptFocus(dir)) != nullptr) {
                 return focus;
-    }
-    else // prev
-    {
+            }
+        }
+    } else { // prev
         F2BIter    iter(this);
         SkView*    child, *focus;
-        while ((child = iter.next()) != nullptr)
-            if ((focus = child->acceptFocus(dir)) != nullptr)
+        while ((child = iter.next()) != nullptr) {
+            if ((focus = child->acceptFocus(dir)) != nullptr) {
                 return focus;
-
-        if (this->acceptFocus())
+            }
+        }
+        if (this->acceptFocus()) {
             return this;
+        }
     }
-
     return nullptr;
 }
 
-SkView* SkView::moveFocus(FocusDirection dir)
-{
+SkView* SkView::moveFocus(FocusDirection dir) {
     SkView* focus = this->getFocusView();
 
-    if (focus == nullptr)
-    {    // start with the root
+    if (focus == nullptr) {    // start with the root
         focus = this;
-        while (focus->fParent)
+        while (focus->fParent) {
             focus = focus->fParent;
+        }
     }
 
-    SkView*    child, *parent;
+    SkView* child, *parent;
 
-    if (dir == kNext_FocusDirection)
-    {
+    if (dir == kNext_FocusDirection) {
         parent = focus;
         child = focus->fFirstChild;
         if (child)
             goto FIRST_CHILD;
         else
             goto NEXT_SIB;
 
         do {
-            while (child != parent->fFirstChild)
-            {
+            while (child != parent->fFirstChild) {
     FIRST_CHILD:
                 if ((focus = child->acceptFocus(dir)) != nullptr)
                     return focus;
                 child = child->fNextSibling;
             }
     NEXT_SIB:
             child = parent->fNextSibling;
             parent = parent->fParent;
         } while (parent != nullptr);
-    }
-    else    // prevfocus
-    {
+    } else {    // prevfocus
         parent = focus->fParent;
-        if (parent == nullptr)    // we're the root
+        if (parent == nullptr) {    // we're the root
             return focus->acceptFocus(dir);
-        else
-        {
+        } else {
             child = focus;
-            while (parent)
-            {
-                while (child != parent->fFirstChild)
-                {
+            while (parent) {
+                while (child != parent->fFirstChild) {
                     child = child->fPrevSibling;
-                    if ((focus = child->acceptFocus(dir)) != nullptr)
+                    if ((focus = child->acceptFocus(dir)) != nullptr) {
                         return focus;
+                    }
                 }
-                if (parent->acceptFocus())
+                if (parent->acceptFocus()) {
                     return parent;
-
+                }
                 child = parent;
                 parent = parent->fParent;
             }
         }
     }
     return nullptr;
 }
 
-void SkView::onFocusChange(bool gainFocusP)
-{
+void SkView::onFocusChange(bool gainFocusP) {
     this->inval(nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
-SkView::Click::Click(SkView* target)
-{
+SkView::Click::Click(SkView* target) {
     SkASSERT(target);
     fTargetID = target->getSinkID();
     fType = nullptr;
     fWeOwnTheType = false;
     fOwner = nullptr;
 }
 
-SkView::Click::~Click()
-{
+SkView::Click::~Click() {
     this->resetType();
 }
 
-void SkView::Click::resetType()
-{
-    if (fWeOwnTheType)
-    {
+void SkView::Click::resetType() {
+    if (fWeOwnTheType) {
         sk_free(fType);
         fWeOwnTheType = false;
     }
     fType = nullptr;
 }
 
-bool SkView::Click::isType(const char type[]) const
-{
+bool SkView::Click::isType(const char type[]) const {
     const char* t = fType;
 
-    if (type == t)
+    if (type == t) {
         return true;
-
-    if (type == nullptr)
+    }
+    if (type == nullptr) {
         type = "";
-    if (t == nullptr)
+    }
+    if (t == nullptr) {
         t = "";
+    }
     return !strcmp(t, type);
 }
 
-void SkView::Click::setType(const char type[])
-{
+void SkView::Click::setType(const char type[]) {
     this->resetType();
     fType = (char*)type;
 }
 
-void SkView::Click::copyType(const char type[])
-{
-    if (fType != type)
-    {
+void SkView::Click::copyType(const char type[]) {
+    if (fType != type) {
         this->resetType();
-        if (type)
-        {
-            size_t    len = strlen(type) + 1;
+        if (type) {
+            size_t len = strlen(type) + 1;
             fType = (char*)sk_malloc_throw(len);
             memcpy(fType, type, len);
             fWeOwnTheType = true;
         }
     }
 }
 
 SkView::Click* SkView::findClickHandler(SkScalar x, SkScalar y, unsigned modi) {
     if (x < 0 || y < 0 || x >= fWidth || y >= fHeight) {
         return nullptr;
@@ skipping 18 matching lines @@
 
             if (click) {
                 return click;
             }
         }
     }
 
     return this->onFindClickHandler(x, y, modi);
 }
 
-void SkView::DoClickDown(Click* click, int x, int y, unsigned modi)
-{
+void SkView::DoClickDown(Click* click, int x, int y, unsigned modi) {
     SkASSERT(click);
 
     SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
     if (nullptr == target) {
         return;
     }
 
     click->fIOrig.set(x, y);
     click->fICurr = click->fIPrev = click->fIOrig;
 
     click->fOrig.iset(x, y);
     if (!target->globalToLocal(&click->fOrig)) {
         // no history to let us recover from this failure
         return;
     }
     click->fPrev = click->fCurr = click->fOrig;
 
     click->fState = Click::kDown_State;
     click->fModifierKeys = modi;
     target->onClick(click);
 }
 
-void SkView::DoClickMoved(Click* click, int x, int y, unsigned modi)
-{
+void SkView::DoClickMoved(Click* click, int x, int y, unsigned modi) {
     SkASSERT(click);
 
     SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
     if (nullptr == target) {
         return;
     }
 
     click->fIPrev = click->fICurr;
     click->fICurr.set(x, y);
 
     click->fPrev = click->fCurr;
     click->fCurr.iset(x, y);
     if (!target->globalToLocal(&click->fCurr)) {
         // on failure pretend the mouse didn't move
         click->fCurr = click->fPrev;
     }
 
     click->fState = Click::kMoved_State;
     click->fModifierKeys = modi;
     target->onClick(click);
 }
 
-void SkView::DoClickUp(Click* click, int x, int y, unsigned modi)
-{
+void SkView::DoClickUp(Click* click, int x, int y, unsigned modi) {
     SkASSERT(click);
 
     SkView* target = (SkView*)SkEventSink::FindSink(click->fTargetID);
     if (nullptr == target) {
         return;
     }
 
     click->fIPrev = click->fICurr;
     click->fICurr.set(x, y);
 
@@ skipping 167 matching lines @@
         matrix->reset();
         const SkView* view = this;
         while (view)
         {
             matrix->preConcat(view->getLocalMatrix());
             matrix->preTranslate(-view->fLoc.fX, -view->fLoc.fY);
             view = view->fParent;
         }
     }
 }
-bool SkView::globalToLocal(SkScalar x, SkScalar y, SkPoint* local) const
-{
+
+bool SkView::globalToLocal(SkScalar x, SkScalar y, SkPoint* local) const {
     SkASSERT(this);
 
     if (local) {
         SkMatrix m;
         this->localToGlobal(&m);
         if (!m.invert(&m)) {
             return false;
         }
         SkPoint p;
         m.mapXY(x, y, &p);
@@ skipping 25 matching lines @@
 
     // inflate the flags
 
     static const char* gFlagNames[] = {
         "visible", "enabled", "focusable", "flexH", "flexV"
     };
     SkASSERT(SK_ARRAY_COUNT(gFlagNames) == kFlagShiftCount);
 
     bool     b;
     uint32_t flags = this->getFlags();
-    for (unsigned i = 0; i < SK_ARRAY_COUNT(gFlagNames); i++)
-        if (dom.findBool(node, gFlagNames[i], &b))
+    for (unsigned i = 0; i < SK_ARRAY_COUNT(gFlagNames); i++) {
+        if (dom.findBool(node, gFlagNames[i], &b)) {
             flags = SkSetClearShift(flags, b, i);
+        }
+    }
     this->setFlags(flags);
 }
 
 void SkView::inflate(const SkDOM& dom, const SkDOM::Node* node) {
     this->onInflate(dom, node);
 }
 
 void SkView::onPostInflate(const SkTDict<SkView*>&) {
     // override in subclass as needed
 }
@@ skipping 81 matching lines @@
     if (fParent) {
         SkASSERT(fNextSibling);
         SkASSERT(fPrevSibling);
     } else {
         bool nextNull = nullptr == fNextSibling;
         bool prevNull = nullptr == fNextSibling;
         SkASSERT(nextNull == prevNull);
     }
 }
 
-static inline void show_if_nonzero(const char name[], SkScalar value)
-{
-    if (value)
+static inline void show_if_nonzero(const char name[], SkScalar value) {
+    if (value) {
         SkDebugf("%s=\"%g\"", name, value/65536.);
+    }
 }
 
-static void tab(int level)
-{
-    for (int i = 0; i < level; i++)
+static void tab(int level) {
+    for (int i = 0; i < level; i++) {
         SkDebugf("    ");
+    }
 }
 
-static void dumpview(const SkView* view, int level, bool recurse)
-{
+static void dumpview(const SkView* view, int level, bool recurse) {
     tab(level);
 
     SkDebugf("<view");
     show_if_nonzero(" x", view->locX());
     show_if_nonzero(" y", view->locY());
     show_if_nonzero(" width", view->width());
     show_if_nonzero(" height", view->height());
 
-    if (recurse)
-    {
+    if (recurse) {
         SkView::B2FIter    iter(view);
         SkView*            child;
         bool            noChildren = true;
 
-        while ((child = iter.next()) != nullptr)
-        {
-            if (noChildren)
+        while ((child = iter.next()) != nullptr) {
+            if (noChildren) {
                 SkDebugf(">\n");
+            }
             noChildren = false;
             dumpview(child, level + 1, true);
         }
 
-        if (!noChildren)
-        {
+        if (!noChildren) {
             tab(level);
             SkDebugf("</view>\n");
+        } else {
+            goto ONELINER;
         }
-        else
-            goto ONELINER;
-    }
-    else
-    {
+    } else {
     ONELINER:
         SkDebugf(" />\n");
     }
 }
 
-void SkView::dump(bool recurse) const
-{
+void SkView::dump(bool recurse) const {
     dumpview(this, 0, recurse);
 }
 
 #endif