Learn Flux-architecture, Greensock and Radium

Animations attract the eye and add a higher level of engagement for your users. But they’re not easy to set up, and they don’t always look the way they should on every browser. 

Greensock is the best platform available for creating performant, highly-customizable animations. This course will walk you through the features of Greensock, including how to:

- animate an element
- manually control an animation
- animate between CSS classes

…and more, with cross-browser support to ensure your animations look sharp everywhere.

Ultra high-performance, professional-grade HTML5 animation for the modern web

greensock

Create Amazing Animations with GreenSock

As a React application grows, so does the needs for organization and patterns. How do components communicate? How do we manage state across the application? How is data shared between components? 

These are the questions that Flux was built to answer.

In this series, we will explore React Flux, using ES6 (ES2015), babel, and webpack to manage our developer workflow.

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

React: Flux Architecture (ES6)

In this lesson we'll look at an overview of how Flux works, setup our application structure and tools, and create our first component.

Flux Architecture: Overview and Project Setup

In this lesson we'll create a very simple application dispatcher utilizing the open source flux dispatcher from Facebook.

Flux Architecture: Application Dispatcher

In this lesson we'll create our Flux application's store which will manage the state of our application.

Flux Architecture: Application Store

In this lesson we'll create our initial components using the architecture we've built so far.

Flux Architecture: Components/Views

In this lesson we'll shift the responsibility of managing the state of our application over to a higher-order component rather than having each component managing it's own state.

Flux Architecture: Higher-Order Components

In this lesson we'll organize our components by feature.

Flux Architecture: Project Organization

Using our established architecture we'll make short work of a few remaining tasks to meet our application requirements.

Flux Architecture: Component Wrap Up

In this lesson we'll simplify future development by reducing the logic contained in our application's store.

Flux Architecture: Dumb Stores

In this lesson we'll build our actions which will be sent to our dispatcher.

Flux Architecture: Application Actions

In a CSS library like Bootstrap we can set a button's style to be "primary" or "secondary" by appending classes. For React components we want to be able to do this via props. Radium enables this by composing styles via an array. This mimicks the cascade of CSS.  

Radium: Updating Button Styles via Props

React's inline styles allow components to stand on their own by not requiring any external CSS. However HTML's style attributes don't support pseudo selectors like `:hover` and `:active`. By using Radium to listen to mouse events we can restore `:hover` and `:active` selectors to inline styles.

Styling a React button component with Radium

In this lesson we'll introduce routing into our application using react-router 1.0

Flux Architecture: Routing with react-router 1.0

In this lesson, we will look at Greensock's Draggable API. We will implement a scrollable `<div>` container and explore some options available.

Create scrollable DOM elements with Greensock

Modern development requires modern tooling. Rather than adding GreenSock as a script to an HTML page, we're going to install GreenSock using Yarn and set up our development environment using Parcel. This will allow us to quickly iterate and test out our animation ideas. GreenSock is abbreviated as `gsap` when importing.

Setup GreenSock as a Module with Parcel

Animating an element to a click event is as simple as passing the x and y coordinates of the click event to the properties of the `TweenMax.to` call. To be able to center the element where the mouse clicks, you also need to adjust the special xPercent and yPercent properties so the element is properly offset.

Animate and Center an Element to a Click Event with GreenSock

Rotating an element with GreenSock is as simple as changing the `rotation` property using `TweenMax`. But there's also a hugely convenient trick using the `+=` or `-+` syntax as a string that allows you to adjust based on the previous value of the rotation.

Rotate an Element Based on Previous Values with GreenSock

Animations often have multiple steps. GreenSock makes this simple with the concept of a timeline where you code each point you want your element to move to. This lesson will show you how to set up a timeline as well as pause and resume the timeline animation.

Create Animation Steps with GreenSock's Timeline

You often need to pause or resume an animation based on whether or not the current animation running. The `isActive()` getter returns a boolean that provides you with that information (the opposite information can be found with using the `paused()` getter).

Pause or Resume an Animation by Checking isActive with GreenSock

GreenSock also supports the ability to animate `from` a variable point to the current point. If you think `to` starts at a static point and moves to a variable point then `from` essentially does the opposite. `fromTo` supports the scenario where both points are variables and requires passing in a "from" set of properties and a "to" set of properties.

Topics

Instructors

Content Type

Free or Pro