Book Image

LESS WEB DEVELOPMENT COOKBOOK

Book Image

LESS WEB DEVELOPMENT COOKBOOK

Overview of this book

Related Content you might be interested in

Current Title:

Small book image
LESS WEB DEVELOPMENT COOKBOOK
Jan, 2015 | 394 pages
No titles found
Table of Contents (19 chapters)
Less Web Development Cookbook
Less Web Development Cookbook
Credits
Credits
Foreword
Foreword
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Getting to Grips with the Basics of Less
Getting to Grips with the Basics of Less
Introduction
Downloading, installing, and integrating less.js
Installing the lessc compiler with npm
Using less.js with Rhino
Declaring variables with Less for commonly used values
Setting the properties of CSS styles with mixins
Writing more intuitive code and making inheritance clear with nested rules
Creating complex relationships between properties
Using the built-in functions of Less
Using namespaces to make your code reusable and portable
2
Debugging and Documenting Your Less Code
Debugging and Documenting Your Less Code
Introduction
Debugging your code with less.js
Using CSS source maps to debug your code
Using Chrome Developer Tools to debug your code
Commenting your code in Less
Building style guides with tdcss.js
Building style guides with StyleDocco
3
Using Variables and Mixins
Using Variables and Mixins
Introduction
Deriving a set of variables from a single base variable
Value escaping with the ~"value" syntax
Using variable interpolation
Redeclaring variables based on lazy loading
Using mixins to set properties
Declaring a class and mixin at once
Using selectors inside mixins
Using parametric mixins
4
Leveraging the Less Built-in Functions
Leveraging the Less Built-in Functions
Introduction
Converting units with the convert() function
Using the default() function
Embedding images with data URIs
Formatting strings
Replacing a text within a string
Working with lists
Using mathematical functions
Using the color() function
Evaluating the type of a value
Creating color objects with RGB values
Getting information about a color
Creating a color variant with the darken() and lighten() functions
Creating overlays of two colors with Less
5
Extending and Referencing
Extending and Referencing
Introduction
Referencing parent selectors with the & operator
Referencing to the parent selector more than once
Changing the selecting order with the & operator
Using extend to merge selectors
Using extend inside a ruleset
Extending with the all keyword
Extending with media queries
Using extend to reduce the compiled CSS size
Using extend as an alternative for a mixin
6
Advanced Less Coding
Advanced Less Coding
Introduction
Giving your rules importance with the !important statement
Using mixins with multiple parameters
Using duplicate mixin names
Building a switch to leverage argument matching
Avoiding individual parameters to leverage the @arguments variable
Using the @rest... variable to use mixins with a variable number of arguments
Using mixins as functions
Passing rulesets to mixins
Using mixin guards (as an alternative for the if…else statements)
Building loops leveraging mixin guards
Applying guards to the CSS selectors
Creating color contrasts with Less
Changing the background color dynamically
Aggregating values under a single property
7
Leveraging Libraries with Prebuilt Mixins
Leveraging Libraries with Prebuilt Mixins
Introduction
Importing and downloading prebuilt mixin libraries
Using namespacing with prebuilt libraries
Creating background gradients
Building unlimited gradients with Less Hat
Building a layout with the CSS3 flexbox module
Getting retina ready with Preboot
Generating font-face declarations with Clearless
Improving your website's SEO with 3L mixins
Leveraging sprite images with Pre
Creating bidirectional styling without code duplication
Creating animations with animations.css
Creating animations with More.less
Building semantic grids with semantic.gs
Building an alternative for fluid grids with Frameless
Building a fluid responsive grid system
8
Building a Layout with Less
Building a Layout with Less
Introduction
Using CSS Reset with Less
Importing and organizing your Less files
Importing files with the @import directive
Building a grid with grid classes
Creating responsive grids
Building a semantic grid with mixins
Applying the flexbox grid on your design
Integrating a navigation menu in the layout
Repositioning your content
9
Using Bootstrap with Less
Using Bootstrap with Less
Introduction
Downloading and installing Bootstrap
Customizing Bootstrap with variables
Making custom buttons
Making custom panels
Making custom navigation bars
Extending components using :extend
Reusing Bootstrap's grid
Using Bootstrap classes and mixins
Extending Bootstrap with your own mixins
Making custom color schemes with 1pxdeep
Autoprefixing Bootstrap's CSS
10
Less and WordPress
Less and WordPress
Introduction
Installing WordPress
Developing your WordPress theme with Less
Integrating Bootstrap into your WordPress theme
Using Semantic UI to theme your WordPress website
Customizing Roots.io with Less
Building a WordPress website with the JBST theme
11
Compiling Less Real Time for Development Using Grunt
Compiling Less Real Time for Development Using Grunt
Introduction
Installing Node and Grunt
Installing Grunt plugins
Utilizing the Gruntfile.js file
Loading Grunt tasks
Adding a configuration definition for a plugin
Adding the Less compiler task
Creating CSS source maps with the Less compiler task
Cleaning and minimizing your code
Adding the watch task
Adding the connect and open task
Adding the concurrent task
Analyzing your code with CSS Lint
Removing unused CSS using Grunt
Compiling style guides with Grunt
Automatically prefix your code with Grunt
Installing the Grunt LiveReload plugin
Index
Index

