Web Development4unow: September 2016

Thanks to flexbox, nowadays we can build some really attractive and modern layouts with relative ease. In this tutorial we’re going to look at an interface used recently for Google National Parks, and see how flexbox can help us improve on it.

As always, before going any further, let’s look at what we’ll be building (you may need to check out the larger version as the full effect kicks in on viewports wider than 800px):

Be sure to hover over the links to trigger the corresponding effects.

The Markup

First, let’s examine the markup we’ll be using to build this layout. We define a div element with five links within it (you can use whichever elements you feel are appropriate). Each of our links contains a div with the class of overlay. Below you can see the skeleton of our code:

<div class="flex-wrapper">
  <a href="" class="one">
    <div class="overlay">
      <div class="overlay-inner">
        <h2>Title #1</h2>
        <p>Fusce vulputate orci at nulla consequat, ac tincidunt quam ultrices.</p>
      </div>
    </div>
  </a>
  
  <!-- four more links here -->
</div>

Initial CSS Styles

With the markup ready, we start defining some initial CSS styles, specifically:

Specify the outermost div as a flex container and set its height equal to the viewport height with height: 100vh;.
Set an equal width for all links (flex items). To achieve that, we give them each flex: 1. Additionally, all of our links will have a background image (sourced from unsplash.com) which covers the viewport height. As a fallback (in case an image isn’t available), we also specify a unique background color for each one.
When we hover over a link, its size becomes three times bigger relative to the size of the other links. We do this by changing the value of the flex property of the target link. Happily enough this property belongs to the animated CSS properties, so we’re able to generate a smooth transition effect (at least in most recent browsers).

Here’s part of the CSS code demonstrating what we’ve described above:

.flex-wrapper {
  display: flex;
  height: 100vh;
}

.flex-wrapper a {
  position: relative;
  flex: 1;
  background-size: cover;
  background-position: center;
  background-repeat: no-repeat;
  transition: flex .4s;
}

.flex-wrapper .one {
  background-image: url(IMAGE_PATH);
  background-color: red;
}

.flex-wrapper a:hover {
  flex: 3;
}

So far, if we preview the demo in a browser that supports flexbox, we’ll see this result:

Styling the Overlay

Our next step is to assign a few styles to the overlay. Here’s what we’ll do:

Give overlay the same dimensions as the parent link. We can achieve this behavior by positioning it absolutely (relative to the immediate parent) and then specifying zero values for all the offset properties.
Define the overlay as a flex container. This way, we’re able to center its direct child (i.e. .overlay-inner element) vertically and horizontally.
Add a semi-transparent grey background to the overlay when we hover over the parent link.

Here are the associated CSS styles:

.flex-wrapper .overlay {
  display: flex;
  align-items: center;
  justify-content: center;
  padding: 0 10px; 
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  transition: background-color .4s;
}

.flex-wrapper a:hover .overlay {
  background-color: rgba(0, 0, 0, .5);
}

Inner Overlay

Now, it’s time to style the inner parts of our overlay. By default these are hidden and should appear only when we hover over the corresponding parent link. But not immediately, we’ll reveal them after a small delay. This delay is important; if we don’t define it specifically, the transition effect will look a little bit ugly. Remove it and test the demo to understand what I mean.

So just to recap, first the link gets bigger, then the overlay elements become visible. Also, we use the translate3d() to create some slide in effects. Last but not least, we use the transform-style: preserve-3d hack (or a similar one) to prevent possible flickering effects across different browsers.

And here are the related CSS styles:

.flex-wrapper .overlay-inner * {
  visibility: hidden;
  opacity: 0;
  transform-style: preserve-3d;
}

.flex-wrapper .overlay h2 {
  transform: translate3d(0, -60px, 0);
}

.flex-wrapper .overlay p {
  transform: translate3d(0, 60px, 0);
}

.flex-wrapper a:hover .overlay-inner * {
  opacity: 1;
  visibility: visible;
  transform: none;
  transition: all .3s .3s;
}

Let’s see what that’s given us.

Going Responsive

The page looks great on large screens, but perhaps on small, or even on medium screens we’ll have to make a few adjustments. For example, here are a few things we can do:

Flip the main-axis of the flex container by adding flex-direction: column to it. In doing so the flex items will flow from top to bottom.
Cancel all the transition effects and show the overlay elements by default .

Our desktop-first media query looks as follows (I’ve used 800px only because that suits the embedded demos in this post–you can choose whatever you feel is best):

