SlideDir::FocusController Class Reference

Inheritance diagram for SlideDir::FocusController:

Public Member Functions
	FocusController (const SlideDir *dir, const SkRect &focusRect)
bool	hasFocus () const
void	startFocus (const Rec *target)
void	startUnfocus ()
bool	onMouse (SkScalar x, SkScalar y, skui::InputState state, skui::ModifierKey modifiers)
bool	onChar (SkUnichar c)
Public Member Functions inherited from SlideDir::Animator
	Animator (const Animator &)=delete
Animator &	operator= (const Animator &)=delete
void	tick (float t)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
void	onTick (float t) override
Protected Member Functions inherited from SlideDir::Animator
	Animator ()=default

Detailed Description

Definition at line 136 of file SlideDir.cpp.

Constructor & Destructor Documentation

FocusController()

SlideDir::FocusController::FocusController ( const SlideDir *  dir, const SkRect &  focusRect  )

inline

Definition at line 138 of file SlideDir.cpp.

        : fDir(dir)
        , fRect(focusRect)
        , fTarget(nullptr)
        , fMap(kFocusCtrl1, kFocusCtrl0)
        , fState(State::kIdle) {
        fShadePaint = sksg::Color::Make(kFocusShade);
        fShade = sksg::Draw::Make(sksg::Plane::Make(), fShadePaint);
    }

Member Function Documentation

hasFocus()

bool SlideDir::FocusController::hasFocus ( ) const

inline

Definition at line 148 of file SlideDir.cpp.

{ return fState == State::kFocused; }

onChar()

bool SlideDir::FocusController::onChar ( SkUnichar  c )

inline

Definition at line 201 of file SlideDir.cpp.

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

onMouse()

bool SlideDir::FocusController::onMouse ( SkScalar  x, SkScalar  y, skui::InputState  state, skui::ModifierKey  modifiers  )

inline

Definition at line 185 of file SlideDir.cpp.

                                                                                          {
        SkASSERT(fTarget);
 
        if (!fRect.contains(x, y)) {
            this->startUnfocus();
            return true;
        }
 
        // Map coords to slide space.
        const auto xform = SkMatrix::RectToRect(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);
    }

onTick()

void SlideDir::FocusController::onTick ( float  t )

inlineoverrideprotectedvirtual

Implements SlideDir::Animator.

Definition at line 208 of file SlideDir.cpp.

                                  {
        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;
        }
    }

startFocus()

void SlideDir::FocusController::startFocus ( const Rec *  target )

inline

Definition at line 150 of file SlideDir.cpp.

                                       {
        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);
    }

startUnfocus()

void SlideDir::FocusController::startUnfocus ( )

inline

Definition at line 174 of file SlideDir.cpp.

                        {
        SkASSERT(fTarget);
 
        using std::swap;
        swap(fM0, fM1);
        swap(fOpacity0, fOpacity1);
 
        fTimeBase = 0;
        fState = State::kUnfocusing;
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/tools/viewer/SlideDir.cpp