Creating complex relationships between properties

Less supports basic arithmetic operations. These operations, such as division (/), can be applied to any number, variable, or even color. They can be used to create complex relationships between properties.

Getting ready

You will first need to create a Less file named project.less and a valid HTML5 document named index.html. You should make sure the head section of the index.html file contains the following lines of code:

  <link rel="stylesheet/less" type="text/css" href="project.less">
  <script src="less.js" type="text/javascript"></script>

How to do it…

  1. First create an HTML structure in the index.html file as follows:

    <div class="container">
  <section role="main">Content</section>
  <aside role="complementary">Side bar</aside>
</div>

  2. To set the width of the content and sidebar dependent on the width of the container, you can use the following Less code:

    @basic-width: 800px;

.container {
  width: @basic-width;

  section {
    width: @basic-width * 2/3;
    background-color:red;
    color:white;
    float:left;
  }
  aside {
    width: @basic-width * 1/3;
    background-color: black;
    color: white;
    float: right;
  }

}

  3. Now you can open the index.html file in your browser, which will look like the following screenshot:

Note

Note that browsers can use different algorithms to round the pixel values when you assign them with decimal numbers. This phenomenon has also been described as Sub-Pixel problems in CSS. You can read more about these sub-pixel problems in CSS at http://ejohn.org/blog/sub-pixel-problems-in-css/.

How it works…

In Less, you can operate numbers, variables, and colors. The compiler understands colors and units. Take a look at the following Less code:

@width: 50px;
@color: yellow;
p {
  width: @width * 50; 
  color: @color + #111;
}

This will actually compile into the following CSS code:

p { 
  width: 2500px; 
  color: #ffff11; 
}

The Less compiler accepts different types of color definitions. In Less, you can use the hexadecimal notation for red, green, and blue (RGB) values, the RGB functional notation, or one of the 148 color names defined in CSS3. A complete overview of the color definition can be found at http://www.w3.org/TR/css3-color/ and http://lesscss.org/functions/#color-definition. When applying a basic operation on two or more colors, the compiler gives the result as a color even when different types of color definitions are used. As you can see, yellow + #111 compiles into #ffff11.

When multiplying 50px fifty times, the compiler automatically adds the px unit after the calculated result.

There's more…

In this recipe, you learned about some basic operations on colors. Less also has many built-in functions to define and manipulate colors. You can read more about Less's built-in color functions in Chapter 4, Leveraging the Less Built-in Functions.

See also

Previous Section
End of Section 9
Next Section