8 Tips for Creating a Killer Infographic

Infographics are the new phenomenon on the internet which presents the technical things in very artistic manner. This is relatively new than other informative means, but they are on the rage. According to the Hubspot, the number of time infographics has been searched on the Google has increased...

[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]

by DIW via Digital Information World

Flow, a typeface built for wirefram

Flow is a typeface built for wireframing. The font comes in three weights – circular, rounded and block. Pay what you want.

by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery

UI/UX Designer&Front-end Developer

Currently full-time Senior UI/UX Designer & Front-end Developer at Danat FZ LLC. I love building UI/UX design experiences that improve user’s everyday life + I convert the design into responsive HTML5/CSS3 that I call PSD to HTML Development

by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery

Alts solution

webd esign company in kerala

by csreladm via CSSREEL | CSS Website Awards | World best websites | website design awards | CSS Gallery

Instant Form Validation Using JavaScript

HTML5 introduces a couple of new attributes for implementing browser-based form validation. The pattern attribute is a regular-expression that defines the range of valid inputs for textarea elements and most types of input. The required attribute specifies whether a field is required. For legacy browsers that don't implement these attributes, we can use their values as the basis of a polyfill. We can also use them to provide a more interesting enhancement - instant form validation.

We have to be very careful here not to get carried away, creating overly aggressive validation that breaks the natural browsing behavior and gets in people's way. For example, I've seen forms where it's impossible to Tab away from an invalid field - JavaScript is used (or rather abused) to force the focus to stay inside the field until it's valid. This is very poor usability, and directly contravenes accessibility guidelines.

What we're going to do in this article is far less intrusive. It's not even full client-side validation - it's just a subtle usability enhancement, implemented in an accessible way, which (as I discovered while testing the script) is almost identical to something that Firefox now does natively!

The Basic Concept

In recent versions of Firefox, if a required field is empty or its value doesn't match the pattern then the field will show a red outline, as illustrated by the following figure.

This doesn't happen straight away of course. If it did, then every required field would have that outline by default. Instead, these outlines are only shown after you've interacted with the field, which is basically (though not precisely) analogous to the onchange event.

So that's what we're going to do, using onchange as the triggering event. As an alternative, we could use the oninput event, which fires as soon as any value is typed or pasted into the field. But this is really too instant, as it could easily be triggered on and off many types in rapid succession while typing, creating a flashing effect which would be annoying or impossibly distracting for some users. And, in any case, oninput doesn't fire from programmatic input, which onchange does, and we might need that to handle things like auto-complete from third-party add-ons.

Defining the HTML and CSS

So let's have a look at our implementation, starting with the HTML it's based on:

<form action="#" method="post">
  <fieldset>

    <legend><strong>Add your comment</strong></legend>

    <p>
      <label for="author">Name <abbr title="Required">*</abbr></label>
      <input 
        aria-required="true"
        id="author"
        name="author"
        pattern="^([- \w\d\u00c0-\u024f]+)$"
        required="required"
        size="20"
        spellcheck="false"
        title="Your name (no special characters, diacritics are okay)"
        type="text"
        value="">
    </p>

    <p>
      <label for="email">Email <abbr title="Required">*</abbr></label>
      <input 
        aria-required="true"
        id="email"
        name="email"
        pattern="^(([-\w\d]+)(\.[-\w\d]+)*@([-\w\d]+)(\.[-\w\d]+)*(\.([a-zA-Z]{2,5}|[\d]{1,3})){1,2})$" 
        required="required"
        size="30"
        spellcheck="false"
        title="Your email address"
        type="email"
        value="">
    </p>

    <p>
      <label for="website">Website</label>
      <input
        id="website"
        name="website"
        pattern="^(http[s]?:\/\/)?([-\w\d]+)(\.[-\w\d]+)*(\.([a-zA-Z]{2,5}|[\d]{1,3})){1,2}(\/([-~%\.\(\)\w\d]*\/*)*(#[-\w\d]+)?)?$"
        size="30"
        spellcheck="false"
        title="Your website address"
        type="url"
        value="">
    </p>

    <p>
      <label for="text">Comment <abbr title="Required">*</abbr></label> 
      <textarea
        aria-required="true"
        cols="40"
        id="text"
        name="text"
        required="required"
        rows="10"
        spellcheck="true"
        title="Your comment"></textarea>
    </p>

  </fieldset>
  <fieldset>

    <button name="preview" type="submit">Preview</button>
    <button name="save" type="submit">Submit Comment</button>

  </fieldset>