@media screen and (max-width: 800px) {
  .flex-wrapper {
    flex-direction: column;
  }
  
  .flex-wrapper a:hover {
    flex: 1;
  }
  
  .flex-wrapper a:hover .overlay {
    background-color: transparent;
  }
  
  .flex-wrapper .overlay h2,
  .flex-wrapper .overlay p {
    opacity: 1;
    visibility: visible;
    transform: none;
  }
}

Here’s the final appearance of our navigation:

Browser Support

The demo works in all recent browsers that support flexbox.

In some browsers you may notice that the animation of the flex property isn’t as smooth as it should be, or perhaps doesn’t work at all. For example, IE11 doesn’t animate this property, whereas Edge does. This is reasonable enough, considering the fact that flexbox is a new layout mode which is still gaining traction.

Conclusion

In this tutorial, we improved our flexbox knowledge by learning how to build a stylish navigation layout. Hopefully you enjoyed what we’ve built here and have taken some inspiration for your next projects!

If you build a similar layout, don’t forget to show us the approach (pure CSS or JavaScript-based solution) you used.

In the Wild

Before closing, I’d like to share with you a few sites which use a similar layout to what we’ve just created:

Building Your Startup: Exporting iCal Files into Calendar Events

How to Create a Football Text Effect in Adobe Illustrator

Monday, September 26, 2016

Master Color Correction With These Two Courses

Digital Drawing for Beginners: An Introduction to the Tools

15 Professional PowerPoint Templates - For Better Business Presentations

How to Recreate Apple TV’s Parallax Thumbnail Rollover Effect

An Introduction to the UserNotifications Framework

How to Draw a Classic Steam Locomotive From Scratch

Particles.js: Control Particle Count and Shape

How to Pick The Best Way to Print Your Photos

How to Design a Logo When You’re Short on Time!

Sunday, September 25, 2016

Home Mastering 101: Finishing the Master and Applying EQ

Creating a Realistic Teddy Bear in Maya—Part 2

Saturday, September 24, 2016

Home Mastering 101: Making Mixes Loud and Powerful

Friday, September 23, 2016

How Artists Make a Living With Patreon

The Best Online Accounting Software for Your Small Business

Google Play Services: Google Cast v3 and Media

Particles.js: Introduction

Photoshop in 60 Seconds: How to Create Flower Brushes

Photoshop in 60 Seconds: How to Create an Easy Sketch Effect

Learn Typography and Branding With These Graphic Design Courses

Thursday, September 22, 2016

How to Create a Presentation From a Google Slides Theme

Photoshop in 60 Seconds: How to Properly Fill a Drawn Outline

10 Creative Presentation Ideas: That Will Inspire Your Audience to Action

How to Set Up Basic Routing in Angular 2

How to Create a 3D Black and Gold Text and Logo Mockup

Exploring Devise, Part 1

In some of my previous articles about image uploading in Rails, I made mention of Devise but did not go deep into it. In this tutorial, I will be teaching you about Devise.

Ready? Let's get started!

Devise Introduction and Modules

Devise is an authentication solution for Rails built with Warden and provided by the awesome people at Plataformatec. Devise provides different modules:

Database Authenticatable: This encrypts and stores a password to the database to validate the authenticity of a user while signing in.
Omniauthable: This attaches OmniAuth support to Devise. Users of your application will be able to sign in using accounts such as Facebook, Twitter, and Google.
Confirmable: This enables the sending of emails with instructions that will help in the verification of an account.
Recoverable: This module helps in times when users forget their password and need to recover it. With this, the user will be able to reset the password.
Registerable: This handles the signup of users. It also allows users to edit and delete their accounts.
Rememberable: This module makes it possible for your application to remember a logged-in user by storing a cookie.
Trackable: This module helps track sign-in count, timestamps, and IP address.
Timeoutable: This module is responsible for expiring a session that has not been active for a period of time.
Validatable: With this module, email and password get to be validated.
Lockable: This provides an extra layer of security—when activated, an account can be locked after a given number of failed sign-in attempts.

Devise Integration

For the purpose of this tutorial, we are going to generate a Rails application that we'll use to check out the workings of Devise. Let's proceed!

rails new devise-app -T

The -T flag tells Rails to generate the application without the default test suite. Navigate to your application directory and drop the following gems into your Gemfile.

#Gemfile

gem 'devise', '~> 4.1'
gem 'bootstrap-sass', '~> 3.3'

Now install the Devise and Bootstrap gems you just added.

bundle install

Rename your app/assets/stylesheets/application.css file to app/assets/stylesheets/application.scss and add the following lines in it:

#app/assets/stylesheets/application.scss

@import "bootstrap-sprockets";
@import "bootstrap";

Open up the app/assets/javascripts/application.js file and require bootstrap-sprockets. Mine looks like this:

