Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

touch

  • Loading branch information...
commit 8a250ab1f85597db677aabb134a0280715b1b882 1 parent d6d7c89
@gawel authored
View
295 static/impress/impress/README.md
@@ -0,0 +1,295 @@
+impress.js
+============
+
+It's a presentation framework based on the power of CSS3 transforms and
+transitions in modern browsers and inspired by the idea behind prezi.com.
+
+**WARNING**
+
+impress.js may not help you if you have nothing interesting to say ;)
+
+
+ABOUT THE NAME
+----------------
+
+impress.js name in [courtesy of @skuzniak](http://twitter.com/skuzniak/status/143627215165333504).
+
+It's an (un)fortunate coincidence that a Open/LibreOffice presentation tool is called Impress ;)
+
+
+VERSION HISTORY
+-----------------
+
+### 0.5.3 ([browse](http://github.com/bartaz/impress.js/tree/0.5.3), [zip](http://github.com/bartaz/impress.js/zipball/0.5.3), [tar](http://github.com/bartaz/impress.js/tarball/0.5.3))
+
+#### BUGFIX RELEASE
+
+Version 0.5 introduced events including `impress:stepenter`, but this event was not triggered properly in some
+specific transition types (for example when only scale was changing between steps). It was caused by the fact that
+in such cases expected `transitionend` event was not triggered.
+
+This version fixes this issue. Unfortunately modern `transitionend` event is no longer used to detect when the
+transition has finished, but old school (and more reliable) `setTimeout` is used.
+
+
+### 0.5.2 ([browse](http://github.com/bartaz/impress.js/tree/0.5.2), [zip](http://github.com/bartaz/impress.js/zipball/0.5.2), [tar](http://github.com/bartaz/impress.js/tarball/0.5.2))
+
+#### DOCUMENTATION RELEASE
+
+More descriptive comments added to demo CSS and impress.js source file, so now not only `index.html` is worth reading ;)
+
+
+### 0.5.1 ([browse](http://github.com/bartaz/impress.js/tree/0.5.1), [zip](http://github.com/bartaz/impress.js/zipball/0.5.1), [tar](http://github.com/bartaz/impress.js/tarball/0.5.1))
+
+#### BUGFIX RELEASE
+
+Changes in version 0.5 introduced a bug (#126) that was preventing clicks on links (or any clickable elements) on
+currently active step. This release fixes this issue.
+
+
+
+### 0.5 ([browse](http://github.com/bartaz/impress.js/tree/0.5), [zip](http://github.com/bartaz/impress.js/zipball/0.5), [tar](http://github.com/bartaz/impress.js/tarball/0.5))
+
+#### CHANGELOG
+
+* API changed, so that `impress()` function no longer automatically initialize presentation; new method called `init`
+ was added to API and it should be used to start the presentation
+* event `impress:init` is triggered on root presentation element (`#impress` by default) when presentation is initialized
+* new CSS classes were added: `impress-disabled` is added to body element by the impress.js script and it's changed to
+ `impress-enabled` when `init()` function is called
+* events added when step is entered and left - custom `impress:stepenter` and `impress:stepleave` events are triggered
+ on step elements and can be handled like any other DOM events (with `addEventListener`)
+* additional `past`, `present` and `future` classes are added to step elements
+ - `future` class appears on steps that were not yet visited
+ - `present` class appears on currently visible step - it's different from `active` class as `present` class
+ is added when transition finishes (step is entered)
+ - `past` class is added to already visited steps (when the step is left)
+* and good news, `goto()` API method is back! it seems that `goto` **was** a future reserved word but isn't anymore,
+ so we can use this short and pretty name instead of camelCassy `stepTo` - and yes, that means API changed again...
+* additionally `goto()` method now supports new types of parameters:
+ - you can give it a number of step you want to go to: `impress().goto(7)`
+ - or its id: `impress().goto("the-best-slide-ever")`
+ - of course DOM element is still acceptable: `impress().goto( document.getElementById("overview") )`
+* and if it's not enough, `goto()` also accepts second parameter to define the transition duration in ms, for example
+ `impress().goto("make-it-quick", 300)` or `impress().goto("now", 0)`
+
+#### UPGRADING FROM PREVIOUS VERSIONS
+
+In current version calling `impress()` doesn't automatically initialize the presentation. You need to call `init()`
+function from the API. So in a place were you called `impress()` to initialize impress.js simply change this call
+to `impress().init()`.
+
+Version 0.4 changed `goto` API method into `stepTo`. It turned out that `goto` is not a reserved word anymore, so it
+can be used in JavaScript. That's why version 0.5 brings it back and removes `stepTo`.
+
+So if you have been using version 0.4 and have any reference to `stepTo` API method make sure to change it to `goto`.
+
+
+
+### 0.4.1 ([browse](http://github.com/bartaz/impress.js/tree/0.4.1), [zip](http://github.com/bartaz/impress.js/zipball/0.4.1), [tar](http://github.com/bartaz/impress.js/tarball/0.4.1))
+
+#### BUGFIX RELEASE
+
+Changes is version 0.4 introduced a bug causing JavaScript errors being thrown all over the place in fallback mode.
+This release fixes this issue.
+
+It also adds a flag `impress.supported` that can be used in JavaScript to check if impress.js is supported in the browser.
+
+
+
+### 0.4 ([browse](http://github.com/bartaz/impress.js/tree/0.4), [zip](http://github.com/bartaz/impress.js/zipball/0.4), [tar](http://github.com/bartaz/impress.js/tarball/0.4))
+
+#### CHANGELOG
+
+* configuration options on `#impress` element: `data-perspective` (in px, defaults so 1000),
+ `data-transition-duration` (in ms, defaults to 1000)
+* automatic scaling to fit window size, with configuration options: `data-width` (in px, defaults to 1024),
+ `data-height` (in px, defaults to 768), `max-scale` (defaults to 1), `min-scale` (defaults to 0)
+* `goto` API function was renamed to `stepTo` because `goto` is a future reserved work in JavaScript,
+ so **please make sure to update your code**
+* fallback `impress-not-supported` class is now set on `body` element instead of `#impress` element and it's
+ replaced with `impress-supported` when browser supports all required features
+* classes `step-ID` used to indicate progress of the presentation are now renamed to `impress-on-ID` and are
+ set on `body` element, so **please make sure to update your code**
+* basic validation of configuration options
+* couple of typos and bugs fixed
+* favicon added ;)
+
+
+#### UPGRADING FROM PREVIOUS VERSIONS
+
+If in your custom JavaScript code you were using `goto()` function from impress.js API make sure to change it
+to `stepTo()`.
+
+If in your CSS you were using classes based on currently active step with `step-` prefix, such as `step-bored`
+(where `bored` is the id of the step element) make sure to change it to `impress-on-` prefix
+(for example `impress-on-bored`). Also in previous versions these classes were assigned to `#impress` element
+and now they are added to `body` element, so if your CSS code depends on this, it also should be updated.
+
+Same happened to `impress-not-supported` class name - it was moved from `#impress` element to `body`, so update
+your CSS if it's needed.
+
+#### NOTE ON BLACKBERRY PLAYBOOK
+
+Changes and fixes added in this version have broken the experience on Blackberry Playbook with OS in version 1.0.
+It happened due to a bug in the Playbook browser in this version. Fortunately in version 2.0 of Playbook OS this
+bug was fixed and impress.js works fine.
+
+So currently impress.js work only on Blackberry Playbook with latest OS. Fortunately, [it seems that most of the
+users](http://twitter.com/n_adam_stanley/status/178188611827679233) [are quite quick with updating their devices]
+(http://twitter.com/brcewane/status/178230406196379648)
+
+
+
+### 0.3 ([browse](http://github.com/bartaz/impress.js/tree/0.3), [zip](http://github.com/bartaz/impress.js/zipball/0.3), [tar](http://github.com/bartaz/impress.js/tarball/0.3))
+
+#### CHANGELOG
+
+* minor CSS 3D fixes
+* basic API to control the presentation flow from JavaScript
+* touch event support
+* basic support for iPad (iOS 5 and iOS 4 with polyfills) and Blackberry Playbook
+
+#### UPGRADING FROM PREVIOUS VERSIONS
+
+Because API was introduced the way impress.js script is initialized was changed a bit. You not only has to include
+`impress.js` script file, but also call `impress()` function.
+
+See the source of `index.html` for example and more details.
+
+
+### 0.2 ([browse](http://github.com/bartaz/impress.js/tree/0.2), [zip](http://github.com/bartaz/impress.js/zipball/0.2), [tar](http://github.com/bartaz/impress.js/tarball/0.2))
+
+* tutorial/documentation added to `index.html` source file
+* being even more strict with strict mode
+* code clean-up
+* couple of small bug-fixes
+
+
+### 0.1 ([browse](http://github.com/bartaz/impress.js/tree/0.1), [zip](http://github.com/bartaz/impress.js/zipball/0.1), [tar](http://github.com/bartaz/impress.js/tarball/0.1))
+
+First release.
+
+Contains basic functionality for step placement and transitions between them
+with simple fallback for non-supporting browsers.
+
+
+
+HOW TO USE IT
+---------------
+
+[Use the source](http://github.com/bartaz/impress.js/blob/master/index.html), Luke ;)
+
+If you have no idea what I mean by that, or you just clicked that link above and got
+very confused by all these strange characters that got displayed on your screen,
+it's a sign, that impress.js is not for you.
+
+Sorry.
+
+Fortunately there are some guys on GitHub that got quite excited with the idea of building
+editing tool for impress.js. Let's hope they will manage to do it.
+
+
+EXAMPLES AND DEMOS
+--------------------
+
+### Official demo
+
+[impress.js demo](http://bartaz.github.com/impress.js) by [@bartaz](http://twitter.com/bartaz)
+
+### Other examples
+
+More examples and demos can be found on [Examples and demos wiki page](http://github.com/bartaz/impress.js/wiki/Examples-and-demos).
+
+Feel free to add your own example presentations (or websites) there.
+
+
+
+WANT TO CONTRIBUTE?
+---------------------
+
+If you've found a bug or have a great idea for new feature let me know by [adding your suggestion]
+(http://github.com/bartaz/impress.js/issues/new) to [issues list](https://github.com/bartaz/impress.js/issues).
+
+If you have fixed a bug or implemented a feature that you'd like to share, send your pull request against [dev branch]
+(http://github.com/bartaz/impress.js/tree/dev). But remember that I only accept code that fits my vision of impress.js
+and my coding standards - so make sure you are open for discussion :)
+
+
+
+BROWSER SUPPORT
+-----------------
+
+### TL;DR;
+
+Currently impress.js works fine in latest Chrome/Chromium browser, Safari 5.1 and Firefox 10.
+With addition of some HTML5 polyfills (see below for details) it should work in Internet Explorer 10
+(currently available as Developers Preview).
+It doesn't work in Opera, as it doesn't support CSS 3D transforms.
+
+As a presentation tool it was not developed with mobile browsers in mind, but some tablets are good
+enough to run it, so it should work quite well on iPad (iOS 5, or iOS 4 with HTML5 polyfills) and
+Blackberry Playbook.
+
+### Still interested? Read more...
+
+Additionally for the animations to run smoothly it's required to have hardware
+acceleration support in your browser. This depends on the browser, your operating
+system and even kind of graphic hardware you have in your machine.
+
+For browsers not supporting CSS3 3D transforms impress.js adds `impress-not-supported`
+class on `#impress` element, so fallback styles can be applied to make all the content accessible.
+
+
+### Even more explanation and technical stuff
+
+Let's put this straight -- wide browser support was (and is) not on top of my priority list for
+impress.js. It's built on top of fresh technologies that just start to appear in the browsers
+and I'd like to rather look forward and develop for the future than being slowed down by the past.
+
+But it's not "hard-coded" for any particular browser or engine. If any browser in future will
+support features required to run impress.js, it will just begin to work there without changes in
+the code.
+
+From technical point of view all the positioning of presentation elements in 3D requires CSS 3D
+transforms support. Transitions between presentation steps are based on CSS transitions.
+So these two features are required by impress.js to display presentation correctly.
+
+Unfortunately the support for CSS 3D transforms and transitions is not enough for animations to
+run smoothly. If the browser doesn't support hardware acceleration or the graphic card is not
+good enough the transitions will be laggy.
+
+Additionally the code of impress.js relies on APIs proposed in HTML5 specification, including
+`classList` and `dataset` APIs. If they are not available in the browser, impress.js will not work.
+
+Fortunately, as these are JavaScript APIs there are polyfill libraries that patch older browsers
+with these APIs.
+
+For example IE10 is said to support CSS 3D transforms and transitions, but it doesn't have `classList`
+not `dataset` APIs implemented at the moment. So including polyfill libraries *should* help IE10
+with running impress.js.
+
+
+### And few more details about mobile support
+
+Mobile browsers are currently not supported. Even Android browsers that support CSS 3D transforms are
+forced into fallback view at this point.
+
+Fortunately some tablets seem to have good enough hardware support and browsers to handle it.
+Currently impress.js presentations should work on iPad and Blackberry Playbook.
+
+In theory iPhone should also be able to run it (as it runs the same software as iPad), but I haven't
+found a good way to handle it's small screen.
+
+Also note that iOS supports `classList` and `dataset` APIs starting with version 5, so iOS 4.X and older
+requires polyfills to work.
+
+
+LICENSE
+---------
+
+Copyright 2011-2012 Bartek Szopka
+
+Released under the MIT and GPL Licenses.
+
+
View
BIN  static/impress/impress/apple-touch-icon.png
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
View
703 static/impress/impress/css/impress-demo.css
@@ -0,0 +1,703 @@
+/*
+ So you like the style of impress.js demo?
+ Or maybe you are just curious how it was done?
+
+ You couldn't find a better place to find out!
+
+ Welcome to the stylesheet impress.js demo presentation.
+
+ Please remember that it is not meant to be a part of impress.js and is
+ not required by impress.js.
+ I expect that anyone creating a presentation for impress.js would create
+ their own set of styles.
+
+ But feel free to read through it and learn how to get the most of what
+ impress.js provides.
+
+ And let me be your guide.
+
+ Shall we begin?
+*/
+
+
+/*
+ We start with a good ol' reset.
+ That's the one by Eric Meyer http://meyerweb.com/eric/tools/css/reset/
+
+ You can probably argue if it is needed here, or not, but for sure it
+ doesn't do any harm and gives us a fresh start.
+*/
+
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, embed,
+figure, figcaption, footer, header, hgroup,
+menu, nav, output, ruby, section, summary,
+time, mark, audio, video {
+ margin: 0;
+ padding: 0;
+ border: 0;
+ font-size: 100%;
+ font: inherit;
+ vertical-align: baseline;
+}
+
+/* HTML5 display-role reset for older browsers */
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+ display: block;
+}
+body {
+ line-height: 1;
+}
+ol, ul {
+ list-style: none;
+}
+blockquote, q {
+ quotes: none;
+}
+blockquote:before, blockquote:after,
+q:before, q:after {
+ content: '';
+ content: none;
+}
+
+table {
+ border-collapse: collapse;
+ border-spacing: 0;
+}
+
+/*
+ Now here is when interesting things start to appear.
+
+ We set up <body> styles with default font and nice gradient in the background.
+ And yes, there is a lot of repetition there because of -prefixes but we don't
+ want to leave anybody behind.
+*/
+body {
+ font-family: 'PT Sans', sans-serif;
+ min-height: 740px;
+
+ background: rgb(215, 215, 215);
+ background: -webkit-gradient(radial, 50% 50%, 0, 50% 50%, 500, from(rgb(240, 240, 240)), to(rgb(190, 190, 190)));
+ background: -webkit-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+ background: -moz-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+ background: -ms-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+ background: -o-radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+ background: radial-gradient(rgb(240, 240, 240), rgb(190, 190, 190));
+}
+
+/*
+ Now let's bring some text styles back ...
+*/
+b, strong { font-weight: bold }
+i, em { font-style: italic }
+
+/*
+ ... and give links a nice look.
+*/
+a {
+ color: inherit;
+ text-decoration: none;
+ padding: 0 0.1em;
+ background: rgba(255,255,255,0.5);
+ text-shadow: -1px -1px 2px rgba(100,100,100,0.9);
+ border-radius: 0.2em;
+
+ -webkit-transition: 0.5s;
+ -moz-transition: 0.5s;
+ -ms-transition: 0.5s;
+ -o-transition: 0.5s;
+ transition: 0.5s;
+}
+
+a:hover,
+a:focus {
+ background: rgba(255,255,255,1);
+ text-shadow: -1px -1px 2px rgba(100,100,100,0.5);
+}
+
+/*
+ Because the main point behind the impress.js demo is to demo impress.js
+ we display a fallback message for users with browsers that don't support
+ all the features required by it.
+
+ All of the content will be still fully accessible for them, but I want
+ them to know that they are missing something - that's what the demo is
+ about, isn't it?
+
+ And then we hide the message, when support is detected in the browser.
+*/
+
+.fallback-message {
+ font-family: sans-serif;
+ line-height: 1.3;
+
+ width: 780px;
+ padding: 10px 10px 0;
+ margin: 20px auto;
+
+ border: 1px solid #E4C652;
+ border-radius: 10px;
+ background: #EEDC94;
+}
+
+.fallback-message p {
+ margin-bottom: 10px;
+}
+
+.impress-supported .fallback-message {
+ display: none;
+}
+
+/*
+ Now let's style the presentation steps.
+
+ We start with basics to make sure it displays correctly in everywhere ...
+*/
+
+.step {
+ position: relative;
+ width: 900px;
+ padding: 40px;
+ margin: 20px auto;
+
+ -webkit-box-sizing: border-box;
+ -moz-box-sizing: border-box;
+ -ms-box-sizing: border-box;
+ -o-box-sizing: border-box;
+ box-sizing: border-box;
+
+ font-family: 'PT Serif', georgia, serif;
+ font-size: 48px;
+ line-height: 1.5;
+}
+
+/*
+ ... and we enhance the styles for impress.js.
+
+ Basically we remove the margin and make inactive steps a little bit transparent.
+*/
+.impress-enabled .step {
+ margin: 0;
+ opacity: 0.3;
+
+ -webkit-transition: opacity 1s;
+ -moz-transition: opacity 1s;
+ -ms-transition: opacity 1s;
+ -o-transition: opacity 1s;
+ transition: opacity 1s;
+}
+
+.impress-enabled .step.active { opacity: 1 }
+
+/*
+ These 'slide' step styles were heavily inspired by HTML5 Slides:
+ http://html5slides.googlecode.com/svn/trunk/styles.css
+
+ ;)
+
+ They cover everything what you see on first three steps of the demo.
+*/
+.slide {
+ display: block;
+
+ width: 900px;
+ height: 700px;
+ padding: 40px 60px;
+
+ background-color: white;
+ border: 1px solid rgba(0, 0, 0, .3);
+ border-radius: 10px;
+ box-shadow: 0 2px 6px rgba(0, 0, 0, .1);
+
+ color: rgb(102, 102, 102);
+ text-shadow: 0 2px 2px rgba(0, 0, 0, .1);
+
+ font-family: 'Open Sans', Arial, sans-serif;
+ font-size: 30px;
+ line-height: 36px;
+ letter-spacing: -1px;
+}
+
+.slide q {
+ display: block;
+ font-size: 50px;
+ line-height: 72px;
+
+ margin-top: 100px;
+}
+
+.slide q strong {
+ white-space: nowrap;
+}
+
+/*
+ And now we start to style each step separately.
+
+ I agree that this may be not the most efficient, object-oriented and
+ scalable way of styling, but most of steps have quite a custom look
+ and typography tricks here and there, so they had to be styles separately.
+
+ First is the title step with a big <h1> (no room for padding) and some
+ 3D positioning along Z axis.
+*/
+
+#title {
+ padding: 0;
+}
+
+#title .try {
+ font-size: 64px;
+ position: absolute;
+ top: -0.5em;
+ left: 1.5em;
+
+ -webkit-transform: translateZ(20px);
+ -moz-transform: translateZ(20px);
+ -ms-transform: translateZ(20px);
+ -o-transform: translateZ(20px);
+ transform: translateZ(20px);
+}
+
+#title h1 {
+ font-size: 190px;
+
+ -webkit-transform: translateZ(50px);
+ -moz-transform: translateZ(50px);
+ -ms-transform: translateZ(50px);
+ -o-transform: translateZ(50px);
+ transform: translateZ(50px);
+}
+
+#title .footnote {
+ font-size: 32px;
+}
+
+/*
+ Second step is nothing special, just a text with a link, so it doesn't need
+ any special styling.
+
+ Let's move to 'big thoughts' with centered text and custom font sizes.
+*/
+#big {
+ width: 600px;
+ text-align: center;
+ font-size: 60px;
+ line-height: 1;
+}
+
+#big b {
+ display: block;
+ font-size: 250px;
+ line-height: 250px;
+}
+
+#big .thoughts {
+ font-size: 90px;
+ line-height: 150px;
+}
+
+/*
+ 'Tiny ideas' just need some tiny styling.
+*/
+#tiny {
+ width: 500px;
+ text-align: center;
+}
+
+/*
+ This step has some animated text ...
+*/
+#ing { width: 500px }
+
+/*
+ ... so we define display to `inline-block` to enable transforms and
+ transition duration to 0.5s ...
+*/
+#ing b {
+ display: inline-block;
+ -webkit-transition: 0.5s;
+ -moz-transition: 0.5s;
+ -ms-transition: 0.5s;
+ -o-transition: 0.5s;
+ transition: 0.5s;
+}
+
+/*
+ ... and we want 'positioning` word to move up a bit when the step gets
+ `present` class ...
+*/
+#ing.present .positioning {
+ -webkit-transform: translateY(-10px);
+ -moz-transform: translateY(-10px);
+ -ms-transform: translateY(-10px);
+ -o-transform: translateY(-10px);
+ transform: translateY(-10px);
+}
+
+/*
+ ... 'rotating' to rotate quater of a second later ...
+*/
+#ing.present .rotating {
+ -webkit-transform: rotate(-10deg);
+ -moz-transform: rotate(-10deg);
+ -ms-transform: rotate(-10deg);
+ -o-transform: rotate(-10deg);
+ transform: rotate(-10deg);
+
+ -webkit-transition-delay: 0.25s;
+ -moz-transition-delay: 0.25s;
+ -ms-transition-delay: 0.25s;
+ -o-transition-delay: 0.25s;
+ transition-delay: 0.25s;
+}
+
+/*
+ ... and 'scaling' to scale down after another quater of a second.
+*/
+#ing.present .scaling {
+ -webkit-transform: scale(0.7);
+ -moz-transform: scale(0.7);
+ -ms-transform: scale(0.7);
+ -o-transform: scale(0.7);
+ transform: scale(0.7);
+
+ -webkit-transition-delay: 0.5s;
+ -moz-transition-delay: 0.5s;
+ -ms-transition-delay: 0.5s;
+ -o-transition-delay: 0.5s;
+ transition-delay: 0.5s;
+}
+
+/*
+ The 'imagination' step is again some boring font-sizing.
+*/
+
+#imagination {
+ width: 600px;
+}
+
+#imagination .imagination {
+ font-size: 78px;
+}
+
+/*
+ There is nothing really special about 'use the source, Luke' step, too,
+ except maybe of the Yoda background.
+
+ As you can see below I've 'hard-coded' it in data URL.
+ That's not the best way to serve images, but because that's just this one
+ I decided it will be OK to have it this way.
+
+ Just make sure you don't blindly copy this approach.
+*/
+#source {
+ width: 700px;
+ padding-bottom: 300px;
+
+ /* Yoda Icon :: Pixel Art from Star Wars http://www.pixeljoint.com/pixelart/1423.htm */
+ background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAARgAAAEYCAMAAACwUBm+AAAAAXNSR0IArs4c6QAAAKtQTFRFsAAAvbWSLUUrLEQqY1s8UYJMqJ1vNTEgOiIdIzYhjIFVLhsXZ6lgSEIsP2U8JhcCVzMsSXZEgXdOO145XJdWOl03LzAYMk4vSXNExr+hwcuxRTs1Qmk+RW9Am49eFRANQz4pUoNMQWc+OSMDTz0wLBsCNVMxa2NBOyUDUoNNSnlEWo9VRGxAVzYFl6tXCggHbLNmMUIcHhwTXkk5f3VNRT8wUT8xAAAACQocRBWFFwAAAAF0Uk5TAEDm2GYAAAPCSURBVHja7d3JctNAFIZRMwRCCGEmzPM8z/D+T8bu/ptbXXJFdij5fMt2Wuo+2UgqxVmtttq5WVotLzBgwIABAwYMGDCn0qVqbo69psPqVpWx+1XG5iaavF8wYMCAAQMGDBgwi4DJ6Y6qkxB1HNlcN3a92gbR5P2CAQMGDBgwYMCAWSxMlrU+UY5yu2l9okfV4bAxUVbf7TJnAwMGDBgwYMCAAbMLMHeqbGR82Zy+VR1Ht81nVca6R+UdTLaU24Ruzd3qM/e4yjnAgAEDBgwYMGDA7AJMd1l/3NRdVGcj3eX/2WEhCmDGxnM7yqygu8XIPjJj8iN/MGDAgAEDBgwYMAuDGb8q0RGlLCHLv1t9qDKWn3vdNHVuEI6HPaxO9Jo3GDBgwIABAwYMmIXBdC9ShGgMk+XnkXUeuGcsP/e1+lhNnZsL/G5Vs3OAAQMGDBgwYMCAWSxMR3SzOmraG5atdy9wZKzb+vg16qyqe2FltbnAgAEDBgwYMGDALAxmTJSuN3WA76rnVca6GTnemGN1WoEBAwYMGDBgwIBZGMxUomy4+xO899V4LAg5Xnc2MGDAgAEDBgwYMGA218Wq+2K1LDqvY9xZu8zN8fICdM6btYABAwYMGDBgwIABMzfH0+pGU5afze2tXebmeAfVz+p8BQYMGDBgwIABAwbMPBzZ+oWmfJrln1273FhkbHzee9WWbw7AgAEDBgwYMGDALAKm43hcdctKgblcPamOhuXnXlY5Xs6bsW4FGyQCAwYMGDBgwIABswiYMceZKgvMo+h8mrHLTdn676rj+FEFoTtHd8MwOxEYMGDAgAEDBgyYRcBM5UhXqiymW3R3c9ARhWO/OmjqfjVZy+xEYMCAAQMGDBgwYBYG073OnCV0RFNhMhaOa9WfKmOB6XjHMN1tQmaAAQMGDBgwYMCA2VWY7vXjz1U4croAzgPztwIDBgwYMGDAgAEDZhswh035NBw59Dww3RgYMGDAgAEDBgwYMJuD6f4tXT7NUqfCdBvZLkxXdgQGDBgwYMCAAQNmt2DGj8WzwAfV/w7T/aq7mxwwYMCAAQMGDBgwuwqTOo7uTwTngflSzQ3TdaJvAwEDBgwYMGDAgAED5gSvgbyo5oHZ4Pc+gwEDBgwYMGDAgAEzhOm+5G0qTGaAAQMGDBgwYMCAAXNaMOcnls3tNwWm+zRzp54NDBgwYMCAAQMGDJh5YNL36k1TLuGvVq+qnKMbS5n7tulT9asCAwYMGDBgwIABA2ZumKuztLnjgQEDBgwYMGDAgNl5mH/4/ltKA6vBNAAAAABJRU5ErkJggg==);
+ background-position: bottom right;
+ background-repeat: no-repeat;
+}
+
+#source q {
+ font-size: 60px;
+}
+
+/*
+ And the "it's in 3D" step again brings some 3D typography - just for fun.
+
+ Because we want to position <span> elements in 3D we set transform-style to
+ `preserve-3d` on the paragraph.
+ It is not needed by webkit browsers, but it is in Firefox. It's hard to say
+ which behaviour is correct as 3D transforms spec is not very clear about it.
+*/
+#its-in-3d p {
+ -webkit-transform-style: preserve-3d;
+ -moz-transform-style: preserve-3d; /* Y U need this Firefox?! */
+ -ms-transform-style: preserve-3d;
+ -o-transform-style: preserve-3d;
+ transform-style: preserve-3d;
+}
+
+/*
+ Below we position each word separately along Z axis and we want it to transition
+ to default position in 0.5s when the step gets `present` class.
+
+ Quite a simple idea, but lot's of styles and prefixes.
+*/
+#its-in-3d span,
+#its-in-3d b {
+ display: inline-block;
+ -webkit-transform: translateZ(40px);
+ -moz-transform: translateZ(40px);
+ -ms-transform: translateZ(40px);
+ -o-transform: translateZ(40px);
+ transform: translateZ(40px);
+
+ -webkit-transition: 0.5s;
+ -moz-transition: 0.5s;
+ -ms-transition: 0.5s;
+ -o-transition: 0.5s;
+ transition: 0.5s;
+}
+
+#its-in-3d .have {
+ -webkit-transform: translateZ(-40px);
+ -moz-transform: translateZ(-40px);
+ -ms-transform: translateZ(-40px);
+ -o-transform: translateZ(-40px);
+ transform: translateZ(-40px);
+}
+
+#its-in-3d .you {
+ -webkit-transform: translateZ(20px);
+ -moz-transform: translateZ(20px);
+ -ms-transform: translateZ(20px);
+ -o-transform: translateZ(20px);
+ transform: translateZ(20px);
+}
+
+#its-in-3d .noticed {
+ -webkit-transform: translateZ(-40px);
+ -moz-transform: translateZ(-40px);
+ -ms-transform: translateZ(-40px);
+ -o-transform: translateZ(-40px);
+ transform: translateZ(-40px);
+}
+
+#its-in-3d .its {
+ -webkit-transform: translateZ(60px);
+ -moz-transform: translateZ(60px);
+ -ms-transform: translateZ(60px);
+ -o-transform: translateZ(60px);
+ transform: translateZ(60px);
+}
+
+#its-in-3d .in {
+ -webkit-transform: translateZ(-10px);
+ -moz-transform: translateZ(-10px);
+ -ms-transform: translateZ(-10px);
+ -o-transform: translateZ(-10px);
+ transform: translateZ(-10px);
+}
+
+#its-in-3d .footnote {
+ font-size: 32px;
+
+ -webkit-transform: translateZ(-10px);
+ -moz-transform: translateZ(-10px);
+ -ms-transform: translateZ(-10px);
+ -o-transform: translateZ(-10px);
+ transform: translateZ(-10px);
+}
+
+#its-in-3d.present span,
+#its-in-3d.present b {
+ -webkit-transform: translateZ(0px);
+ -moz-transform: translateZ(0px);
+ -ms-transform: translateZ(0px);
+ -o-transform: translateZ(0px);
+ transform: translateZ(0px);
+}
+
+/*
+ The last step is an overview.
+ There is no content in it, so we make sure it's not visible because we want
+ to be able to click on other steps.
+
+*/
+#overview { display: none }
+
+/*
+ We also make other steps visible and give them a pointer cursor using the
+ `impress-on-` class.
+*/
+.impress-on-overview .step {
+ opacity: 1;
+ cursor: pointer;
+}
+
+
+/*
+ Now, when we have all the steps styled let's give users a hint how to navigate
+ around the presentation.
+
+ The best way to do this would be to use JavaScript, show a delayed hint for a
+ first time users, then hide it and store a status in cookie or localStorage...
+
+ But I wanted to have some CSS fun and avoid additional scripting...
+
+ Let me explain it first, so maybe the transition magic will be more readable
+ when you read the code.
+
+ First of all I wanted the hint to appear only when user is idle for a while.
+ You can't detect the 'idle' state in CSS, but I delayed a appearing of the
+ hint by 5s using transition-delay.
+
+ You also can't detect in CSS if the user is a first-time visitor, so I had to
+ make an assumption that I'll only show the hint on the first step. And when
+ the step is changed hide the hint, because I can assume that user already
+ knows how to navigate.
+
+ To summarize it - hint is shown when the user is on the first step for longer
+ than 5 seconds.
+
+ The other problem I had was caused by the fact that I wanted the hint to fade
+ in and out. It can be easily achieved by transitioning the opacity property.
+ But that also meant that the hint was always on the screen, even if totally
+ transparent. It covered part of the screen and you couldn't correctly clicked
+ through it.
+ Unfortunately you cannot transition between display `block` and `none` in pure
+ CSS, so I needed a way to not only fade out the hint but also move it out of
+ the screen.
+
+ I solved this problem by positioning the hint below the bottom of the screen
+ with CSS transform and moving it up to show it. But I also didn't want this move
+ to be visible. I wanted the hint only to fade in and out visually, so I delayed
+ the fade in transition, so it starts when the hint is already in its correct
+ position on the screen.
+
+ I know, it sounds complicated ... maybe it would be easier with the code?
+*/
+
+.hint {
+ /*
+ We hide the hint until presentation is started and from browsers not supporting
+ impress.js, as they will have a linear scrollable view ...
+ */
+ display: none;
+
+ /*
+ ... and give it some fixed position and nice styles.
+ */
+ position: fixed;
+ left: 0;
+ right: 0;
+ bottom: 200px;
+
+ background: rgba(0,0,0,0.5);
+ color: #EEE;
+ text-align: center;
+
+ font-size: 50px;
+ padding: 20px;
+
+ z-index: 100;
+
+ /*
+ By default we don't want the hint to be visible, so we make it transparent ...
+ */
+ opacity: 0;
+
+ /*
+ ... and position it below the bottom of the screen (relative to it's fixed position)
+ */
+ -webkit-transform: translateY(400px);
+ -moz-transform: translateY(400px);
+ -ms-transform: translateY(400px);
+ -o-transform: translateY(400px);
+ transform: translateY(400px);
+
+ /*
+ Now let's imagine that the hint is visible and we want to fade it out and move out
+ of the screen.
+
+ So we define the transition on the opacity property with 1s duration and another
+ transition on transform property delayed by 1s so it will happen after the fade out
+ on opacity finished.
+
+ This way user will not see the hint moving down.
+ */
+ -webkit-transition: opacity 1s, -webkit-transform 0.5s 1s;
+ -moz-transition: opacity 1s, -moz-transform 0.5s 1s;
+ -ms-transition: opacity 1s, -ms-transform 0.5s 1s;
+ -o-transition: opacity 1s, -o-transform 0.5s 1s;
+ transition: opacity 1s, transform 0.5s 1s;
+}
+
+/*
+ Now we 'enable' the hint when presentation is initialized ...
+*/
+.impress-enabled .hint { display: block }
+
+/*
+ ... and we will show it when the first step (with id 'bored') is active.
+*/
+.impress-on-bored .hint {
+ /*
+ We remove the transparency and position the hint in its default fixed
+ position.
+ */
+ opacity: 1;
+
+ -webkit-transform: translateY(0px);
+ -moz-transform: translateY(0px);
+ -ms-transform: translateY(0px);
+ -o-transform: translateY(0px);
+ transform: translateY(0px);
+
+ /*
+ Now for fade in transition we have the oposite situation from the one
+ above.
+
+ First after 4.5s delay we animate the transform property to move the hint
+ into its correct position and after that we fade it in with opacity
+ transition.
+ */
+ -webkit-transition: opacity 1s 5s, -webkit-transform 0.5s 4.5s;
+ -moz-transition: opacity 1s 5s, -moz-transform 0.5s 4.5s;
+ -ms-transition: opacity 1s 5s, -ms-transform 0.5s 4.5s;
+ -o-transition: opacity 1s 5s, -o-transform 0.5s 4.5s;
+ transition: opacity 1s 5s, transform 0.5s 4.5s;
+}
+
+/*
+ And as the last thing there is a workaround for quite strange bug.
+ It happens a lot in Chrome. I don't remember if I've seen it in Firefox.
+
+ Sometimes the element positioned in 3D (especially when it's moved back
+ along Z axis) is not clickable, because it falls 'behind' the <body>
+ element.
+
+ To prevent this, I decided to make <body> non clickable by setting
+ pointer-events property to `none` value.
+ Value if this property is inherited, so to make everything else clickable
+ I bring it back on the #impress element.
+
+ If you want to know more about `pointer-events` here are some docs:
+ https://developer.mozilla.org/en/CSS/pointer-events
+
+ There is one very important thing to notice about this workaround - it makes
+ everything 'unclickable' except what's in #impress element.
+
+ So use it wisely ... or don't use at all.
+*/
+.impress-enabled { pointer-events: none }
+.impress-enabled #impress { pointer-events: auto }
+
+/*
+ There is one funny thing I just realized.
+
+ Thanks to this workaround above everything except #impress element is invisible
+ for click events. That means that the hint element is also not clickable.
+ So basically all of this transforms and delayed transitions trickery was probably
+ not needed at all...
+
+ But it was fun to learn about it, wasn't it?
+*/
+
+/*
+ That's all I have for you in this file.
+ Thanks for reading. I hope you enjoyed it at least as much as I enjoyed writing it
+ for you.
+*/
View
BIN  static/impress/impress/favicon.png
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
View
438 static/impress/impress/index.html
@@ -0,0 +1,438 @@
+<!doctype html>
+
+<!--
+
+ Welcome to the light side of the source, young padawan.
+
+ One step closer to learn something interesting you are...
+
+ ____
+ _.' : `._
+ .-.'`. ; .'`.-.
+ __ / : ___\ ; /___ ; \ __
+ ,'_ ""=-.:__;".-.";: :".-.":__;.-="" _`,
+ :' `.t""=-.. '<@.`;_ ',@:` ..-=""j.' `;
+ `:-.._J '-.-'L__ `-.-' L_..-;'
+ "-.__ ; .-" "-. : __.-"
+ L ' /.======.\ ' J
+ "-. "__" .-"
+ __.l"-:_JL_;-";.__
+ .-j/'.; ;"""" / .'\"-.
+ .' /:`. "-.: .-" .'; `.
+ .-" / ; "-. "-..-" .-" : "-.
+ .+"-. : : "-.__.-" ;-._ \
+ ; \ `.; ; : : "+. ;
+ : ; ; ; : ; : \:
+ ; : ; : ;: ; :
+ : \ ; : ; : ; / ::
+ ; ; : ; : ; : ;:
+ : : ; : ; : : ; : ;
+ ;\ : ; : ; ; ; ;
+ : `."-; : ; : ; / ;
+ ; -: ; : ; : .-" :
+ :\ \ : ; : \.-" :
+ ;`. \ ; : ;.'_..-= / ;
+ : "-. "-: ; :/." .' :
+ \ \ : ;/ __ :
+ \ .-`.\ /t-"" ":-+. :
+ `. .-" `l __/ /`. : ; ; \ ;
+ \ .-" .-"-.-" .' .'j \ / ;/
+ \ / .-" /. .'.' ;_:' ;
+ :-""-.`./-.' / `.___.'
+ \ `t ._ /
+ "-.t-._:'
+
+-->
+
+<!--
+
+ So you'd like to know how to use impress.js?
+
+ You've made the first, very important step - you're reading the source code.
+ And that's how impress.js presentations are built - with HTML and CSS code.
+
+ Believe me, you need quite decent HTML and CSS skills to be able to use impress.js effectively.
+ And what is even more important, you need to be a designer, too, because there are no default
+ styles for impress.js presentations, there is no default or automatic layout for them.
+
+ You need to design and build it by hand.
+
+ So...
+
+ Would you still like to know how to use impress.js?
+
+-->
+
+<html lang="en">
+<head>
+ <meta charset="utf-8" />
+ <meta name="viewport" content="width=1024" />
+ <meta name="apple-mobile-web-app-capable" content="yes" />
+ <title>impress.js | presentation tool based on the power of CSS3 transforms and transitions in modern browsers | by Bartek Szopka @bartaz</title>
+
+ <meta name="description" content="impress.js is a presentation tool based on the power of CSS3 transforms and transitions in modern browsers and inspired by the idea behind prezi.com." />
+ <meta name="author" content="Bartek Szopka" />
+
+ <link href="http://fonts.googleapis.com/css?family=Open+Sans:regular,semibold,italic,italicsemibold|PT+Sans:400,700,400italic,700italic|PT+Serif:400,700,400italic,700italic" rel="stylesheet" />
+
+ <!--
+
+ Impress.js doesn't depend on any external stylesheet. Script adds all styles it needs for
+ presentation to work.
+
+ This style below contains styles only for demo presentation. Browse it to see how impress.js
+ classes are used to style presentation steps, or how to apply fallback styles, but I don't want
+ you to use them directly in your presentation.
+
+ Be creative, build your own. We don't really want all impress.js presentations to look the same,
+ do we?
+
+ When creating your own presentation get rid of this file. Start from scratch, it's fun!
+
+ -->
+ <link href="css/impress-demo.css" rel="stylesheet" />
+
+ <link rel="shortcut icon" href="favicon.png" />
+ <link rel="apple-touch-icon" href="apple-touch-icon.png" />
+</head>
+
+<!--
+
+ Body element is used by impress.js to set some useful class names, that will allow you to detect
+ the support and state of the presentation in CSS or other scripts.
+
+ First very useful class name is `impress-not-supported`. This class means, that browser doesn't
+ support features required by impress.js, so you should apply some fallback styles in your CSS.
+ It's not necessary to add it manually on this element. If the script detects that browser is not
+ good enough it will add this class, but keeping it in HTML means that users without JavaScript
+ will also get fallback styles.
+
+ When impress.js script detects that browser supports all required features, this class name will
+ be removed.
+
+ The class name on body element also depends on currently active presentation step. More details about
+ it can be found later, when `hint` element is being described.
+
+-->
+<body class="impress-not-supported">
+
+<!--
+ For example this fallback message is only visible when there is `impress-not-supported` class on body.
+-->
+<div class="fallback-message">
+ <p>Your browser <b>doesn't support the features required</b> by impress.js, so you are presented with a simplified version of this presentation.</p>
+ <p>For the best experience please use the latest <b>Chrome</b>, <b>Safari</b> or <b>Firefox</b> browser.</p>
+</div>
+
+<!--
+
+ Now that's the core element used by impress.js.
+
+ That's the wrapper for your presentation steps. In this element all the impress.js magic happens.
+ It doesn't have to be a `<div>`. Only `id` is important here as that's how the script find it.
+
+ You probably won't need it now, but there are some configuration options that can be set on this element.
+
+ To change the duration of the transition between slides use `data-transition-duration="2000"` giving it
+ a number of ms. It defaults to 1000 (1s).
+
+ You can also control the perspective with `data-perspective="500"` giving it a number of pixels.
+ It defaults to 1000. You can set it to 0 if you don't want any 3D effects.
+ If you are willing to change this value make sure you understand how CSS perspective works:
+ https://developer.mozilla.org/en/CSS/perspective
+
+ But as I said, you won't need it for now, so don't worry - there are some simple but interesing things
+ right around the corner of this tag ;)
+
+-->
+<div id="impress">
+
+ <!--
+
+ Here is where interesting thing start to happen.
+
+ Each step of the presentation should be an element inside the `#impress` with a class name
+ of `step`. These step elements are positioned, rotated and scaled by impress.js, and
+ the 'camera' shows them on each step of the presentation.
+
+ Positioning information is passed through data attributes.
+
+ In the example below we only specify x and y position of the step element with `data-x="-1000"`
+ and `data-y="-1500` attributes. This means that **the center** of the element (yes, the center)
+ will be positioned in point x = -1000px and y = -1500px of the presentation 'canvas'.
+
+ It will not be rotated or scaled.
+
+ -->
+ <div id="bored" class="step slide" data-x="-1000" data-y="-1500">
+ <q>Aren't you just <b>bored</b> with all those slides-based presentations?</q>
+ </div>
+
+ <!--
+
+ The `id` attribute of the step element is used to identify it in the URL, but it's optional.
+ If it is not defined, it will get a default value of `step-N` where N is a number of slide.
+
+ So in the example below it'll be `step-2`.
+
+ The hash part of the url when this step is active will be `#/step-2`.
+
+ You can also use `#step-2` in a link, to point directly to this particular step.
+
+ Please note, that while `#/step-2` (with slash) would also work in a link it's not recommended.
+ Using classic `id`-based links like `#step-2` makes these links usable also in fallback mode.
+
+ -->
+ <div class="step slide" data-x="0" data-y="-1500">
+ <q>Don't you think that presentations given <strong>in modern browsers</strong> shouldn't <strong>copy the limits</strong> of 'classic' slide decks?</q>
+ </div>
+
+ <div class="step slide" data-x="1000" data-y="-1500">
+ <q>Would you like to <strong>impress your audience</strong> with <strong>stunning visualization</strong> of your talk?</q>
+ </div>
+
+ <!--
+
+ This is an example of step element being scaled.
+
+ Again, we use a `data-` attribute, this time it's `data-scale="4"`, so it means that this
+ element will be 4 times larger than the others.
+ From presentation and transitions point of view it means, that it will have to be scaled
+ down (4 times) to make it back to it's correct size.
+
+ -->
+ <div id="title" class="step" data-x="0" data-y="0" data-scale="4">
+ <span class="try">then you should try</span>
+ <h1>impress.js<sup>*</sup></h1>
+ <span class="footnote"><sup>*</sup> no rhyme intended</span>
+ </div>
+
+ <!--
+
+ This element introduces rotation.
+
+ Notation shouldn't be a surprise. We use `data-rotate="90"` attribute, meaning that this
+ element should be rotated by 90 degrees clockwise.
+
+ -->
+ <div id="its" class="step" data-x="850" data-y="3000" data-rotate="90" data-scale="5">
+ <p>It's a <strong>presentation tool</strong> <br/>
+ inspired by the idea behind <a href="http://prezi.com">prezi.com</a> <br/>
+ and based on the <strong>power of CSS3 transforms and transitions</strong> in modern browsers.</p>
+ </div>
+
+ <div id="big" class="step" data-x="3500" data-y="2100" data-rotate="180" data-scale="6">
+ <p>visualize your <b>big</b> <span class="thoughts">thoughts</span></p>
+ </div>
+
+ <!--
+
+ And now it gets really exiting! We move into third dimension!
+
+ Along with `data-x` and `data-y`, you can define the position on third (Z) axis, with
+ `data-z`. In the example below we use `data-z="-3000"` meaning that element should be
+ positioned far away from us (by 3000px).
+
+ -->
+ <div id="tiny" class="step" data-x="2825" data-y="2325" data-z="-3000" data-rotate="300" data-scale="1">
+ <p>and <b>tiny</b> ideas</p>
+ </div>
+
+ <!--
+
+ This step here doesn't introduce anything new when it comes to data attributes, but you
+ should notice in the demo that some words of this text are being animated.
+ It's a very basic CSS transition that is applied to the elements when this step element is
+ reached.
+
+ At the very beginning of the presentation all step elements are given the class of `future`.
+ It means that they haven't been visited yet.
+
+ When the presentation moves to given step `future` is changed to `present` class name.
+ That's how animation on this step works - text moves when the step has `present` class.
+
+ Finally when the step is left the `present` class is removed from the element and `past`
+ class is added.
+
+ So basically every step element has one of three classes: `future`, `present` and `past`.
+ Only one current step has the `present` class.
+
+ -->
+ <div id="ing" class="step" data-x="3500" data-y="-850" data-rotate="270" data-scale="6">
+ <p>by <b class="positioning">positioning</b>, <b class="rotating">rotating</b> and <b class="scaling">scaling</b> them on an infinite canvas</p>
+ </div>
+
+ <div id="imagination" class="step" data-x="6700" data-y="-300" data-scale="6">
+ <p>the only <b>limit</b> is your <b class="imagination">imagination</b></p>
+ </div>
+
+ <div id="source" class="step" data-x="6300" data-y="2000" data-rotate="20" data-scale="4">
+ <p>want to know more?</p>
+ <q><a href="http://github.com/bartaz/impress.js">use the source</a>, Luke!</q>
+ </div>
+
+ <div id="one-more-thing" class="step" data-x="6000" data-y="4000" data-scale="2">
+ <p>one more thing...</p>
+ </div>
+
+ <!--
+
+ And the last one shows full power and flexibility of impress.js.
+
+ You can not only position element in 3D, but also rotate it around any axis.
+ So this one here will get rotated by -40 degrees (40 degrees anticlockwise) around X axis and
+ 10 degrees (clockwise) around Y axis.
+
+ You can of course rotate it around Z axis with `data-rotate-z` - it has exactly the same effect
+ as `data-rotate` (these two are basically aliases).
+
+ -->
+ <div id="its-in-3d" class="step" data-x="6200" data-y="4300" data-z="-100" data-rotate-x="-40" data-rotate-y="10" data-scale="2">
+ <p><span class="have">have</span> <span class="you">you</span> <span class="noticed">noticed</span> <span class="its">it's</span> <span class="in">in</span> <b>3D<sup>*</sup></b>?</p>
+ <span class="footnote">* beat that, prezi ;)</span>
+ </div>
+
+ <!--
+
+ So to make a summary of all the possible attributes used to position presentation steps, we have:
+
+ * `data-x`, `data-y`, `data-z` - they define the position of **the center** of step element on
+ the canvas in pixels; their default value is 0;
+ * `data-rotate-x`, `data-rotate-y`, 'data-rotate-z`, `data-rotate` - they define the rotation of
+ the element around given axis in degrees; their default value is 0; `data-rotate` and `data-rotate-z`
+ are exactly the same;
+ * `data-scale` - defines the scale of step element; default value is 1
+
+ These values are used by impress.js in CSS transformation functions, so for more information consult
+ CSS transfrom docs: https://developer.mozilla.org/en/CSS/transform
+
+ -->
+ <div id="overview" class="step" data-x="3000" data-y="1500" data-scale="10">
+ </div>
+
+</div>
+
+<!--
+
+ Hint is not related to impress.js in any way.
+
+ But it can show you how to use impress.js features in creative way.
+
+ When the presentation step is shown (selected) its element gets the class of "active" and the body element
+ gets the class based on active step id `impress-on-ID` (where ID is the step's id)... It may not be
+ so clear because of all these "ids" in previous sentence, so for example when the first step (the one with
+ the id of `bored`) is active, body element gets a class of `impress-on-bored`.
+
+ This class is used by this hint below. Check CSS file to see how it's shown with delayed CSS animation when
+ the first step of presentation is visible for a couple of seconds.
+
+ ...
+
+ And when it comes to this piece of JavaScript below ... kids, don't do this at home ;)
+ It's just a quick and dirty workaround to get different hint text for touch devices.
+ In a real world it should be at least placed in separate JS file ... and the touch content should be
+ probably just hidden somewhere in HTML - not hard-coded in the script.
+
+ Just sayin' ;)
+
+-->
+<div class="hint">
+ <p>Use a spacebar or arrow keys to navigate</p>
+</div>
+<script>
+if ("ontouchstart" in document.documentElement) {
+ document.querySelector(".hint").innerHTML = "<p>Tap on the left or right to navigate</p>";
+}
+</script>
+
+<!--
+
+ Last, but not least.
+
+ To make all described above really work, you need to include impress.js in the page.
+ I strongly encourage to minify it first.
+
+ In here I just include full source of the script to make it more readable.
+
+ You also need to call a `impress().init()` function to initialize impress.js presentation.
+ And you should do it in the end of your document. Not only because it's a good practice, but also
+ because it should be done when the whole document is ready.
+ Of course you can wrap it in any kind of "DOM ready" event, but I was too lazy to do so ;)
+
+-->
+<script src="js/impress.js"></script>
+<script>impress().init();</script>
+
+<!--
+
+ The `impress()` function also gives you access to the API that controls the presentation.
+
+ Just store the result of the call:
+
+ var api = impress();
+
+ and you will get three functions you can call:
+
+ `api.init()` - initializes the presentation,
+ `api.next()` - moves to next step of the presentation,
+ `api.prev()` - moves to previous step of the presentation,
+ `api.goto( idx | id | element, [duration] )` - moves the presentation to the step given by its index number
+ id or the DOM element; second parameter can be used to define duration of the transition in ms,
+ but it's optional - if not provided default transition duration for the presentation will be used.
+
+ You can also simply call `impress()` again to get the API, so `impress().next()` is also allowed.
+ Don't worry, it wont initialize the presentation again.
+
+ For some example uses of this API check the last part of the source of impress.js where the API
+ is used in event handlers.
+
+-->
+
+</body>
+</html>
+
+<!--
+
+ Now you know more or less everything you need to build your first impress.js presentation, but before
+ you start...
+
+ Oh, you've already cloned the code from GitHub?
+
+ You have it open in text editor?
+
+ Stop right there!
+
+ That's not how you create awesome presentations. This is only a code. Implementation of the idea that
+ first needs to grow in your mind.
+
+ So if you want to build great presentation take a pencil and piece of paper. And turn off the computer.
+
+ Sketch, draw and write. Brainstorm your ideas on a paper. Try to build a mind-map of what you'd like
+ to present. It will get you closer and closer to the layout you'll build later with impress.js.
+
+ Get back to the code only when you have your presentation ready on a paper. It doesn't make sense to do
+ it earlier, because you'll only waste your time fighting with positioning of useless points.
+
+ If you think I'm crazy, please put your hands on a book called "Presentation Zen". It's all about
+ creating awesome and engaging presentations.
+
+ Think about it. 'Cause impress.js may not help you, if you have nothing interesting to say.
+
+-->
+
+<!--
+
+ Are you still reading this?
+
+ For real?
+
+ I'm impressed! Feel free to let me know that you got that far (I'm @bartaz on Twitter), 'cause I'd like
+ to congratulate you personally :)
+
+ But you don't have to do it now. Take my advice and take some time off. Make yourself a cup of coffee, tea,
+ or anything you like to drink. And raise a glass for me ;)
+
+ Cheers!
+
+-->
+
View
800 static/impress/impress/js/impress.js
@@ -0,0 +1,800 @@
+/**
+ * impress.js
+ *
+ * impress.js is a presentation tool based on the power of CSS3 transforms and transitions
+ * in modern browsers and inspired by the idea behind prezi.com.
+ *
+ *
+ * Copyright 2011-2012 Bartek Szopka (@bartaz)
+ *
+ * Released under the MIT and GPL Licenses.
+ *
+ * ------------------------------------------------
+ * author: Bartek Szopka
+ * version: 0.5.3
+ * url: http://bartaz.github.com/impress.js/
+ * source: http://github.com/bartaz/impress.js/
+ */
+
+/*jshint bitwise:true, curly:true, eqeqeq:true, forin:true, latedef:true, newcap:true,
+ noarg:true, noempty:true, undef:true, strict:true, browser:true */
+
+// You are one of those who like to know how thing work inside?
+// Let me show you the cogs that make impress.js run...
+(function ( document, window ) {
+ 'use strict';
+
+ // HELPER FUNCTIONS
+
+ // `pfx` is a function that takes a standard CSS property name as a parameter
+ // and returns it's prefixed version valid for current browser it runs in.
+ // The code is heavily inspired by Modernizr http://www.modernizr.com/
+ var pfx = (function () {
+
+ var style = document.createElement('dummy').style,
+ prefixes = 'Webkit Moz O ms Khtml'.split(' '),
+ memory = {};
+
+ return function ( prop ) {
+ if ( typeof memory[ prop ] === "undefined" ) {
+
+ var ucProp = prop.charAt(0).toUpperCase() + prop.substr(1),
+ props = (prop + ' ' + prefixes.join(ucProp + ' ') + ucProp).split(' ');
+
+ memory[ prop ] = null;
+ for ( var i in props ) {
+ if ( style[ props[i] ] !== undefined ) {
+ memory[ prop ] = props[i];
+ break;
+ }
+ }
+
+ }
+
+ return memory[ prop ];
+ };
+
+ })();
+
+ // `arraify` takes an array-like object and turns it into real Array
+ // to make all the Array.prototype goodness available.
+ var arrayify = function ( a ) {
+ return [].slice.call( a );
+ };
+
+ // `css` function applies the styles given in `props` object to the element
+ // given as `el`. It runs all property names through `pfx` function to make
+ // sure proper prefixed version of the property is used.
+ var css = function ( el, props ) {
+ var key, pkey;
+ for ( key in props ) {
+ if ( props.hasOwnProperty(key) ) {
+ pkey = pfx(key);
+ if ( pkey !== null ) {
+ el.style[pkey] = props[key];
+ }
+ }
+ }
+ return el;
+ };
+
+ // `toNumber` takes a value given as `numeric` parameter and tries to turn
+ // it into a number. If it is not possible it returns 0 (or other value
+ // given as `fallback`).
+ var toNumber = function (numeric, fallback) {
+ return isNaN(numeric) ? (fallback || 0) : Number(numeric);
+ };
+
+ // `byId` returns element with given `id` - you probably have guessed that ;)
+ var byId = function ( id ) {
+ return document.getElementById(id);
+ };
+
+ // `$` returns first element for given CSS `selector` in the `context` of
+ // the given element or whole document.
+ var $ = function ( selector, context ) {
+ context = context || document;
+ return context.querySelector(selector);
+ };
+
+ // `$$` return an array of elements for given CSS `selector` in the `context` of
+ // the given element or whole document.
+ var $$ = function ( selector, context ) {
+ context = context || document;
+ return arrayify( context.querySelectorAll(selector) );
+ };
+
+ // `triggerEvent` builds a custom DOM event with given `eventName` and `detail` data
+ // and triggers it on element given as `el`.
+ var triggerEvent = function (el, eventName, detail) {
+ var event = document.createEvent("CustomEvent");
+ event.initCustomEvent(eventName, true, true, detail);
+ el.dispatchEvent(event);
+ };
+
+ // `translate` builds a translate transform string for given data.
+ var translate = function ( t ) {
+ return " translate3d(" + t.x + "px," + t.y + "px," + t.z + "px) ";
+ };
+
+ // `rotate` builds a rotate transform string for given data.
+ // By default the rotations are in X Y Z order that can be reverted by passing `true`
+ // as second parameter.
+ var rotate = function ( r, revert ) {
+ var rX = " rotateX(" + r.x + "deg) ",
+ rY = " rotateY(" + r.y + "deg) ",
+ rZ = " rotateZ(" + r.z + "deg) ";
+
+ return revert ? rZ+rY+rX : rX+rY+rZ;
+ };
+
+ // `scale` builds a scale transform string for given data.
+ var scale = function ( s ) {
+ return " scale(" + s + ") ";
+ };
+
+ // `perspective` builds a perspective transform string for given data.
+ var perspective = function ( p ) {
+ return " perspective(" + p + "px) ";
+ };
+
+ // `getElementFromHash` returns an element located by id from hash part of
+ // window location.
+ var getElementFromHash = function () {
+ // get id from url # by removing `#` or `#/` from the beginning,
+ // so both "fallback" `#slide-id` and "enhanced" `#/slide-id` will work
+ return byId( window.location.hash.replace(/^#\/?/,"") );
+ };
+
+ // `computeWindowScale` counts the scale factor between window size and size
+ // defined for the presentation in the config.
+ var computeWindowScale = function ( config ) {
+ var hScale = window.innerHeight / config.height,
+ wScale = window.innerWidth / config.width,
+ scale = hScale > wScale ? wScale : hScale;
+
+ if (config.maxScale && scale > config.maxScale) {
+ scale = config.maxScale;
+ }
+
+ if (config.minScale && scale < config.minScale) {
+ scale = config.minScale;
+ }
+
+ return scale;
+ };
+
+ // CHECK SUPPORT
+ var body = document.body;
+
+ var ua = navigator.userAgent.toLowerCase();
+ var impressSupported =
+ // browser should support CSS 3D transtorms
+ ( pfx("perspective") !== null ) &&
+
+ // and `classList` and `dataset` APIs
+ ( body.classList ) &&
+ ( body.dataset ) &&
+
+ // but some mobile devices need to be blacklisted,
+ // because their CSS 3D support or hardware is not
+ // good enough to run impress.js properly, sorry...
+ ( ua.search(/(iphone)|(ipod)|(android)/) === -1 );
+
+ if (!impressSupported) {
+ // we can't be sure that `classList` is supported
+ body.className += " impress-not-supported ";
+ } else {
+ body.classList.remove("impress-not-supported");
+ body.classList.add("impress-supported");
+ }
+
+ // GLOBALS AND DEFAULTS
+
+ // This is were the root elements of all impress.js instances will be kept.
+ // Yes, this means you can have more than one instance on a page, but I'm not
+ // sure if it makes any sense in practice ;)
+ var roots = {};
+
+ // some default config values.
+ var defaults = {
+ width: 1024,
+ height: 768,
+ maxScale: 1,
+ minScale: 0,
+
+ perspective: 1000,
+
+ transitionDuration: 1000
+ };
+
+ // it's just an empty function ... and a useless comment.
+ var empty = function () { return false; };
+
+ // IMPRESS.JS API
+
+ // And that's where interesting things will start to happen.
+ // It's the core `impress` function that returns the impress.js API
+ // for a presentation based on the element with given id ('impress'
+ // by default).
+ var impress = window.impress = function ( rootId ) {
+
+ // If impress.js is not supported by the browser return a dummy API
+ // it may not be a perfect solution but we return early and avoid
+ // running code that may use features not implemented in the browser.
+ if (!impressSupported) {
+ return {
+ init: empty,
+ goto: empty,
+ prev: empty,
+ next: empty
+ };
+ }
+
+ rootId = rootId || "impress";
+
+ // if given root is already initialized just return the API
+ if (roots["impress-root-" + rootId]) {
+ return roots["impress-root-" + rootId];
+ }
+
+ // data of all presentation steps
+ var stepsData = {};
+
+ // element of currently active step
+ var activeStep = null;
+
+ // current state (position, rotation and scale) of the presentation
+ var currentState = null;
+
+ // array of step elements
+ var steps = null;
+
+ // configuration options
+ var config = null;
+
+ // scale factor of the browser window
+ var windowScale = null;
+
+ // root presentation elements
+ var root = byId( rootId );
+ var canvas = document.createElement("div");
+
+ var initialized = false;
+
+ // STEP EVENTS
+ //
+ // There are currently two step events triggered by impress.js
+ // `impress:stepenter` is triggered when the step is shown on the
+ // screen (the transition from the previous one is finished) and
+ // `impress:stepleave` is triggered when the step is left (the
+ // transition to next step just starts).
+
+ // reference to last entered step
+ var lastEntered = null;
+
+ // `onStepEnter` is called whenever the step element is entered
+ // but the event is triggered only if the step is different than
+ // last entered step.
+ var onStepEnter = function (step) {
+ if (lastEntered !== step) {
+ triggerEvent(step, "impress:stepenter");
+ lastEntered = step;
+ }
+ };
+
+ // `onStepLeave` is called whenever the step element is left
+ // but the event is triggered only if the step is the same as
+ // last entered step.
+ var onStepLeave = function (step) {
+ if (lastEntered === step) {
+ triggerEvent(step, "impress:stepleave");
+ lastEntered = null;
+ }
+ };
+
+ // `initStep` initializes given step element by reading data from its
+ // data attributes and setting correct styles.
+ var initStep = function ( el, idx ) {
+ var data = el.dataset,
+ step = {
+ translate: {
+ x: toNumber(data.x),
+ y: toNumber(data.y),
+ z: toNumber(data.z)
+ },
+ rotate: {
+ x: toNumber(data.rotateX),
+ y: toNumber(data.rotateY),
+ z: toNumber(data.rotateZ || data.rotate)
+ },
+ scale: toNumber(data.scale, 1),
+ el: el
+ };
+
+ if ( !el.id ) {
+ el.id = "step-" + (idx + 1);
+ }
+
+ stepsData["impress-" + el.id] = step;
+
+ css(el, {
+ position: "absolute",
+ transform: "translate(-50%,-50%)" +
+ translate(step.translate) +
+ rotate(step.rotate) +
+ scale(step.scale),
+ transformStyle: "preserve-3d"
+ });
+ };
+
+ // `init` API function that initializes (and runs) the presentation.
+ var init = function () {
+ if (initialized) { return; }
+
+ // First we set up the viewport for mobile devices.
+ // For some reason iPad goes nuts when it is not done properly.
+ var meta = $("meta[name='viewport']") || document.createElement("meta");
+ meta.content = "width=device-width, minimum-scale=1, maximum-scale=1, user-scalable=no";
+ if (meta.parentNode !== document.head) {
+ meta.name = 'viewport';
+ document.head.appendChild(meta);
+ }
+
+ // initialize configuration object
+ var rootData = root.dataset;
+ config = {
+ width: toNumber( rootData.width, defaults.width ),
+ height: toNumber( rootData.height, defaults.height ),
+ maxScale: toNumber( rootData.maxScale, defaults.maxScale ),
+ minScale: toNumber( rootData.minScale, defaults.minScale ),
+ perspective: toNumber( rootData.perspective, defaults.perspective ),
+ transitionDuration: toNumber( rootData.transitionDuration, defaults.transitionDuration )
+ };
+
+ windowScale = computeWindowScale( config );
+
+ // wrap steps with "canvas" element
+ arrayify( root.childNodes ).forEach(function ( el ) {
+ canvas.appendChild( el );
+ });
+ root.appendChild(canvas);
+
+ // set initial styles
+ document.documentElement.style.height = "100%";
+
+ css(body, {
+ height: "100%",
+ overflow: "hidden"
+ });
+
+ var rootStyles = {
+ position: "absolute",
+ transformOrigin: "top left",
+ transition: "all 0s ease-in-out",
+ transformStyle: "preserve-3d"
+ };
+
+ css(root, rootStyles);
+ css(root, {
+ top: "50%",
+ left: "50%",
+ transform: perspective( config.perspective/windowScale ) + scale( windowScale )
+ });
+ css(canvas, rootStyles);
+
+ body.classList.remove("impress-disabled");
+ body.classList.add("impress-enabled");
+
+ // get and init steps
+ steps = $$(".step", root);
+ steps.forEach( initStep );
+
+ // set a default initial state of the canvas
+ currentState = {
+ translate: { x: 0, y: 0, z: 0 },
+ rotate: { x: 0, y: 0, z: 0 },
+ scale: 1
+ };
+
+ initialized = true;
+
+ triggerEvent(root, "impress:init", { api: roots[ "impress-root-" + rootId ] });
+ };
+
+ // `getStep` is a helper function that returns a step element defined by parameter.
+ // If a number is given, step with index given by the number is returned, if a string
+ // is given step element with such id is returned, if DOM element is given it is returned
+ // if it is a correct step element.
+ var getStep = function ( step ) {
+ if (typeof step === "number") {
+ step = step < 0 ? steps[ steps.length + step] : steps[ step ];
+ } else if (typeof step === "string") {
+ step = byId(step);
+ }
+ return (step && step.id && stepsData["impress-" + step.id]) ? step : null;
+ };
+
+ // used to reset timeout for `impress:stepenter` event
+ var stepEnterTimeout = null;
+
+ // `goto` API function that moves to step given with `el` parameter (by index, id or element),
+ // with a transition `duration` optionally given as second parameter.
+ var goto = function ( el, duration ) {
+
+ if ( !initialized || !(el = getStep(el)) ) {
+ // presentation not initialized or given element is not a step
+ return false;
+ }
+
+ // Sometimes it's possible to trigger focus on first link with some keyboard action.
+ // Browser in such a case tries to scroll the page to make this element visible
+ // (even that body overflow is set to hidden) and it breaks our careful positioning.
+ //
+ // So, as a lousy (and lazy) workaround we will make the page scroll back to the top
+ // whenever slide is selected
+ //
+ // If you are reading this and know any better way to handle it, I'll be glad to hear about it!
+ window.scrollTo(0, 0);
+
+ var step = stepsData["impress-" + el.id];
+
+ if ( activeStep ) {
+ activeStep.classList.remove("active");
+ body.classList.remove("impress-on-" + activeStep.id);
+ }
+ el.classList.add("active");
+
+ body.classList.add("impress-on-" + el.id);
+
+ // compute target state of the canvas based on given step
+ var target = {
+ rotate: {
+ x: -step.rotate.x,
+ y: -step.rotate.y,
+ z: -step.rotate.z
+ },
+ translate: {
+ x: -step.translate.x,
+ y: -step.translate.y,
+ z: -step.translate.z
+ },
+ scale: 1 / step.scale
+ };
+
+ // Check if the transition is zooming in or not.
+ //
+ // This information is used to alter the transition style:
+ // when we are zooming in - we start with move and rotate transition
+ // and the scaling is delayed, but when we are zooming out we start
+ // with scaling down and move and rotation are delayed.
+ var zoomin = target.scale >= currentState.scale;
+
+ duration = toNumber(duration, config.transitionDuration);
+ var delay = (duration / 2);
+
+ // if the same step is re-selected, force computing window scaling,
+ // because it is likely to be caused by window resize
+ if (el === activeStep) {
+ windowScale = computeWindowScale(config);
+ }
+
+ var targetScale = target.scale * windowScale;
+
+ // trigger leave of currently active element (if it's not the same step again)
+ if (activeStep && activeStep !== el) {
+ onStepLeave(activeStep);
+ }
+
+ // Now we alter transforms of `root` and `canvas` to trigger transitions.
+ //
+ // And here is why there are two elements: `root` and `canvas` - they are
+ // being animated separately:
+ // `root` is used for scaling and `canvas` for translate and rotations.
+ // Transitions on them are triggered with different delays (to make
+ // visually nice and 'natural' looking transitions), so we need to know
+ // that both of them are finished.
+ css(root, {
+ // to keep the perspective look similar for different scales
+ // we need to 'scale' the perspective, too
+ transform: perspective( config.perspective / targetScale ) + scale( targetScale ),
+ transitionDuration: duration + "ms",
+ transitionDelay: (zoomin ? delay : 0) + "ms"
+ });
+
+ css(canvas, {
+ transform: rotate(target.rotate, true) + translate(target.translate),
+ transitionDuration: duration + "ms",
+ transitionDelay: (zoomin ? 0 : delay) + "ms"
+ });
+
+ // Here is a tricky part...
+ //
+ // If there is no change in scale or no change in rotation and translation, it means there was actually
+ // no delay - because there was no transition on `root` or `canvas` elements.
+ // We want to trigger `impress:stepenter` event in the correct moment, so here we compare the current
+ // and target values to check if delay should be taken into account.
+ //
+ // I know that this `if` statement looks scary, but it's pretty simple when you know what is going on
+ // - it's simply comparing all the values.
+ if ( currentState.scale === target.scale ||
+ (currentState.rotate.x === target.rotate.x && currentState.rotate.y === target.rotate.y &&
+ currentState.rotate.z === target.rotate.z && currentState.translate.x === target.translate.x &&
+ currentState.translate.y === target.translate.y && currentState.translate.z === target.translate.z) ) {
+ delay = 0;
+ }
+
+ // store current state
+ currentState = target;
+ activeStep = el;
+
+ // And here is where we trigger `impress:stepenter` event.
+ // We simply set up a timeout to fire it taking transition duration (and possible delay) into account.
+ //
+ // I really wanted to make it in more elegant way. The `transitionend` event seemed to be the best way
+ // to do it, but the fact that I'm using transitions on two separate elements and that the `transitionend`
+ // event is only triggered when there was a transition (change in the values) caused some bugs and
+ // made the code really complicated, cause I had to handle all the conditions separately. And it still
+ // needed a `setTimeout` fallback for the situations when there is no transition at all.
+ // So I decided that I'd rather make the code simpler than use shiny new `transitionend`.
+ //
+ // If you want learn something interesting and see how it was done with `transitionend` go back to
+ // version 0.5.2 of impress.js: http://github.com/bartaz/impress.js/blob/0.5.2/js/impress.js
+ window.clearTimeout(stepEnterTimeout);
+ stepEnterTimeout = window.setTimeout(function() {
+ onStepEnter(activeStep);
+ }, duration + delay);
+
+ return el;
+ };
+
+ // `prev` API function goes to previous step (in document order)
+ var prev = function () {
+ var prev = steps.indexOf( activeStep ) - 1;
+ prev = prev >= 0 ? steps[ prev ] : steps[ steps.length-1 ];
+
+ return goto(prev);
+ };
+
+ // `next` API function goes to next step (in document order)
+ var next = function () {
+ var next = steps.indexOf( activeStep ) + 1;
+ next = next < steps.length ? steps[ next ] : steps[ 0 ];
+
+ return goto(next);
+ };
+
+ // Adding some useful classes to step elements.
+ //
+ // All the steps that have not been shown yet are given `future` class.
+ // When the step is entered the `future` class is removed and the `present`
+ // class is given. When the step is left `present` class is replaced with
+ // `past` class.
+ //
+ // So every step element is always in one of three possible states:
+ // `future`, `present` and `past`.
+ //
+ // There classes can be used in CSS to style different types of steps.
+ // For example the `present` class can be used to trigger some custom
+ // animations when step is shown.
+ root.addEventListener("impress:init", function(){
+ // STEP CLASSES
+ steps.forEach(function (step) {
+ step.classList.add("future");
+ });
+
+ root.addEventListener("impress:stepenter", function (event) {
+ event.target.classList.remove("past");
+ event.target.classList.remove("future");
+ event.target.classList.add("present");
+ }, false);
+
+ root.addEventListener("impress:stepleave", function (event) {
+ event.target.classList.remove("present");
+ event.target.classList.add("past");
+ }, false);
+
+ }, false);
+
+ // Adding hash change support.
+ root.addEventListener("impress:init", function(){
+
+ // last hash detected
+ var lastHash = "";
+
+ // `#/step-id` is used instead of `#step-id` to prevent default browser
+ // scrolling to element in hash.
+ //
+ // And it has to be set after animation finishes, because in Chrome it
+ // makes transtion laggy.
+ // BUG: http://code.google.com/p/chromium/issues/detail?id=62820
+ root.addEventListener("impress:stepenter", function (event) {
+ window.location.hash = lastHash = "#/" + event.target.id;
+ }, false);
+
+ window.addEventListener("hashchange", function () {
+ // When the step is entered hash in the location is updated
+ // (just few lines above from here), so the hash change is
+ // triggered and we would call `goto` again on the same element.
+ //
+ // To avoid this we store last entered hash and compare.
+ if (window.location.hash !== lastHash) {
+ goto( getElementFromHash() );
+ }
+ }, false);
+
+ // START
+ // by selecting step defined in url or first step of the presentation
+ goto(getElementFromHash() || steps[0], 0);
+ }, false);
+
+ body.classList.add("impress-disabled");
+
+ // store and return API for given impress.js root element
+ return (roots[ "impress-root-" + rootId ] = {
+ init: init,
+ goto: goto,
+ next: next,
+ prev: prev
+ });
+
+ };
+
+ // flag that can be used in JS to check if browser have passed the support test
+ impress.supported = impressSupported;
+
+})(document, window);
+
+// NAVIGATION EVENTS
+
+// As you can see this part is separate from the impress.js core code.
+// It's because these navigation actions only need what impress.js provides with
+// its simple API.
+//
+// In future I think about moving it to make them optional, move to separate files
+// and treat more like a 'plugins'.
+(function ( document, window ) {
+ 'use strict';
+
+ // throttling function calls, by Remy Sharp
+ // http://remysharp.com/2010/07/21/throttling-function-calls/
+ var throttle = function (fn, delay) {
+ var timer = null;
+ return function () {
+ var context = this, args = arguments;
+ clearTimeout(timer);
+ timer = setTimeout(function () {
+ fn.apply(context, args);
+ }, delay);
+ };
+ };
+
+ // wait for impress.js to be initialized
+ document.addEventListener("impress:init", function (event) {
+ // Getting API from event data.
+ // So you don't event need to know what is the id of the root element
+ // or anything. `impress:init` event data gives you everything you
+ // need to control the presentation that was just initialized.
+ var api = event.detail.api;
+
+ // KEYBOARD NAVIGATION HANDLERS
+
+ // Prevent default keydown action when one of supported key is pressed.
+ document.addEventListener("keydown", function ( event ) {
+ if ( event.keyCode === 9 || ( event.keyCode >= 32 && event.keyCode <= 34 ) || (event.keyCode >= 37 && event.keyCode <= 40) ) {
+ event.preventDefault();
+ }
+ }, false);
+
+ // Trigger impress action (next or prev) on keyup.
+
+ // Supported keys are:
+ // [space] - quite common in presentation software to move forward
+ // [up] [right] / [down] [left] - again common and natural addition,
+ // [pgdown] / [pgup] - often triggered by remote controllers,
+ // [tab] - this one is quite controversial, but the reason it ended up on
+ // this list is quite an interesting story... Remember that strange part
+ // in the impress.js code where window is scrolled to 0,0 on every presentation
+ // step, because sometimes browser scrolls viewport because of the focused element?
+ // Well, the [tab] key by default navigates around focusable elements, so clicking
+ // it very often caused scrolling to focused element and breaking impress.js
+ // positioning. I didn't want to just prevent this default action, so I used [tab]
+ // as another way to moving to next step... And yes, I know that for the sake of
+ // consistency I should add [shift+tab] as opposite action...
+ document.addEventListener("keyup", function ( event ) {
+ if ( event.keyCode === 9 || ( event.keyCode >= 32 && event.keyCode <= 34 ) || (event.keyCode >= 37 && event.keyCode <= 40) ) {
+ switch( event.keyCode ) {
+ case 33: // pg up
+ case 37: // left
+ case 38: // up
+ api.prev();
+ break;
+ case 9: // tab
+ case 32: // space
+ case 34: // pg down
+ case 39: // right
+ case 40: // down
+ api.next();
+ break;
+ }
+
+ event.preventDefault();
+ }
+ }, false);
+
+ // delegated handler for clicking on the links to presentation steps
+ document.addEventListener("click", function ( event ) {
+ // event delegation with "bubbling"
+ // check if event target (or any of its parents is a link)
+ var target = event.target;
+ while ( (target.tagName !== "A") &&
+ (target !== document.documentElement) ) {
+ target = target.parentNode;
+ }
+
+ if ( target.tagName === "A" ) {
+ var href = target.getAttribute("href");
+
+ // if it's a link to presentation step, target this step
+ if ( href && href[0] === '#' ) {
+ target = document.getElementById( href.slice(1) );
+ }
+ }
+
+ if ( api.goto(target) ) {
+ event.stopImmediatePropagation();
+ event.preventDefault();
+ }
+ }, false);
+
+ // delegated handler for clicking on step elements
+ document.addEventListener("click", function ( event ) {
+ var target = event.target;
+ // find closest step element that is not active
+ while ( !(target.classList.contains("step") && !target.classList.contains("active")) &&
+ (target !== document.documentElement) ) {
+ target = target.parentNode;
+ }
+
+ if ( api.goto(target) ) {
+ event.preventDefault();
+ }
+ }, false);
+
+ // touch handler to detect taps on the left and right side of the screen
+ // based on awesome work of @hakimel: https://github.com/hakimel/reveal.js
+ document.addEventListener("touchstart", function ( event ) {
+ if (event.touches.length === 1) {
+ var x = event.touches[0].clientX,
+ width = window.innerWidth * 0.3,
+ result = null;
+
+ if ( x < width ) {
+ result = api.prev();
+ } else if ( x > window.innerWidth - width ) {
+ result = api.next();
+ }
+
+ if (result) {
+ event.preventDefault();
+ }
+ }
+ }, false);
+
+ // rescale presentation when window is resized
+ window.addEventListener("resize", throttle(function () {
+ // force going to active step again, to trigger rescaling
+ api.goto( document.querySelector(".active"), 500 );
+ }, 250), false);
+
+ }, false);
+
+})(document, window);
+
+// THAT'S ALL FOLKS!
+//
+// Thanks for reading it all.
+// Or thanks for scrolling down and reading the last part.
+//
+// I've learnt a lot when building impress.js and I hope this code and comments
+// will help somebody learn at least some part of it.
Please sign in to comment.
Something went wrong with that request. Please try again.