HTML5 and CSS3 all-in-one for dummies
(Book)
Average Rating
Author
Status
On Shelf
General Shelving - 3rd Floor
QA76.76.H94 H3716 2014
1 available
QA76.76.H94 H3716 2014
1 available
Description
Loading Description...
Copies
| Location | Call Number | Status |
|---|---|---|
| General Shelving - 3rd Floor | QA76.76.H94 H3716 2014 | On Shelf |
Table of Contents
Introduction:
About this book
Foolish assumptions
Use any computer
Don't buy and software
How this book is organized
New for the third edition
Icons used in this book
Beyond the book
Where to go from
Part 1: Creating The HTML Foundation:
Sound HTML Foundations:
Creating a basic page
Understanding the HTML in the basic page
Meeting your new friends, the tags
Setting up your system:
Displaying file extensions
Setting up you software
It's All About Validation:
Somebody stop the HTML madness!:
XHTML had some great ideas
Validating your page:
Aesop visits W3C
Using tidy to repair pages
Choosing Your Tools:
What's wrong with the big boys: Expression Web and Adobe Dreamweaver
How about online site builders?
Alternative web development tools
Picking a text editor:
Tools to avoid unless you have nothing else
Suggested programmer's editors
My personal choice: Komodo edit
Other text editors
Bottom line on editors
Finding a good web developer's browser:
Little ancient history
Overview of the prominent browsers
Other notable browsers
Bottom line in browsers
Managing Information With Lists And Tables:
Making a list and checking it twice:
Creating an unordered list
Creating ordered lists
Making nested lists
Building the definition list
Building tables:
Defining the table
Spanning rows and columns
Avoiding the table-based layout trap
Making Connections With Links:
Making your text hyper:
Introducing the anchor tag
Comparing block-level and inline elements
Analyzing an anchor
Introducing URLs
Making lists of links
Working with absolute and relative references:
Understanding absolute references
Introducing relative references
Adding Images, Sound, And Video:
Adding images to your pages:
Linking to an image
Adding inline images using the ![]()
tag
src (source)
Height and width
alt (alternate text)
Choosing an image manipulation tool:
Image is worth 3-4 million words
Introducing Irfan view
Choosing an image format:
BMP
JPG/JPEG
GIF
PNG
SVG
Summary of web image formats
Manipulating your images:
Changing formats in IrfanView
Resizing your images
Enhancing image colors
Using built-in effects
Other effect you can use
Batch processing
Working with audio:
Adding video
Creating Forms:
You have great form:
Forms must have some form
Building text-style inputs
Making a standard text field
Building a password field:
Making multi-line text input
Creating multiple selection elements:
Making selections
Building check boxes
Creating radio buttons
Pressing your buttons:
Making input-style buttons
Building a submit button
It's a do-over: the reset button
Introducing the
New form input types:
date
time
datetime
datetime-local
week
month
color
number
range
search
email
tel
url
Part 2: Styling With CSS:
Coloring Your World:
Not you have an element of style:
Setting up a style sheet
Changing the colors
Specifying colors in CSS:
Using color names
Putting a hex on your colors
Coloring by number
Hex education
Using the web-safe color palette
Choosing your colors:
Starting with web-safe colors
Modifying your colors
Doing it on your own pages
Changing CSS on the fly
Creating your own color scheme:
Understanding hue, saturation, and lightness
Using HSL colors in your pages
Using the color scheme designer
Selecting a base hue
Picking a color scheme
Styling Text:
Setting the font family:
Applying the font-family style attribute
Using generic fonts
Making a list of fonts
Curse of web-based fonts:
Understanding the problem
Using embedded fonts
Using images for headlines
Specifying the font size:
Size is only a suggestion!
Using the font-size style attribute
Absolute measurement units
Relative measurement units
Determining other font characteristics:
Using font-style for italics
Using font-weight for bold
Using text-decoration
Using text-align for basic alignment
Other text attributes
Using the font shortcut
Working with subscripts and superscripts
Selectors: Coding With Class And Style:
Selecting particular segments:
Defining more than one kind of paragraph
Styling identified paragraphs
Using emphasis and strong emphasis
Modifying the display of em and strong
Defining classes:
Adding classes to the page
Using classes
Combining classes
Introducing div and span:
Organizing the page by meaning
Why not make a table?
Using pseudo-classes to style links:
Styling a standard link
Styling the link states
Best link practices
Selecting in context
Defining styles for multiple elements
Using new VSS3 selectors:
attribute selection
not
nth-child
Other new pseudo-classes
Borders And Backgrounds:
Joining the border patrol:
Using the border attributes
Defining border styles
Using the border shortcut
Creating partial borders
Introducing the box model:
Borders, margin and padding
Positioning elements with margins and padding
New CSS3 border techniques:
Image borders
Adding rounded corners
Adding a box shadow
Changing the background image
Getting a background check
Solutions to the background conundrum
Manipulating background images:
Turning off the repeat
Using CSS3 gradients
Using images in lists
Levels Of CSS:
Managing levels of style:
Using local styles
Using an external style sheet
Understanding the cascading part of cascading style sheets:
Inheriting styles
Hierarchy of styles
Overriding styles
Precedence of style definitions
Managing browser incompatibility:
Coping with incompatibility
Making Internet Explorer-specific code
Using a conditional comment with CSS
Checking the Internet Explorer version
Using a CSS reset
CSS Special Effects:
Image effects:
Transparency
Reflections
Text effects:
Text stroke
Text-shadow
Transformations and transitions:
Transformations
Three-dimensional transformations
Three-dimensional transformations
Transition animation
Animations.
Part 3: Building Layouts With CSS:
Fun With The Fabulous Float:
Avoding old-school layout pitfalls:
Problems with frames
Problems with tables
Problems with huge images
Problems with flash
Introducing the floating layout mechanism:
Using float with images
Adding the float property
Using float with block-level elements:
Floating a paragraph
Adjusting the width
Setting the next margin
Using float to style forms:
Using float to beautify the form
Adjusting the fieldset width
Using the clear attribute to control page layout
Building Floating Page Layouts:
Creating a basic two-column design:
Designing the page
Building the HTML
Using temporary background colors
Setting up the floating columns
Tuning up the borders
Advantages of a fluid layout
Using semantic tags
Building a three-column design:
Styling the three-column page
Problems with the floating layout
Specifying a min-height
Using height and overflow
Building a fixed-width layout:
Setting up the HTML
Fixing the width with CSS
Building a centered fixed-width layout:
Making a surrogate body with an all div
How the jello layout works
Limitations of the jello layout
Styling Lists And Menus:
Revisiting list styles:
Defining navigation as a list of links
Turning links into buttons
Building horizontal lists
Creating dynamic lists:
Building a nested list
Hiding the inner lists
Getting the inner lists to appear on cue
Building a basic menu system:
Building a vertical menu with CSS
Building a horizontal menu
Using Alternative Positioning:
Working with absolute positioning:
Setting up the HTML
Adding position guidelines
Making absolute positioning work
Managing z-index:
Handling depth
Working with z-index
Building b page layout with absolute positioning:
Overview of absolute layout
Writing the HTML
Adding the CSS
Creating a more flexible layout:
Designing with percentages:
Building the layout
Exploring other types of positioning:
Creating affixed menu system
Setting up the HTML
Setting the CSS values
Flexible box layout model:
Creating a flexible box layout
Viewing a flexible box layout
Now for a little reality
Determining your layout scheme
Part 4: Client-Side Programming With JavaScript:
Getting Started With JavaScript:
Working in JavaScript:
Choosing a JavaScript editor
Picking our test browser
Writing your first JavaScript program
Embedding your JavaScript code
Creating comments
using the alert() method for output
Adding the semicolon
Introducing variables:
Creating a variable for data storage
Asking the user for information
Responding to the user
Using concatenation to build better greetings:
Comparing literals and variables
Including spaces in your concatenated phrases
Understanding the string object:
Introducing object-based programming (and cows)
Investing the length of a string
Using string methods to manipulate text
Understanding variable types:
Adding numbers
Adding the user's numbers
Trouble with dynamic data
Pesky plus sign
Changing variables to the desired type:
Using variable conversion tools
Fixing the addInput code
Taking To The Page:
Understanding the document object model:
Previewing the DOM
Getting the blues, JavaScript-style
Writing JavaScript code to change colors
Managing button events:
Adding a function for more-functionality
Making a more flexible function
Embedding quotes within quotes
Writing the changeColor function
Managing text input and output:
Introducing event-driven programming
Creating the HTML form
Using getElementByld to get access to the page
Manipulating the text fields
Writing to the document:
Preparing the HTML framework
Writing the JavaScript
Finding your innerHTML
Working with other text elements:
Building the form
Writing the function
Understanding generated source
What if you're not in Chrome?
Decisions And Debugging:
Making choices with if
Different flavors of if
Conditional operators
Nesting your if statements
Making decisions with switch
Managing repetition with for loops:
Setting up the web page
Initializing the output
Creating the basic for loop
Introducing shortcut operators
Counting back
Counting by fives
Understanding the Zen of for loops
Building while loops:
Making a basic while loop
Getting your loops to behave
Managing more complex loops
Managing errors with a debugger:
Debugging with the interactive console
Debugging strategies
Resolving syntax errors
Squashing logic bugs
Functions, Arrays, And Objects:
Breaking code into functions:
Thinking about structure
Building the antsFunction -html program
Passing data to and from functions:
Examining the makeSong code
Looking at the chorus
Handling the verses
Managing scope:
Introducing local and global variables
Examining variable scope
Building a basic array:
Accessing array data
Using arrays with for loops
Revisiting the ants song
Working with two-dimension arrays:
Setting up the arrays
Getting a city
Creating a main () function
Creating your own objects:
Building a basic object
Adding methods to an object
Building a reusable object
Building a reusable object
Using your shiny new objects
Introducing JSON:
Storing data in JSON format
Building a more complex JSON structure
Getting Valid Input:
Getting input from a drop-down list:
Building the form
Reading the list box
Managing multiple selections:
Coding a multiple selection select object
Writing the JavaScript code
Check, please: reading check boxes:
Building the check box page
Responding to the check boxes
Working with radio buttons
Interpreting radio buttons
Working with regular expressions:
Introducing regular expressions
Using characters in regular expressions
Marking the beginning and end of the line
Working with special characters
Conducting repetition operations
Working with pattern memory
New HTML5/CSS3 tricks for validation:
Adding a pattern
Marking a field as required
Adding placeholder text
Drawing On The Canvas:
Canvas basics:
Setting up the canvas
How
Fill and stroke styles:
Colors
Gradients
Patterns
Drawing essential shapes:
Rectangle functions
Drawing text
Adding shadows
Working with paths:
Line-drawing options
Drawing arcs and circles
Drawing quadratic curves
Building a Bezier curve
Images:
Drawing an image on the canvas
Drawing part of an image
Manipulating pixels
Animation With The Canvas:
Transformations:
Building a transformed image
Few thoughts about transformations
Animation:
Overview of the animation loop
Setting up the constants
Initializing the animation
Animate the current frame
Moving an element
Bouncing off the walls
Reading the keyboard:
Managing basic keyboard input
Moving an image with the keyboard.
Part 5: Server-Side Programming With PHP:
Getting Started On the Server:
Introducing server-side programming:
Programming on the server
Serving your programs
Picking a language
Installing your web server
Inspecting phpinfo()
Building HTML wit PHP
Coding with quotation marks
Working with variables PHP-style:
Concatenation
Interpolating variables into text
Building HTML output:
Using double quote interpolation
Generating output with heredocs
Switching from PHP to HTML
PHP And HTML Forms:
Exploring the relationship between PHP and HTML:
Embedding PHP inside HTML
Viewing the results
Sending data to a PHP program:
Creating a form for PHP processing
Receiving data in PHP
Choosing the method of your madness:
Using get to send data
Using the post method to transmit form data
Getting data from the form
Retrieving data from other form elements:
Building a form with complex elements
Responding to a complex form
Using Control Structures:
Introducing conditions (again)
Building the classic if statement:
Rolling dice the PHP way
Checking your six
Understanding comparison operators
Taking the middle road
Building a program that makes its own form
Making a switch
Looping with for
Looping with while
Working With Arrays:
Using one-dimensional arrays:
Creating an array
Filling an array
Viewing the elements of an array
Preloading an array
Using loops with arrays:
Simplifying loops with foreach
Arrays and HTML
Introducing associative arrays:
Using foreach with associative arrays
Introducing multidimensional arrays:
We're going on a trip
Looking up the distance
Breaking a string into an array:
Creating arrays with explode
Creating arrays with preg_split
Using Functions And Session Variables:
Creating your own functions:
Rolling dice the old-fashioned way
Improving code with functions
Managing variable scope
Returning data from function
Managing persistence with session variables:
Understanding session variables
Adding session variables to your code
Working With Files And Directories:
Text file manipulation:
Writing text to files
Writing a basic text file
Reading from the file
Using delimited data:
Storing data in a CSV file
Viewing CSV data directly
Reading the CSB data in PHP
Working with file and directory functions:
opendire()
readdir()
chdir()
Generating the list of file links
Exceptions And Objects:
Object-oriented programming in PHP:
Building a basic object
Using your brand-new class
Protecting your data with access modifiers
Using access modifiers
You've got your momma's eyes: inheritance:
Building a critter based on another critter
How to inherit the wind (and anything else)
Catching exceptions:
Introducing exception handling
Knowing when to trap for exceptions
Part 6: Managing Data With MySQL:
Getting Stared With Data:
Examining the basic structure of data:
Determining the fields in a record
Introducing SQL data types
Specifying the length of a record
Defining a primary key
Defining the table structure
Introducing MySQL:
Why use MySQL?
Understanding the three-tier architecture
Practicing with MySQL
Setting up phpMyAdmin:
Changing the root password
Adding a user
Using phpMyAdmin on a remote server
Implementing a database with phpMyAdmin
Managing Data With MySQL:
Writing SQL code by hand:
Understanding SQL syntax rules
Examining the buildContact-sql script
Dropping a table
Creating a table
Adding records to the table
Viewing the sample data
Running a script with phpMyAdmin
Using AUTO_INCREMENT for primary keys
Selecting data from your tables:
Selecting only a few fields
Selecting a subset of records
Searching with partial information
Searching for the ending value of a field
Searching for any text in a field
Searching with regular expressions
Sorting your responses
Editing records:
Updating a record
Deleting a record
Exporting your data and structure:
Exporting SQL code
Creating XML data
Normalizing Your Data:
Recognizing problems with single-table data:
Identity crisis
Listed powers
Repetition and reliability
Fields with changeable data
Deletion problems
Introducing entity-relationship diagrams:
Using MySQL workbench to draw ER diagrams
Creating a table definition in workbench
Introducing normalization:
First normal form
Second normal form
Third normal form
Identifying relationships in your data
Putting Data Together With Joins:
Calculating virtual fields:
Introducing SQL functions
Knowing when to calculate virtual fields
Calculating data values:
Using DATEDIFF to determine age
Adding a calculation to get years
Converting the days integer into a date
Using YEAR () and MOHTH() to get readable values
Concatenating to make one field
Creating a view
Using an inner join to combine tables:
Building a Cartesian join and an inner join
Enforcing one-to-many relationships
Counting the advantages of inner joins
Building a view to encapsulate the join
Managing many-to-many joins:
Understanding link tables
Using link tables to make many-to-many joins
Connecting PHP To A MySQL Database:
PHP and MySQL: a perfect (but geeky) romance:
Understanding data connections
Introducing PDO
Building a connection
Retrieving data from the at base
Using HTML tables for output
Allowing user interaction:
Building an HTML search form
Responding to the search request.
Part 7: Integrating The Client And Server With AJAX:
AJAX Essentials:
AJAX spelled out:
A is for asynchronous
J is for-JavaScript
A is for-and?
And X is for -data
Making a basic AJAX connection:
Building the HTML form
Creating an XMLHttpRequest object
Opening a connection to the server
Sending the request and parameters
Checking the status
All together now: making the connection asynchronous:
Setting up the program
Building the getAJAX() function
Reading the response
Improving JavaScript And AJAX With jQuery:
Introducing jQuery:
Installing jQuery
Importing jQuery from Google
Your first jQuery app:
Setting up the page
Meet the jQuery node object
Creating an initialization function:
Using $(document)-ready()
Alternatives to document-ready
Investing the jQuery object:
Changing the style of an element
Selecting jQuery objects
Modifying the style
Adding events to objects:
Adding a hover event
Changing classes on the fly
Making and AJAX request with jQuery:
Including a text file with AJAX
Building a poor man's CMS with AJAX
Animating jQuery:
Playing hide and seek:
Getting transition support
Writing the HTML and CSS foundation
Initializing the page
Hiding and showing the content
Toggling visibility
Sliding an element
Fading an element in and out
Changing position with jQuery:
Creating the framework
Setting up the events
Building the move() function with chaining
Building time-based animation with animate()
Move a little bit: relative motion
Modifying elements on the fly:
Building the basic page
Initializing the code
Adding text
Attack of the clones
It's a wrap
Alternating styles
Resetting the page
More fun with selectors and filters
Using The jQuery User Interface Toolkit:
What is jQuery user interface brings to the table:
It's a theme park
Using the themeRoller to get an overview of jQuery
Wanna drag?: Making components draggable
Downloading the library
Writing the program
Resizing on a theme:
Examining the HTML and standard CSS
Importing the files
Making a resizable element
Adding themes to your elements
Adding an icon
Dragging, dropping, and calling back:
Building the basic page
Initializing the page
Handling the drop
Beauty school dropout events
Cloning the elements
Improving Usability With jQuery:
Multi-element designs:
Playing the accordion widget
Building a tabbed interface
Using tabs with AJAX
Improving usability:
Playing the dating game
Picking numbers with the sliders
Selectable elements
Building a sortable list
Creating a custom dialog box
Working With AJAX Data:
Sending requests AJAX style:
Sending the data
Building a multipass application:
Setting up the HTML framework
Loading the select element
Writing the loadList-php program
Responding to selections
Writing the showHero-php script
Working with XML data:
Review of XML
Manipulating XML wit jQuery
Creating the HTML
Retrieving the data
Processing the results
Printing the pet name
Working with JSON data:
Knowing JSON's pros
Reading JSON data with jQuery
Managing the framework
Retrieving the JSON data
Processing the results
Going Mobile:
Thinking in mobile
Building a responsive site
Specifying a media type
Adding a qualifier
Making your page responsive:
Building the wide layout
Adding the narrow CSS
Using jQuery mobile to build mobile interfaces:
Building a basic jQuery mobile page
Working with collapsible content
Building a multi-page document
Going from site to app:
Adding an icon to your program
Removing the Safari toolbar
Storing your program offline
Part 8: Moving From Pages To Sites:
Managing Your Servers:
Understanding clients and servers:
Parts of a client-side development system
Parts of a server-side system
Creating your own server with XAMPP:
Running XAMPP
Testing your XAMPP configuration
Adding your own files
Setting the security level
Compromising between functionality and security
Choosing a web host:
Finding a hosting service
Connecting to a hosting service
Managing a remote site:
Using web-based file tools
Understanding file permissions
Using FTP to manage your site
Using an FTP client
Naming your site:
Understanding domain names
Registering a domain name
Managing data remotely:
Creating your database
Finding the MySQL server name
Planning Your Sites:
Creating a multipage web site
Planning a larger site
Understanding the client:
Ensuring that the client's expectations are clear
Delineating the tasks
Understanding the audience:
Determining whom you want to reach
Finding out the user's technical expertise
Building a site plan:
Creating a site overview
Building the site diagram
Creating page templates:
Sketching the page design
Building the HTML template framework
Creating page styles
Building a data framework
Fleshing out the project:
Making the site live
Contemplating efficiency
Introducing Content Management Systems:
Overview of content management systems
Previewing common CMSs:
Moodle
WordPress
Drupal
Building a CMS site with WebsiteBaker
Installing your CMS
Getting an overview of WebsiteBaker
Adding your content
Using the WYSIWYG editor
Changing the template
Adding additional templates
Building custom themes:
Adding new functionality
Starting with a prebuilt template
Changing the info-php file
Modifying index-php
Modifying the CSS files
Packaging your template
Editing Graphics:
Using a graphic editor
Choosing an editor
Introducing gimp:
Creating an image
Painting tools
Selection tools
Modification tools
Managing tool options
Utilities
Understanding layers
Introducing filters
Solving common web graphics problems:
Changing a color
Building a banner graphic
Building a tiled background
Taking Control Of Content:
Building a "poor man's CMS" with your own code:
Using server side includes (SSIs)
Using AJAX and jQuery for client-side inclusion
Building a page with PHP includes
Creating your own data-based CMS:
Using a database to manage content
Writing a PHP page to read from the table
Allowing user-generated content
Adding a new block
Improving the dbCMS design
Index.
Excerpt
Loading Excerpt...
Author Notes
Loading Author Notes...
Subjects
Bisac Subjects
OCLC Fast Subjects
More Details
Format
Book
Physical Desc
xxvi, 1070 pages : illustrations ; 24 cm.
Language
English
Notes
General Note
Includes index.
Description
A new edition of a bestseller covers the latest advances in web development! HTML5 and CSS3 are essential tools for creating dynamic websites and boast updates and enhanced features that can make your websites even more effective and unique. This friendly, all-in-one guide covers everything you need to know about each of these technologies and their latest versions so that you can use them together. Building on the bestselling formats of the first two editions, this new edition teaches you the fundamentals of HTML5 and CSS3, and then presents ways for using them with JavaScript, MySQL, and Ajax to create websites that work. Covers using JavaScript, PHP, MySQL, and Ajax in the context of programming dynamic web pages with CSS3 and HTML5Includes self-contained minibooks that review HTML, CSS, design and layout, client-side JavaScript, Ajax and server-side, and putting it all togetherExamines new web development advancements including new technologies and changes to the standards Features a website that contains supporting materials including code and several valuable programs that are useful for web development "HTML5 and CSS3 All-in-One For Dummies, 3rd Edition" serves as the perfect reference for both web development beginners and seasoned professionals looking to learn more about how to get the most out of the powerful combination of HTML5 and CSS3. -- Provided by publisher.
Local note
SACFinal081324
Reviews from GoodReads
Loading GoodReads Reviews.
Citations
APA Citation, 7th Edition (style guide)
Harris, A. (2014). HTML5 and CSS3 all-in-one for dummies (Third edition.). John Wiley & Sons, Inc..
Chicago / Turabian - Author Date Citation, 17th Edition (style guide)Harris, Andrew, 1964-. 2014. HTML5 and CSS3 All-in-one for Dummies. Hoboken, New Jersey: John Wiley & Sons, Inc.
Chicago / Turabian - Humanities (Notes and Bibliography) Citation, 17th Edition (style guide)Harris, Andrew, 1964-. HTML5 and CSS3 All-in-one for Dummies Hoboken, New Jersey: John Wiley & Sons, Inc, 2014.
Harvard Citation (style guide)Harris, A. (2014). Html5 and css3 all-in-one for dummies. Third edn. Hoboken, New Jersey: John Wiley & Sons, Inc.
MLA Citation, 9th Edition (style guide)Harris, Andrew. HTML5 and CSS3 All-in-one for Dummies Third edition., John Wiley & Sons, Inc., 2014.
Note! Citations contain only title, author, edition, publisher, and year published. Citations should be used as a guideline and should be double checked for accuracy. Citation formats are based on standards as of August 2021.
Staff View
Loading Staff View.