HTML5 and CSS3 All-in-One For Dummies, 3rd Edition

Table of contents

1. 1. Introduction
      1. About This Book
      2. Foolish Assumptions
      3. Use Any Computer
      4. Don't Buy Any Software
      5. How This Book Is Organized
      6. New for the Third Edition
      7. Icons Used in This Book
      8. Beyond the Book
      9. Where to Go from Here
   2. Book I: Creating the HTML Foundation
      1. Chapter 1: Sound HTML Foundations
         1. Creating a Basic Page
         2. Understanding the HTML in the Basic Page
         3. Meeting Your New Friends, the Tags
         4. Setting Up Your System
            1. Displaying file extensions
            2. Setting up your software
      2. Chapter 2: It's All About Validation
         1. Somebody Stop the HTML Madness!
            1. XHTML had some great ideas
         2. Validating Your Page
            1. Aesop visits W3C
         3. Using Tidy to repair pages
      3. Chapter 3: Choosing Your Tools
         1. What's Wrong with the Big Boys: Expression Web and Adobe Dreamweaver
         2. How About Online Site Builders?
         3. Alternative Web Development Tools
         4. Picking a Text Editor
            1. Tools to avoid unless you have nothing else
            2. Suggested programmer's editors
            3. My personal choice: Komodo Edit
            4. Other text editors
            5. The bottom line on editors
         5. Finding a Good Web Developer's Browser
            1. A little ancient history
            2. Overview of the prominent browsers
            3. Other notable browsers
            4. The bottom line in browsers
      4. Chapter 4: Managing Information with Lists and Tables
         1. Making a List and Checking It Twice
            1. Creating an unordered list
            2. Creating ordered lists
            3. Making nested lists
            4. Building the definition list
         2. Building Tables
            1. Defining the table
            2. Spanning rows and columns
            3. Avoiding the table-based layout trap
      5. Chapter 5: Making Connections with Links
         1. Making Your Text Hyper
            1. Introducing the anchor tag
            2. Comparing block-level and inline elements
            3. Analyzing an anchor
            4. Introducing URLs
         2. Making Lists of Links
         3. Working with Absolute and Relative References
            1. Understanding absolute references
            2. Introducing relative references
      6. Chapter 6: Adding Images, Sound, and Video
         1. Adding Images to Your Pages
            1. Linking to an image
            2. Adding inline images using the <img> tag
            3. src (source)
            4. height and width
            5. alt (alternate text)
         2. Choosing an Image Manipulation Tool
            1. An image is worth 3.4 million words
            2. Introducing IrfanView
         3. Choosing an Image Format
            1. BMP
            2. JPG/JPEG
            3. GIF
            4. PNG
            5. SVG
            6. Summary of web image formats
         4. Manipulating Your Images
            1. Changing formats in IrfanView
            2. Resizing your images
            3. Enhancing image colors
            4. Using built-in effects
            5. Other effects you can use
            6. Batch processing
         5. Working with Audio
            1. Adding Video
      7. Chapter 7: Creating Forms
         1. You Have Great Form
            1. Forms must have some form
         2. Building Text-Style Inputs
         3. Making a standard text field
         4. Building a password field
            1. Making multi-line text input
         5. Creating Multiple Selection Elements
            1. Making selections
            2. Building check boxes
            3. Creating radio buttons
         6. Pressing Your Buttons
            1. Making input-style buttons
            2. Building a Submit button
            3. It's a do-over: The Reset button
            4. Introducing the <button> tag
         7. New Form Input Types
            1. date
            2. time
            3. datetime
            4. datetime-local
            5. week
            6. month
            7. color
            8. number
            9. range
            10. search
            11. email
            12. tel
            13. url
   3. Book II: Styling with CSS
      1. Chapter 1: Coloring Your World
         1. Now You Have an Element of Style
            1. Setting up a style sheet
            2. Changing the colors
         2. Specifying Colors in CSS
            1. Using color names
            2. Putting a hex on your colors
            3. Coloring by number
            4. Hex education
            5. Using the web-safe color palette
         3. Choosing Your Colors
            1. Starting with web-safe colors
            2. Modifying your colors
            3. Doing it on your own pages
            4. Changing CSS on the fly
         4. Creating Your Own Color Scheme
            1. Understanding hue, saturation, and lightness
            2. Using HSL colors in your pages
            3. Using the Color Scheme Designer
            4. Selecting a base hue
            5. Picking a color scheme
      2. Chapter 2: Styling Text
         1. Setting the Font Family
            1. Applying the font-family style attribute
            2. Using generic fonts
            3. Making a list of fonts
         2. The Curse of Web-Based Fonts
            1. Understanding the problem
            2. Using embedded fonts
            3. Using images for headlines
         3. Specifying the Font Size
            1. Size is only a suggestion!
            2. Using the font-size style attribute
            3. Absolute measurement units
         4. Relative measurement units
         5. Determining Other Font Characteristics
            1. Using font-style for italics
            2. Using font-weight for bold
            3. Using text-decoration
            4. Using text-align for basic alignment
            5. Other text attributes
            6. Using the font shortcut
            7. Working with subscripts and superscripts
      3. Chapter 3: Selectors: Coding with Class and Style
         1. Selecting Particular Segments
            1. Defining more than one kind of paragraph
            2. Styling identified paragraphs
         2. Using Emphasis and Strong Emphasis
         3. Modifying the Display of em and strong
         4. Defining Classes
            1. Adding classes to the page
            2. Using classes
            3. Combining classes
         5. Introducing div and span
            1. Organizing the page by meaning
            2. Why not make a table?
         6. Using Pseudo-Classes to Style Links
            1. Styling a standard link
            2. Styling the link states
            3. Best link practices
         7. Selecting in Context
         8. Defining Styles for Multiple Elements
         9. Using New CSS3 Selectors
            1. Attribute selection
            2. not
            3. nth-child
            4. Other new pseudo-classes
      4. Chapter 4: Borders and Backgrounds
         1. Joining the Border Patrol
            1. Using the border attributes
            2. Defining border styles
            3. Using the border shortcut
            4. Creating partial borders
         2. Introducing the Box Model
            1. Border, margin, and padding
            2. Positioning elements with margins and padding
         3. New CSS3 Border Techniques
            1. Image borders
            2. Adding Rounded Corners
            3. Adding a box shadow
         4. Changing the Background Image
            1. Getting a background check
            2. Solutions to the background conundrum
         5. Manipulating Background Images
            1. Turning off the repeat
            2. Using CSS3 Gradients
         6. Using Images in Lists
      5. Chapter 5: Levels of CSS
         1. Managing Levels of Style
            1. Using local styles
            2. Using an external style sheet
         2. Understanding the Cascading Part of Cascading Style Sheets
            1. Inheriting styles
            2. Hierarchy of styles
            3. Overriding styles
            4. Precedence of style definitions
         3. Managing Browser Incompatibility
            1. Coping with incompatibility
            2. Making Internet Explorer–specific code
            3. Using a conditional comment with CSS
            4. Checking the Internet Explorer version
            5. Using a CSS reset
      6. Chapter 6: CSS Special Effects
         1. Image Effects
            1. Transparency
            2. Reflections
         2. Text Effects
            1. Text stroke
            2. Text-shadow
         3. Transformations and Transitions
            1. Transformations
            2. Three-dimensional transformations
            3. Transition animation
            4. Animations
   4. Book III: Building Layouts with CSS
      1. Chapter 1: Fun with the Fabulous Float
         1. Avoiding Old-School Layout Pitfalls
            1. Problems with frames
            2. Problems with tables
            3. Problems with huge images
            4. Problems with Flash
         2. Introducing the Floating Layout Mechanism
            1. Using float with images
            2. Adding the float property
         3. Using Float with Block-Level Elements
            1. Floating a paragraph
            2. Adjusting the width
            3. Setting the next margin
         4. Using Float to Style Forms
            1. Using float to beautify the form
            2. Adjusting the fieldset width
            3. Using the clear attribute to control page layout
      2. Chapter 2: Building Floating Page Layouts
         1. Creating a Basic Two-Column Design
            1. Designing the page
            2. Building the HTML
            3. Using temporary background colors
            4. Setting up the floating columns
            5. Tuning up the borders
            6. Advantages of a fluid layout
            7. Using semantic tags
         2. Building a Three-Column Design
            1. Styling the three-column page
            2. Problems with the floating layout
            3. Specifying a min-height
            4. Using height and overflow
         3. Building a Fixed-Width Layout
            1. Setting up the HTML
            2. Fixing the width with CSS
         4. Building a Centered Fixed-Width Layout
            1. Making a surrogate body with an all div
            2. How the jello layout works
            3. Limitations of the jello layout
      3. Chapter 3: Styling Lists and Menus
         1. Revisiting List Styles
            1. Defining navigation as a list of links
            2. Turning links into buttons
            3. Building horizontal lists
         2. Creating Dynamic Lists
            1. Building a nested list
            2. Hiding the inner lists
            3. Getting the inner lists to appear on cue
         3. Building a Basic Menu System
            1. Building a vertical menu with CSS
            2. Building a horizontal menu
      4. Chapter 4: Using Alternative Positioning
         1. Working with Absolute Positioning
            1. Setting up the HTML
            2. Adding position guidelines
            3. Making absolute positioning work
         2. Managing z-index
            1. Handling depth
            2. Working with z-index
         3. Building a Page Layout with Absolute Positioning
            1. Overview of absolute layout
            2. Writing the HTML
            3. Adding the CSS
         4. Creating a More Flexible Layout
            1. Designing with percentages
            2. Building the layout
         5. Exploring Other Types of Positioning
            1. Creating a fixed menu system
            2. Setting up the HTML
            3. Setting the CSS values
         6. Flexible Box Layout Model
            1. Creating a flexible box layout
            2. Viewing a flexible box layout
            3. … And now for a little reality
         7. Determining Your Layout Scheme
   5. Book IV: Client-Side Programming with JavaScript
      1. Chapter 1: Getting Started with JavaScript
         1. Working in JavaScript
            1. Choosing a JavaScript editor
            2. Picking your test browser
         2. Writing Your First JavaScript Program
            1. Embedding your JavaScript code
            2. Creating comments
            3. Using the alert() method for output
            4. Adding the semicolon
         3. Introducing Variables
            1. Creating a variable for data storage
            2. Asking the user for information
            3. Responding to the user
         4. Using Concatenation to Build Better Greetings
            1. Comparing literals and variables
            2. Including spaces in your concatenated phrases
         5. Understanding the String Object
            1. Introducing object-based programming (and cows)
            2. Investigating the length of a string
            3. Using string methods to manipulate text
         6. Understanding Variable Types
            1. Adding numbers
            2. Adding the user's numbers
            3. The trouble with dynamic data
            4. The pesky plus sign
         7. Changing Variables to the Desired Type
            1. Using variable conversion tools
            2. Fixing the addInput code
      2. Chapter 2: Talking to the Page
         1. Understanding the Document Object Model
            1. Previewing the DOM
            2. Getting the blues, JavaScript-style
            3. Writing JavaScript code to change colors
         2. Managing Button Events
            1. Adding a function for more … functionality
            2. Making a more flexible function
            3. Embedding quotes within quotes
            4. Writing the changeColor function
         3. Managing Text Input and Output
            1. Introducing event-driven programming
            2. Creating the HTML form
            3. Using getElementById to get access to the page
            4. Manipulating the text fields
         4. Writing to the Document
            1. Preparing the HTML framework
            2. Writing the JavaScript
            3. Finding your innerHTML
         5. Working with Other Text Elements
            1. Building the form
            2. Writing the function
            3. Understanding generated source
            4. What if you're not in Chrome?
      3. Chapter 3: Decisions and Debugging
         1. Making Choices with if
            1. Changing the greeting with if
            2. The different flavors of if
            3. Conditional operators
            4. Nesting your if statements
            5. Making decisions with switch
         2. Managing Repetition with for Loops
            1. Setting up the web page
            2. Initializing the output
            3. Creating the basic for loop
            4. Introducing shortcut operators
            5. Counting backwards
            6. Counting by fives
            7. Understanding the Zen of for loops
         3. Building while Loops
            1. Making a basic while loop
            2. Getting your loops to behave
            3. Managing more complex loops
         4. Managing Errors with a Debugger
            1. Debugging with the interactive console
            2. Debugging strategies
            3. Resolving syntax errors
            4. Squashing logic bugs
      4. Chapter 4: Functions, Arrays, and Objects
         1. Breaking Code into Functions
            1. Thinking about structure
            2. Building the antsFunction.html program
         2. Passing Data to and from Functions
            1. Examining the makeSong code
            2. Looking at the chorus
            3. Handling the verses
         3. Managing Scope
            1. Introducing local and global variables
            2. Examining variable scope
         4. Building a Basic Array
            1. Accessing array data
            2. Using arrays with for loops
            3. Revisiting the ants song
         5. Working with Two-Dimension Arrays
            1. Setting up the arrays
            2. Getting a city
            3. Creating a main() function
         6. Creating Your Own Objects
            1. Building a basic object
            2. Adding methods to an object
            3. Building a reusable object
            4. Using your shiny new objects
         7. Introducing JSON
            1. Storing data in JSON format
            2. Building a more complex JSON structure
      5. Chapter 5: Getting Valid Input
         1. Getting Input from a Drop-Down List
            1. Building the form
            2. Reading the list box
         2. Managing Multiple Selections
            1. Coding a multiple selection select object
            2. Writing the JavaScript code
         3. Check, Please: Reading Check Boxes
            1. Building the check box page
            2. Responding to the check boxes
         4. Working with Radio Buttons
         5. Interpreting Radio Buttons
         6. Working with Regular Expressions
            1. Introducing regular expressions
            2. Using characters in regular expressions
            3. Marking the beginning and end of the line
            4. Working with special characters
            5. Conducting repetition operations
            6. Working with pattern memory
         7. New HTML5/CSS3 Tricks for Validation
            1. Adding a pattern
            2. Marking a field as required
            3. Adding placeholder text
      6. Chapter 6: Drawing on the Canvas
         1. Canvas Basics
            1. Setting up the canvas
            2. How <canvas> works
         2. Fill and Stroke Styles
            1. Colors
            2. Gradients
            3. Patterns
         3. Drawing Essential Shapes
            1. Rectangle functions
            2. Drawing text
            3. Adding shadows
         4. Working with Paths
            1. Line-drawing options
            2. Drawing arcs and circles
            3. Drawing quadratic curves
            4. Building a Bézier curve
         5. Images
            1. Drawing an image on the canvas
            2. Drawing part of an image
         6. Manipulating Pixels
      7. Chapter 7: Animation with the Canvas
         1. Transformations
            1. Building a transformed image
            2. A few thoughts about transformations
         2. Animation
            1. Overview of the animation loop
            2. Setting up the constants
            3. Initializing the animation
            4. Animate the current frame
            5. Moving an element
            6. Bouncing off the walls
         3. Reading the Keyboard
            1. Managing basic keyboard input
            2. Moving an image with the keyboard
   6. Book V: Server-Side Programming with PHP
      1. Chapter 1: Getting Started on the Server
         1. Introducing Server-Side Programming
            1. Programming on the server
            2. Serving your programs
            3. Picking a language
         2. Installing Your Web Server
         3. Inspecting phpinfo()
         4. Building HTML with PHP
         5. Coding with Quotation Marks
         6. Working with Variables PHP-Style
            1. Concatenation
            2. Interpolating variables into text
         7. Building HTML Output
            1. Using double quote interpolation
            2. Generating output with heredocs
            3. Switching from PHP to HTML
      2. Chapter 2: PHP and HTML Forms
         1. Exploring the Relationship between PHP and HTML
            1. Embedding PHP inside HTML
            2. Viewing the results
         2. Sending Data to a PHP Program
            1. Creating a form for PHP processing
            2. Receiving data in PHP
         3. Choosing the Method of Your Madness
            1. Using get to send data
            2. Using the post method to transmit form data
            3. Getting data from the form
         4. Retrieving Data from Other Form Elements
            1. Building a form with complex elements
            2. Responding to a complex form
      3. Chapter 3: Using Control Structures
         1. Introducing Conditions (Again)
         2. Building the Classic if Statement
            1. Rolling dice the PHP way
            2. Checking your six
            3. Understanding comparison operators
            4. Taking the middle road
            5. Building a program that makes its own form
         3. Making a switch
         4. Looping with for
         5. Looping with while
      4. Chapter 4: Working with Arrays
         1. Using One-Dimensional Arrays
            1. Creating an array
            2. Filling an array
            3. Viewing the elements of an array
            4. Preloading an array
         2. Using Loops with Arrays
            1. Simplifying loops with foreach
            2. Arrays and HTML
         3. Introducing Associative Arrays
            1. Using foreach with associative arrays
         4. Introducing Multidimensional Arrays
            1. We're going on a trip
            2. Looking up the distance
         5. Breaking a String into an Array
            1. Creating arrays with explode
            2. Creating arrays with preg_split
      5. Chapter 5: Using Functions and Session Variables
         1. Creating Your Own Functions
            1. Rolling dice the old-fashioned way
            2. Improving code with functions
            3. Managing variable scope
            4. Returning data from functions
         2. Managing Persistence with Session Variables
            1. Understanding session variables
            2. Adding session variables to your code
      6. Chapter 6: Working with Files and Directories
         1. Text File Manipulation
            1. Writing text to files
            2. Writing a basic text file
            3. Reading from the file
         2. Using Delimited Data
            1. Storing data in a CSV file
            2. Viewing CSV data directly
            3. Reading the CSV data in PHP
         3. Working with File and Directory Functions
            1. opendir( )
            2. readdir( )
            3. chdir( )
            4. Generating the list of file links
      7. Chapter 7: Exceptions and Objects
         1. Object-Oriented Programming in PHP
            1. Building a basic object
            2. Using your brand-new class
            3. Protecting your data with access modifiers
            4. Using access modifiers
         2. You've Got Your Momma's Eyes: Inheritance
            1. Building a critter based on another critter
            2. How to inherit the wind (and anything else)
         3. Catching Exceptions
            1. Introducing exception handling
            2. Knowing when to trap for exceptions
   7. Book VI: Managing Data with MySQL
      1. Chapter 1: Getting Started with Data
         1. Examining the Basic Structure of Data
            1. Determining the fields in a record
            2. Introducing SQL data types
            3. Specifying the length of a record
            4. Defining a primary key
            5. Defining the table structure
         2. Introducing MySQL
            1. Why use MySQL?
            2. Understanding the three-tier architecture
            3. Practicing with MySQL
         3. Setting Up phpMyAdmin
            1. Changing the root password
            2. Adding a user
            3. Using phpMyAdmin on a remote server
         4. Implementing a Database with phpMyAdmin
      2. Chapter 2: Managing Data with MySQL
         1. Writing SQL Code by Hand
            1. Understanding SQL syntax rules
            2. Examining the buildContact.sql script
            3. Dropping a table
            4. Creating a table
            5. Adding records to the table
            6. Viewing the sample data
         2. Running a Script with phpMyAdmin
         3. Using AUTO_INCREMENT for Primary Keys
         4. Selecting Data from Your Tables
            1. Selecting only a few fields
            2. Selecting a subset of records
            3. Searching with partial information
            4. Searching for the ending value of a field
            5. Searching for any text in a field
            6. Searching with regular expressions
            7. Sorting your responses
         5. Editing Records
            1. Updating a record
            2. Deleting a record
         6. Exporting Your Data and Structure
            1. Exporting SQL code
            2. Creating XML data
      3. Chapter 3: Normalizing Your Data
         1. Recognizing Problems with Single-Table Data
            1. The identity crisis
            2. The listed powers
            3. Repetition and reliability
            4. Fields with changeable data
            5. Deletion problems
         2. Introducing Entity-Relationship Diagrams
            1. Using MySQL Workbench to draw ER diagrams
            2. Creating a table definition in Workbench
         3. Introducing Normalization
            1. First normal form
            2. Second normal form
            3. Third normal form
         4. Identifying Relationships in Your Data
      4. Chapter 4: Putting Data Together with Joins
         1. Calculating Virtual Fields
            1. Introducing SQL functions
            2. Knowing when to calculate virtual fields
         2. Calculating Date Values
            1. Using DATEDIFF to determine age
            2. Adding a calculation to get years
            3. Converting the days integer into a date
            4. Using YEAR() and MONTH() to get readable values
            5. Concatenating to make one field
         3. Creating a View
         4. Using an Inner Join to Combine Tables
            1. Building a Cartesian join and an inner join
            2. Enforcing one-to-many relationships
            3. Counting the advantages of inner joins
            4. Building a view to encapsulate the join
         5. Managing Many-to-Many Joins
            1. Understanding link tables
            2. Using link tables to make many-to-many joins
      5. Chapter 5: Connecting PHP to a MySQL Database
         1. PHP and MySQL: A Perfect (but Geeky) Romance
            1. Understanding data connections
            2. Introducing PDO
            3. Building a connection
            4. Retrieving data from the database
            5. Using HTML tables for output
         2. Allowing User Interaction
            1. Building an HTML search form
            2. Responding to the search request
   8. Book VII: Integrating the Client and Server with AJAX
      1. Chapter 1: AJAX Essentials
         1. AJAX Spelled Out
            1. A is for asynchronous
            2. J is for JavaScript
            3. A is for . . . and?
            4. And X is for . . . data
         2. Making a Basic AJAX Connection
            1. Building the HTML form
            2. Creating an XMLHttpRequest object
            3. Opening a connection to the server
            4. Sending the request and parameters
            5. Checking the status
         3. All Together Now — Making the Connection Asynchronous
            1. Setting up the program
            2. Building the getAJAX() function
            3. Reading the response
      2. Chapter 2: Improving JavaScript and AJAX with jQuery
         1. Introducing jQuery
            1. Installing jQuery
            2. Importing jQuery from Google
         2. Your First jQuery App
            1. Setting up the page
            2. Meet the jQuery node object
         3. Creating an Initialization Function
            1. Using $(document).ready()
            2. Alternatives to document.ready
         4. Investigating the jQuery Object
            1. Changing the style of an element
            2. Selecting jQuery objects
            3. Modifying the style
         5. Adding Events to Objects
            1. Adding a hover event
            2. Changing classes on the fly
         6. Making an AJAX Request with jQuery
            1. Including a text file with AJAX
            2. Building a poor man's CMS with AJAX
      3. Chapter 3: Animating jQuery
         1. Playing Hide and Seek
            1. Getting transition support
            2. Writing the HTML and CSS foundation
            3. Initializing the page
            4. Hiding and showing the content
            5. Toggling visibility
            6. Sliding an element
            7. Fading an element in and out
         2. Changing Position with jQuery
            1. Creating the framework
            2. Setting up the events
            3. Building the move() function with chaining
            4. Building time-based animation with animate()
            5. Move a little bit: Relative motion
         3. Modifying Elements on the Fly
            1. Building the basic page
            2. Initializing the code
            3. Adding text
            4. Attack of the clones
            5. It's a wrap
            6. Alternating styles
            7. Resetting the page
            8. More fun with selectors and filters
      4. Chapter 4: Using the jQuery User Interface Toolkit
         1. What the jQuery User Interface Brings to the Table
            1. It's a theme park
            2. Using the themeRoller to get an overview of jQuery
            3. Wanna drag? Making components draggable
            4. Downloading the library
            5. Writing the program
         2. Resizing on a Theme
            1. Examining the HTML and standard CSS
            2. Importing the files
            3. Making a resizable element
            4. Adding themes to your elements
            5. Adding an icon
         3. Dragging, Dropping, and Calling Back
            1. Building the basic page
            2. Initializing the page
            3. Handling the drop
            4. Beauty school dropout events
            5. Cloning the elements
      5. Chapter 5: Improving Usability with jQuery
         1. Multi-Element Designs
            1. Playing the accordion widget
            2. Building a tabbed interface
            3. Using tabs with AJAX
         2. Improving Usability
            1. Playing the dating game
            2. Picking numbers with the slider
            3. Selectable elements
            4. Building a sortable list
            5. Creating a custom dialog box
      6. Chapter 6: Working with AJAX Data
         1. Sending Requests AJAX Style
            1. Sending the data
         2. Building a Multipass Application
            1. Setting up the HTML framework
            2. Loading the select element
            3. Writing the loadList.php program
            4. Responding to selections
            5. Writing the showHero.php script
         3. Working with XML Data
            1. Review of XML
            2. Manipulating XML with jQuery
            3. Creating the HTML
            4. Retrieving the data
            5. Processing the results
            6. Printing the pet name
         4. Working with JSON Data
            1. Knowing JSON's pros
            2. Reading JSON data with jQuery
            3. Managing the framework
            4. Retrieving the JSON data
            5. Processing the results
      7. Chapter 7: Going Mobile
         1. Thinking in Mobile
         2. Building a Responsive Site
            1. Specifying a media type
            2. Adding a qualifier
         3. Making Your Page Responsive
            1. Building the wide layout
            2. Adding the narrow CSS
         4. Using jQuery Mobile to Build Mobile Interfaces
            1. Building a basic jQuery mobile page
            2. Working with collapsible content
            3. Building a multi-page document
         5. Going from Site to App
            1. Adding an icon to your program
            2. Removing the Safari toolbar
            3. Storing your program offline
   9. Book VIII: Moving from Pages to Sites
      1. Chapter 1: Managing Your Servers
         1. Understanding Clients and Servers
            1. Parts of a client-side development system
            2. Parts of a server-side system
         2. Creating Your Own Server with XAMPP
            1. Running XAMPP
            2. Testing your XAMPP configuration
            3. Adding your own files
            4. Setting the security level
            5. Compromising between functionality and security
         3. Choosing a Web Host
            1. Finding a hosting service
            2. Connecting to a hosting service
         4. Managing a Remote Site
            1. Using web-based file tools
            2. Understanding file permissions
            3. Using FTP to manage your site
            4. Using an FTP client
         5. Naming Your Site
            1. Understanding domain names
            2. Registering a domain name
         6. Managing Data Remotely
            1. Creating your database
            2. Finding the MySQL server name
      2. Chapter 2: Planning Your Sites
         1. Creating a Multipage Website
         2. Planning a Larger Site
         3. Understanding the Client
            1. Ensuring that the client's expectations are clear
            2. Delineating the tasks
         4. Understanding the Audience
            1. Determining whom you want to reach
            2. Finding out the user's technical expertise
         5. Building a Site Plan
            1. Creating a site overview
            2. Building the site diagram
         6. Creating Page Templates
            1. Sketching the page design
            2. Building the HTML template framework
            3. Creating page styles
            4. Building a data framework
         7. Fleshing Out the Project
            1. Making the site live
            2. Contemplating efficiency
      3. Chapter 3: Introducing Content Management Systems
         1. Overview of Content Management Systems
         2. Previewing Common CMSs
            1. Moodle
            2. WordPress
            3. Drupal
            4. Building a CMS site with WebsiteBaker
            5. Installing your CMS
            6. Getting an overview of WebsiteBaker
            7. Adding your content
            8. Using the WYSIWYG editor
            9. Changing the template
            10. Adding additional templates
            11. Adding new functionality
         3. Building Custom Themes
            1. Starting with a prebuilt template
            2. Changing the info.php file
            3. Modifying index.php
            4. Modifying the CSS files
            5. Packaging your template
      4. Chapter 4: Editing Graphics
         1. Using a Graphics Editor
         2. Choosing an Editor
         3. Introducing Gimp
            1. Creating an image
            2. Painting tools
            3. Selection tools
            4. Modification tools
            5. Managing tool options
            6. Utilities
         4. Understanding Layers
         5. Introducing Filters
         6. Solving Common Web Graphics Problems
            1. Changing a color
            2. Building a banner graphic
            3. Building a tiled background
      5. Chapter 5: Taking Control of Content
         1. Building a “Poor Man's CMS” with Your Own Code
            1. Using Server Side Includes (SSIs)
            2. Using AJAX and jQuery for client-side inclusion
            3. Building a page with PHP includes
         2. Creating Your Own Data-Based CMS
            1. Using a database to manage content
            2. Writing a PHP page to read from the table
            3. Allowing user-generated content
            4. Adding a new block
            5. Improving the dbCMS design
   10. About the Author
   11. Cheat Sheet
   12. More Dummies Products