SlideDir Class Reference

#include <SlideDir.h>

Inheritance diagram for SlideDir:

Classes
class	Animator
class	FocusController
struct	Rec

Public Member Functions
	SlideDir (const SkString &name, skia_private::TArray< sk_sp< Slide > > &&, int columns=kDefaultColumnCount)
Public Member Functions inherited from Slide
virtual void	gpuTeardown ()
virtual void	resize (SkScalar winWidth, SkScalar winHeight)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
const SkString &	getName ()
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Protected Member Functions
void	load (SkScalar winWidth, SkScalar winHeight) override
void	unload () override
SkISize	getDimensions () const override
void	draw (SkCanvas *) override
bool	animate (double) override
bool	onChar (SkUnichar) override
bool	onMouse (SkScalar x, SkScalar y, skui::InputState, skui::ModifierKey modifiers) override

Additional Inherited Members
Protected Attributes inherited from Slide
SkString	fName

Detailed Description

Definition at line 32 of file SlideDir.h.

Constructor & Destructor Documentation

SlideDir()

SlideDir::SlideDir	(	const SkString &	name,
		skia_private::TArray< sk_sp< Slide > > &&	slides,
		int	columns = kDefaultColumnCount
	)

Definition at line 275 of file SlideDir.cpp.

    : fSlides(std::move(slides))
    , fColumns(columns) {
    fName = name;
}

Member Function Documentation

animate()

bool SlideDir::animate ( double  nanos )

overrideprotectedvirtual

Reimplemented from Slide.

Definition at line 376 of file SlideDir.cpp.

                                   {
    SkMSec msec = TimeUtils::NanosToMSec(nanos);
    if (fTimeBase == 0) {
        // Reset the animation time.
        fTimeBase = msec;
    }
 
    const auto t = msec - fTimeBase;
    for (const auto& anim : fSceneAnimators) {
        anim->tick(t);
    }
    fFocusController->tick(t);
 
    return true;
}

draw()

void SlideDir::draw ( SkCanvas *  canvas )

overrideprotectedvirtual

Implements Slide.

Definition at line 372 of file SlideDir.cpp.

                                    {
    fScene->render(canvas);
}

getDimensions()

SkISize SlideDir::getDimensions ( ) const

overrideprotectedvirtual

A slide may have a content dimensions that is independent of the current window size. An empty size indicates that the Slide's dimensions are equal to the window's dimensions.

Reimplemented from Slide.

Definition at line 367 of file SlideDir.cpp.

                                      {
    return SkSize::Make(fWinSize.width(),
                        fCellSize.height() * (1 + (fSlides.size() - 1) / fColumns)).toCeil();
}

load()

void SlideDir::load ( SkScalar  winWidth, SkScalar  winHeight  )

overrideprotectedvirtual

Reimplemented from Slide.

Definition at line 294 of file SlideDir.cpp.

                                                         {
    // 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);
 
    fRoot = sksg::Group::Make();
 
    for (int i = 0; i < fSlides.size(); ++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);
 
        fSceneAnimators.push_back(adapter->makeForwardingAnimator());
 
        fRoot->addChild(slideRoot);
        fRecs.push_back({ slide, slideRoot, slideMatrix, slideRect });
    }
 
    fScene = sksg::Scene::Make(fRoot);
 
    const auto focusRect = SkRect::MakeSize(fWinSize).makeInset(kFocusInset.width(),
                                                                kFocusInset.height());
    fFocusController = std::make_unique<FocusController>(this, focusRect);
}

onChar()

bool SlideDir::onChar ( SkUnichar  c )

overrideprotectedvirtual

Reimplemented from Slide.

Definition at line 392 of file SlideDir.cpp.

                                 {
    if (fFocusController->hasFocus()) {
        if (c == kUnfocusKey) {
            fFocusController->startUnfocus();
            return true;
        }
        return fFocusController->onChar(c);
    }
 
    return false;
}

onMouse()

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

overrideprotectedvirtual

Reimplemented from Slide.

Definition at line 404 of file SlideDir.cpp.

                                                  {
    modifiers &= ~skui::ModifierKey::kFirstPress;
    if (state == skui::InputState::kMove || sknonstd::Any(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 skui::InputState::kDown:
        fTrackingCell = cell;
        fTrackingPos = SkPoint::Make(x, y);
        break;
    case skui::InputState::kUp:
        if (cell == fTrackingCell &&
            SkPoint::Distance(fTrackingPos, SkPoint::Make(x, y)) < kClickMoveTolerance) {
            fFocusController->startFocus(cell);
        }
        break;
    default:
        break;
    }
 
    return false;
}

unload()

void SlideDir::unload ( )

overrideprotectedvirtual

Reimplemented from Slide.

Definition at line 355 of file SlideDir.cpp.

                      {
    for (const auto& slide : fSlides) {
        slide->unload();
    }
 
    fRecs.clear();
    fScene.reset();
    fFocusController.reset();
    fRoot.reset();
    fTimeBase = 0;
}

---

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

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