This NeXT workstation (a NeXTcube) was used by Tim Berners-Lee as the first Web server on the World Wide Web. It is shown here as displayed in 2005 at Microcosm, the public science museum at CERN (where Berners-Lee was working in 1991 when he invented the Web).
The document resting on the keyboard is a copy of "Information Management: A Proposal," which was Berners-Lee's original proposal for the World Wide Web.
The partly peeled off label on the cube itself has the following text: "This machine is a server. DO NOT POWER IT DOWN!!" Just below the keyboard (not shown) is a label which reads: "At the end of the 80s, Tim Berners-Lee invented the World Wide Web using this Next computer as the first Web server." The book is probably "Enquire Within upon Everything", which TBL describes on page one of his book Weaving the Web as "a musty old book of Victorian advice I noticed as a child in my parents' house outside London".
Until now, there has not been a standard for showing a video/movie on a web page.
Today, most videos are shown through a plug-in (like flash). However, different browsers may have different plug-ins.
HTML5 defines a new element which specifies a standard way to embed a video/movie on a web page: the <video> element.
Browser Support
Internet Explorer 9, Firefox, Opera, Chrome, and Safari support the <video> element.
Note:Internet Explorer 8 and earlier versions, do not support the <video> element.
HTML5 Video - How It Works
To show a video in HTML5, this is all you need:
Example
<video width="320" height="240" controls>
<source src="movie.mp4" type="video/mp4">
<source src="movie.ogg" type="video/ogg">
Your browser does not support the video tag.
</video>
The control attribute adds video controls, like play, pause, and volume.
It is also a good idea to always include width and height attributes. If height and width are set, the space required for the video is reserved when the page is loaded. However, without these attributes, the browser does not know the size of the video, and cannot reserve the appropriate space to it. The effect will be that the page layout will change during loading (while the video loads).
You should also insert text content between the <video> and </video> tags for browsers that do not support the <video> element.
The <video> element allows multiple <source> elements. <source> elements can link to different video files. The browser will use the first recognized format.
Video Formats and Browser Support
Currently, there are 3 supported video formats for the <video> element: MP4, WebM, and Ogg:
Browser
MP4
WebM
Ogg
Internet Explorer 9+
YES
NO
NO
Chrome 6+
YES
YES
YES
Firefox 3.6+
NO
YES
YES
Safari 5+
YES
NO
NO
Opera 10.6+
NO
YES
YES
MP4 = MPEG 4 files with H264 video codec and AAC audio codec
WebM = WebM files with VP8 video codec and Vorbis audio codec
Ogg = Ogg files with Theora video codec and Vorbis audio codec
MIME Types for Video Formats
Format
MIME-type
MP4
video/mp4
WebM
video/webm
Ogg
video/ogg
HTML5 <video> - DOM Methods and Properties
HTML5 has DOM methods, properties, and events for the <video> and <audio> elements.
These methods, properties, and events allow you to manipulate <video> and <audio> elements using JavaScript.
There are methods for playing, pausing, and loading, for example and there are properties (like duration and volume). There are also DOM events that can notify you when the <video> element begins to play, is paused, is ended, etc.
The example below illustrate, in a simple way, how to address a <video> element, read and set properties, and call methods.
Example 1
Create simple play/pause + resize controls for a video:
It might seem complicated, but lets go through all the different parts of a drag and drop event.
Make an Element Draggable
First of all: To make an element draggable, set the draggable attribute to true:
<img draggable="true">
What to Drag - ondragstart and setData()
Then, specify what should happen when the element is dragged.
In the example above, the ondragstart attribute calls a function, drag(event), that specifies what data to be dragged.
The dataTransfer.setData() method sets the data type and the value of the dragged data:
function drag(ev) { ev.dataTransfer.setData("Text",ev.target.id); }
In this case, the data type is "Text" and the value is the id of the draggable element ("drag1").
Where to Drop - ondragover
The ondragover event specifies where the dragged data can be dropped.
By default, data/elements cannot be dropped in other elements. To allow a drop, we must prevent the default handling of the element.
This is done by calling the event.preventDefault() method for the ondragover event:
event.preventDefault()
Do the Drop - ondrop
When the dragged data is dropped, a drop event occurs.
In the example above, the ondrop attribute calls a function, drop(event):
function drop(ev) { ev.preventDefault(); var data=ev.dataTransfer.getData("Text"); ev.target.appendChild(document.getElementById(data)); }
Code explained:
Call preventDefault() to prevent the browser default handling of the data (default is open as link on drop)
Get the dragged data with the dataTransfer.getData("Text") method. This method will return any data that was set to the same type in the setData() method
The dragged data is the id of the dragged element ("drag1")
A class describes the behavior and properties common to any
particular type of object. For a string object (in Objective-C, this is
an instance of the class NSString), the class offers
various ways to examine and convert the internal characters that it
represents. Similarly, the class used to describe a number object (NSNumber) offers functionality around an internal numeric value, such as converting that value to a different numeric type.
In
the same way that multiple buildings constructed from the same
blueprint are identical in structure, every instance of a class shares
the same properties and behavior as all other instances of that class.
Every NSString instance behaves in the same way, regardless of the internal string of characters it holds.
Any
particular object is designed to be used in specific ways. You might
know that a string object represents some string of characters, but you
don’t need to know the exact internal mechanisms used to store those
characters. You don’t know anything about the internal behavior used by
the object itself to work directly with its characters, but you do need
to know how you are expected to interact with the object, perhaps to ask
it for specific characters or request a new object in which all the
original characters are converted to uppercase.
In Objective-C, the class interface
specifies exactly how a given type of object is intended to be used by
other objects. In other words, it defines the public interface between
instances of the class and the outside world.