</form>

Continue reading %Instant Form Validation Using JavaScript%

by James Edwards via SitePoint

Fine Uploader – Javascript Upload Library

Fine Uploader is a multiple file upload plugin with image previews, drag and drop, progress bars. S3 and Azure support, image scaling, form support, chunking, resume, pause, and tons of other features.

by via jQuery-Plugins.net RSS Feed

GreenSock for Beginners (Part 2): GSAP’s Timeline

The aim of this second part of GreenSock for Beginners is to introduce you to GreenSock's TimelineMax. You'll be learning:

• Why you need a timeline
• How to include multiple tweens in a timeline
• How to package multiple timelines into functions and nest them inside a master timeline for greater flexibility.

By the end of this tutorial, you'll be comfortable working with GreenSock's timeline to manipulate and fully control multiple tweens.

For an introduction to the basics of GreenSock, including how to work with TweenMax for sequencing and staggering simple animations, head over to part 1 of this multi-part article.

The GreenSock articles are part of the series Beyond CSS: Dynamic DOM Animation Libraries. Here's what I covered in the past instalments:

• Animating the DOM with Anime.js touches on how to make the best use of animation on the web and when you could consider using a JavaScript animation library instead of CSS-only animation. It then focuses on Anime.js, a free and lightweight JavaScript animation library
• Fun Animation Effects with KUTE.js introduces you to KUTE.js, a free and feature-rich JavaScript animation library
• Make Your Website Interactive and Fun with Velocity.js (No jQuery) shows you how to use Velocity.js, an open source, robust free animation library, to create performant web animations
• GreenSock for Beginners: a Web Animation Tutorial (Part 1) is an overview of GreenSock, also known as GSAP (GreenSock Animation Platform), where I discuss the library's modules and licensing model. I also show you how to code a simple tween, sequences of tweens, and staggering animations using GSAP TweenMax.

Why Would You Need GreenSock's Timeline to Code Your Web Animations?

In Part 1, you learned how to add different animations to an element or multiple elements by creating a number of independent tweens and coordinating their timings with each tween's delay property.

By default, stacking one tween after another results in all tweens happening at once.

What would be more helpful, however, is to be able to control when a tween is going to happen with respect to other tweens, e.g., at the same time, 1 second or half a second before or after, etc.

Take this basic example with just two tweens. Here's what happens:

• Tween 1: a circle shape grows and shrinks as it rotates on its X and Y axes
• Tween 2: some text pops up.

The GSAP snippet that makes it work looks like this:

[code language="js"]
// scale down the text
// and hide it before the animation begins
TweenMax.set('.example__title', {
scale: 0.2,
autoAlpha: 0
});

// scale the circle shape down before
// the animation begins
TweenMax.set('.example__ball', {
scale: 0.2
});

// tween 1
TweenMax.to('.example__ball', 0.5, {
rotationX: 360,
rotationY: 180,
scale: 1,
ease: Elastic.easeIn.config(2, 1)
});

// tween 2
TweenMax.to('.example__title', 0.5, {
autoAlpha: 1,
scale: 1,
ease: Back.easeOut.config(4)
});
[/code]

As you can see, both tweens happen at the same time, which is not the desired effect:

See the Pen GSAP Tutorial Part 2: Why the Timeline by SitePoint (@SitePoint) on CodePen.

If you want the text to appear just when the shape is about to stop rotating, you'll need to add an appropriate delay to tween2, like this:

[code language="js"]
// tween 2
TweenMax.to('.example__title', 0.5, {
// rest of the code here
delay: 0.6
});
[/code]

See the Pen GSAP Tutorial Part 2: Managing Sequences with Delay by SitePoint (@SitePoint) on CodePen.

This works, but imagine you want to change the duration of the first tween, or the number of times it repeats. You'll soon realize that the second tween doesn't automatically wait for the first one to come to a close before starting. Therefore, you'll need to adjust the delay's value on the second tween. With just two tweens and such a simple animation this won't be much of a problem. Not so when your animations are more ambitious and the number of tweens grows.

That's when you'll be super happy to know that GSAP has you covered with its robust and flexible TimelineLite and TimelineMax, both included in TweenMax.

Coordinating Multiple Tweens with GSAP's Timeline

Continue reading %GreenSock for Beginners (Part 2): GSAP’s Timeline%

by Maria Antonietta Perna via SitePoint