tools/viewer/SlideDir.cpp - platform/external/skia - Gitiles

 /*
  * Copyright 2018 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "SlideDir.h"

 #include "SkAnimTimer.h"
 #include "SkCanvas.h"
 #include "SkCubicMap.h"
 #include "SkMakeUnique.h"
 #include "SkSGColor.h"
 #include "SkSGDraw.h"
 #include "SkSGGroup.h"
 #include "SkSGPlane.h"
 #include "SkSGRect.h"
 #include "SkSGRenderNode.h"
 #include "SkSGScene.h"
 #include "SkSGText.h"
 #include "SkSGTransform.h"
 #include "SkTypeface.h"

 #include <cmath>
 #include <utility>

 namespace {

 static constexpr float  kAspectRatio   = 1.5f;
 static constexpr float  kLabelSize     = 12.0f;
 static constexpr SkSize kPadding       = { 12.0f , 24.0f };

 static constexpr float   kFocusDuration = 500;
 static constexpr SkSize  kFocusInset    = { 100.0f, 100.0f };
 static constexpr SkPoint kFocusCtrl0    = {   0.3f,   1.0f };
 static constexpr SkPoint kFocusCtrl1    = {   0.0f,   1.0f };
 static constexpr SkColor kFocusShade    = 0xa0000000;

 // TODO: better unfocus binding?
 static constexpr SkUnichar kUnfocusKey = ' ';

 class SlideAdapter final : public sksg::RenderNode {
 public:
     explicit SlideAdapter(sk_sp<Slide> slide)
         : fSlide(std::move(slide)) {
         SkASSERT(fSlide);
     }

     std::unique_ptr<sksg::Animator> makeForwardingAnimator() {
         // Trivial sksg::Animator -> skottie::Animation tick adapter
         class ForwardingAnimator final : public sksg::Animator {
         public:
             explicit ForwardingAnimator(sk_sp<SlideAdapter> adapter)
                 : fAdapter(std::move(adapter)) {}

         protected:
             void onTick(float t) override {
                 fAdapter->tick(SkScalarRoundToInt(t));
             }

         private:
             sk_sp<SlideAdapter> fAdapter;
         };

         return skstd::make_unique<ForwardingAnimator>(sk_ref_sp(this));
     }

 protected:
     SkRect onRevalidate(sksg::InvalidationController* ic, const SkMatrix& ctm) override {
         const auto isize = fSlide->getDimensions();
         return SkRect::MakeIWH(isize.width(), isize.height());
     }

     void onRender(SkCanvas* canvas, const RenderContext* ctx) const override {
         SkAutoCanvasRestore acr(canvas, true);
         canvas->clipRect(SkRect::Make(fSlide->getDimensions()), true);

         // TODO: commit the context?
         fSlide->draw(canvas);
     }

     const RenderNode* onNodeAt(const SkPoint&) const override { return nullptr; }

 private:
     void tick(SkMSec t) {
         fSlide->animate(SkAnimTimer(t * 1e6));
         this->invalidate();
     }

     const sk_sp<Slide> fSlide;

     using INHERITED = sksg::RenderNode;
 };

 SkMatrix SlideMatrix(const sk_sp<Slide>& slide, const SkRect& dst) {
     const auto slideSize = slide->getDimensions();
     return SkMatrix::MakeRectToRect(SkRect::MakeIWH(slideSize.width(), slideSize.height()),
                                     dst,
                                     SkMatrix::kCenter_ScaleToFit);
 }

 } // namespace

 struct SlideDir::Rec {
     sk_sp<Slide>                  fSlide;
     sk_sp<sksg::RenderNode>       fSlideRoot;
     sk_sp<sksg::Matrix<SkMatrix>> fMatrix;
     SkRect                        fRect;
 };

 class SlideDir::FocusController final : public sksg::Animator {
 public:
     FocusController(const SlideDir* dir, const SkRect& focusRect)
         : fDir(dir)
         , fRect(focusRect)
         , fTarget(nullptr)
         , fState(State::kIdle) {
         fMap.setPts(kFocusCtrl1, kFocusCtrl0);

         fShadePaint = sksg::Color::Make(kFocusShade);
         fShade = sksg::Draw::Make(sksg::Plane::Make(), fShadePaint);
     }

     bool hasFocus() const { return fState == State::kFocused; }

     void startFocus(const Rec* target) {
         if (fState != State::kIdle)
             return;

         fTarget = target;

         // Move the shade & slide to front.
         fDir->fRoot->removeChild(fTarget->fSlideRoot);
         fDir->fRoot->addChild(fShade);
         fDir->fRoot->addChild(fTarget->fSlideRoot);

         fM0 = SlideMatrix(fTarget->fSlide, fTarget->fRect);
         fM1 = SlideMatrix(fTarget->fSlide, fRect);

         fOpacity0 = 0;
         fOpacity1 = 1;

         fTimeBase = 0;
         fState = State::kFocusing;

         // Push initial state to the scene graph.
         this->onTick(fTimeBase);
     }

     void startUnfocus() {
         SkASSERT(fTarget);

         using std::swap;
         swap(fM0, fM1);
         swap(fOpacity0, fOpacity1);

         fTimeBase = 0;
         fState = State::kUnfocusing;
     }

     bool onMouse(SkScalar x, SkScalar y, sk_app::Window::InputState state, uint32_t modifiers) {
         SkASSERT(fTarget);

         if (!fRect.contains(x, y)) {
             this->startUnfocus();
             return true;
         }

         // Map coords to slide space.
         const auto xform = SkMatrix::MakeRectToRect(fRect,
                                                     SkRect::MakeSize(fDir->fWinSize),
                                                     SkMatrix::kCenter_ScaleToFit);
         const auto pt = xform.mapXY(x, y);

         return fTarget->fSlide->onMouse(pt.x(), pt.y(), state, modifiers);
     }

     bool onChar(SkUnichar c) {
         SkASSERT(fTarget);

         return fTarget->fSlide->onChar(c);
     }

 protected:
     void onTick(float t) {
         if (!this->isAnimating())
             return;

         if (!fTimeBase) {
             fTimeBase = t;
         }

         const auto rel_t = (t - fTimeBase) / kFocusDuration,
                    map_t = SkTPin(fMap.computeYFromX(rel_t), 0.0f, 1.0f);

         SkMatrix m;
         for (int i = 0; i < 9; ++i) {
             m[i] = fM0[i] + map_t * (fM1[i] - fM0[i]);
         }

         SkASSERT(fTarget);
         fTarget->fMatrix->setMatrix(m);

         const auto shadeOpacity = fOpacity0 + map_t * (fOpacity1 - fOpacity0);
         fShadePaint->setOpacity(shadeOpacity);

         if (rel_t < 1)
             return;

         switch (fState) {
         case State::kFocusing:
             fState = State::kFocused;
             break;
         case State::kUnfocusing:
             fState  = State::kIdle;
             fDir->fRoot->removeChild(fShade);
             break;

         case State::kIdle:
         case State::kFocused:
             SkASSERT(false);
             break;
         }
     }

 private:
     enum class State {
         kIdle,
         kFocusing,
         kUnfocusing,
         kFocused,
     };

     bool isAnimating() const { return fState == State::kFocusing || fState == State::kUnfocusing; }

     const SlideDir*         fDir;
     const SkRect            fRect;
     const Rec*              fTarget;

     SkCubicMap              fMap;
     sk_sp<sksg::RenderNode> fShade;
     sk_sp<sksg::PaintNode>  fShadePaint;

     SkMatrix        fM0       = SkMatrix::I(),
                     fM1       = SkMatrix::I();
     float           fOpacity0 = 0,
                     fOpacity1 = 1,
                     fTimeBase = 0;
     State           fState    = State::kIdle;

     using INHERITED = sksg::Animator;
 };

 SlideDir::SlideDir(const SkString& name, SkTArray<sk_sp<Slide>>&& slides, int columns)
     : fSlides(std::move(slides))
     , fColumns(columns) {
     fName = name;
 }

 static sk_sp<sksg::RenderNode> MakeLabel(const SkString& txt,
                                          const SkPoint& pos,
                                          const SkMatrix& dstXform) {
     const auto size = kLabelSize / std::sqrt(dstXform.getScaleX() * dstXform.getScaleY());
     auto text = sksg::Text::Make(nullptr, txt);
     text->setEdging(SkFont::Edging::kAntiAlias);
     text->setSize(size);
     text->setAlign(SkTextUtils::kCenter_Align);
     text->setPosition(pos + SkPoint::Make(0, size));

     return sksg::Draw::Make(std::move(text), sksg::Color::Make(SK_ColorBLACK));
 }

 void SlideDir::load(SkScalar winWidth, SkScalar winHeight) {
     // Build a global scene using transformed animation fragments:
     //
     // [Group(root)]
     //     [Transform]
     //         [Group]
     //             [AnimationWrapper]
     //             [Draw]
     //                 [Text]
     //                 [Color]
     //     [Transform]
     //         [Group]
     //             [AnimationWrapper]
     //             [Draw]
     //                 [Text]
     //                 [Color]
     //     ...
     //

     fWinSize = SkSize::Make(winWidth, winHeight);
     const auto  cellWidth =  winWidth / fColumns;
     fCellSize = SkSize::Make(cellWidth, cellWidth / kAspectRatio);

     sksg::AnimatorList sceneAnimators;
     fRoot = sksg::Group::Make();

     for (int i = 0; i < fSlides.count(); ++i) {
         const auto& slide     = fSlides[i];
         slide->load(winWidth, winHeight);

         const auto  slideSize = slide->getDimensions();
         const auto  cell      = SkRect::MakeXYWH(fCellSize.width()  * (i % fColumns),
                                                  fCellSize.height() * (i / fColumns),
                                                  fCellSize.width(),
                                                  fCellSize.height()),
                     slideRect = cell.makeInset(kPadding.width(), kPadding.height());

         auto slideMatrix = sksg::Matrix<SkMatrix>::Make(SlideMatrix(slide, slideRect));
         auto adapter     = sk_make_sp<SlideAdapter>(slide);
         auto slideGrp    = sksg::Group::Make();
         slideGrp->addChild(sksg::Draw::Make(sksg::Rect::Make(SkRect::MakeIWH(slideSize.width(),
                                                                              slideSize.height())),
                                             sksg::Color::Make(0xfff0f0f0)));
         slideGrp->addChild(adapter);
         slideGrp->addChild(MakeLabel(slide->getName(),
                                      SkPoint::Make(slideSize.width() / 2, slideSize.height()),
                                      slideMatrix->getMatrix()));
         auto slideRoot = sksg::TransformEffect::Make(std::move(slideGrp), slideMatrix);

         sceneAnimators.push_back(adapter->makeForwardingAnimator());

         fRoot->addChild(slideRoot);
         fRecs.push_back({ slide, slideRoot, slideMatrix, slideRect });
     }

     fScene = sksg::Scene::Make(fRoot, std::move(sceneAnimators));

     const auto focusRect = SkRect::MakeSize(fWinSize).makeInset(kFocusInset.width(),
                                                                 kFocusInset.height());
     fFocusController = skstd::make_unique<FocusController>(this, focusRect);
 }

 void SlideDir::unload() {
     for (const auto& slide : fSlides) {
         slide->unload();
     }

     fRecs.reset();
     fScene.reset();
     fFocusController.reset();
     fRoot.reset();
     fTimeBase = 0;
 }

 SkISize SlideDir::getDimensions() const {
     return SkSize::Make(fWinSize.width(),
                         fCellSize.height() * (1 + (fSlides.count() - 1) / fColumns)).toCeil();
 }

 void SlideDir::draw(SkCanvas* canvas) {
     fScene->render(canvas);
 }

 bool SlideDir::animate(const SkAnimTimer& timer) {
     if (fTimeBase == 0) {
         // Reset the animation time.
         fTimeBase = timer.msec();
     }

     const auto t = timer.msec() - fTimeBase;
     fScene->animate(t);
     fFocusController->tick(t);

     return true;
 }

 bool SlideDir::onChar(SkUnichar c) {
     if (fFocusController->hasFocus()) {
         if (c == kUnfocusKey) {
             fFocusController->startUnfocus();
             return true;
         }
         return fFocusController->onChar(c);
     }

     return false;
 }

 bool SlideDir::onMouse(SkScalar x, SkScalar y, sk_app::Window::InputState state,
                        uint32_t modifiers) {
     if (state == sk_app::Window::kMove_InputState || modifiers)
         return false;

     if (fFocusController->hasFocus()) {
         return fFocusController->onMouse(x, y, state, modifiers);
     }

     const auto* cell = this->findCell(x, y);
     if (!cell)
         return false;

     static constexpr SkScalar kClickMoveTolerance = 4;

     switch (state) {
     case sk_app::Window::kDown_InputState:
         fTrackingCell = cell;
         fTrackingPos = SkPoint::Make(x, y);
         break;
     case sk_app::Window::kUp_InputState:
         if (cell == fTrackingCell &&
             SkPoint::Distance(fTrackingPos, SkPoint::Make(x, y)) < kClickMoveTolerance) {
             fFocusController->startFocus(cell);
         }
         break;
     default:
         break;
     }

     return false;
 }

 const SlideDir::Rec* SlideDir::findCell(float x, float y) const {
     // TODO: use SG hit testing instead of layout info?
     const auto size = this->getDimensions();
     if (x < 0 || y < 0 || x >= size.width() || y >= size.height()) {
         return nullptr;
     }

     const int col = static_cast<int>(x / fCellSize.width()),
               row = static_cast<int>(y / fCellSize.height()),
               idx = row * fColumns + col;

     return idx < fRecs.count() ? &fRecs[idx] : nullptr;
 }
	/*
	* Copyright 2018 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "SlideDir.h"

	#include "SkAnimTimer.h"
	#include "SkCanvas.h"
	#include "SkCubicMap.h"
	#include "SkMakeUnique.h"
	#include "SkSGColor.h"
	#include "SkSGDraw.h"
	#include "SkSGGroup.h"
	#include "SkSGPlane.h"
	#include "SkSGRect.h"
	#include "SkSGRenderNode.h"
	#include "SkSGScene.h"
	#include "SkSGText.h"
	#include "SkSGTransform.h"
	#include "SkTypeface.h"

	#include <cmath>
	#include <utility>

	namespace {

	static constexpr float kAspectRatio = 1.5f;
	static constexpr float kLabelSize = 12.0f;
	static constexpr SkSize kPadding = { 12.0f , 24.0f };

	static constexpr float kFocusDuration = 500;
	static constexpr SkSize kFocusInset = { 100.0f, 100.0f };
	static constexpr SkPoint kFocusCtrl0 = { 0.3f, 1.0f };
	static constexpr SkPoint kFocusCtrl1 = { 0.0f, 1.0f };
	static constexpr SkColor kFocusShade = 0xa0000000;

	// TODO: better unfocus binding?
	static constexpr SkUnichar kUnfocusKey = ' ';

	class SlideAdapter final : public sksg::RenderNode {
	public:
	explicit SlideAdapter(sk_sp<Slide> slide)
	: fSlide(std::move(slide)) {
	SkASSERT(fSlide);
	}

	std::unique_ptr<sksg::Animator> makeForwardingAnimator() {
	// Trivial sksg::Animator -> skottie::Animation tick adapter
	class ForwardingAnimator final : public sksg::Animator {
	public:
	explicit ForwardingAnimator(sk_sp<SlideAdapter> adapter)
	: fAdapter(std::move(adapter)) {}

	protected:
	void onTick(float t) override {
	fAdapter->tick(SkScalarRoundToInt(t));
	}

	private:
	sk_sp<SlideAdapter> fAdapter;
	};

	return skstd::make_unique<ForwardingAnimator>(sk_ref_sp(this));
	}

	protected:
	SkRect onRevalidate(sksg::InvalidationController* ic, const SkMatrix& ctm) override {
	const auto isize = fSlide->getDimensions();
	return SkRect::MakeIWH(isize.width(), isize.height());
	}

	void onRender(SkCanvas* canvas, const RenderContext* ctx) const override {
	SkAutoCanvasRestore acr(canvas, true);
	canvas->clipRect(SkRect::Make(fSlide->getDimensions()), true);

	// TODO: commit the context?
	fSlide->draw(canvas);
	}

	const RenderNode* onNodeAt(const SkPoint&) const override { return nullptr; }

	private:
	void tick(SkMSec t) {
	fSlide->animate(SkAnimTimer(t * 1e6));
	this->invalidate();
	}

	const sk_sp<Slide> fSlide;

	using INHERITED = sksg::RenderNode;
	};

	SkMatrix SlideMatrix(const sk_sp<Slide>& slide, const SkRect& dst) {
	const auto slideSize = slide->getDimensions();
	return SkMatrix::MakeRectToRect(SkRect::MakeIWH(slideSize.width(), slideSize.height()),
	dst,
	SkMatrix::kCenter_ScaleToFit);
	}

	} // namespace

	struct SlideDir::Rec {
	sk_sp<Slide> fSlide;
	sk_sp<sksg::RenderNode> fSlideRoot;
	sk_sp<sksg::Matrix<SkMatrix>> fMatrix;
	SkRect fRect;
	};

	class SlideDir::FocusController final : public sksg::Animator {
	public:
	FocusController(const SlideDir* dir, const SkRect& focusRect)
	: fDir(dir)
	, fRect(focusRect)
	, fTarget(nullptr)
	, fState(State::kIdle) {
	fMap.setPts(kFocusCtrl1, kFocusCtrl0);

	fShadePaint = sksg::Color::Make(kFocusShade);
	fShade = sksg::Draw::Make(sksg::Plane::Make(), fShadePaint);
	}

	bool hasFocus() const { return fState == State::kFocused; }

	void startFocus(const Rec* target) {
	if (fState != State::kIdle)
	return;

	fTarget = target;

	// Move the shade & slide to front.
	fDir->fRoot->removeChild(fTarget->fSlideRoot);
	fDir->fRoot->addChild(fShade);
	fDir->fRoot->addChild(fTarget->fSlideRoot);

	fM0 = SlideMatrix(fTarget->fSlide, fTarget->fRect);
	fM1 = SlideMatrix(fTarget->fSlide, fRect);

	fOpacity0 = 0;
	fOpacity1 = 1;

	fTimeBase = 0;
	fState = State::kFocusing;

	// Push initial state to the scene graph.
	this->onTick(fTimeBase);
	}

	void startUnfocus() {
	SkASSERT(fTarget);

	using std::swap;
	swap(fM0, fM1);
	swap(fOpacity0, fOpacity1);

	fTimeBase = 0;
	fState = State::kUnfocusing;
	}

	bool onMouse(SkScalar x, SkScalar y, sk_app::Window::InputState state, uint32_t modifiers) {
	SkASSERT(fTarget);

	if (!fRect.contains(x, y)) {
	this->startUnfocus();
	return true;
	}

	// Map coords to slide space.
	const auto xform = SkMatrix::MakeRectToRect(fRect,
	SkRect::MakeSize(fDir->fWinSize),
	SkMatrix::kCenter_ScaleToFit);
	const auto pt = xform.mapXY(x, y);

	return fTarget->fSlide->onMouse(pt.x(), pt.y(), state, modifiers);
	}

	bool onChar(SkUnichar c) {
	SkASSERT(fTarget);

	return fTarget->fSlide->onChar(c);
	}

	protected:
	void onTick(float t) {
	if (!this->isAnimating())
	return;

	if (!fTimeBase) {
	fTimeBase = t;
	}

	const auto rel_t = (t - fTimeBase) / kFocusDuration,
	map_t = SkTPin(fMap.computeYFromX(rel_t), 0.0f, 1.0f);

	SkMatrix m;
	for (int i = 0; i < 9; ++i) {
	m[i] = fM0[i] + map_t * (fM1[i] - fM0[i]);
	}

	SkASSERT(fTarget);
	fTarget->fMatrix->setMatrix(m);

	const auto shadeOpacity = fOpacity0 + map_t * (fOpacity1 - fOpacity0);
	fShadePaint->setOpacity(shadeOpacity);

	if (rel_t < 1)
	return;

	switch (fState) {
	case State::kFocusing:
	fState = State::kFocused;
	break;
	case State::kUnfocusing:
	fState = State::kIdle;
	fDir->fRoot->removeChild(fShade);
	break;

	case State::kIdle:
	case State::kFocused:
	SkASSERT(false);
	break;
	}
	}

	private:
	enum class State {
	kIdle,
	kFocusing,
	kUnfocusing,
	kFocused,
	};

	bool isAnimating() const { return fState == State::kFocusing \|\| fState == State::kUnfocusing; }

	const SlideDir* fDir;
	const SkRect fRect;
	const Rec* fTarget;

	SkCubicMap fMap;
	sk_sp<sksg::RenderNode> fShade;
	sk_sp<sksg::PaintNode> fShadePaint;

	SkMatrix fM0 = SkMatrix::I(),
	fM1 = SkMatrix::I();
	float fOpacity0 = 0,
	fOpacity1 = 1,
	fTimeBase = 0;
	State fState = State::kIdle;

	using INHERITED = sksg::Animator;
	};

	SlideDir::SlideDir(const SkString& name, SkTArray<sk_sp<Slide>>&& slides, int columns)
	: fSlides(std::move(slides))
	, fColumns(columns) {
	fName = name;
	}

	static sk_sp<sksg::RenderNode> MakeLabel(const SkString& txt,
	const SkPoint& pos,
	const SkMatrix& dstXform) {
	const auto size = kLabelSize / std::sqrt(dstXform.getScaleX() * dstXform.getScaleY());
	auto text = sksg::Text::Make(nullptr, txt);
	text->setEdging(SkFont::Edging::kAntiAlias);
	text->setSize(size);
	text->setAlign(SkTextUtils::kCenter_Align);
	text->setPosition(pos + SkPoint::Make(0, size));

	return sksg::Draw::Make(std::move(text), sksg::Color::Make(SK_ColorBLACK));
	}

	void SlideDir::load(SkScalar winWidth, SkScalar winHeight) {
	// Build a global scene using transformed animation fragments:
	//
	// [Group(root)]
	// [Transform]
	// [Group]
	// [AnimationWrapper]
	// [Draw]
	// [Text]
	// [Color]
	// [Transform]
	// [Group]
	// [AnimationWrapper]
	// [Draw]
	// [Text]
	// [Color]
	// ...
	//

	fWinSize = SkSize::Make(winWidth, winHeight);
	const auto cellWidth = winWidth / fColumns;
	fCellSize = SkSize::Make(cellWidth, cellWidth / kAspectRatio);

	sksg::AnimatorList sceneAnimators;
	fRoot = sksg::Group::Make();

	for (int i = 0; i < fSlides.count(); ++i) {
	const auto& slide = fSlides[i];
	slide->load(winWidth, winHeight);

	const auto slideSize = slide->getDimensions();
	const auto cell = SkRect::MakeXYWH(fCellSize.width() * (i % fColumns),
	fCellSize.height() * (i / fColumns),
	fCellSize.width(),
	fCellSize.height()),
	slideRect = cell.makeInset(kPadding.width(), kPadding.height());

	auto slideMatrix = sksg::Matrix<SkMatrix>::Make(SlideMatrix(slide, slideRect));
	auto adapter = sk_make_sp<SlideAdapter>(slide);
	auto slideGrp = sksg::Group::Make();
	slideGrp->addChild(sksg::Draw::Make(sksg::Rect::Make(SkRect::MakeIWH(slideSize.width(),
	slideSize.height())),
	sksg::Color::Make(0xfff0f0f0)));
	slideGrp->addChild(adapter);
	slideGrp->addChild(MakeLabel(slide->getName(),
	SkPoint::Make(slideSize.width() / 2, slideSize.height()),
	slideMatrix->getMatrix()));
	auto slideRoot = sksg::TransformEffect::Make(std::move(slideGrp), slideMatrix);

	sceneAnimators.push_back(adapter->makeForwardingAnimator());

	fRoot->addChild(slideRoot);
	fRecs.push_back({ slide, slideRoot, slideMatrix, slideRect });
	}

	fScene = sksg::Scene::Make(fRoot, std::move(sceneAnimators));

	const auto focusRect = SkRect::MakeSize(fWinSize).makeInset(kFocusInset.width(),
	kFocusInset.height());
	fFocusController = skstd::make_unique<FocusController>(this, focusRect);
	}

	void SlideDir::unload() {
	for (const auto& slide : fSlides) {
	slide->unload();
	}

	fRecs.reset();
	fScene.reset();
	fFocusController.reset();
	fRoot.reset();
	fTimeBase = 0;
	}

	SkISize SlideDir::getDimensions() const {
	return SkSize::Make(fWinSize.width(),
	fCellSize.height() * (1 + (fSlides.count() - 1) / fColumns)).toCeil();
	}

	void SlideDir::draw(SkCanvas* canvas) {
	fScene->render(canvas);
	}

	bool SlideDir::animate(const SkAnimTimer& timer) {
	if (fTimeBase == 0) {
	// Reset the animation time.
	fTimeBase = timer.msec();
	}

	const auto t = timer.msec() - fTimeBase;
	fScene->animate(t);
	fFocusController->tick(t);

	return true;
	}

	bool SlideDir::onChar(SkUnichar c) {
	if (fFocusController->hasFocus()) {
	if (c == kUnfocusKey) {
	fFocusController->startUnfocus();
	return true;
	}
	return fFocusController->onChar(c);
	}

	return false;
	}

	bool SlideDir::onMouse(SkScalar x, SkScalar y, sk_app::Window::InputState state,
	uint32_t modifiers) {
	if (state == sk_app::Window::kMove_InputState \|\| modifiers)
	return false;

	if (fFocusController->hasFocus()) {
	return fFocusController->onMouse(x, y, state, modifiers);
	}

	const auto* cell = this->findCell(x, y);
	if (!cell)
	return false;

	static constexpr SkScalar kClickMoveTolerance = 4;

	switch (state) {
	case sk_app::Window::kDown_InputState:
	fTrackingCell = cell;
	fTrackingPos = SkPoint::Make(x, y);
	break;
	case sk_app::Window::kUp_InputState:
	if (cell == fTrackingCell &&
	SkPoint::Distance(fTrackingPos, SkPoint::Make(x, y)) < kClickMoveTolerance) {
	fFocusController->startFocus(cell);
	}
	break;
	default:
	break;
	}

	return false;
	}

	const SlideDir::Rec* SlideDir::findCell(float x, float y) const {
	// TODO: use SG hit testing instead of layout info?
	const auto size = this->getDimensions();
	if (x < 0 \|\| y < 0 \|\| x >= size.width() \|\| y >= size.height()) {
	return nullptr;
	}

	const int col = static_cast<int>(x / fCellSize.width()),
	row = static_cast<int>(y / fCellSize.height()),
	idx = row * fColumns + col;

	return idx < fRecs.count() ? &fRecs[idx] : nullptr;
	}