#app/assets/javascripts/application.js

//= require jquery
//= require bootstrap-sprockets
//= require jquery_ujs
//= require turbolinks
//= require_tree .

Next, you need to run the Rails command to install the configuration files for Devise. You do so by running this command:

rails generate devise:install

The command generates the following on your terminal. You should read it to understand what happened.

create  config/initializers/devise.rb
     create  config/locales/devise.en.yml
===============================================================================

Some setup you must do manually if you haven't yet:

 1. Ensure you have defined default url options in your environments files. Here
    is an example of default_url_options appropriate for a development environment
    in config/environments/development.rb:

      config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

    In production, :host should be set to the actual host of your application.

 2. Ensure you have defined root_url to *something* in your config/routes.rb.
    For example:

      root to: "home#index"

 3. Ensure you have flash messages in app/views/layouts/application.html.erb.
    For example:

      <p class="notice"><%= notice %></p>
      <p class="alert"><%= alert %></p>

 4. If you are deploying on Heroku with Rails 3.2 only, you may want to set:

      config.assets.initialize_on_precompile = false

    On config/application.rb forcing your application to not access the DB
    or load models when precompiling your assets.

 5. You can copy Devise views (for customization) to your app by running:

      rails g devise:views

      ===============================================================================

The command also generates two files, which you can find in the config directory. It also gives us some instructions on what we should do.

Navigate to your application layout, app/views/layouts/application.html.erb, and make it look like what I have below:

#app/views/layouts/application.html.erb

<!DOCTYPE html>
<html>
<head>
  <title>DeviseApp</title>
  <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track' => true %>
  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
  <%= csrf_meta_tags %>
</head>
<body>
  <div class="container-fluid">
    <p class="notice"><%= notice %></p>
    <p class="alert"><%= alert %></p>
  </div>

  <div class="container-fluid">
    <%= yield %>
  </div>

</body>
</html>

You need to define the default URL options for your development environment. Add the code below in config/environments/development.rb.

#config/environments/development.rb

config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }

Now you need to create a User model for Devise. You can do so using your terminal.

rails generate devise User

This will generate a user.rb file in your app/models directory. The file generated will look like this:

class User < ActiveRecord::Base
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable
end

You can see that it contains the default modules I mentioned above. The command you ran also modified your config/routes.rb file by adding a route for devise. You should check that out.

At this point, you need to migrate your database. You do so by running:

rake db:migrate

Authentication Using Devise

Now you need to create a PagesController and wrap Devise authentication around it—this will prevent unauthorized persons from seeing the page.

rails generate controller Pages index

Open up your routes file and set the root of your application.

#config/routes.rb

Rails.application.routes.draw do
  devise_for :users
  root to: "pages#index"
end

Open up your PagesController and add authentication for your index and new pages.

#app/controllers/pages_controller.rb

class PagesController < ApplicationController
  before_action :authenticate_user!, only: [:index, :new]

  def index
  end

  def new
  end
end

The code shows that the index and new pages are accessible only to registered users. Open up your terminal and start your rails server. Point your browser to http://localhost:3000 and you will automatically be redirected to the Devise sign-in page.

Signing in Without Using Email

The default means of signing into Devise involves the use of email address and password. What if you want to enable users to sign in with their unique username? If that is what you want, it is possible. Let's see how.

Run the command:

rails generate migration AddUsernameToUSers username:string

This will add a new column for username in your users table. Migrate your database.

rake db:migrate

You need to add a field to your views where your users can enter their username. When you go to your app/views directory, you will not find any file that renders the Devise views. This is because Devise loads the views from its gemset. To customize it, you have to generate copies of the views. The command below does the magic.

rails generate devise:views

This will generate some folders and files in your app/views directory.

You will need to edit the page for signing in, signing up, and updating user information. Just paste the blocks of code below into their respective files.

Sign-Up

#app/views/devise/registrations/new.html.erb

<h2>Sign up</h2>

<%= form_for(resource, as: resource_name, url: registration_path(resource_name)) do |f| %>
  <%= devise_error_messages! %>

  <div class="form-group">
    <%= f.label :email %><br />
    <%= f.email_field :email, autofocus: true, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :username %>
    <%= f.text_field :username, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :password %>
    <% if @minimum_password_length %>
    <em>(<%= @minimum_password_length %> characters minimum)</em>
    <% end %><br />
    <%= f.password_field :password, autocomplete: "off", class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :password_confirmation %><br />
    <%= f.password_field :password_confirmation, autocomplete: "off", class: "form-control" %>
  </div>

  <div class="actions">
    <%= f.submit "Sign up", class: "btn btn-primary" %>
  </div>
<% end %>

<%= render "devise/shared/links" %>

Edit

#app/views/devise/registrations/edit.html.erb

<h2>Edit <%= resource_name.to_s.humanize %></h2>

<%= form_for(resource, as: resource_name, url: registration_path(resource_name), html: { method: :put }) do |f| %>
  <%= devise_error_messages! %>

  <div class="form-group">
    <%= f.label :email %><br />
    <%= f.email_field :email, autofocus: true, class: "form-control" %>
  </div>

  <% if devise_mapping.confirmable? && resource.pending_reconfirmation? %>
    <div>Currently waiting confirmation for: <%= resource.unconfirmed_email %></div>
  <% end %>

  <div class="form-group">
    <%= f.label :username %>
    <%= f.text_field :username, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :password %> <i>(leave blank if you don't want to change it)</i><br />
    <%= f.password_field :password, autocomplete: "off", class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :password_confirmation %><br />
    <%= f.password_field :password_confirmation, autocomplete: "off", class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :current_password %> <i>(we need your current password to confirm your changes)</i><br />
    <%= f.password_field :current_password, autocomplete: "off", class: "form-control" %>
  </div>

  <div class="actions">
    <%= f.submit "Update", class: "btn btn-primary" %>
  </div>
<% end %>

<h3>Cancel my account</h3>

<p>Unhappy? <%= button_to "Cancel my account", registration_path(resource_name), data: { confirm: "Are you sure?" }, method: :delete %></p>

<%= link_to "Back", :back %>

Sign-In

#app/views/devise/sessions/new.html.erb

<h2>Log in</h2>

<%= form_for(resource, as: resource_name, url: session_path(resource_name)) do |f| %>
  <div class="form-group">
    <%= f.label :username %><br />
    <%= f.text_field :username, autofocus: true, class: "form-control" %>
  </div>

  <div class="form-group">
    <%= f.label :password %><br />
    <%= f.password_field :password, autocomplete: "off", class: "form-control" %>
  </div>

  <% if devise_mapping.rememberable? -%>
    <div class="form-group">
      <%= f.check_box :remember_me %>
      <%= f.label :remember_me %>
    </div>
  <% end -%>

  <div class="actions">
    <%= f.submit "Log in", class: "btn btn-primary" %>
  </div>
<% end %>

<%= render "devise/shared/links" %>

Using your text editor, navigate to app/controllers/application_controller.rb. You need to modify it to permit the use of username. Modify it to look like this:

#app/controllers/application_controller.rb

class ApplicationController < ActionController::Base
  # Prevent CSRF attacks by raising an exception.
  # For APIs, you may want to use :null_session instead.
  protect_from_forgery with: :exception

  before_action :configure_permitted_parameters, if: :devise_controller?

  protected

  def configure_permitted_parameters
    added_attrs = [:username, :email, :password, :password_confirmation, :remember_me]
    devise_parameter_sanitizer.permit :sign_up, keys: added_attrs
    devise_parameter_sanitizer.permit :account_update, keys: added_attrs
  end
end

Now a user can sign in with his/her username. At this point there is something not right about your application. When a user signs in, there is no way of signing out. This does not result in a great user experience. I'll show you how to fix that.

From your terminal, create a new directory called shared in your app/views folder.

mkdir app/views/shared
touch app/views/shared/_navigation.html.erb

The file you created above is a partial where the code for your navigation bar will be written. Drop in the following code.

#app/views/shared/_navigation.html.erb

<nav class="navbar navbar-inverse">
  <div class="container">
    <div class="navbar-header">
      <%= link_to 'Tutsplus Devise', root_path, class: 'navbar-brand' %>
    </div>
    <div id="navbar">
      <ul class="nav navbar-nav">
        <li><%= link_to 'Home', root_path %></li>
      </ul>
      <ul class="nav navbar-nav pull-right">
        <% if user_signed_in? %>
          <li class="dropdown">
            <a class="dropdown-toggle" data-toggle="dropdown" href="#">
              <%= current_user.name %>
              <span class="caret"></span>
            </a>
            <ul class="dropdown-menu" role="menu">
              <li><%= link_to 'Profile', edit_user_registration_path %></li>
              <li><%= link_to 'Log out', destroy_user_session_path, method: :delete %></li>
            </ul>
          </li>
        <% else %>
          <li><%= link_to 'Log In', new_user_session_path %></li>
          <li><%= link_to 'Sign Up', new_user_registration_path %></li>
        <% end %>
      </ul>
    </div>
  </div>
</nav>

Now you need to render the navigation bar in your application layout. Open up app/views/layouts/application.html.erb and drop in the code to render your navigation bar.

#app/views/layouts/application.html.erb

...
<div class="container-fluid">
  <%= render "shared/navigation" %>

  <p class="notice"><%= notice %></p>
  <p class="alert"><%= alert %></p>
</div>
...

Conclusion

In this part you learned how to install Devise and add authentication to your pages. I also made mention of a partial. I will cover that in a separate tutorial.

In the next part, we will cover some areas more advanced than this. I hope this was worth your time!

Creating Custom WordPress Administration Pages, Part 3

CSS Grid Layout: Fluid Columns and Better Gutters

In this tutorial we’re going to take the grid from our previous tutorial and use it as a playground to explore different units of measurement and Grid’s properties.

Flexible Units

The whole point of Grid is to enable us to properly control layout on the web, so let’s make our static grid fluid before we go any further. If you recall, we were defining our grid with static pixel measurements:

grid-template-columns: 150px 20px 150px 20px 150px;
grid-template-rows: auto 20px auto 20px auto;

It’s quite possible to use other units here too, such as ems, or rems for example. Or even more unusual units like vh and vmin.

In this case we’re going to change our pixel units for percentages. As we’re defining our column widths and our gutter widths manually we have to make sure the total values equal 100%:

grid-template-columns: 30% 5% 30% 5% 30%;

Mind the Gap

There does exist a newer, more efficient way to declare gutter measurements, and that’s with a purpose-made property. We can use grid-column-gap and grid-row-gap, or the shorthand grid-gap property instead.

Using this means we no longer need to include grid tracks to accommodate our gutters, we only need to declare the columns and rows, so in our case that means three of each:

  grid-template-columns: 33.33% 33.33% 33.33%;
  grid-template-rows: auto auto auto;

Hmm, that’s a bit messy, but it sort of does the job. The difference you’ll notice is that the column widths now add up to 100%; our gutters will actually be subtracted from them automatically.

Repeat

Let’s write this is a neater way, using the repeat() function:

grid-template-columns: repeat(3, 33.33%);

This states “repeat 33.33% three times” giving us three columns. And we don’t even need the grid-template-rows declaration because the auto value is assigned as default anyway. Now we just need to state how big we want our gutters:

  grid-template-columns: repeat(3, 33.33%);
  grid-gap: 20px;

grid-gap will accept fixed or flexible units, which means we can perfectly combine fluid columns and fixed gutters without any complex calculations on our part.

Resetting Our `grid-column` and `grid-row` Values

Something is amiss: we still have a load of grid-column and grid-row declarations on our grid items, but they’re all wrong because we no longer have as many grid tracks. Happily, because we’re using grid-gap to define our gutters, we can leave positioning of the items to automatic placement–items will no longer fall into the gutters. For now, remove all the positioning:

The fr Unit

One final improvement can be made to our simple grid; we’re going to introduce the fr, or fraction unit. A single fr unit describes “one piece of however many pieces we’re splitting this into”. For example, we could declare our columns using:

  grid-template-columns: 1fr 1fr 1fr;

Here there’s a total of three fr units, so each column would be one third wide. Here’s another example:

  grid-template-columns: 2fr 1fr 1fr

Now there’s a total of four fr units, so the first column would take up half the available width, with the other two columns each taking a quarter.

These units are really powerful, especially in combination with other units of measurement:

grid-template-columns: 300px 1fr 3fr 20%;

Here we’ve declared four columns:

the first is fixed at 300px wide
the last is a flexible 20% of the grid container element wide
then the fr units are calculated, leaving the second column with one piece of the remaining space
and the third with three pieces.

It looks like this, perfectly highlighting auto-placement as our nine items shift to fill the gaps:

But back to our original grid. Let’s replace the clumsy and inaccurate 33.33% value with 1fr:

  grid-template-columns: repeat(3, 1fr);

Finished pen:

Conclusion

So, to recap:

Grid will accept flexible units in combination with fixed units of measurements.
We needn’t declare gutters within our grid-template, we can use the grid-gap properties instead.
grid-gap means we are less bound to positioning our grid items–we can hand more responsibility over to auto-placement.
The repeat() function will save us time and keep our stylesheets maintainable.
The fr, or fraction unit is a very powerful way of describing grid templates.

We’ve come a long way in just two tutorials, but you’re now the proud owner of a very neat and concise grid! In the next tutorial we’ll explore grid areas, taking a look at the span keyword and some practical layouts.

Useful Resources

The <fraction> type and fr unit on W3C
Again, follow @rachelandrew

How to Create a Set of Retro Media Icons in Affinity Designer