From: Vincent Vanwaelscappel Date: Mon, 19 Dec 2022 15:49:34 +0000 (+0100) Subject: wip #5661 @0.5 X-Git-Url: http://git.cubedesigners.com/?a=commitdiff_plain;h=338a14d55e1f48d0e2d62db9b465869d3852c628;p=fluidbook-toolbox.git wip #5661 @0.5 --- diff --git a/.gitignore b/.gitignore index 5ccf8244a..bfff84cf7 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,14 @@ yarn-error.log /public/packages/fluidbook/toolbox/css/style.css.map /.idea/ .DS_Store +/resources/cubedesigners-oxygene/ +/resources/css/ +/resources/pdfjs-legacy-min/ +/resources/pdfjs-min/ +/resources/fluidbookpublication/player/ +/resources/elearningpackage/dist/ +/resources/quiz/dist/ +/resources/elearningmedia/dist/ +/resources/elearningmedia/css/ +/resources/linkeditor/dist/ +/resources/compiler/ diff --git a/app/Fluidbook/Packager/Base.php b/app/Fluidbook/Packager/Base.php index 7cb739764..847950955 100644 --- a/app/Fluidbook/Packager/Base.php +++ b/app/Fluidbook/Packager/Base.php @@ -4,6 +4,7 @@ namespace App\Fluidbook\Packager; use Cubist\Util\CommandLine; use Cubist\Util\PHP; +use Cubist\Util\Text; class Base extends \App\Jobs\Base { @@ -24,13 +25,14 @@ class Base extends \App\Jobs\Base protected $_compileOnConstruct = false; public $cleanOnDestruct = true; + const COMPILE_ASSETS = '/application/resources/fluidbookpublication/packager/'; + public static function package($book_id, $version, $zip = true, $cleanOnDestruct = true, $options = []) { global $packager; PHP::neverStop(); - if ($version === 'html') { $packager = new Online($book_id, null, true, $options); } else if ($version === 'scorm') { @@ -74,7 +76,6 @@ class Base extends \App\Jobs\Base mkdir($this->dir, 0777, true); } - $this->daoBook = new wsDAOBook($core->con); $this->book = $this->daoBook->selectById($book_id); $forceCompile = false; if (count($options)) { @@ -169,7 +170,7 @@ class Base extends \App\Jobs\Base protected function escapeTitle() { - $res = cubeText::str2URL($this->book->parametres->title); + $res = Text::str2URL($this->book->parametres->title); if ($res == '') { $res = 'fluidbook'; } diff --git a/app/Fluidbook/Packager/ChromeOS.php b/app/Fluidbook/Packager/ChromeOS.php index 2f7068cf7..7347dbb73 100644 --- a/app/Fluidbook/Packager/ChromeOS.php +++ b/app/Fluidbook/Packager/ChromeOS.php @@ -15,7 +15,7 @@ class ChromeOS extends Online protected function preparePackage() { - $res = parent::preparePackage(); + parent::preparePackage(); $manifest = ['name' => $this->book->parametres->offlineTitle == '' ? $this->book->parametres->title : $this->book->parametres->offlineTitle, 'version' => '1.0.' . time(), 'manifest_version' => 3, @@ -32,7 +32,6 @@ class ChromeOS extends Online // } file_put_contents($this->vdir . '/m/manifest.json', json_encode($manifest)); - return $res; } public function makePackage($zip) diff --git a/app/Fluidbook/Packager/MacOS.php b/app/Fluidbook/Packager/MacOS.php index 42fb150d0..afff8cc28 100644 --- a/app/Fluidbook/Packager/MacOS.php +++ b/app/Fluidbook/Packager/MacOS.php @@ -2,7 +2,7 @@ namespace App\Fluidbook\Packager; use Cubist\Util\CommandLine; -class MacOS extends Offline +class MacOS extends OfflineHTML { protected $nwplatform = 'osx64'; protected $nwversion = '0.49.2'; @@ -55,7 +55,6 @@ class MacOS extends Offline } $cl = new CommandLine('nwbuild'); - $cl->setPath(CONVERTER_PATH); $cl->setArg('p', $this->nwplatform); $cl->setArg('o', $this->buildPath); $cl->setArg('v', $this->nwversion); @@ -101,7 +100,7 @@ class MacOS extends Offline // Sign app $cl = new CommandLine($local_root . 'sign'); - $cl->setSSH(wsExporter::VINCENT, 'vincent', 'atacama', 22022); + $cl->setSSH('paris.cubedesigners.com', 'vincent', 'atacama', 22022); $cl->setArg(null, $local_root . $f); $cl->execute(); $cl->debug(); diff --git a/resources/html5app/_android/AndroidManifestOffline.xml b/resources/html5app/_android/AndroidManifestOffline.xml new file mode 100644 index 000000000..2ba8de0d3 --- /dev/null +++ b/resources/html5app/_android/AndroidManifestOffline.xml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/resources/html5app/_android/AndroidManifestOfflineStandalone.xml b/resources/html5app/_android/AndroidManifestOfflineStandalone.xml new file mode 100644 index 000000000..3d068e766 --- /dev/null +++ b/resources/html5app/_android/AndroidManifestOfflineStandalone.xml @@ -0,0 +1,52 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/resources/html5app/_android/AndroidManifestOnline.xml b/resources/html5app/_android/AndroidManifestOnline.xml new file mode 100644 index 000000000..3d068e766 --- /dev/null +++ b/resources/html5app/_android/AndroidManifestOnline.xml @@ -0,0 +1,52 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/resources/html5app/_android/MainOffline.java b/resources/html5app/_android/MainOffline.java new file mode 100644 index 000000000..0ad497d8d --- /dev/null +++ b/resources/html5app/_android/MainOffline.java @@ -0,0 +1,26 @@ +package $namespace; + +import com.fluidbook.android.expansion.ExpansionApp; +import com.fluidbook.android.expansion.ExpansionFile; +import android.os.Bundle; + +public class $activity extends ExpansionApp { + + @Override + protected ExpansionFile[] getExpansionFiles() { + ExpansionApp.drawableScreen = R.drawable.screen; + //ZipFileContentProvider.authority = "$namespace.provider.ZipFileContentProvider"; + ExpansionFile[] res = {new ExpansionFile(true, getBuildVersion(), $obbmainsize)}; + return res; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + } + + @Override + public void setBackground() { + this.appView.getView().setBackgroundColor($background); + } +} diff --git a/resources/html5app/_android/MainOfflineStandalone.java b/resources/html5app/_android/MainOfflineStandalone.java new file mode 100644 index 000000000..f25418223 --- /dev/null +++ b/resources/html5app/_android/MainOfflineStandalone.java @@ -0,0 +1,19 @@ +package $namespace; + +import com.fluidbook.android.OnlineApp; +import android.os.Bundle; + +public class $activity extends OnlineApp { + @Override + public void onCreate(Bundle savedInstanceState) { + drawableScreen = R.drawable.screen; + super.onCreate(savedInstanceState); + + setBackground(); + } + + @Override + public void setBackground() { + this.appView.getView().setBackgroundColor($background); + } +} diff --git a/resources/html5app/_android/MainOnline.java b/resources/html5app/_android/MainOnline.java new file mode 100644 index 000000000..f25418223 --- /dev/null +++ b/resources/html5app/_android/MainOnline.java @@ -0,0 +1,19 @@ +package $namespace; + +import com.fluidbook.android.OnlineApp; +import android.os.Bundle; + +public class $activity extends OnlineApp { + @Override + public void onCreate(Bundle savedInstanceState) { + drawableScreen = R.drawable.screen; + super.onCreate(savedInstanceState); + + setBackground(); + } + + @Override + public void setBackground() { + this.appView.getView().setBackgroundColor($background); + } +} diff --git a/resources/html5app/_android/debug-signing.properties b/resources/html5app/_android/debug-signing.properties new file mode 100644 index 000000000..f245a0299 --- /dev/null +++ b/resources/html5app/_android/debug-signing.properties @@ -0,0 +1,5 @@ +storeFile=H:/Works/cles/Certificats/Android/Google_Play_Cubedesigners +storeType=jks +keyAlias=mainkey +keyPassword=atacama +storePassword=atacama \ No newline at end of file diff --git a/resources/html5app/_android/fluidbook-dependencies/catalogues-fluidbook.gradle b/resources/html5app/_android/fluidbook-dependencies/catalogues-fluidbook.gradle new file mode 100644 index 000000000..48dff6d03 --- /dev/null +++ b/resources/html5app/_android/fluidbook-dependencies/catalogues-fluidbook.gradle @@ -0,0 +1,11 @@ +repositories { + mavenCentral() +} +dependencies { + compile 'com.google.android.gms:play-services:4.0.30' + compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.+' + compile group: 'org.slf4j', name: 'slf4j-simple', version: '1.6.+' +} +android { + useLibrary 'org.apache.http.legacy' +} \ No newline at end of file diff --git a/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/APEZProvider.java b/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/APEZProvider.java new file mode 100644 index 000000000..1ba910bf0 --- /dev/null +++ b/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/APEZProvider.java @@ -0,0 +1,287 @@ +package com.android.vending.expansion.zipfile; + +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//To implement APEZProvider in your application, you'll want to change +//the AUTHORITY to match what you define in the manifest. + +import com.android.vending.expansion.zipfile.ZipResourceFile.ZipEntryRO; + +import android.content.ContentProvider; +import android.content.ContentProviderOperation; +import android.content.ContentProviderResult; +import android.content.ContentValues; +import android.content.Context; +import android.content.OperationApplicationException; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.content.pm.ProviderInfo; +import android.content.res.AssetFileDescriptor; +import android.database.Cursor; +import android.database.MatrixCursor; +import android.net.Uri; +import android.os.ParcelFileDescriptor; +import android.provider.BaseColumns; + +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.ArrayList; + +/** + * This content provider is an optional part of the library. + * + *

Most apps don't need to use this class. This defines a + * ContentProvider that marshalls the data from the ZIP files through a + * content provider Uri in order to provide file access for certain Android APIs + * that expect Uri access to media files. + * + */ +public abstract class APEZProvider extends ContentProvider { + + private ZipResourceFile mAPKExtensionFile; + private boolean mInit; + + public static final String FILEID = BaseColumns._ID; + public static final String FILENAME = "ZPFN"; + public static final String ZIPFILE = "ZFIL"; + public static final String MODIFICATION = "ZMOD"; + public static final String CRC32 = "ZCRC"; + public static final String COMPRESSEDLEN = "ZCOL"; + public static final String UNCOMPRESSEDLEN = "ZUNL"; + public static final String COMPRESSIONTYPE = "ZTYP"; + + public static final String[] ALL_FIELDS = { + FILEID, + FILENAME, + ZIPFILE, + MODIFICATION, + CRC32, + COMPRESSEDLEN, + UNCOMPRESSEDLEN, + COMPRESSIONTYPE + }; + + public static final int FILEID_IDX = 0; + public static final int FILENAME_IDX = 1; + public static final int ZIPFILE_IDX = 2; + public static final int MOD_IDX = 3; + public static final int CRC_IDX = 4; + public static final int COMPLEN_IDX = 5; + public static final int UNCOMPLEN_IDX = 6; + public static final int COMPTYPE_IDX = 7; + + public static final int[] ALL_FIELDS_INT = { + FILEID_IDX, + FILENAME_IDX, + ZIPFILE_IDX, + MOD_IDX, + CRC_IDX, + COMPLEN_IDX, + UNCOMPLEN_IDX, + COMPTYPE_IDX + }; + + /** + * This needs to match the authority in your manifest + */ + public abstract String getAuthority(); + + @Override + public int delete(Uri arg0, String arg1, String[] arg2) { + // TODO Auto-generated method stub + return 0; + } + + @Override + public String getType(Uri uri) { + return "vnd.android.cursor.item/asset"; + } + + @Override + public Uri insert(Uri uri, ContentValues values) { + // TODO Auto-generated method stub + return null; + } + + static private final String NO_FILE = "N"; + + private boolean initIfNecessary() { + if ( !mInit ) { + Context ctx = getContext(); + PackageManager pm = ctx.getPackageManager(); + ProviderInfo pi = pm.resolveContentProvider(getAuthority(), PackageManager.GET_META_DATA); + PackageInfo packInfo; + try { + packInfo = pm.getPackageInfo(ctx.getPackageName(), 0); + } catch (NameNotFoundException e1) { + e1.printStackTrace(); + return false; + } + int patchFileVersion; + int mainFileVersion; + int appVersionCode = packInfo.versionCode; + String[] resourceFiles = null; + if ( null != pi.metaData ) { + mainFileVersion = pi.metaData.getInt("mainVersion", appVersionCode); + patchFileVersion = pi.metaData.getInt("patchVersion", appVersionCode); + String mainFileName = pi.metaData.getString("mainFilename", NO_FILE); + if ( NO_FILE != mainFileName ) { + String patchFileName = pi.metaData.getString("patchFilename", NO_FILE); + if ( NO_FILE != patchFileName ) { + resourceFiles = new String[] { mainFileName, patchFileName }; + } else { + resourceFiles = new String[] { mainFileName }; + } + } + } else { + mainFileVersion = patchFileVersion = appVersionCode; + } + try { + if ( null == resourceFiles ) { + mAPKExtensionFile = APKExpansionSupport.getAPKExpansionZipFile(ctx, mainFileVersion, patchFileVersion); + } else { + mAPKExtensionFile = APKExpansionSupport.getResourceZipFile(resourceFiles); + } + mInit = true; + return true; + } catch (IOException e) { + e.printStackTrace(); + } + } + return false; + } + + @Override + public boolean onCreate() { + return true; + } + + @Override + public AssetFileDescriptor openAssetFile(Uri uri, String mode) + throws FileNotFoundException { + initIfNecessary(); + String path = uri.getEncodedPath(); + if ( path.startsWith("/") ) { + path = path.substring(1); + } + return mAPKExtensionFile.getAssetFileDescriptor(path); + } + + @Override + public ContentProviderResult[] applyBatch( + ArrayList operations) + throws OperationApplicationException { + initIfNecessary(); + return super.applyBatch(operations); + } + + @Override + public ParcelFileDescriptor openFile(Uri uri, String mode) + throws FileNotFoundException { + initIfNecessary(); + AssetFileDescriptor af = openAssetFile(uri, mode); + if ( null != af ) { + return af.getParcelFileDescriptor(); + } + return null; + } + + @Override + public Cursor query(Uri uri, String[] projection, String selection, + String[] selectionArgs, String sortOrder) { + initIfNecessary(); + // lists all of the items in the file that match + ZipEntryRO[] zipEntries; + if ( null == mAPKExtensionFile ) { + zipEntries = new ZipEntryRO[0]; + } else { + zipEntries = mAPKExtensionFile.getAllEntries(); + } + int[] intProjection; + if ( null == projection ) { + intProjection = ALL_FIELDS_INT; + projection = ALL_FIELDS; + } else { + int len = projection.length; + intProjection = new int[len]; + for ( int i = 0; i < len; i++ ) { + if ( projection[i].equals(FILEID) ) { + intProjection[i] = FILEID_IDX; + } else if ( projection[i].equals(FILENAME) ) { + intProjection[i] = FILENAME_IDX; + } else if ( projection[i].equals(ZIPFILE) ) { + intProjection[i] = ZIPFILE_IDX; + } else if ( projection[i].equals(MODIFICATION) ) { + intProjection[i] = MOD_IDX; + } else if ( projection[i].equals(CRC32) ) { + intProjection[i] = CRC_IDX; + } else if ( projection[i].equals(COMPRESSEDLEN) ) { + intProjection[i] = COMPLEN_IDX; + } else if ( projection[i].equals(UNCOMPRESSEDLEN) ) { + intProjection[i] = UNCOMPLEN_IDX; + } else if ( projection[i].equals(COMPRESSIONTYPE) ) { + intProjection[i] = COMPTYPE_IDX; + } else { + throw new RuntimeException(); + } + } + } + MatrixCursor mc = new MatrixCursor(projection, zipEntries.length); + int len = intProjection.length; + for ( ZipEntryRO zer : zipEntries ) { + MatrixCursor.RowBuilder rb = mc.newRow(); + for ( int i = 0; i < len; i++ ) { + switch (intProjection[i]) { + case FILEID_IDX: + rb.add(i); + break; + case FILENAME_IDX: + rb.add(zer.mFileName); + break; + case ZIPFILE_IDX: + rb.add(zer.getZipFileName()); + break; + case MOD_IDX: + rb.add(zer.mWhenModified); + break; + case CRC_IDX: + rb.add(zer.mCRC32); + break; + case COMPLEN_IDX: + rb.add(zer.mCompressedLength); + break; + case UNCOMPLEN_IDX: + rb.add(zer.mUncompressedLength); + break; + case COMPTYPE_IDX: + rb.add(zer.mMethod); + break; + } + } + } + return mc; + } + + @Override + public int update(Uri uri, ContentValues values, String selection, + String[] selectionArgs) { + // TODO Auto-generated method stub + return 0; + } + +} diff --git a/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/APKExpansionSupport.java b/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/APKExpansionSupport.java new file mode 100644 index 000000000..d02af84dc --- /dev/null +++ b/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/APKExpansionSupport.java @@ -0,0 +1,79 @@ +package com.android.vending.expansion.zipfile; +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import java.io.File; +import java.io.FileFilter; +import java.io.IOException; +import java.util.Vector; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import android.content.Context; +import android.os.Environment; + +public class APKExpansionSupport { + // The shared path to all app expansion files + private final static String EXP_PATH = "/Android/obb/"; + + static String[] getAPKExpansionFiles(Context ctx, int mainVersion, int patchVersion) { + String packageName = ctx.getPackageName(); + Vector ret = new Vector(); + if (Environment.getExternalStorageState().equals( + Environment.MEDIA_MOUNTED)) { + // Build the full path to the app's expansion files + File root = Environment.getExternalStorageDirectory(); + File expPath = new File(root.toString() + EXP_PATH + packageName); + + // Check that expansion file path exists + if (expPath.exists()) { + if ( mainVersion > 0 ) { + String strMainPath = expPath + File.separator + "main." + mainVersion + "." + packageName + ".obb"; + File main = new File(strMainPath); + if ( main.isFile() ) { + ret.add(strMainPath); + } + } + if ( patchVersion > 0 ) { + String strPatchPath = expPath + File.separator + "patch." + mainVersion + "." + packageName + ".obb"; + File main = new File(strPatchPath); + if ( main.isFile() ) { + ret.add(strPatchPath); + } + } + } + } + String[] retArray = new String[ret.size()]; + ret.toArray(retArray); + return retArray; + } + + static public ZipResourceFile getResourceZipFile(String[] expansionFiles) throws IOException { + ZipResourceFile apkExpansionFile = null; + for (String expansionFilePath : expansionFiles) { + if ( null == apkExpansionFile ) { + apkExpansionFile = new ZipResourceFile(expansionFilePath); + } else { + apkExpansionFile.addPatchFile(expansionFilePath); + } + } + return apkExpansionFile; + } + + static public ZipResourceFile getAPKExpansionZipFile(Context ctx, int mainVersion, int patchVersion) throws IOException{ + String[] expansionFiles = getAPKExpansionFiles(ctx, mainVersion, patchVersion); + return getResourceZipFile(expansionFiles); + } +} diff --git a/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/ZipResourceFile.java b/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/ZipResourceFile.java new file mode 100644 index 000000000..902af3c46 --- /dev/null +++ b/resources/html5app/_android/lib/com/android/vending/expansion/zipfile/ZipResourceFile.java @@ -0,0 +1,428 @@ + +package com.android.vending.expansion.zipfile; + +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import android.content.res.AssetFileDescriptor; +import android.os.ParcelFileDescriptor; +import android.util.Log; + +import java.io.EOFException; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.RandomAccessFile; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.MappedByteBuffer; +import java.nio.channels.FileChannel; +import java.util.Collection; +import java.util.HashMap; +import java.util.Vector; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +public class ZipResourceFile { + + // + // Read-only access to Zip archives, with minimal heap allocation. + // + static final String LOG_TAG = "zipro"; + static final boolean LOGV = false; + + // 4-byte number + static private int swapEndian(int i) + { + return ((i & 0xff) << 24) + ((i & 0xff00) << 8) + ((i & 0xff0000) >>> 8) + + ((i >>> 24) & 0xff); + } + + // 2-byte number + static private int swapEndian(short i) + { + return ((i & 0x00FF) << 8 | (i & 0xFF00) >>> 8); + } + + /* + * Zip file constants. + */ + static final int kEOCDSignature = 0x06054b50; + static final int kEOCDLen = 22; + static final int kEOCDNumEntries = 8; // offset to #of entries in file + static final int kEOCDSize = 12; // size of the central directory + static final int kEOCDFileOffset = 16; // offset to central directory + + static final int kMaxCommentLen = 65535; // longest possible in ushort + static final int kMaxEOCDSearch = (kMaxCommentLen + kEOCDLen); + + static final int kLFHSignature = 0x04034b50; + static final int kLFHLen = 30; // excluding variable-len fields + static final int kLFHNameLen = 26; // offset to filename length + static final int kLFHExtraLen = 28; // offset to extra length + + static final int kCDESignature = 0x02014b50; + static final int kCDELen = 46; // excluding variable-len fields + static final int kCDEMethod = 10; // offset to compression method + static final int kCDEModWhen = 12; // offset to modification timestamp + static final int kCDECRC = 16; // offset to entry CRC + static final int kCDECompLen = 20; // offset to compressed length + static final int kCDEUncompLen = 24; // offset to uncompressed length + static final int kCDENameLen = 28; // offset to filename length + static final int kCDEExtraLen = 30; // offset to extra length + static final int kCDECommentLen = 32; // offset to comment length + static final int kCDELocalOffset = 42; // offset to local hdr + + static final int kCompressStored = 0; // no compression + static final int kCompressDeflated = 8; // standard deflate + + /* + * The values we return for ZipEntryRO use 0 as an invalid value, so we want + * to adjust the hash table index by a fixed amount. Using a large value + * helps insure that people don't mix & match arguments, e.g. to + * findEntryByIndex(). + */ + static final int kZipEntryAdj = 10000; + + static public final class ZipEntryRO { + public ZipEntryRO(final String zipFileName, final File file, final String fileName) { + mFileName = fileName; + mZipFileName = zipFileName; + mFile = file; + } + + public final File mFile; + public final String mFileName; + public final String mZipFileName; + public long mLocalHdrOffset; // offset of local file header + + /* useful stuff from the directory entry */ + public int mMethod; + public long mWhenModified; + public long mCRC32; + public long mCompressedLength; + public long mUncompressedLength; + + public long mOffset = -1; + + public void setOffsetFromFile(RandomAccessFile f, ByteBuffer buf) throws IOException { + long localHdrOffset = mLocalHdrOffset; + try { + f.seek(localHdrOffset); + f.readFully(buf.array()); + if (buf.getInt(0) != kLFHSignature) { + Log.w(LOG_TAG, "didn't find signature at start of lfh"); + throw new IOException(); + } + int nameLen = buf.getShort(kLFHNameLen) & 0xFFFF; + int extraLen = buf.getShort(kLFHExtraLen) & 0xFFFF; + mOffset = localHdrOffset + kLFHLen + nameLen + extraLen; + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException ioe) { + ioe.printStackTrace(); + } + } + + /** + * Calculates the offset of the start of the Zip file entry within the + * Zip file. + * + * @return the offset, in bytes from the start of the file of the entry + */ + public long getOffset() { + return mOffset; + } + + /** + * isUncompressed + * + * @return true if the file is stored in uncompressed form + */ + public boolean isUncompressed() { + return mMethod == kCompressStored; + } + + public AssetFileDescriptor getAssetFileDescriptor() { + if (mMethod == kCompressStored) { + ParcelFileDescriptor pfd; + try { + pfd = ParcelFileDescriptor.open(mFile, ParcelFileDescriptor.MODE_READ_ONLY); + return new AssetFileDescriptor(pfd, getOffset(), mUncompressedLength); + } catch (FileNotFoundException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + return null; + } + + public String getZipFileName() { + return mZipFileName; + } + + public File getZipFile() { + return mFile; + } + + } + + private HashMap mHashMap = new HashMap(); + + /* for reading compressed files */ + public HashMap mZipFiles = new HashMap(); + + public ZipResourceFile(String zipFileName) throws IOException { + addPatchFile(zipFileName); + } + + ZipEntryRO[] getEntriesAt(String path) { + Vector zev = new Vector(); + Collection values = mHashMap.values(); + if (null == path) + path = ""; + int length = path.length(); + for (ZipEntryRO ze : values) { + if (ze.mFileName.startsWith(path)) { + if (-1 == ze.mFileName.indexOf('/', length)) { + zev.add(ze); + } + } + } + ZipEntryRO[] entries = new ZipEntryRO[zev.size()]; + return zev.toArray(entries); + } + + public ZipEntryRO[] getAllEntries() { + Collection values = mHashMap.values(); + return values.toArray(new ZipEntryRO[values.size()]); + } + + /** + * getAssetFileDescriptor allows for ZipResourceFile to directly feed + * Android API's that want an fd, offset, and length such as the + * MediaPlayer. It also allows for the class to be used in a content + * provider that can feed video players. The file must be stored + * (non-compressed) in the Zip file for this to work. + * + * @param assetPath + * @return the asset file descriptor for the file, or null if the file isn't + * present or is stored compressed + */ + public AssetFileDescriptor getAssetFileDescriptor(String assetPath) { + ZipEntryRO entry = mHashMap.get(assetPath); + if (null != entry) { + return entry.getAssetFileDescriptor(); + } + return null; + } + + /** + * getInputStream returns an AssetFileDescriptor.AutoCloseInputStream + * associated with the asset that is contained in the Zip file, or a + * standard ZipInputStream if necessary to uncompress the file + * + * @param assetPath + * @return an input stream for the named asset path, or null if not found + * @throws IOException + */ + public InputStream getInputStream(String assetPath) throws IOException { + ZipEntryRO entry = mHashMap.get(assetPath); + if (null != entry) { + if (entry.isUncompressed()) { + return entry.getAssetFileDescriptor().createInputStream(); + } else { + ZipFile zf = mZipFiles.get(entry.getZipFile()); + /** read compressed files **/ + if (null == zf) { + zf = new ZipFile(entry.getZipFile(), ZipFile.OPEN_READ); + mZipFiles.put(entry.getZipFile(), zf); + } + ZipEntry zi = zf.getEntry(assetPath); + if (null != zi) + return zf.getInputStream(zi); + } + } + return null; + } + + ByteBuffer mLEByteBuffer = ByteBuffer.allocate(4); + + static private int read4LE(RandomAccessFile f) throws EOFException, IOException { + return swapEndian(f.readInt()); + } + + /* + * Opens the specified file read-only. We memory-map the entire thing and + * close the file before returning. + */ + void addPatchFile(String zipFileName) throws IOException + { + File file = new File(zipFileName); + RandomAccessFile f = new RandomAccessFile(file, "r"); + long fileLength = f.length(); + + if (fileLength < kEOCDLen) { + throw new java.io.IOException(); + } + + long readAmount = kMaxEOCDSearch; + if (readAmount > fileLength) + readAmount = fileLength; + + /* + * Make sure this is a Zip archive. + */ + f.seek(0); + + int header = read4LE(f); + if (header == kEOCDSignature) { + Log.i(LOG_TAG, "Found Zip archive, but it looks empty"); + throw new IOException(); + } else if (header != kLFHSignature) { + Log.v(LOG_TAG, "Not a Zip archive"); + throw new IOException(); + } + + /* + * Perform the traditional EOCD snipe hunt. We're searching for the End + * of Central Directory magic number, which appears at the start of the + * EOCD block. It's followed by 18 bytes of EOCD stuff and up to 64KB of + * archive comment. We need to read the last part of the file into a + * buffer, dig through it to find the magic number, parse some values + * out, and use those to determine the extent of the CD. We start by + * pulling in the last part of the file. + */ + long searchStart = fileLength - readAmount; + + f.seek(searchStart); + ByteBuffer bbuf = ByteBuffer.allocate((int) readAmount); + byte[] buffer = bbuf.array(); + f.readFully(buffer); + bbuf.order(ByteOrder.LITTLE_ENDIAN); + + /* + * Scan backward for the EOCD magic. In an archive without a trailing + * comment, we'll find it on the first try. (We may want to consider + * doing an initial minimal read; if we don't find it, retry with a + * second read as above.) + */ + + // EOCD == 0x50, 0x4b, 0x05, 0x06 + int eocdIdx; + for (eocdIdx = buffer.length - kEOCDLen; eocdIdx >= 0; eocdIdx--) { + if (buffer[eocdIdx] == 0x50 && bbuf.getInt(eocdIdx) == kEOCDSignature) + { + if (LOGV) { + Log.v(LOG_TAG, "+++ Found EOCD at index: " + eocdIdx); + } + break; + } + } + + if (eocdIdx < 0) { + Log.d(LOG_TAG, "Zip: EOCD not found, " + zipFileName + " is not zip"); + } + + /* + * Grab the CD offset and size, and the number of entries in the + * archive. After that, we can release our EOCD hunt buffer. + */ + + int numEntries = bbuf.getShort(eocdIdx + kEOCDNumEntries); + long dirSize = bbuf.getInt(eocdIdx + kEOCDSize) & 0xffffffffL; + long dirOffset = bbuf.getInt(eocdIdx + kEOCDFileOffset) & 0xffffffffL; + + // Verify that they look reasonable. + if (dirOffset + dirSize > fileLength) { + Log.w(LOG_TAG, "bad offsets (dir " + dirOffset + ", size " + dirSize + ", eocd " + + eocdIdx + ")"); + throw new IOException(); + } + if (numEntries == 0) { + Log.w(LOG_TAG, "empty archive?"); + throw new IOException(); + } + + if (LOGV) { + Log.v(LOG_TAG, "+++ numEntries=" + numEntries + " dirSize=" + dirSize + " dirOffset=" + + dirOffset); + } + + MappedByteBuffer directoryMap = f.getChannel() + .map(FileChannel.MapMode.READ_ONLY, dirOffset, dirSize); + directoryMap.order(ByteOrder.LITTLE_ENDIAN); + + byte[] tempBuf = new byte[0xffff]; + + /* + * Walk through the central directory, adding entries to the hash table. + */ + + int currentOffset = 0; + + /* + * Allocate the local directory information + */ + ByteBuffer buf = ByteBuffer.allocate(kLFHLen); + buf.order(ByteOrder.LITTLE_ENDIAN); + + for (int i = 0; i < numEntries; i++) { + if (directoryMap.getInt(currentOffset) != kCDESignature) { + Log.w(LOG_TAG, "Missed a central dir sig (at " + currentOffset + ")"); + throw new IOException(); + } + + /* useful stuff from the directory entry */ + int fileNameLen = directoryMap.getShort(currentOffset + kCDENameLen) & 0xffff; + int extraLen = directoryMap.getShort(currentOffset + kCDEExtraLen) & 0xffff; + int commentLen = directoryMap.getShort(currentOffset + kCDECommentLen) & 0xffff; + + /* get the CDE filename */ + + directoryMap.position(currentOffset + kCDELen); + directoryMap.get(tempBuf, 0, fileNameLen); + directoryMap.position(0); + + /* UTF-8 on Android */ + String str = new String(tempBuf, 0, fileNameLen); + if (LOGV) { + Log.v(LOG_TAG, "Filename: " + str); + } + + ZipEntryRO ze = new ZipEntryRO(zipFileName, file, str); + ze.mMethod = directoryMap.getShort(currentOffset + kCDEMethod) & 0xffff; + ze.mWhenModified = directoryMap.getInt(currentOffset + kCDEModWhen) & 0xffffffffL; + ze.mCRC32 = directoryMap.getLong(currentOffset + kCDECRC) & 0xffffffffL; + ze.mCompressedLength = directoryMap.getLong(currentOffset + kCDECompLen) & 0xffffffffL; + ze.mUncompressedLength = directoryMap.getLong(currentOffset + kCDEUncompLen) & 0xffffffffL; + ze.mLocalHdrOffset = directoryMap.getInt(currentOffset + kCDELocalOffset) & 0xffffffffL; + + // set the offsets + buf.clear(); + ze.setOffsetFromFile(f, buf); + + // put file into hash + mHashMap.put(str, ze); + + // go to next directory entry + currentOffset += kCDELen + fileNameLen + extraLen + commentLen; + } + if (LOGV) { + Log.v(LOG_TAG, "+++ zip good scan " + numEntries + " entries"); + } + } +} diff --git a/resources/html5app/_android/lib/com/fluidbook/android/BaseApp.java b/resources/html5app/_android/lib/com/fluidbook/android/BaseApp.java new file mode 100644 index 000000000..ddde776a4 --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/android/BaseApp.java @@ -0,0 +1,75 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package com.fluidbook.android; + +import android.content.res.Configuration; +import android.view.ViewGroup; +import android.webkit.WebView; +import android.widget.LinearLayout; +import org.apache.cordova.CordovaActivity; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; + +/** + * @author Vincent + */ +public class BaseApp extends CordovaActivity { + + public static int drawableScreen; + + protected int splashScreenTime() { + return 2000; + } + + @Override + public void onConfigurationChanged(Configuration newConfig) { + super.onConfigurationChanged(newConfig); + +// if (super.splashDialog != null) { +// ViewGroup rootView = (ViewGroup) super.splashDialog.getWindow() +// .getDecorView().findViewById(android.R.id.content); +// LinearLayout linearLayout = (LinearLayout) rootView.getChildAt(0); +// // manually refresh the splash image +// linearLayout.setBackgroundResource(drawableScreen); +// } + } + + public void setBackground() { + + } + + public int getBuildVersion() { + PackageInfo pInfo = null; + try { + pInfo = getPackageManager().getPackageInfo(getPackageName(), 0); + return pInfo.versionCode; + } catch (PackageManager.NameNotFoundException e) { + e.printStackTrace(); + } + return 0; + } + + public WebView getWebView() { + return (WebView) this.appView.getView(); + } + + @Override + protected void init() { + super.init(); + this.beforeAppViewLoaded(); + } + + public void beforeAppViewLoaded() { + this.getWebView().getSettings().setJavaScriptEnabled(true); + this.getWebView().getSettings().setDomStorageEnabled(true); + } + + public void appViewCreated() { + this.getWebView().getSettings().setBuiltInZoomControls(true); + this.getWebView().getSettings().setSupportZoom(true); + } + +} diff --git a/resources/html5app/_android/lib/com/fluidbook/android/OnlineApp.java b/resources/html5app/_android/lib/com/fluidbook/android/OnlineApp.java new file mode 100644 index 000000000..c11415fa0 --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/android/OnlineApp.java @@ -0,0 +1,25 @@ +/* + * To change this license header, choose License Headers in Project Properties. + * To change this template file, choose Tools | Templates + * and open the template in the editor. + */ +package com.fluidbook.android; + +import android.content.res.Configuration; +import android.os.Bundle; +import android.view.ViewGroup; +import android.widget.LinearLayout; +import org.apache.cordova.Config; + +/** + * @author Vincent + */ +public class OnlineApp extends BaseApp { + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + super.loadUrl(Config.getStartUrl()); + } + +} diff --git a/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionApp.java b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionApp.java new file mode 100644 index 000000000..e24cb01ae --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionApp.java @@ -0,0 +1,336 @@ +package com.fluidbook.android.expansion; + +import android.app.PendingIntent; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager.NameNotFoundException; +import android.content.res.ObbInfo; +import android.content.res.ObbScanner; +import android.os.Bundle; +import android.os.Messenger; +import android.os.storage.OnObbStateChangeListener; +import android.os.storage.StorageManager; +import android.util.Log; +import com.google.android.vending.expansion.downloader.DownloadProgressInfo; +import com.google.android.vending.expansion.downloader.DownloaderClientMarshaller; +import com.google.android.vending.expansion.downloader.DownloaderServiceMarshaller; +import com.google.android.vending.expansion.downloader.Helpers; +import com.google.android.vending.expansion.downloader.IDownloaderClient; +import com.google.android.vending.expansion.downloader.IDownloaderService; +import com.google.android.vending.expansion.downloader.IStub; + +import java.io.File; +import java.io.IOException; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class ExpansionApp extends BaseApp implements IDownloaderClient { + + public String expansionFile; + public int port; + public long expansionSize; + private int mState; + private IDownloaderService mRemoteService; + private IStub mDownloaderClientStub; + protected static String _obbURL; + protected StorageManager storageManager; + protected OnObbStateChangeListener listener; + + private void setState(int newState) { + if (mState != newState) { + mState = newState; + } + } + + @Override + public void onCreate(Bundle savedInstanceState) { + Log.d("apk-expansion-files", "Create !"); + + super.onCreate(savedInstanceState); + + boolean checkOBB = true; + try { + checkOBB = this.checkOBB(); + } catch (IOException ex) { + Logger.getLogger(ExpansionApp.class.getName()).log(Level.SEVERE, null, ex); + } + if (!expansionFilesDelivered()) { + Intent launcher = getIntent(); + Intent fromNotification = new Intent(this, getClass()); + fromNotification.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK + | Intent.FLAG_ACTIVITY_CLEAR_TOP); + fromNotification.setAction(launcher.getAction()); + if (launcher.getCategories() != null) { + for (String cat : launcher.getCategories()) { + fromNotification.addCategory(cat); + } + } + PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, + fromNotification, PendingIntent.FLAG_UPDATE_CURRENT); + try { + // Start the download + int result = DownloaderClientMarshaller + .startDownloadServiceIfRequired(this, pendingIntent, + ExpansionFileDownloaderService.class); + if (DownloaderClientMarshaller.NO_DOWNLOAD_REQUIRED != result) { + Log.d("apk-expansion-files", "Start donwloading : " + + result); + mDownloaderClientStub = DownloaderClientMarshaller + .CreateStub(this, + ExpansionFileDownloaderService.class); + + return; + } + } catch (NameNotFoundException e) { + Log.e("apk-expansion-files", "NameNotFoundException occurred. " + + e.getMessage(), e); + } + + } + try { + start(); + } catch (IOException ex) { + Logger.getLogger(ExpansionApp.class.getName()).log(Level.SEVERE, null, ex); + } + } + + protected void start() throws IOException { + Log.d("OBB", "Start :D"); + listener = new OnObbStateChangeListener() { + @Override + public void onObbStateChange(String path, int state) { + Log.d("OBB", "new state : " + state); + super.onObbStateChange(path, state); + if (state == OnObbStateChangeListener.ERROR_ALREADY_MOUNTED && _obbURL == null) { + Log.d("OBB", "already mounted but without url"); + storageManager.unmountObb(path, true, new OnObbStateChangeListener() { + @Override + public void onObbStateChange(String path, int state) { + if (state == OnObbStateChangeListener.UNMOUNTED) { + try { + mountExpansion(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + }); + } else { + if (state == OnObbStateChangeListener.MOUNTED) { + ExpansionApp._obbURL = storageManager.getMountedObbPath(path); + Log.d("OBB", "-->MOUNTED :: " + storageManager.getMountedObbPath(path)); + + try { + expansionMounted(); + } catch (IOException ex) { + Log.e("OBB", ex.getMessage()); + } + + } else { + Log.d("OBB", "Path: " + path + "; state: " + state + " :: "); + } + } + } + }; + mountExpansion(); + } + + protected void expansionMounted() throws IOException { + Log.d("App", "Start !!! " + this.initialURL() + " " + this.splashScreenTime()); + File f = new File(this.initialURL()); + Log.d("App", "Index details !!! " + f.exists() + " " + f.length() + " " + f.toURI().toURL().toString()); + + super.loadUrl(f.toURI().toURL().toString()); + this.appViewCreated(); + } + + protected boolean checkOBB() throws IOException { + return true; + } + + @Override + protected void onResume() { + Log.d("apk-expansion-files", "Resume !"); + if (null != mDownloaderClientStub) { + mDownloaderClientStub.connect(this); + } + super.onResume(); + } + + @Override + protected void onStart() { + Log.d("apk-expansion-files", "Start !"); + if (null != mDownloaderClientStub) { + mDownloaderClientStub.connect(this); + } + super.onStart(); + } + + @Override + protected void onStop() { + Log.d("apk-expansion-files", "Stop !"); + if (null != mDownloaderClientStub) { + mDownloaderClientStub.disconnect(this); + } + super.onStop(); + } + + @Override + public void onDownloadProgress(DownloadProgressInfo arg0) { + // TODO Auto-generated method stub + Log.d("apk-expansion-files", "Progress : "); + } + + @Override + public void onServiceConnected(Messenger m) { + Log.d("apk-expansion-files", "Service connected !"); + mRemoteService = DownloaderServiceMarshaller.CreateProxy(m); + mRemoteService.onClientUpdated(mDownloaderClientStub.getMessenger()); + } + + /** + * The download state should trigger changes in the UI --- it may be useful + * to show the state as being indeterminate at times. This sample can be + * considered a guideline. + */ + @Override + public void onDownloadStateChanged(int newState) { + Log.d("apk-expansion-files", "new state : " + newState); + setState(newState); + boolean showDashboard = true; + boolean showCellMessage = false; + boolean paused; + boolean indeterminate; + + switch (newState) { + + case IDownloaderClient.STATE_IDLE: + // STATE_IDLE means the service is listening, so it's + // safe to start making calls via mRemoteService. + paused = false; + indeterminate = true; + break; + case IDownloaderClient.STATE_CONNECTING: + case IDownloaderClient.STATE_FETCHING_URL: + showDashboard = true; + paused = false; + indeterminate = true; + break; + case IDownloaderClient.STATE_DOWNLOADING: + paused = false; + showDashboard = true; + indeterminate = false; + break; + + case IDownloaderClient.STATE_FAILED_CANCELED: + case IDownloaderClient.STATE_FAILED: + case IDownloaderClient.STATE_FAILED_FETCHING_URL: + case IDownloaderClient.STATE_FAILED_UNLICENSED: + paused = true; + showDashboard = false; + indeterminate = false; + break; + case IDownloaderClient.STATE_PAUSED_NEED_CELLULAR_PERMISSION: + case IDownloaderClient.STATE_PAUSED_WIFI_DISABLED_NEED_CELLULAR_PERMISSION: + showDashboard = false; + paused = true; + indeterminate = false; + showCellMessage = true; + break; + + case IDownloaderClient.STATE_PAUSED_BY_REQUEST: + paused = true; + indeterminate = false; + break; + case IDownloaderClient.STATE_PAUSED_ROAMING: + case IDownloaderClient.STATE_PAUSED_SDCARD_UNAVAILABLE: + paused = true; + indeterminate = false; + break; + case IDownloaderClient.STATE_COMPLETED: + showDashboard = false; + paused = false; + indeterminate = false; + try { + this.start(); + } catch (IOException ex) { + Logger.getLogger(ExpansionApp.class.getName()).log(Level.SEVERE, null, ex); + } + return; + default: + paused = true; + indeterminate = true; + showDashboard = true; + } + } + + boolean expansionFilesDelivered() { + for (ExpansionFile xf : getExpansionFiles()) { + String fileName = Helpers.getExpansionAPKFileName(this, xf.mIsMain, + xf.mFileVersion); + File f = new File(Helpers.generateSaveFileName(this, fileName)); + + if (!f.exists()) { + Log.d("apk-expansion-files", "OBB (" + f.getPath() + ") does not exists !"); + return false; + } + } + return true; + } + + protected ExpansionFile[] getExpansionFiles() { + ExpansionFile[] res = {}; + return res; + } + + public String getOBBUrl() { + return ExpansionApp._obbURL + "/"; + } + + public String initialURL() throws IOException { + + return this.getOBBUrl() + "index.html"; + } + + public String mountExpansion() throws IOException { + storageManager = (StorageManager) getSystemService(Context.STORAGE_SERVICE); + for (final ExpansionFile xf : getExpansionFiles()) { + String fileName = Helpers.getExpansionAPKFileName(this, xf.mIsMain, xf.mFileVersion); + File obbFile = new File(Helpers.generateSaveFileName(this, fileName)); + + ObbInfo info = ObbScanner.getObbInfo(obbFile.getAbsolutePath()); + + Log.d("OBB", info.filename + ", version : " + info.version + ", " + info.packageName); + + ExpansionApp._obbURL = storageManager.getMountedObbPath(obbFile.getAbsolutePath()); + Log.d("OBB", "try this url " + _obbURL); + + if (!storageManager.isObbMounted(obbFile.getAbsolutePath()) || _obbURL == null) { + if (_obbURL == null) { + Log.d("OBB", "without url"); + } + if (!storageManager.isObbMounted(obbFile.getAbsolutePath())) { + Log.d("OBB", "not mounted"); + } + if (!obbFile.exists()) { + Log.e("OBB", "obb file don't exist"); + } else { + Log.d("OBB", "obb file " + obbFile.getAbsolutePath() + " exists"); + } + + boolean b = storageManager.mountObb(obbFile.getAbsolutePath(), null, listener); + + if (b) { + Log.d("OBB", "SUCCESSFULLY QUEUED"); + } else { + Log.d("OBB", "FAILED"); + } + } else { + Log.d("OBB", info.filename + " already mounted"); + expansionMounted(); + } + } + //Log.d("STORAGE", "OBB URL : " + _obbURL); + return _obbURL; + } +} diff --git a/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFile.java b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFile.java new file mode 100644 index 000000000..fec1678eb --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFile.java @@ -0,0 +1,18 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package com.fluidbook.android.expansion; + +public class ExpansionFile { + + public final boolean mIsMain; + public final int mFileVersion; + public final long mFileSize; + + public ExpansionFile(boolean isMain, int fileVersion, long fileSize) { + mIsMain = isMain; + mFileVersion = fileVersion; + mFileSize = fileSize; + } +} \ No newline at end of file diff --git a/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFileAlarmReceiver.java b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFileAlarmReceiver.java new file mode 100644 index 000000000..fe99fd996 --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFileAlarmReceiver.java @@ -0,0 +1,23 @@ +package com.fluidbook.android.expansion; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager.NameNotFoundException; +import android.util.Log; + +import com.google.android.vending.expansion.downloader.DownloaderClientMarshaller; + +public class ExpansionFileAlarmReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + try { + Log.d("apk-expansion-files","receive alarm"); + DownloaderClientMarshaller.startDownloadServiceIfRequired(context, + intent, ExpansionFileDownloaderService.class); + } catch (NameNotFoundException e) { + Log.e("apk-expansion-files", + "NameNotFoundException occurred. " + e.getMessage(), e); + } + } +} diff --git a/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFileDownloaderService.java b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFileDownloaderService.java new file mode 100644 index 000000000..1ba5a632b --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/android/expansion/ExpansionFileDownloaderService.java @@ -0,0 +1,28 @@ +package com.fluidbook.android.expansion; + +import android.util.Log; +import com.google.android.vending.expansion.downloader.impl.DownloaderService; + + +public class ExpansionFileDownloaderService extends DownloaderService { + public ExpansionFileDownloaderService() { + Log.d("apk-expansion-files", "Construct service"); + } + + @Override + public String getPublicKey() { + return "$license_key"; + } + + @Override + public byte[] getSALT() { + return new byte[]{$salt}; + } + + @Override + public String getAlarmReceiverClassName() { + String res = ExpansionFileAlarmReceiver.class.getName(); + Log.d("apk-expansion-files", "alarm class name : " + res); + return res; + } +} diff --git a/resources/html5app/_android/lib/com/fluidbook/webintent/WebIntent.java b/resources/html5app/_android/lib/com/fluidbook/webintent/WebIntent.java new file mode 100644 index 000000000..49a6829de --- /dev/null +++ b/resources/html5app/_android/lib/com/fluidbook/webintent/WebIntent.java @@ -0,0 +1,235 @@ +package com.fluidbook.webintent; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.cordova.CordovaActivity; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import android.content.ActivityNotFoundException; +import android.content.Intent; +import android.net.Uri; +import android.text.Html; + +import org.apache.cordova.CordovaPlugin; +import org.apache.cordova.PluginResult; +import org.apache.cordova.CallbackContext; + +/** + * WebIntent is a PhoneGap plugin that bridges Android intents and web applications: + * + * 1. web apps can spawn intents that call native Android applications. 2. (after setting up correct intent filters for + * PhoneGap applications), Android intents can be handled by PhoneGap web applications. + * + * @author boris@borismus.com + * + */ +public class WebIntent extends CordovaPlugin { + + private CallbackContext onNewIntentCallback = null; + + /** + * Executes the request and returns PluginResult. + * + * @param action The action to execute. + * @param args JSONArray of arguments for the plugin. + * @param callbackContext The callbackContext used when calling back into JavaScript. + * @return boolean + */ + public boolean execute(String action, JSONArray args, CallbackContext callbackContext) { + try { + if (action.equals("startActivity")) { + if (args.length() != 1) { + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + } + + // Parse the arguments + JSONObject obj = args.getJSONObject(0); + String type = obj.has("type") ? obj.getString("type") : null; + Uri uri = obj.has("url") ? Uri.parse(obj.getString("url")) : null; + JSONObject extras = obj.has("extras") ? obj.getJSONObject("extras") : null; + JSONObject handler = obj.has("handler") ? obj.getJSONObject("handler") : null; + Map extrasMap = new HashMap(); + Map handlerMap = null; + + // Populate the extras if any exist + if (extras != null) { + JSONArray extraNames = extras.names(); + for (int i = 0; i < extraNames.length(); i++) { + String key = extraNames.getString(i); + String value = extras.getString(key); + extrasMap.put(key, value); + } + } + + if (handler != null) { + handlerMap = new HashMap(); + + handlerMap.put("packageName", handler.getString("packageName")); + handlerMap.put("className", handler.getString("className")); + } + + try{ + startActivity(obj.getString("action"), uri, type, extrasMap, handlerMap); + } catch (ActivityNotFoundException e){ + callbackContext.error(e.getMessage()); + return false; + } + + callbackContext.success(); + return true; + + } else if (action.equals("hasExtra")) { + if (args.length() != 1) { + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + } + Intent i = ((CordovaActivity) this.cordova.getActivity()).getIntent(); + String extraName = args.getString(0); + PluginResult res = new PluginResult(PluginResult.Status.OK, i.hasExtra(extraName)); + callbackContext.sendPluginResult(res); + return true; + + } else if (action.equals("getExtra")) { + if (args.length() != 1) { + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + } + Intent i = ((CordovaActivity) this.cordova.getActivity()).getIntent(); + String extraName = args.getString(0); + + if (i.hasExtra(extraName)) { + PluginResult res = new PluginResult(PluginResult.Status.OK, i.hasExtra(extraName)); + callbackContext.sendPluginResult(res); + return true; + + } else { + PluginResult res = new PluginResult(PluginResult.Status.ERROR); + callbackContext.sendPluginResult(res); + return false; + } + + } else if (action.equals("getUri")) { + if (args.length() != 0) { + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + } + + Intent i = ((CordovaActivity) this.cordova.getActivity()).getIntent(); + String uri = i.getDataString(); + + callbackContext.success(uri); + return true; + + } else if (action.equals("onNewIntent")) { + if (args.length() != 0) { + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + } + + this.onNewIntentCallback = callbackContext; + PluginResult res = new PluginResult(PluginResult.Status.NO_RESULT); + res.setKeepCallback(true); + callbackContext.sendPluginResult(res); + return true; + + } else if (action.equals("sendBroadcast")) { + if (args.length() != 1) { + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + } + + // Parse the arguments + JSONObject obj = args.getJSONObject(0); + + JSONObject extras = obj.has("extras") ? obj.getJSONObject("extras") : null; + Map extrasMap = new HashMap(); + + // Populate the extras if any exist + if (extras != null) { + JSONArray extraNames = extras.names(); + for (int i = 0; i < extraNames.length(); i++) { + String key = extraNames.getString(i); + String value = extras.getString(key); + extrasMap.put(key, value); + } + } + + sendBroadcast(obj.getString("action"), extrasMap); + callbackContext.success(); + return true; + + } + + PluginResult res = new PluginResult(PluginResult.Status.INVALID_ACTION); + callbackContext.sendPluginResult(res); + return false; + + } + catch (JSONException e) { + callbackContext.error(e.getMessage()); + return false; + } + } + + @Override + public void onNewIntent(Intent intent) { + if (this.onNewIntentCallback != null) { + this.onNewIntentCallback.success(intent.getDataString()); + } + } + + void startActivity(String action, Uri uri, String type, Map extras, Map handlerMap) { + Intent i = (uri != null ? new Intent(action, uri) : new Intent(action)); + + if (handlerMap != null) { + i.setClassName(handlerMap.get("packageName"), handlerMap.get("className")); + } + + if (type != null && uri != null) { + i.setDataAndType(uri, type); // Fix the crash problem with android 2.3.6 + } else { + if (type != null) { + i.setType(type); + } + } + + for (String key : extras.keySet()) { + String value = extras.get(key); + // If type is text html, the extra text must sent as HTML + if (key.equals(Intent.EXTRA_TEXT) && type.equals("text/html")) { + i.putExtra(key, Html.fromHtml(value)); + } else if (key.equals(Intent.EXTRA_STREAM)) { + // allowes sharing of images as attachments. + // value in this case should be a URI of a file + i.putExtra(key, Uri.parse(value)); + } else if (key.equals(Intent.EXTRA_EMAIL)) { + // allows to add the email address of the receiver + i.putExtra(Intent.EXTRA_EMAIL, new String[] { value }); + } else { + i.putExtra(key, value); + } + } + ((CordovaActivity) this.cordova.getActivity()).startActivity(i); + } + + void sendBroadcast(String action, Map extras) { + Intent intent = new Intent(); + intent.setAction(action); + for (String key : extras.keySet()) { + String value = extras.get(key); + intent.putExtra(key, value); + } + + ((CordovaActivity) this.cordova.getActivity()).sendBroadcast(intent); + } +} \ No newline at end of file diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/Constants.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/Constants.java new file mode 100644 index 000000000..ff2c6f535 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/Constants.java @@ -0,0 +1,236 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import java.io.File; + + +/** + * Contains the internal constants that are used in the download manager. + * As a general rule, modifying these constants should be done with care. + */ +public class Constants { + /** Tag used for debugging/logging */ + public static final String TAG = "LVLDL"; + + /** + * Expansion path where we store obb files + */ + public static final String EXP_PATH = File.separator + "Android" + + File.separator + "obb" + File.separator; + + /** The intent that gets sent when the service must wake up for a retry */ + public static final String ACTION_RETRY = "android.intent.action.DOWNLOAD_WAKEUP"; + + /** the intent that gets sent when clicking a successful download */ + public static final String ACTION_OPEN = "android.intent.action.DOWNLOAD_OPEN"; + + /** the intent that gets sent when clicking an incomplete/failed download */ + public static final String ACTION_LIST = "android.intent.action.DOWNLOAD_LIST"; + + /** the intent that gets sent when deleting the notification of a completed download */ + public static final String ACTION_HIDE = "android.intent.action.DOWNLOAD_HIDE"; + + /** + * When a number has to be appended to the filename, this string is used to separate the + * base filename from the sequence number + */ + public static final String FILENAME_SEQUENCE_SEPARATOR = "-"; + + /** The default user agent used for downloads */ + public static final String DEFAULT_USER_AGENT = "Android.LVLDM"; + + /** The buffer size used to stream the data */ + public static final int BUFFER_SIZE = 4096; + + /** The minimum amount of progress that has to be done before the progress bar gets updated */ + public static final int MIN_PROGRESS_STEP = 4096; + + /** The minimum amount of time that has to elapse before the progress bar gets updated, in ms */ + public static final long MIN_PROGRESS_TIME = 1000; + + /** The maximum number of rows in the database (FIFO) */ + public static final int MAX_DOWNLOADS = 1000; + + /** + * The number of times that the download manager will retry its network + * operations when no progress is happening before it gives up. + */ + public static final int MAX_RETRIES = 5; + + /** + * The minimum amount of time that the download manager accepts for + * a Retry-After response header with a parameter in delta-seconds. + */ + public static final int MIN_RETRY_AFTER = 30; // 30s + + /** + * The maximum amount of time that the download manager accepts for + * a Retry-After response header with a parameter in delta-seconds. + */ + public static final int MAX_RETRY_AFTER = 24 * 60 * 60; // 24h + + /** + * The maximum number of redirects. + */ + public static final int MAX_REDIRECTS = 5; // can't be more than 7. + + /** + * The time between a failure and the first retry after an IOException. + * Each subsequent retry grows exponentially, doubling each time. + * The time is in seconds. + */ + public static final int RETRY_FIRST_DELAY = 30; + + /** Enable separate connectivity logging */ + public static final boolean LOGX = true; + + /** Enable verbose logging */ + public static final boolean LOGV = false; + + /** Enable super-verbose logging */ + private static final boolean LOCAL_LOGVV = false; + public static final boolean LOGVV = LOCAL_LOGVV && LOGV; + + /** + * This download has successfully completed. + * Warning: there might be other status values that indicate success + * in the future. + * Use isSucccess() to capture the entire category. + */ + public static final int STATUS_SUCCESS = 200; + + /** + * This request couldn't be parsed. This is also used when processing + * requests with unknown/unsupported URI schemes. + */ + public static final int STATUS_BAD_REQUEST = 400; + + /** + * This download can't be performed because the content type cannot be + * handled. + */ + public static final int STATUS_NOT_ACCEPTABLE = 406; + + /** + * This download cannot be performed because the length cannot be + * determined accurately. This is the code for the HTTP error "Length + * Required", which is typically used when making requests that require + * a content length but don't have one, and it is also used in the + * client when a response is received whose length cannot be determined + * accurately (therefore making it impossible to know when a download + * completes). + */ + public static final int STATUS_LENGTH_REQUIRED = 411; + + /** + * This download was interrupted and cannot be resumed. + * This is the code for the HTTP error "Precondition Failed", and it is + * also used in situations where the client doesn't have an ETag at all. + */ + public static final int STATUS_PRECONDITION_FAILED = 412; + + /** + * The lowest-valued error status that is not an actual HTTP status code. + */ + public static final int MIN_ARTIFICIAL_ERROR_STATUS = 488; + + /** + * The requested destination file already exists. + */ + public static final int STATUS_FILE_ALREADY_EXISTS_ERROR = 488; + + /** + * Some possibly transient error occurred, but we can't resume the download. + */ + public static final int STATUS_CANNOT_RESUME = 489; + + /** + * This download was canceled + */ + public static final int STATUS_CANCELED = 490; + + /** + * This download has completed with an error. + * Warning: there will be other status values that indicate errors in + * the future. Use isStatusError() to capture the entire category. + */ + public static final int STATUS_UNKNOWN_ERROR = 491; + + /** + * This download couldn't be completed because of a storage issue. + * Typically, that's because the filesystem is missing or full. + * Use the more specific {@link #STATUS_INSUFFICIENT_SPACE_ERROR} + * and {@link #STATUS_DEVICE_NOT_FOUND_ERROR} when appropriate. + */ + public static final int STATUS_FILE_ERROR = 492; + + /** + * This download couldn't be completed because of an HTTP + * redirect response that the download manager couldn't + * handle. + */ + public static final int STATUS_UNHANDLED_REDIRECT = 493; + + /** + * This download couldn't be completed because of an + * unspecified unhandled HTTP code. + */ + public static final int STATUS_UNHANDLED_HTTP_CODE = 494; + + /** + * This download couldn't be completed because of an + * error receiving or processing data at the HTTP level. + */ + public static final int STATUS_HTTP_DATA_ERROR = 495; + + /** + * This download couldn't be completed because of an + * HttpException while setting up the request. + */ + public static final int STATUS_HTTP_EXCEPTION = 496; + + /** + * This download couldn't be completed because there were + * too many redirects. + */ + public static final int STATUS_TOO_MANY_REDIRECTS = 497; + + /** + * This download couldn't be completed due to insufficient storage + * space. Typically, this is because the SD card is full. + */ + public static final int STATUS_INSUFFICIENT_SPACE_ERROR = 498; + + /** + * This download couldn't be completed because no external storage + * device was found. Typically, this is because the SD card is not + * mounted. + */ + public static final int STATUS_DEVICE_NOT_FOUND_ERROR = 499; + + /** + * The wake duration to check to see if a download is possible. + */ + public static final long WATCHDOG_WAKE_TIMER = 60*1000; + + /** + * The wake duration to check to see if the process was killed. + */ + public static final long ACTIVE_THREAD_WATCHDOG = 5*1000; + +} \ No newline at end of file diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloadProgressInfo.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloadProgressInfo.java new file mode 100644 index 000000000..9cb294d72 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloadProgressInfo.java @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import android.os.Parcel; +import android.os.Parcelable; + + +/** + * This class contains progress information about the active download(s). + * + * When you build the Activity that initiates a download and tracks the + * progress by implementing the {@link IDownloaderClient} interface, you'll + * receive a DownloadProgressInfo object in each call to the {@link + * IDownloaderClient#onDownloadProgress} method. This allows you to update + * your activity's UI with information about the download progress, such + * as the progress so far, time remaining and current speed. + */ +public class DownloadProgressInfo implements Parcelable { + public long mOverallTotal; + public long mOverallProgress; + public long mTimeRemaining; // time remaining + public float mCurrentSpeed; // speed in KB/S + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel p, int i) { + p.writeLong(mOverallTotal); + p.writeLong(mOverallProgress); + p.writeLong(mTimeRemaining); + p.writeFloat(mCurrentSpeed); + } + + public DownloadProgressInfo(Parcel p) { + mOverallTotal = p.readLong(); + mOverallProgress = p.readLong(); + mTimeRemaining = p.readLong(); + mCurrentSpeed = p.readFloat(); + } + + public DownloadProgressInfo(long overallTotal, long overallProgress, + long timeRemaining, + float currentSpeed) { + this.mOverallTotal = overallTotal; + this.mOverallProgress = overallProgress; + this.mTimeRemaining = timeRemaining; + this.mCurrentSpeed = currentSpeed; + } + + public static final Creator CREATOR = new Creator() { + @Override + public DownloadProgressInfo createFromParcel(Parcel parcel) { + return new DownloadProgressInfo(parcel); + } + + @Override + public DownloadProgressInfo[] newArray(int i) { + return new DownloadProgressInfo[i]; + } + }; + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloaderClientMarshaller.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloaderClientMarshaller.java new file mode 100644 index 000000000..220175125 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloaderClientMarshaller.java @@ -0,0 +1,277 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import com.google.android.vending.expansion.downloader.impl.DownloaderService; + +import android.app.PendingIntent; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.content.pm.PackageManager.NameNotFoundException; +import android.os.Bundle; +import android.os.Handler; +import android.os.IBinder; +import android.os.Message; +import android.os.Messenger; +import android.os.RemoteException; +import android.util.Log; + + + +/** + * This class binds the service API to your application client. It contains the IDownloaderClient proxy, + * which is used to call functions in your client as well as the Stub, which is used to call functions + * in the client implementation of IDownloaderClient. + * + *

The IPC is implemented using an Android Messenger and a service Binder. The connect method + * should be called whenever the client wants to bind to the service. It opens up a service connection + * that ends up calling the onServiceConnected client API that passes the service messenger + * in. If the client wants to be notified by the service, it is responsible for then passing its + * messenger to the service in a separate call. + * + *

Critical methods are {@link #startDownloadServiceIfRequired} and {@link #CreateStub}. + * + *

When your application first starts, you should first check whether your app's expansion files are + * already on the device. If not, you should then call {@link #startDownloadServiceIfRequired}, which + * starts your {@link impl.DownloaderService} to download the expansion files if necessary. The method + * returns a value indicating whether download is required or not. + * + *

If a download is required, {@link #startDownloadServiceIfRequired} begins the download through + * the specified service and you should then call {@link #CreateStub} to instantiate a member {@link + * IStub} object that you need in order to receive calls through your {@link IDownloaderClient} + * interface. + */ +public class DownloaderClientMarshaller { + public static final int MSG_ONDOWNLOADSTATE_CHANGED = 10; + public static final int MSG_ONDOWNLOADPROGRESS = 11; + public static final int MSG_ONSERVICECONNECTED = 12; + + public static final String PARAM_NEW_STATE = "newState"; + public static final String PARAM_PROGRESS = "progress"; + public static final String PARAM_MESSENGER = DownloaderService.EXTRA_MESSAGE_HANDLER; + + public static final int NO_DOWNLOAD_REQUIRED = DownloaderService.NO_DOWNLOAD_REQUIRED; + public static final int LVL_CHECK_REQUIRED = DownloaderService.LVL_CHECK_REQUIRED; + public static final int DOWNLOAD_REQUIRED = DownloaderService.DOWNLOAD_REQUIRED; + + private static class Proxy implements IDownloaderClient { + private Messenger mServiceMessenger; + + @Override + public void onDownloadStateChanged(int newState) { + Bundle params = new Bundle(1); + params.putInt(PARAM_NEW_STATE, newState); + send(MSG_ONDOWNLOADSTATE_CHANGED, params); + } + + @Override + public void onDownloadProgress(DownloadProgressInfo progress) { + Bundle params = new Bundle(1); + params.putParcelable(PARAM_PROGRESS, progress); + send(MSG_ONDOWNLOADPROGRESS, params); + } + + private void send(int method, Bundle params) { + Message m = Message.obtain(null, method); + m.setData(params); + try { + mServiceMessenger.send(m); + } catch (RemoteException e) { + e.printStackTrace(); + } + } + + public Proxy(Messenger msg) { + mServiceMessenger = msg; + } + + @Override + public void onServiceConnected(Messenger m) { + /** + * This is never called through the proxy. + */ + } + } + + private static class Stub implements IStub { + private IDownloaderClient mItf = null; + private Class mDownloaderServiceClass; + private boolean mBound; + private Messenger mServiceMessenger; + private Context mContext; + /** + * Target we publish for clients to send messages to IncomingHandler. + */ + final Messenger mMessenger = new Messenger(new Handler() { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case MSG_ONDOWNLOADPROGRESS: + Bundle bun = msg.getData(); + if ( null != mContext ) { + bun.setClassLoader(mContext.getClassLoader()); + DownloadProgressInfo dpi = (DownloadProgressInfo) msg.getData() + .getParcelable(PARAM_PROGRESS); + mItf.onDownloadProgress(dpi); + } + break; + case MSG_ONDOWNLOADSTATE_CHANGED: + mItf.onDownloadStateChanged(msg.getData().getInt(PARAM_NEW_STATE)); + break; + case MSG_ONSERVICECONNECTED: + mItf.onServiceConnected( + (Messenger) msg.getData().getParcelable(PARAM_MESSENGER)); + break; + } + } + }); + + public Stub(IDownloaderClient itf, Class downloaderService) { + mItf = itf; + mDownloaderServiceClass = downloaderService; + } + + /** + * Class for interacting with the main interface of the service. + */ + private ServiceConnection mConnection = new ServiceConnection() { + public void onServiceConnected(ComponentName className, IBinder service) { + // This is called when the connection with the service has been + // established, giving us the object we can use to + // interact with the service. We are communicating with the + // service using a Messenger, so here we get a client-side + // representation of that from the raw IBinder object. + mServiceMessenger = new Messenger(service); + mItf.onServiceConnected( + mServiceMessenger); + } + + public void onServiceDisconnected(ComponentName className) { + // This is called when the connection with the service has been + // unexpectedly disconnected -- that is, its process crashed. + mServiceMessenger = null; + } + }; + + @Override + public void connect(Context c) { + mContext = c; + Intent bindIntent = new Intent(c, mDownloaderServiceClass); + bindIntent.putExtra(PARAM_MESSENGER, mMessenger); + if ( !c.bindService(bindIntent, mConnection, Context.BIND_DEBUG_UNBIND) ) { + if ( Constants.LOGVV ) { + Log.d(Constants.TAG, "Service Unbound"); + } + } else { + mBound = true; + } + + } + + @Override + public void disconnect(Context c) { + if (mBound) { + c.unbindService(mConnection); + mBound = false; + } + mContext = null; + } + + @Override + public Messenger getMessenger() { + return mMessenger; + } + } + + /** + * Returns a proxy that will marshal calls to IDownloaderClient methods + * + * @param msg + * @return + */ + public static IDownloaderClient CreateProxy(Messenger msg) { + return new Proxy(msg); + } + + /** + * Returns a stub object that, when connected, will listen for marshaled + * {@link IDownloaderClient} methods and translate them into calls to the supplied + * interface. + * + * @param itf An implementation of IDownloaderClient that will be called + * when remote method calls are unmarshaled. + * @param downloaderService The class for your implementation of {@link + * impl.DownloaderService}. + * @return The {@link IStub} that allows you to connect to the service such that + * your {@link IDownloaderClient} receives status updates. + */ + public static IStub CreateStub(IDownloaderClient itf, Class downloaderService) { + return new Stub(itf, downloaderService); + } + + /** + * Starts the download if necessary. This function starts a flow that does ` + * many things. 1) Checks to see if the APK version has been checked and + * the metadata database updated 2) If the APK version does not match, + * checks the new LVL status to see if a new download is required 3) If the + * APK version does match, then checks to see if the download(s) have been + * completed 4) If the downloads have been completed, returns + * NO_DOWNLOAD_REQUIRED The idea is that this can be called during the + * startup of an application to quickly ascertain if the application needs + * to wait to hear about any updated APK expansion files. Note that this does + * mean that the application MUST be run for the first time with a network + * connection, even if Market delivers all of the files. + * + * @param context Your application Context. + * @param notificationClient A PendingIntent to start the Activity in your application + * that shows the download progress and which will also start the application when download + * completes. + * @param serviceClass the class of your {@link imp.DownloaderService} implementation + * @return whether the service was started and the reason for starting the service. + * Either {@link #NO_DOWNLOAD_REQUIRED}, {@link #LVL_CHECK_REQUIRED}, or {@link + * #DOWNLOAD_REQUIRED}. + * @throws NameNotFoundException + */ + public static int startDownloadServiceIfRequired(Context context, PendingIntent notificationClient, + Class serviceClass) + throws NameNotFoundException { + return DownloaderService.startDownloadServiceIfRequired(context, notificationClient, + serviceClass); + } + + /** + * This version assumes that the intent contains the pending intent as a parameter. This + * is used for responding to alarms. + *

The pending intent must be in an extra with the key {@link + * impl.DownloaderService#EXTRA_PENDING_INTENT}. + * + * @param context + * @param notificationClient + * @param serviceClass the class of the service to start + * @return + * @throws NameNotFoundException + */ + public static int startDownloadServiceIfRequired(Context context, Intent notificationClient, + Class serviceClass) + throws NameNotFoundException { + return DownloaderService.startDownloadServiceIfRequired(context, notificationClient, + serviceClass); + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloaderServiceMarshaller.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloaderServiceMarshaller.java new file mode 100644 index 000000000..054eaa989 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/DownloaderServiceMarshaller.java @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import com.google.android.vending.expansion.downloader.impl.DownloaderService; + +import android.content.Context; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.os.Messenger; +import android.os.RemoteException; + + + +/** + * This class is used by the client activity to proxy requests to the Downloader + * Service. + * + * Most importantly, you must call {@link #CreateProxy} during the {@link + * IDownloaderClient#onServiceConnected} callback in your activity in order to instantiate + * an {@link IDownloaderService} object that you can then use to issue commands to the {@link + * DownloaderService} (such as to pause and resume downloads). + */ +public class DownloaderServiceMarshaller { + + public static final int MSG_REQUEST_ABORT_DOWNLOAD = + 1; + public static final int MSG_REQUEST_PAUSE_DOWNLOAD = + 2; + public static final int MSG_SET_DOWNLOAD_FLAGS = + 3; + public static final int MSG_REQUEST_CONTINUE_DOWNLOAD = + 4; + public static final int MSG_REQUEST_DOWNLOAD_STATE = + 5; + public static final int MSG_REQUEST_CLIENT_UPDATE = + 6; + + public static final String PARAMS_FLAGS = "flags"; + public static final String PARAM_MESSENGER = DownloaderService.EXTRA_MESSAGE_HANDLER; + + private static class Proxy implements IDownloaderService { + private Messenger mMsg; + + private void send(int method, Bundle params) { + Message m = Message.obtain(null, method); + m.setData(params); + try { + mMsg.send(m); + } catch (RemoteException e) { + e.printStackTrace(); + } + } + + public Proxy(Messenger msg) { + mMsg = msg; + } + + @Override + public void requestAbortDownload() { + send(MSG_REQUEST_ABORT_DOWNLOAD, new Bundle()); + } + + @Override + public void requestPauseDownload() { + send(MSG_REQUEST_PAUSE_DOWNLOAD, new Bundle()); + } + + @Override + public void setDownloadFlags(int flags) { + Bundle params = new Bundle(); + params.putInt(PARAMS_FLAGS, flags); + send(MSG_SET_DOWNLOAD_FLAGS, params); + } + + @Override + public void requestContinueDownload() { + send(MSG_REQUEST_CONTINUE_DOWNLOAD, new Bundle()); + } + + @Override + public void requestDownloadStatus() { + send(MSG_REQUEST_DOWNLOAD_STATE, new Bundle()); + } + + @Override + public void onClientUpdated(Messenger clientMessenger) { + Bundle bundle = new Bundle(1); + bundle.putParcelable(PARAM_MESSENGER, clientMessenger); + send(MSG_REQUEST_CLIENT_UPDATE, bundle); + } + } + + private static class Stub implements IStub { + private IDownloaderService mItf = null; + final Messenger mMessenger = new Messenger(new Handler() { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case MSG_REQUEST_ABORT_DOWNLOAD: + mItf.requestAbortDownload(); + break; + case MSG_REQUEST_CONTINUE_DOWNLOAD: + mItf.requestContinueDownload(); + break; + case MSG_REQUEST_PAUSE_DOWNLOAD: + mItf.requestPauseDownload(); + break; + case MSG_SET_DOWNLOAD_FLAGS: + mItf.setDownloadFlags(msg.getData().getInt(PARAMS_FLAGS)); + break; + case MSG_REQUEST_DOWNLOAD_STATE: + mItf.requestDownloadStatus(); + break; + case MSG_REQUEST_CLIENT_UPDATE: + mItf.onClientUpdated((Messenger) msg.getData().getParcelable( + PARAM_MESSENGER)); + break; + } + } + }); + + public Stub(IDownloaderService itf) { + mItf = itf; + } + + @Override + public Messenger getMessenger() { + return mMessenger; + } + + @Override + public void connect(Context c) { + + } + + @Override + public void disconnect(Context c) { + + } + } + + /** + * Returns a proxy that will marshall calls to IDownloaderService methods + * + * @param ctx + * @return + */ + public static IDownloaderService CreateProxy(Messenger msg) { + return new Proxy(msg); + } + + /** + * Returns a stub object that, when connected, will listen for marshalled + * IDownloaderService methods and translate them into calls to the supplied + * interface. + * + * @param itf An implementation of IDownloaderService that will be called + * when remote method calls are unmarshalled. + * @return + */ + public static IStub CreateStub(IDownloaderService itf) { + return new Stub(itf); + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/Helpers.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/Helpers.java new file mode 100644 index 000000000..1e84e54a0 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/Helpers.java @@ -0,0 +1,306 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import com.android.vending.expansion.downloader.R; + +import android.content.Context; +import android.os.Environment; +import android.os.StatFs; +import android.os.SystemClock; +import android.util.Log; + +import java.io.File; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Locale; +import java.util.Random; +import java.util.TimeZone; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Some helper functions for the download manager + */ +public class Helpers { + + public static Random sRandom = new Random(SystemClock.uptimeMillis()); + + /** Regex used to parse content-disposition headers */ + private static final Pattern CONTENT_DISPOSITION_PATTERN = Pattern + .compile("attachment;\\s*filename\\s*=\\s*\"([^\"]*)\""); + + private Helpers() { + } + + /* + * Parse the Content-Disposition HTTP Header. The format of the header is + * defined here: http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html This + * header provides a filename for content that is going to be downloaded to + * the file system. We only support the attachment type. + */ + static String parseContentDisposition(String contentDisposition) { + try { + Matcher m = CONTENT_DISPOSITION_PATTERN.matcher(contentDisposition); + if (m.find()) { + return m.group(1); + } + } catch (IllegalStateException ex) { + // This function is defined as returning null when it can't parse + // the header + } + return null; + } + + /** + * @return the root of the filesystem containing the given path + */ + public static File getFilesystemRoot(String path) { + File cache = Environment.getDownloadCacheDirectory(); + if (path.startsWith(cache.getPath())) { + return cache; + } + File external = Environment.getExternalStorageDirectory(); + if (path.startsWith(external.getPath())) { + return external; + } + throw new IllegalArgumentException( + "Cannot determine filesystem root for " + path); + } + + public static boolean isExternalMediaMounted() { + if (!Environment.getExternalStorageState().equals( + Environment.MEDIA_MOUNTED)) { + // No SD card found. + if ( Constants.LOGVV ) { + Log.d(Constants.TAG, "no external storage"); + } + return false; + } + return true; + } + + /** + * @return the number of bytes available on the filesystem rooted at the + * given File + */ + public static long getAvailableBytes(File root) { + StatFs stat = new StatFs(root.getPath()); + // put a bit of margin (in case creating the file grows the system by a + // few blocks) + long availableBlocks = (long) stat.getAvailableBlocks() - 4; + return stat.getBlockSize() * availableBlocks; + } + + /** + * Checks whether the filename looks legitimate + */ + public static boolean isFilenameValid(String filename) { + filename = filename.replaceFirst("/+", "/"); // normalize leading + // slashes + return filename.startsWith(Environment.getDownloadCacheDirectory().toString()) + || filename.startsWith(Environment.getExternalStorageDirectory().toString()); + } + + /* + * Delete the given file from device + */ + /* package */static void deleteFile(String path) { + try { + File file = new File(path); + file.delete(); + } catch (Exception e) { + Log.w(Constants.TAG, "file: '" + path + "' couldn't be deleted", e); + } + } + + /** + * Showing progress in MB here. It would be nice to choose the unit (KB, MB, + * GB) based on total file size, but given what we know about the expected + * ranges of file sizes for APK expansion files, it's probably not necessary. + * + * @param overallProgress + * @param overallTotal + * @return + */ + + static public String getDownloadProgressString(long overallProgress, long overallTotal) { + if (overallTotal == 0) { + if ( Constants.LOGVV ) { + Log.e(Constants.TAG, "Notification called when total is zero"); + } + return ""; + } + return String.format("%.2f", + (float) overallProgress / (1024.0f * 1024.0f)) + + "MB /" + + String.format("%.2f", (float) overallTotal / + (1024.0f * 1024.0f)) + "MB"; + } + + /** + * Adds a percentile to getDownloadProgressString. + * + * @param overallProgress + * @param overallTotal + * @return + */ + static public String getDownloadProgressStringNotification(long overallProgress, + long overallTotal) { + if (overallTotal == 0) { + if ( Constants.LOGVV ) { + Log.e(Constants.TAG, "Notification called when total is zero"); + } + return ""; + } + return getDownloadProgressString(overallProgress, overallTotal) + " (" + + getDownloadProgressPercent(overallProgress, overallTotal) + ")"; + } + + public static String getDownloadProgressPercent(long overallProgress, long overallTotal) { + if (overallTotal == 0) { + if ( Constants.LOGVV ) { + Log.e(Constants.TAG, "Notification called when total is zero"); + } + return ""; + } + return Long.toString(overallProgress * 100 / overallTotal) + "%"; + } + + public static String getSpeedString(float bytesPerMillisecond) { + return String.format("%.2f", bytesPerMillisecond * 1000 / 1024); + } + + public static String getTimeRemaining(long durationInMilliseconds) { + SimpleDateFormat sdf; + if (durationInMilliseconds > 1000 * 60 * 60) { + sdf = new SimpleDateFormat("HH:mm", Locale.getDefault()); + } else { + sdf = new SimpleDateFormat("mm:ss", Locale.getDefault()); + } + return sdf.format(new Date(durationInMilliseconds - TimeZone.getDefault().getRawOffset())); + } + + /** + * Returns the file name (without full path) for an Expansion APK file from + * the given context. + * + * @param c the context + * @param mainFile true for main file, false for patch file + * @param versionCode the version of the file + * @return String the file name of the expansion file + */ + public static String getExpansionAPKFileName(Context c, boolean mainFile, int versionCode) { + return (mainFile ? "main." : "patch.") + versionCode + "." + c.getPackageName() + ".obb"; + } + + /** + * Returns the filename (where the file should be saved) from info about a + * download + */ + static public String generateSaveFileName(Context c, String fileName) { + String path = getSaveFilePath(c) + + File.separator + fileName; + return path; + } + + static public String getSaveFilePath(Context c) { + File root = Environment.getExternalStorageDirectory(); + String path = root.toString() + Constants.EXP_PATH + c.getPackageName(); + return path; + } + + /** + * Helper function to ascertain the existence of a file and return + * true/false appropriately + * + * @param c the app/activity/service context + * @param fileName the name (sans path) of the file to query + * @param fileSize the size that the file must match + * @param deleteFileOnMismatch if the file sizes do not match, delete the + * file + * @return true if it does exist, false otherwise + */ + static public boolean doesFileExist(Context c, String fileName, long fileSize, + boolean deleteFileOnMismatch) { + // the file may have been delivered by Market --- let's make sure + // it's the size we expect + File fileForNewFile = new File(Helpers.generateSaveFileName(c, fileName)); + if (fileForNewFile.exists()) { + if (fileForNewFile.length() == fileSize) { + return true; + } + if (deleteFileOnMismatch) { + // delete the file --- we won't be able to resume + // because we cannot confirm the integrity of the file + fileForNewFile.delete(); + } + } + return false; + } + + /** + * Converts download states that are returned by the {@link + * IDownloaderClient#onDownloadStateChanged} callback into usable strings. + * This is useful if using the state strings built into the library to display user messages. + * @param state One of the STATE_* constants from {@link IDownloaderClient}. + * @return string resource ID for the corresponding string. + */ + static public int getDownloaderStringResourceIDFromState(int state) { + switch (state) { + case IDownloaderClient.STATE_IDLE: + return R.string.state_idle; + case IDownloaderClient.STATE_FETCHING_URL: + return R.string.state_fetching_url; + case IDownloaderClient.STATE_CONNECTING: + return R.string.state_connecting; + case IDownloaderClient.STATE_DOWNLOADING: + return R.string.state_downloading; + case IDownloaderClient.STATE_COMPLETED: + return R.string.state_completed; + case IDownloaderClient.STATE_PAUSED_NETWORK_UNAVAILABLE: + return R.string.state_paused_network_unavailable; + case IDownloaderClient.STATE_PAUSED_BY_REQUEST: + return R.string.state_paused_by_request; + case IDownloaderClient.STATE_PAUSED_WIFI_DISABLED_NEED_CELLULAR_PERMISSION: + return R.string.state_paused_wifi_disabled; + case IDownloaderClient.STATE_PAUSED_NEED_CELLULAR_PERMISSION: + return R.string.state_paused_wifi_unavailable; + case IDownloaderClient.STATE_PAUSED_WIFI_DISABLED: + return R.string.state_paused_wifi_disabled; + case IDownloaderClient.STATE_PAUSED_NEED_WIFI: + return R.string.state_paused_wifi_unavailable; + case IDownloaderClient.STATE_PAUSED_ROAMING: + return R.string.state_paused_roaming; + case IDownloaderClient.STATE_PAUSED_NETWORK_SETUP_FAILURE: + return R.string.state_paused_network_setup_failure; + case IDownloaderClient.STATE_PAUSED_SDCARD_UNAVAILABLE: + return R.string.state_paused_sdcard_unavailable; + case IDownloaderClient.STATE_FAILED_UNLICENSED: + return R.string.state_failed_unlicensed; + case IDownloaderClient.STATE_FAILED_FETCHING_URL: + return R.string.state_failed_fetching_url; + case IDownloaderClient.STATE_FAILED_SDCARD_FULL: + return R.string.state_failed_sdcard_full; + case IDownloaderClient.STATE_FAILED_CANCELED: + return R.string.state_failed_cancelled; + default: + return R.string.state_unknown; + } + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IDownloaderClient.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IDownloaderClient.java new file mode 100644 index 000000000..b8511a62a --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IDownloaderClient.java @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import android.os.Messenger; + +/** + * This interface should be implemented by the client activity for the + * downloader. It is used to pass status from the service to the client. + */ +public interface IDownloaderClient { + static final int STATE_IDLE = 1; + static final int STATE_FETCHING_URL = 2; + static final int STATE_CONNECTING = 3; + static final int STATE_DOWNLOADING = 4; + static final int STATE_COMPLETED = 5; + + static final int STATE_PAUSED_NETWORK_UNAVAILABLE = 6; + static final int STATE_PAUSED_BY_REQUEST = 7; + + /** + * Both STATE_PAUSED_WIFI_DISABLED_NEED_CELLULAR_PERMISSION and + * STATE_PAUSED_NEED_CELLULAR_PERMISSION imply that Wi-Fi is unavailable and + * cellular permission will restart the service. Wi-Fi disabled means that + * the Wi-Fi manager is returning that Wi-Fi is not enabled, while in the + * other case Wi-Fi is enabled but not available. + */ + static final int STATE_PAUSED_WIFI_DISABLED_NEED_CELLULAR_PERMISSION = 8; + static final int STATE_PAUSED_NEED_CELLULAR_PERMISSION = 9; + + /** + * Both STATE_PAUSED_WIFI_DISABLED and STATE_PAUSED_NEED_WIFI imply that + * Wi-Fi is unavailable and cellular permission will NOT restart the + * service. Wi-Fi disabled means that the Wi-Fi manager is returning that + * Wi-Fi is not enabled, while in the other case Wi-Fi is enabled but not + * available. + *

+ * The service does not return these values. We recommend that app + * developers with very large payloads do not allow these payloads to be + * downloaded over cellular connections. + */ + static final int STATE_PAUSED_WIFI_DISABLED = 10; + static final int STATE_PAUSED_NEED_WIFI = 11; + + static final int STATE_PAUSED_ROAMING = 12; + + /** + * Scary case. We were on a network that redirected us to another website + * that delivered us the wrong file. + */ + static final int STATE_PAUSED_NETWORK_SETUP_FAILURE = 13; + + static final int STATE_PAUSED_SDCARD_UNAVAILABLE = 14; + + static final int STATE_FAILED_UNLICENSED = 15; + static final int STATE_FAILED_FETCHING_URL = 16; + static final int STATE_FAILED_SDCARD_FULL = 17; + static final int STATE_FAILED_CANCELED = 18; + + static final int STATE_FAILED = 19; + + /** + * Called internally by the stub when the service is bound to the client. + *

+ * Critical implementation detail. In onServiceConnected we create the + * remote service and marshaler. This is how we pass the client information + * back to the service so the client can be properly notified of changes. We + * must do this every time we reconnect to the service. + *

+ * That is, when you receive this callback, you should call + * {@link DownloaderServiceMarshaller#CreateProxy} to instantiate a member + * instance of {@link IDownloaderService}, then call + * {@link IDownloaderService#onClientUpdated} with the Messenger retrieved + * from your {@link IStub} proxy object. + * + * @param m the service Messenger. This Messenger is used to call the + * service API from the client. + */ + void onServiceConnected(Messenger m); + + /** + * Called when the download state changes. Depending on the state, there may + * be user requests. The service is free to change the download state in the + * middle of a user request, so the client should be able to handle this. + *

+ * The Downloader Library includes a collection of string resources that + * correspond to each of the states, which you can use to provide users a + * useful message based on the state provided in this callback. To fetch the + * appropriate string for a state, call + * {@link Helpers#getDownloaderStringResourceIDFromState}. + *

+ * What this means to the developer: The application has gotten a message + * that the download has paused due to lack of WiFi. The developer should + * then show UI asking the user if they want to enable downloading over + * cellular connections with appropriate warnings. If the application + * suddenly starts downloading, the application should revert to showing the + * progress again, rather than leaving up the download over cellular UI up. + * + * @param newState one of the STATE_* values defined in IDownloaderClient + */ + void onDownloadStateChanged(int newState); + + /** + * Shows the download progress. This is intended to be used to fill out a + * client UI. This progress should only be shown in a few states such as + * STATE_DOWNLOADING. + * + * @param progress the DownloadProgressInfo object containing the current + * progress of all downloads. + */ + void onDownloadProgress(DownloadProgressInfo progress); +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IDownloaderService.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IDownloaderService.java new file mode 100644 index 000000000..4789afe19 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IDownloaderService.java @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import com.google.android.vending.expansion.downloader.impl.DownloaderService; +import android.os.Messenger; + +/** + * This interface is implemented by the DownloaderService and by the + * DownloaderServiceMarshaller. It contains functions to control the service. + * When a client binds to the service, it must call the onClientUpdated + * function. + *

+ * You can acquire a proxy that implements this interface for your service by + * calling {@link DownloaderServiceMarshaller#CreateProxy} during the + * {@link IDownloaderClient#onServiceConnected} callback. At which point, you + * should immediately call {@link #onClientUpdated}. + */ +public interface IDownloaderService { + /** + * Set this flag in response to the + * IDownloaderClient.STATE_PAUSED_NEED_CELLULAR_PERMISSION state and then + * call RequestContinueDownload to resume a download + */ + public static final int FLAGS_DOWNLOAD_OVER_CELLULAR = 1; + + /** + * Request that the service abort the current download. The service should + * respond by changing the state to {@link IDownloaderClient.STATE_ABORTED}. + */ + void requestAbortDownload(); + + /** + * Request that the service pause the current download. The service should + * respond by changing the state to + * {@link IDownloaderClient.STATE_PAUSED_BY_REQUEST}. + */ + void requestPauseDownload(); + + /** + * Request that the service continue a paused download, when in any paused + * or failed state, including + * {@link IDownloaderClient.STATE_PAUSED_BY_REQUEST}. + */ + void requestContinueDownload(); + + /** + * Set the flags for this download (e.g. + * {@link DownloaderService.FLAGS_DOWNLOAD_OVER_CELLULAR}). + * + * @param flags + */ + void setDownloadFlags(int flags); + + /** + * Requests that the download status be sent to the client. + */ + void requestDownloadStatus(); + + /** + * Call this when you get {@link + * IDownloaderClient.onServiceConnected(Messenger m)} from the + * DownloaderClient to register the client with the service. It will + * automatically send the current status to the client. + * + * @param clientMessenger + */ + void onClientUpdated(Messenger clientMessenger); +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IStub.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IStub.java new file mode 100644 index 000000000..d5bc3a843 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/IStub.java @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import android.content.Context; +import android.os.Messenger; + +/** + * This is the interface that is used to connect/disconnect from the downloader + * service. + *

+ * You should get a proxy object that implements this interface by calling + * {@link DownloaderClientMarshaller#CreateStub} in your activity when the + * downloader service starts. Then, call {@link #connect} during your activity's + * onResume() and call {@link #disconnect} during onStop(). + *

+ * Then during the {@link IDownloaderClient#onServiceConnected} callback, you + * should call {@link #getMessenger} to pass the stub's Messenger object to + * {@link IDownloaderService#onClientUpdated}. + */ +public interface IStub { + Messenger getMessenger(); + + void connect(Context c); + + void disconnect(Context c); +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/SystemFacade.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/SystemFacade.java new file mode 100644 index 000000000..12edd97ab --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/SystemFacade.java @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader; + +import android.app.Notification; +import android.app.NotificationManager; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager.NameNotFoundException; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.telephony.TelephonyManager; +import android.util.Log; + +/** + * Contains useful helper functions, typically tied to the application context. + */ +class SystemFacade { + private Context mContext; + private NotificationManager mNotificationManager; + + public SystemFacade(Context context) { + mContext = context; + mNotificationManager = (NotificationManager) + mContext.getSystemService(Context.NOTIFICATION_SERVICE); + } + + public long currentTimeMillis() { + return System.currentTimeMillis(); + } + + public Integer getActiveNetworkType() { + ConnectivityManager connectivity = + (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE); + if (connectivity == null) { + Log.w(Constants.TAG, "couldn't get connectivity manager"); + return null; + } + + NetworkInfo activeInfo = connectivity.getActiveNetworkInfo(); + if (activeInfo == null) { + if (Constants.LOGVV) { + Log.v(Constants.TAG, "network is not available"); + } + return null; + } + return activeInfo.getType(); + } + + public boolean isNetworkRoaming() { + ConnectivityManager connectivity = + (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE); + if (connectivity == null) { + Log.w(Constants.TAG, "couldn't get connectivity manager"); + return false; + } + + NetworkInfo info = connectivity.getActiveNetworkInfo(); + boolean isMobile = (info != null && info.getType() == ConnectivityManager.TYPE_MOBILE); + TelephonyManager tm = (TelephonyManager) mContext + .getSystemService(Context.TELEPHONY_SERVICE); + if (null == tm) { + Log.w(Constants.TAG, "couldn't get telephony manager"); + return false; + } + boolean isRoaming = isMobile && tm.isNetworkRoaming(); + if (Constants.LOGVV && isRoaming) { + Log.v(Constants.TAG, "network is roaming"); + } + return isRoaming; + } + + public Long getMaxBytesOverMobile() { + return (long) Integer.MAX_VALUE; + } + + public Long getRecommendedMaxBytesOverMobile() { + return 2097152L; + } + + public void sendBroadcast(Intent intent) { + mContext.sendBroadcast(intent); + } + + public boolean userOwnsPackage(int uid, String packageName) throws NameNotFoundException { + return mContext.getPackageManager().getApplicationInfo(packageName, 0).uid == uid; + } + + public void postNotification(long id, Notification notification) { + /** + * TODO: The system notification manager takes ints, not longs, as IDs, + * but the download manager uses IDs take straight from the database, + * which are longs. This will have to be dealt with at some point. + */ + mNotificationManager.notify((int) id, notification); + } + + public void cancelNotification(long id) { + mNotificationManager.cancel((int) id); + } + + public void cancelAllNotifications() { + mNotificationManager.cancelAll(); + } + + public void startThread(Thread thread) { + thread.start(); + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/AndroidHttpClient.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/AndroidHttpClient.java new file mode 100644 index 000000000..4667acce6 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/AndroidHttpClient.java @@ -0,0 +1,536 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * This is a port of AndroidHttpClient to pre-Froyo devices, that takes advantage of + * the SSLSessionCache added Froyo devices using reflection. + */ + +package com.google.android.vending.expansion.downloader.impl; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.net.URI; +import java.util.zip.GZIPInputStream; +import java.util.zip.GZIPOutputStream; + +import org.apache.http.Header; +import org.apache.http.HttpEntity; +import org.apache.http.HttpEntityEnclosingRequest; +import org.apache.http.HttpException; +import org.apache.http.HttpHost; +import org.apache.http.HttpRequest; +import org.apache.http.HttpRequestInterceptor; +import org.apache.http.HttpResponse; +import org.apache.http.client.ClientProtocolException; +import org.apache.http.client.HttpClient; +import org.apache.http.client.ResponseHandler; +import org.apache.http.client.methods.HttpUriRequest; +import org.apache.http.client.params.HttpClientParams; +import org.apache.http.client.protocol.ClientContext; +import org.apache.http.conn.ClientConnectionManager; +import org.apache.http.conn.scheme.PlainSocketFactory; +import org.apache.http.conn.scheme.Scheme; +import org.apache.http.conn.scheme.SchemeRegistry; +import org.apache.http.conn.scheme.SocketFactory; +import org.apache.http.conn.ssl.SSLSocketFactory; +import org.apache.http.entity.AbstractHttpEntity; +import org.apache.http.entity.ByteArrayEntity; +import org.apache.http.impl.client.DefaultHttpClient; +import org.apache.http.impl.client.RequestWrapper; +import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.params.HttpConnectionParams; +import org.apache.http.params.HttpParams; +import org.apache.http.params.HttpProtocolParams; +import org.apache.http.protocol.BasicHttpContext; +import org.apache.http.protocol.BasicHttpProcessor; +import org.apache.http.protocol.HttpContext; + +import android.content.ContentResolver; +import android.content.Context; +import android.net.SSLCertificateSocketFactory; +import android.os.Looper; +import android.util.Log; + +/** + * Subclass of the Apache {@link DefaultHttpClient} that is configured with + * reasonable default settings and registered schemes for Android, and + * also lets the user add {@link HttpRequestInterceptor} classes. + * Don't create this directly, use the {@link #newInstance} factory method. + * + *

This client processes cookies but does not retain them by default. + * To retain cookies, simply add a cookie store to the HttpContext:

+ * + * 
context.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
+ */ +public final class AndroidHttpClient implements HttpClient { + + static Class sSslSessionCacheClass; + static { + // if we are on Froyo+ devices, we can take advantage of the SSLSessionCache + try { + sSslSessionCacheClass = Class.forName("android.net.SSLSessionCache"); + } catch (Exception e) { + + } + } + + // Gzip of data shorter than this probably won't be worthwhile + public static long DEFAULT_SYNC_MIN_GZIP_BYTES = 256; + + // Default connection and socket timeout of 60 seconds. Tweak to taste. + private static final int SOCKET_OPERATION_TIMEOUT = 60 * 1000; + + private static final String TAG = "AndroidHttpClient"; + + + /** Interceptor throws an exception if the executing thread is blocked */ + private static final HttpRequestInterceptor sThreadCheckInterceptor = + new HttpRequestInterceptor() { + public void process(HttpRequest request, HttpContext context) { + // Prevent the HttpRequest from being sent on the main thread + if (Looper.myLooper() != null && Looper.myLooper() == Looper.getMainLooper() ) { + throw new RuntimeException("This thread forbids HTTP requests"); + } + } + }; + + /** + * Create a new HttpClient with reasonable defaults (which you can update). + * + * @param userAgent to report in your HTTP requests + * @param context to use for caching SSL sessions (may be null for no caching) + * @return AndroidHttpClient for you to use for all your requests. + */ + public static AndroidHttpClient newInstance(String userAgent, Context context) { + HttpParams params = new BasicHttpParams(); + + // Turn off stale checking. Our connections break all the time anyway, + // and it's not worth it to pay the penalty of checking every time. + HttpConnectionParams.setStaleCheckingEnabled(params, false); + + HttpConnectionParams.setConnectionTimeout(params, SOCKET_OPERATION_TIMEOUT); + HttpConnectionParams.setSoTimeout(params, SOCKET_OPERATION_TIMEOUT); + HttpConnectionParams.setSocketBufferSize(params, 8192); + + // Don't handle redirects -- return them to the caller. Our code + // often wants to re-POST after a redirect, which we must do ourselves. + HttpClientParams.setRedirecting(params, false); + + Object sessionCache = null; + // Use a session cache for SSL sockets -- Froyo only + if ( null != context && null != sSslSessionCacheClass ) { + Constructor ct; + try { + ct = sSslSessionCacheClass.getConstructor(Context.class); + sessionCache = ct.newInstance(context); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InstantiationException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + // Set the specified user agent and register standard protocols. + HttpProtocolParams.setUserAgent(params, userAgent); + SchemeRegistry schemeRegistry = new SchemeRegistry(); + schemeRegistry.register(new Scheme("http", + PlainSocketFactory.getSocketFactory(), 80)); + SocketFactory sslCertificateSocketFactory = null; + if ( null != sessionCache ) { + Method getHttpSocketFactoryMethod; + try { + getHttpSocketFactoryMethod = SSLCertificateSocketFactory.class.getDeclaredMethod("getHttpSocketFactory",Integer.TYPE, sSslSessionCacheClass); + sslCertificateSocketFactory = (SocketFactory)getHttpSocketFactoryMethod.invoke(null, SOCKET_OPERATION_TIMEOUT, sessionCache); + } catch (SecurityException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (NoSuchMethodException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalArgumentException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvocationTargetException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + if ( null == sslCertificateSocketFactory ) { + sslCertificateSocketFactory = SSLSocketFactory.getSocketFactory(); + } + schemeRegistry.register(new Scheme("https", + sslCertificateSocketFactory, 443)); + + ClientConnectionManager manager = + new ThreadSafeClientConnManager(params, schemeRegistry); + + // We use a factory method to modify superclass initialization + // parameters without the funny call-a-static-method dance. + return new AndroidHttpClient(manager, params); + } + + /** + * Create a new HttpClient with reasonable defaults (which you can update). + * @param userAgent to report in your HTTP requests. + * @return AndroidHttpClient for you to use for all your requests. + */ + public static AndroidHttpClient newInstance(String userAgent) { + return newInstance(userAgent, null /* session cache */); + } + + private final HttpClient delegate; + + private RuntimeException mLeakedException = new IllegalStateException( + "AndroidHttpClient created and never closed"); + + private AndroidHttpClient(ClientConnectionManager ccm, HttpParams params) { + this.delegate = new DefaultHttpClient(ccm, params) { + @Override + protected BasicHttpProcessor createHttpProcessor() { + // Add interceptor to prevent making requests from main thread. + BasicHttpProcessor processor = super.createHttpProcessor(); + processor.addRequestInterceptor(sThreadCheckInterceptor); + processor.addRequestInterceptor(new CurlLogger()); + + return processor; + } + + @Override + protected HttpContext createHttpContext() { + // Same as DefaultHttpClient.createHttpContext() minus the + // cookie store. + HttpContext context = new BasicHttpContext(); + context.setAttribute( + ClientContext.AUTHSCHEME_REGISTRY, + getAuthSchemes()); + context.setAttribute( + ClientContext.COOKIESPEC_REGISTRY, + getCookieSpecs()); + context.setAttribute( + ClientContext.CREDS_PROVIDER, + getCredentialsProvider()); + return context; + } + }; + } + + @Override + protected void finalize() throws Throwable { + super.finalize(); + if (mLeakedException != null) { + Log.e(TAG, "Leak found", mLeakedException); + mLeakedException = null; + } + } + + /** + * Modifies a request to indicate to the server that we would like a + * gzipped response. (Uses the "Accept-Encoding" HTTP header.) + * @param request the request to modify + * @see #getUngzippedContent + */ + public static void modifyRequestToAcceptGzipResponse(HttpRequest request) { + request.addHeader("Accept-Encoding", "gzip"); + } + + /** + * Gets the input stream from a response entity. If the entity is gzipped + * then this will get a stream over the uncompressed data. + * + * @param entity the entity whose content should be read + * @return the input stream to read from + * @throws IOException + */ + public static InputStream getUngzippedContent(HttpEntity entity) + throws IOException { + InputStream responseStream = entity.getContent(); + if (responseStream == null) return responseStream; + Header header = entity.getContentEncoding(); + if (header == null) return responseStream; + String contentEncoding = header.getValue(); + if (contentEncoding == null) return responseStream; + if (contentEncoding.contains("gzip")) responseStream + = new GZIPInputStream(responseStream); + return responseStream; + } + + /** + * Release resources associated with this client. You must call this, + * or significant resources (sockets and memory) may be leaked. + */ + public void close() { + if (mLeakedException != null) { + getConnectionManager().shutdown(); + mLeakedException = null; + } + } + + public HttpParams getParams() { + return delegate.getParams(); + } + + public ClientConnectionManager getConnectionManager() { + return delegate.getConnectionManager(); + } + + public HttpResponse execute(HttpUriRequest request) throws IOException { + return delegate.execute(request); + } + + public HttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException { + return delegate.execute(request, context); + } + + public HttpResponse execute(HttpHost target, HttpRequest request) + throws IOException { + return delegate.execute(target, request); + } + + public HttpResponse execute(HttpHost target, HttpRequest request, + HttpContext context) throws IOException { + return delegate.execute(target, request, context); + } + + public T execute(HttpUriRequest request, + ResponseHandler responseHandler) + throws IOException, ClientProtocolException { + return delegate.execute(request, responseHandler); + } + + public T execute(HttpUriRequest request, + ResponseHandler responseHandler, HttpContext context) + throws IOException, ClientProtocolException { + return delegate.execute(request, responseHandler, context); + } + + public T execute(HttpHost target, HttpRequest request, + ResponseHandler responseHandler) throws IOException, + ClientProtocolException { + return delegate.execute(target, request, responseHandler); + } + + public T execute(HttpHost target, HttpRequest request, + ResponseHandler responseHandler, HttpContext context) + throws IOException, ClientProtocolException { + return delegate.execute(target, request, responseHandler, context); + } + + /** + * Compress data to send to server. + * Creates a Http Entity holding the gzipped data. + * The data will not be compressed if it is too short. + * @param data The bytes to compress + * @return Entity holding the data + */ + public static AbstractHttpEntity getCompressedEntity(byte data[], ContentResolver resolver) + throws IOException { + AbstractHttpEntity entity; + if (data.length < getMinGzipSize(resolver)) { + entity = new ByteArrayEntity(data); + } else { + ByteArrayOutputStream arr = new ByteArrayOutputStream(); + OutputStream zipper = new GZIPOutputStream(arr); + zipper.write(data); + zipper.close(); + entity = new ByteArrayEntity(arr.toByteArray()); + entity.setContentEncoding("gzip"); + } + return entity; + } + + /** + * Retrieves the minimum size for compressing data. + * Shorter data will not be compressed. + */ + public static long getMinGzipSize(ContentResolver resolver) { + return DEFAULT_SYNC_MIN_GZIP_BYTES; // For now, this is just a constant. + } + + /* cURL logging support. */ + + /** + * Logging tag and level. + */ + private static class LoggingConfiguration { + + private final String tag; + private final int level; + + private LoggingConfiguration(String tag, int level) { + this.tag = tag; + this.level = level; + } + + /** + * Returns true if logging is turned on for this configuration. + */ + private boolean isLoggable() { + return Log.isLoggable(tag, level); + } + + /** + * Prints a message using this configuration. + */ + private void println(String message) { + Log.println(level, tag, message); + } + } + + /** cURL logging configuration. */ + private volatile LoggingConfiguration curlConfiguration; + + /** + * Enables cURL request logging for this client. + * + * @param name to log messages with + * @param level at which to log messages (see {@link android.util.Log}) + */ + public void enableCurlLogging(String name, int level) { + if (name == null) { + throw new NullPointerException("name"); + } + if (level < Log.VERBOSE || level > Log.ASSERT) { + throw new IllegalArgumentException("Level is out of range [" + + Log.VERBOSE + ".." + Log.ASSERT + "]"); + } + + curlConfiguration = new LoggingConfiguration(name, level); + } + + /** + * Disables cURL logging for this client. + */ + public void disableCurlLogging() { + curlConfiguration = null; + } + + /** + * Logs cURL commands equivalent to requests. + */ + private class CurlLogger implements HttpRequestInterceptor { + public void process(HttpRequest request, HttpContext context) + throws HttpException, IOException { + LoggingConfiguration configuration = curlConfiguration; + if (configuration != null + && configuration.isLoggable() + && request instanceof HttpUriRequest) { + // Never print auth token -- we used to check ro.secure=0 to + // enable that, but can't do that in unbundled code. + configuration.println(toCurl((HttpUriRequest) request, false)); + } + } + } + + /** + * Generates a cURL command equivalent to the given request. + */ + private static String toCurl(HttpUriRequest request, boolean logAuthToken) throws IOException { + StringBuilder builder = new StringBuilder(); + + builder.append("curl "); + + for (Header header: request.getAllHeaders()) { + if (!logAuthToken + && (header.getName().equals("Authorization") || + header.getName().equals("Cookie"))) { + continue; + } + builder.append("--header \""); + builder.append(header.toString().trim()); + builder.append("\" "); + } + + URI uri = request.getURI(); + + // If this is a wrapped request, use the URI from the original + // request instead. getURI() on the wrapper seems to return a + // relative URI. We want an absolute URI. + if (request instanceof RequestWrapper) { + HttpRequest original = ((RequestWrapper) request).getOriginal(); + if (original instanceof HttpUriRequest) { + uri = ((HttpUriRequest) original).getURI(); + } + } + + builder.append("\""); + builder.append(uri); + builder.append("\""); + + if (request instanceof HttpEntityEnclosingRequest) { + HttpEntityEnclosingRequest entityRequest = + (HttpEntityEnclosingRequest) request; + HttpEntity entity = entityRequest.getEntity(); + if (entity != null && entity.isRepeatable()) { + if (entity.getContentLength() < 1024) { + ByteArrayOutputStream stream = new ByteArrayOutputStream(); + entity.writeTo(stream); + String entityString = stream.toString(); + + // TODO: Check the content type, too. + builder.append(" --data-ascii \"") + .append(entityString) + .append("\""); + } else { + builder.append(" [TOO MUCH DATA TO INCLUDE]"); + } + } + } + + return builder.toString(); + } + + /** + * Returns the date of the given HTTP date string. This method can identify + * and parse the date formats emitted by common HTTP servers, such as + * RFC 822, + * RFC 850, + * RFC 1036, + * RFC 1123 and + * ANSI + * C's asctime(). + * + * @return the number of milliseconds since Jan. 1, 1970, midnight GMT. + * @throws IllegalArgumentException if {@code dateString} is not a date or + * of an unsupported format. + */ + public static long parseDate(String dateString) { + return HttpDateTime.parse(dateString); + } +} \ No newline at end of file diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/CustomIntentService.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/CustomIntentService.java new file mode 100644 index 000000000..b77af7e08 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/CustomIntentService.java @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import android.app.Service; +import android.content.Intent; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.Looper; +import android.os.Message; +import android.util.Log; + +/** + * This service differs from IntentService in a few minor ways/ It will not + * auto-stop itself after the intent is handled unless the target returns "true" + * in should stop. Since the goal of this service is to handle a single kind of + * intent, it does not queue up batches of intents of the same type. + */ +public abstract class CustomIntentService extends Service { + private String mName; + private boolean mRedelivery; + private volatile ServiceHandler mServiceHandler; + private volatile Looper mServiceLooper; + private static final String LOG_TAG = "CancellableIntentService"; + private static final int WHAT_MESSAGE = -10; + + public CustomIntentService(String paramString) { + this.mName = paramString; + } + + @Override + public IBinder onBind(Intent paramIntent) { + return null; + } + + @Override + public void onCreate() { + super.onCreate(); + HandlerThread localHandlerThread = new HandlerThread("IntentService[" + + this.mName + "]"); + localHandlerThread.start(); + this.mServiceLooper = localHandlerThread.getLooper(); + this.mServiceHandler = new ServiceHandler(this.mServiceLooper); + } + + @Override + public void onDestroy() { + Thread localThread = this.mServiceLooper.getThread(); + if ((localThread != null) && (localThread.isAlive())) { + localThread.interrupt(); + } + this.mServiceLooper.quit(); + Log.d(LOG_TAG, "onDestroy"); + } + + protected abstract void onHandleIntent(Intent paramIntent); + + protected abstract boolean shouldStop(); + + @Override + public void onStart(Intent paramIntent, int startId) { + if (!this.mServiceHandler.hasMessages(WHAT_MESSAGE)) { + Message localMessage = this.mServiceHandler.obtainMessage(); + localMessage.arg1 = startId; + localMessage.obj = paramIntent; + localMessage.what = WHAT_MESSAGE; + this.mServiceHandler.sendMessage(localMessage); + } + } + + @Override + public int onStartCommand(Intent paramIntent, int flags, int startId) { + onStart(paramIntent, startId); + return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY; + } + + public void setIntentRedelivery(boolean enabled) { + this.mRedelivery = enabled; + } + + private final class ServiceHandler extends Handler { + public ServiceHandler(Looper looper) { + super(looper); + } + + @Override + public void handleMessage(Message paramMessage) { + CustomIntentService.this + .onHandleIntent((Intent) paramMessage.obj); + if (shouldStop()) { + Log.d(LOG_TAG, "stopSelf"); + CustomIntentService.this.stopSelf(paramMessage.arg1); + Log.d(LOG_TAG, "afterStopSelf"); + } + } + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/CustomNotificationFactory.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/CustomNotificationFactory.java new file mode 100644 index 000000000..9a0ca0212 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/CustomNotificationFactory.java @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +/** + * Uses the class-loader model to utilize the updated notification builders in + * Honeycomb while maintaining a compatible version for older devices. + */ +public class CustomNotificationFactory { + static public DownloadNotification.ICustomNotification createCustomNotification() { + if (android.os.Build.VERSION.SDK_INT > 13) + return new V14CustomNotification(); + else + return new V3CustomNotification(); + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadInfo.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadInfo.java new file mode 100644 index 000000000..45111b16a --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadInfo.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import com.google.android.vending.expansion.downloader.Constants; +import com.google.android.vending.expansion.downloader.Helpers; + +import android.util.Log; + +/** + * Representation of information about an individual download from the database. + */ +public class DownloadInfo { + public String mUri; + public final int mIndex; + public final String mFileName; + public String mETag; + public long mTotalBytes; + public long mCurrentBytes; + public long mLastMod; + public int mStatus; + public int mControl; + public int mNumFailed; + public int mRetryAfter; + public int mRedirectCount; + + boolean mInitialized; + + public int mFuzz; + + public DownloadInfo(int index, String fileName, String pkg) { + mFuzz = Helpers.sRandom.nextInt(1001); + mFileName = fileName; + mIndex = index; + } + + public void resetDownload() { + mCurrentBytes = 0; + mETag = ""; + mLastMod = 0; + mStatus = 0; + mControl = 0; + mNumFailed = 0; + mRetryAfter = 0; + mRedirectCount = 0; + } + + /** + * Returns the time when a download should be restarted. + */ + public long restartTime(long now) { + if (mNumFailed == 0) { + return now; + } + if (mRetryAfter > 0) { + return mLastMod + mRetryAfter; + } + return mLastMod + + Constants.RETRY_FIRST_DELAY * + (1000 + mFuzz) * (1 << (mNumFailed - 1)); + } + + public void logVerboseInfo() { + Log.v(Constants.TAG, "Service adding new entry"); + Log.v(Constants.TAG, "FILENAME: " + mFileName); + Log.v(Constants.TAG, "URI : " + mUri); + Log.v(Constants.TAG, "FILENAME: " + mFileName); + Log.v(Constants.TAG, "CONTROL : " + mControl); + Log.v(Constants.TAG, "STATUS : " + mStatus); + Log.v(Constants.TAG, "FAILED_C: " + mNumFailed); + Log.v(Constants.TAG, "RETRY_AF: " + mRetryAfter); + Log.v(Constants.TAG, "REDIRECT: " + mRedirectCount); + Log.v(Constants.TAG, "LAST_MOD: " + mLastMod); + Log.v(Constants.TAG, "TOTAL : " + mTotalBytes); + Log.v(Constants.TAG, "CURRENT : " + mCurrentBytes); + Log.v(Constants.TAG, "ETAG : " + mETag); + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadNotification.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadNotification.java new file mode 100644 index 000000000..eef205d7b --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadNotification.java @@ -0,0 +1,231 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import com.android.vending.expansion.downloader.R; +import com.google.android.vending.expansion.downloader.DownloadProgressInfo; +import com.google.android.vending.expansion.downloader.DownloaderClientMarshaller; +import com.google.android.vending.expansion.downloader.Helpers; +import com.google.android.vending.expansion.downloader.IDownloaderClient; + +import android.app.Notification; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.content.Context; +import android.os.Messenger; + +/** + * This class handles displaying the notification associated with the download + * queue going on in the download manager. It handles multiple status types; + * Some require user interaction and some do not. Some of the user interactions + * may be transient. (for example: the user is queried to continue the download + * on 3G when it started on WiFi, but then the phone locks onto WiFi again so + * the prompt automatically goes away) + *

+ * The application interface for the downloader also needs to understand and + * handle these transient states. + */ +public class DownloadNotification implements IDownloaderClient { + + private int mState; + private final Context mContext; + private final NotificationManager mNotificationManager; + private String mCurrentTitle; + + private IDownloaderClient mClientProxy; + final ICustomNotification mCustomNotification; + private Notification mNotification; + private Notification mCurrentNotification; + private CharSequence mLabel; + private String mCurrentText; + private PendingIntent mContentIntent; + private DownloadProgressInfo mProgressInfo; + + static final String LOGTAG = "DownloadNotification"; + static final int NOTIFICATION_ID = LOGTAG.hashCode(); + + public PendingIntent getClientIntent() { + return mContentIntent; + } + + public void setClientIntent(PendingIntent mClientIntent) { + this.mContentIntent = mClientIntent; + } + + public void resendState() { + if (null != mClientProxy) { + mClientProxy.onDownloadStateChanged(mState); + } + } + + @Override + public void onDownloadStateChanged(int newState) { + if (null != mClientProxy) { + mClientProxy.onDownloadStateChanged(newState); + } + if (newState != mState) { + mState = newState; + if (newState == IDownloaderClient.STATE_IDLE || null == mContentIntent) { + return; + } + int stringDownloadID; + int iconResource; + boolean ongoingEvent; + + // get the new title string and paused text + switch (newState) { + case 0: + iconResource = android.R.drawable.stat_sys_warning; + stringDownloadID = R.string.state_unknown; + ongoingEvent = false; + break; + + case IDownloaderClient.STATE_DOWNLOADING: + iconResource = android.R.drawable.stat_sys_download; + stringDownloadID = Helpers.getDownloaderStringResourceIDFromState(newState); + ongoingEvent = true; + break; + + case IDownloaderClient.STATE_FETCHING_URL: + case IDownloaderClient.STATE_CONNECTING: + iconResource = android.R.drawable.stat_sys_download_done; + stringDownloadID = Helpers.getDownloaderStringResourceIDFromState(newState); + ongoingEvent = true; + break; + + case IDownloaderClient.STATE_COMPLETED: + case IDownloaderClient.STATE_PAUSED_BY_REQUEST: + iconResource = android.R.drawable.stat_sys_download_done; + stringDownloadID = Helpers.getDownloaderStringResourceIDFromState(newState); + ongoingEvent = false; + break; + + case IDownloaderClient.STATE_FAILED: + case IDownloaderClient.STATE_FAILED_CANCELED: + case IDownloaderClient.STATE_FAILED_FETCHING_URL: + case IDownloaderClient.STATE_FAILED_SDCARD_FULL: + case IDownloaderClient.STATE_FAILED_UNLICENSED: + iconResource = android.R.drawable.stat_sys_warning; + stringDownloadID = Helpers.getDownloaderStringResourceIDFromState(newState); + ongoingEvent = false; + break; + + default: + iconResource = android.R.drawable.stat_sys_warning; + stringDownloadID = Helpers.getDownloaderStringResourceIDFromState(newState); + ongoingEvent = true; + break; + } + mCurrentText = mContext.getString(stringDownloadID); + mCurrentTitle = mLabel.toString(); + mCurrentNotification.tickerText = mLabel + ": " + mCurrentText; + mCurrentNotification.icon = iconResource; + mCurrentNotification.setLatestEventInfo(mContext, mCurrentTitle, mCurrentText, + mContentIntent); + if (ongoingEvent) { + mCurrentNotification.flags |= Notification.FLAG_ONGOING_EVENT; + } else { + mCurrentNotification.flags &= ~Notification.FLAG_ONGOING_EVENT; + mCurrentNotification.flags |= Notification.FLAG_AUTO_CANCEL; + } + mNotificationManager.notify(NOTIFICATION_ID, mCurrentNotification); + } + } + + @Override + public void onDownloadProgress(DownloadProgressInfo progress) { + mProgressInfo = progress; + if (null != mClientProxy) { + mClientProxy.onDownloadProgress(progress); + } + if (progress.mOverallTotal <= 0) { + // we just show the text + mNotification.tickerText = mCurrentTitle; + mNotification.icon = android.R.drawable.stat_sys_download; + mNotification.setLatestEventInfo(mContext, mLabel, mCurrentText, mContentIntent); + mCurrentNotification = mNotification; + } else { + mCustomNotification.setCurrentBytes(progress.mOverallProgress); + mCustomNotification.setTotalBytes(progress.mOverallTotal); + mCustomNotification.setIcon(android.R.drawable.stat_sys_download); + mCustomNotification.setPendingIntent(mContentIntent); + mCustomNotification.setTicker(mLabel + ": " + mCurrentText); + mCustomNotification.setTitle(mLabel); + mCustomNotification.setTimeRemaining(progress.mTimeRemaining); + mCurrentNotification = mCustomNotification.updateNotification(mContext); + } + mNotificationManager.notify(NOTIFICATION_ID, mCurrentNotification); + } + + public interface ICustomNotification { + void setTitle(CharSequence title); + + void setTicker(CharSequence ticker); + + void setPendingIntent(PendingIntent mContentIntent); + + void setTotalBytes(long totalBytes); + + void setCurrentBytes(long currentBytes); + + void setIcon(int iconResource); + + void setTimeRemaining(long timeRemaining); + + Notification updateNotification(Context c); + } + + /** + * Called in response to onClientUpdated. Creates a new proxy and notifies + * it of the current state. + * + * @param msg the client Messenger to notify + */ + public void setMessenger(Messenger msg) { + mClientProxy = DownloaderClientMarshaller.CreateProxy(msg); + if (null != mProgressInfo) { + mClientProxy.onDownloadProgress(mProgressInfo); + } + if (mState != -1) { + mClientProxy.onDownloadStateChanged(mState); + } + } + + /** + * Constructor + * + * @param ctx The context to use to obtain access to the Notification + * Service + */ + DownloadNotification(Context ctx, CharSequence applicationLabel) { + mState = -1; + mContext = ctx; + mLabel = applicationLabel; + mNotificationManager = (NotificationManager) + mContext.getSystemService(Context.NOTIFICATION_SERVICE); + mCustomNotification = CustomNotificationFactory + .createCustomNotification(); + mNotification = new Notification(); + mCurrentNotification = mNotification; + + } + + @Override + public void onServiceConnected(Messenger m) { + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadThread.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadThread.java new file mode 100644 index 000000000..056d1eca0 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadThread.java @@ -0,0 +1,963 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import com.google.android.vending.expansion.downloader.Constants; +import com.google.android.vending.expansion.downloader.Helpers; +import com.google.android.vending.expansion.downloader.IDownloaderClient; + +import org.apache.http.Header; +import org.apache.http.HttpHost; +import org.apache.http.HttpResponse; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.conn.params.ConnRouteParams; + +import android.content.Context; +import android.net.Proxy; +import android.os.PowerManager; +import android.os.Process; +import android.util.Log; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.SyncFailedException; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.Locale; + +/** + * Runs an actual download + */ +public class DownloadThread { + + private Context mContext; + private DownloadInfo mInfo; + private DownloaderService mService; + private final DownloadsDB mDB; + private final DownloadNotification mNotification; + private String mUserAgent; + + public DownloadThread(DownloadInfo info, DownloaderService service, + DownloadNotification notification) { + mContext = service; + mInfo = info; + mService = service; + mNotification = notification; + mDB = DownloadsDB.getDB(service); + mUserAgent = "APKXDL (Linux; U; Android " + android.os.Build.VERSION.RELEASE + ";" + + Locale.getDefault().toString() + "; " + android.os.Build.DEVICE + "/" + + android.os.Build.ID + ")" + + service.getPackageName(); + } + + /** + * Returns the default user agent + */ + private String userAgent() { + return mUserAgent; + } + + /** + * State for the entire run() method. + */ + private static class State { + public String mFilename; + public FileOutputStream mStream; + public boolean mCountRetry = false; + public int mRetryAfter = 0; + public int mRedirectCount = 0; + public String mNewUri; + public boolean mGotData = false; + public String mRequestUri; + + public State(DownloadInfo info, DownloaderService service) { + mRedirectCount = info.mRedirectCount; + mRequestUri = info.mUri; + mFilename = service.generateTempSaveFileName(info.mFileName); + } + } + + /** + * State within executeDownload() + */ + private static class InnerState { + public int mBytesSoFar = 0; + public int mBytesThisSession = 0; + public String mHeaderETag; + public boolean mContinuingDownload = false; + public String mHeaderContentLength; + public String mHeaderContentDisposition; + public String mHeaderContentLocation; + public int mBytesNotified = 0; + public long mTimeLastNotification = 0; + } + + /** + * Raised from methods called by run() to indicate that the current request + * should be stopped immediately. Note the message passed to this exception + * will be logged and therefore must be guaranteed not to contain any PII, + * meaning it generally can't include any information about the request URI, + * headers, or destination filename. + */ + private class StopRequest extends Throwable { + /** + * + */ + private static final long serialVersionUID = 6338592678988347973L; + public int mFinalStatus; + + public StopRequest(int finalStatus, String message) { + super(message); + mFinalStatus = finalStatus; + } + + public StopRequest(int finalStatus, String message, Throwable throwable) { + super(message, throwable); + mFinalStatus = finalStatus; + } + } + + /** + * Raised from methods called by executeDownload() to indicate that the + * download should be retried immediately. + */ + private class RetryDownload extends Throwable { + + /** + * + */ + private static final long serialVersionUID = 6196036036517540229L; + } + + /** + * Returns the preferred proxy to be used by clients. This is a wrapper + * around {@link android.net.Proxy#getHost()}. Currently no proxy will be + * returned for localhost or if the active network is Wi-Fi. + * + * @param context the context which will be passed to + * {@link android.net.Proxy#getHost()} + * @param url the target URL for the request + * @note Calling this method requires permission + * android.permission.ACCESS_NETWORK_STATE + * @return The preferred proxy to be used by clients, or null if there is no + * proxy. + */ + public HttpHost getPreferredHttpHost(Context context, + String url) { + if (!isLocalHost(url) && !mService.isWiFi()) { + final String proxyHost = Proxy.getHost(context); + if (proxyHost != null) { + return new HttpHost(proxyHost, Proxy.getPort(context), "http"); + } + } + + return null; + } + + static final private boolean isLocalHost(String url) { + if (url == null) { + return false; + } + + try { + final URI uri = URI.create(url); + final String host = uri.getHost(); + if (host != null) { + // TODO: InetAddress.isLoopbackAddress should be used to check + // for localhost. However no public factory methods exist which + // can be used without triggering DNS lookup if host is not + // localhost. + if (host.equalsIgnoreCase("localhost") || + host.equals("127.0.0.1") || + host.equals("[::1]")) { + return true; + } + } + } catch (IllegalArgumentException iex) { + // Ignore (URI.create) + } + + return false; + } + + /** + * Executes the download in a separate thread + */ + public void run() { + Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); + + State state = new State(mInfo, mService); + AndroidHttpClient client = null; + PowerManager.WakeLock wakeLock = null; + int finalStatus = DownloaderService.STATUS_UNKNOWN_ERROR; + + try { + PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); + wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, Constants.TAG); + wakeLock.acquire(); + + if (Constants.LOGV) { + Log.v(Constants.TAG, "initiating download for " + mInfo.mFileName); + Log.v(Constants.TAG, " at " + mInfo.mUri); + } + + client = AndroidHttpClient.newInstance(userAgent(), mContext); + + boolean finished = false; + while (!finished) { + if (Constants.LOGV) { + Log.v(Constants.TAG, "initiating download for " + mInfo.mFileName); + Log.v(Constants.TAG, " at " + mInfo.mUri); + } + // Set or unset proxy, which may have changed since last GET + // request. + // setDefaultProxy() supports null as proxy parameter. + ConnRouteParams.setDefaultProxy(client.getParams(), + getPreferredHttpHost(mContext, state.mRequestUri)); + HttpGet request = new HttpGet(state.mRequestUri); + try { + executeDownload(state, client, request); + finished = true; + } catch (RetryDownload exc) { + // fall through + } finally { + request.abort(); + request = null; + } + } + + if (Constants.LOGV) { + Log.v(Constants.TAG, "download completed for " + mInfo.mFileName); + Log.v(Constants.TAG, " at " + mInfo.mUri); + } + finalizeDestinationFile(state); + finalStatus = DownloaderService.STATUS_SUCCESS; + } catch (StopRequest error) { + // remove the cause before printing, in case it contains PII + Log.w(Constants.TAG, + "Aborting request for download " + mInfo.mFileName + ": " + error.getMessage()); + error.printStackTrace(); + finalStatus = error.mFinalStatus; + // fall through to finally block + } catch (Throwable ex) { // sometimes the socket code throws unchecked + // exceptions + Log.w(Constants.TAG, "Exception for " + mInfo.mFileName + ": " + ex); + finalStatus = DownloaderService.STATUS_UNKNOWN_ERROR; + // falls through to the code that reports an error + } finally { + if (wakeLock != null) { + wakeLock.release(); + wakeLock = null; + } + if (client != null) { + client.close(); + client = null; + } + cleanupDestination(state, finalStatus); + notifyDownloadCompleted(finalStatus, state.mCountRetry, state.mRetryAfter, + state.mRedirectCount, state.mGotData, state.mFilename); + } + } + + /** + * Fully execute a single download request - setup and send the request, + * handle the response, and transfer the data to the destination file. + */ + private void executeDownload(State state, AndroidHttpClient client, HttpGet request) + throws StopRequest, RetryDownload { + InnerState innerState = new InnerState(); + byte data[] = new byte[Constants.BUFFER_SIZE]; + + checkPausedOrCanceled(state); + + setupDestinationFile(state, innerState); + addRequestHeaders(innerState, request); + + // check just before sending the request to avoid using an invalid + // connection at all + checkConnectivity(state); + + mNotification.onDownloadStateChanged(IDownloaderClient.STATE_CONNECTING); + HttpResponse response = sendRequest(state, client, request); + handleExceptionalStatus(state, innerState, response); + + if (Constants.LOGV) { + Log.v(Constants.TAG, "received response for " + mInfo.mUri); + } + + processResponseHeaders(state, innerState, response); + InputStream entityStream = openResponseEntity(state, response); + mNotification.onDownloadStateChanged(IDownloaderClient.STATE_DOWNLOADING); + transferData(state, innerState, data, entityStream); + } + + /** + * Check if current connectivity is valid for this request. + */ + private void checkConnectivity(State state) throws StopRequest { + switch (mService.getNetworkAvailabilityState(mDB)) { + case DownloaderService.NETWORK_OK: + return; + case DownloaderService.NETWORK_NO_CONNECTION: + throw new StopRequest(DownloaderService.STATUS_WAITING_FOR_NETWORK, + "waiting for network to return"); + case DownloaderService.NETWORK_TYPE_DISALLOWED_BY_REQUESTOR: + throw new StopRequest( + DownloaderService.STATUS_QUEUED_FOR_WIFI_OR_CELLULAR_PERMISSION, + "waiting for wifi or for download over cellular to be authorized"); + case DownloaderService.NETWORK_CANNOT_USE_ROAMING: + throw new StopRequest(DownloaderService.STATUS_WAITING_FOR_NETWORK, + "roaming is not allowed"); + case DownloaderService.NETWORK_UNUSABLE_DUE_TO_SIZE: + throw new StopRequest(DownloaderService.STATUS_QUEUED_FOR_WIFI, "waiting for wifi"); + } + } + + /** + * Transfer as much data as possible from the HTTP response to the + * destination file. + * + * @param data buffer to use to read data + * @param entityStream stream for reading the HTTP response entity + */ + private void transferData(State state, InnerState innerState, byte[] data, + InputStream entityStream) throws StopRequest { + for (;;) { + int bytesRead = readFromResponse(state, innerState, data, entityStream); + if (bytesRead == -1) { // success, end of stream already reached + handleEndOfStream(state, innerState); + return; + } + + state.mGotData = true; + writeDataToDestination(state, data, bytesRead); + innerState.mBytesSoFar += bytesRead; + innerState.mBytesThisSession += bytesRead; + reportProgress(state, innerState); + + checkPausedOrCanceled(state); + } + } + + /** + * Called after a successful completion to take any necessary action on the + * downloaded file. + */ + private void finalizeDestinationFile(State state) throws StopRequest { + syncDestination(state); + String tempFilename = state.mFilename; + String finalFilename = Helpers.generateSaveFileName(mService, mInfo.mFileName); + if (!state.mFilename.equals(finalFilename)) { + File startFile = new File(tempFilename); + File destFile = new File(finalFilename); + if (mInfo.mTotalBytes != -1 && mInfo.mCurrentBytes == mInfo.mTotalBytes) { + if (!startFile.renameTo(destFile)) { + throw new StopRequest(DownloaderService.STATUS_FILE_ERROR, + "unable to finalize destination file"); + } + } else { + throw new StopRequest(DownloaderService.STATUS_FILE_DELIVERED_INCORRECTLY, + "file delivered with incorrect size. probably due to network not browser configured"); + } + } + } + + /** + * Called just before the thread finishes, regardless of status, to take any + * necessary action on the downloaded file. + */ + private void cleanupDestination(State state, int finalStatus) { + closeDestination(state); + if (state.mFilename != null && DownloaderService.isStatusError(finalStatus)) { + new File(state.mFilename).delete(); + state.mFilename = null; + } + } + + /** + * Sync the destination file to storage. + */ + private void syncDestination(State state) { + FileOutputStream downloadedFileStream = null; + try { + downloadedFileStream = new FileOutputStream(state.mFilename, true); + downloadedFileStream.getFD().sync(); + } catch (FileNotFoundException ex) { + Log.w(Constants.TAG, "file " + state.mFilename + " not found: " + ex); + } catch (SyncFailedException ex) { + Log.w(Constants.TAG, "file " + state.mFilename + " sync failed: " + ex); + } catch (IOException ex) { + Log.w(Constants.TAG, "IOException trying to sync " + state.mFilename + ": " + ex); + } catch (RuntimeException ex) { + Log.w(Constants.TAG, "exception while syncing file: ", ex); + } finally { + if (downloadedFileStream != null) { + try { + downloadedFileStream.close(); + } catch (IOException ex) { + Log.w(Constants.TAG, "IOException while closing synced file: ", ex); + } catch (RuntimeException ex) { + Log.w(Constants.TAG, "exception while closing file: ", ex); + } + } + } + } + + /** + * Close the destination output stream. + */ + private void closeDestination(State state) { + try { + // close the file + if (state.mStream != null) { + state.mStream.close(); + state.mStream = null; + } + } catch (IOException ex) { + if (Constants.LOGV) { + Log.v(Constants.TAG, "exception when closing the file after download : " + ex); + } + // nothing can really be done if the file can't be closed + } + } + + /** + * Check if the download has been paused or canceled, stopping the request + * appropriately if it has been. + */ + private void checkPausedOrCanceled(State state) throws StopRequest { + if (mService.getControl() == DownloaderService.CONTROL_PAUSED) { + int status = mService.getStatus(); + switch (status) { + case DownloaderService.STATUS_PAUSED_BY_APP: + throw new StopRequest(mService.getStatus(), + "download paused"); + } + } + } + + /** + * Report download progress through the database if necessary. + */ + private void reportProgress(State state, InnerState innerState) { + long now = System.currentTimeMillis(); + if (innerState.mBytesSoFar - innerState.mBytesNotified + > Constants.MIN_PROGRESS_STEP + && now - innerState.mTimeLastNotification + > Constants.MIN_PROGRESS_TIME) { + // we store progress updates to the database here + mInfo.mCurrentBytes = innerState.mBytesSoFar; + mDB.updateDownloadCurrentBytes(mInfo); + + innerState.mBytesNotified = innerState.mBytesSoFar; + innerState.mTimeLastNotification = now; + + long totalBytesSoFar = innerState.mBytesThisSession + mService.mBytesSoFar; + + if (Constants.LOGVV) { + Log.v(Constants.TAG, "downloaded " + mInfo.mCurrentBytes + " out of " + + mInfo.mTotalBytes); + Log.v(Constants.TAG, " total " + totalBytesSoFar + " out of " + + mService.mTotalLength); + } + + mService.notifyUpdateBytes(totalBytesSoFar); + } + } + + /** + * Write a data buffer to the destination file. + * + * @param data buffer containing the data to write + * @param bytesRead how many bytes to write from the buffer + */ + private void writeDataToDestination(State state, byte[] data, int bytesRead) + throws StopRequest { + for (;;) { + try { + if (state.mStream == null) { + state.mStream = new FileOutputStream(state.mFilename, true); + } + state.mStream.write(data, 0, bytesRead); + // we close after every write --- this may be too inefficient + closeDestination(state); + return; + } catch (IOException ex) { + if (!Helpers.isExternalMediaMounted()) { + throw new StopRequest(DownloaderService.STATUS_DEVICE_NOT_FOUND_ERROR, + "external media not mounted while writing destination file"); + } + + long availableBytes = + Helpers.getAvailableBytes(Helpers.getFilesystemRoot(state.mFilename)); + if (availableBytes < bytesRead) { + throw new StopRequest(DownloaderService.STATUS_INSUFFICIENT_SPACE_ERROR, + "insufficient space while writing destination file", ex); + } + throw new StopRequest(DownloaderService.STATUS_FILE_ERROR, + "while writing destination file: " + ex.toString(), ex); + } + } + } + + /** + * Called when we've reached the end of the HTTP response stream, to update + * the database and check for consistency. + */ + private void handleEndOfStream(State state, InnerState innerState) throws StopRequest { + mInfo.mCurrentBytes = innerState.mBytesSoFar; + // this should always be set from the market + // if ( innerState.mHeaderContentLength == null ) { + // mInfo.mTotalBytes = innerState.mBytesSoFar; + // } + mDB.updateDownload(mInfo); + + boolean lengthMismatched = (innerState.mHeaderContentLength != null) + && (innerState.mBytesSoFar != Integer.parseInt(innerState.mHeaderContentLength)); + if (lengthMismatched) { + if (cannotResume(innerState)) { + throw new StopRequest(DownloaderService.STATUS_CANNOT_RESUME, + "mismatched content length"); + } else { + throw new StopRequest(getFinalStatusForHttpError(state), + "closed socket before end of file"); + } + } + } + + private boolean cannotResume(InnerState innerState) { + return innerState.mBytesSoFar > 0 && innerState.mHeaderETag == null; + } + + /** + * Read some data from the HTTP response stream, handling I/O errors. + * + * @param data buffer to use to read data + * @param entityStream stream for reading the HTTP response entity + * @return the number of bytes actually read or -1 if the end of the stream + * has been reached + */ + private int readFromResponse(State state, InnerState innerState, byte[] data, + InputStream entityStream) throws StopRequest { + try { + return entityStream.read(data); + } catch (IOException ex) { + logNetworkState(); + mInfo.mCurrentBytes = innerState.mBytesSoFar; + mDB.updateDownload(mInfo); + if (cannotResume(innerState)) { + String message = "while reading response: " + ex.toString() + + ", can't resume interrupted download with no ETag"; + throw new StopRequest(DownloaderService.STATUS_CANNOT_RESUME, + message, ex); + } else { + throw new StopRequest(getFinalStatusForHttpError(state), + "while reading response: " + ex.toString(), ex); + } + } + } + + /** + * Open a stream for the HTTP response entity, handling I/O errors. + * + * @return an InputStream to read the response entity + */ + private InputStream openResponseEntity(State state, HttpResponse response) + throws StopRequest { + try { + return response.getEntity().getContent(); + } catch (IOException ex) { + logNetworkState(); + throw new StopRequest(getFinalStatusForHttpError(state), + "while getting entity: " + ex.toString(), ex); + } + } + + private void logNetworkState() { + if (Constants.LOGX) { + Log.i(Constants.TAG, + "Net " + + (mService.getNetworkAvailabilityState(mDB) == DownloaderService.NETWORK_OK ? "Up" + : "Down")); + } + } + + /** + * Read HTTP response headers and take appropriate action, including setting + * up the destination file and updating the database. + */ + private void processResponseHeaders(State state, InnerState innerState, HttpResponse response) + throws StopRequest { + if (innerState.mContinuingDownload) { + // ignore response headers on resume requests + return; + } + + readResponseHeaders(state, innerState, response); + + try { + state.mFilename = mService.generateSaveFile(mInfo.mFileName, mInfo.mTotalBytes); + } catch (DownloaderService.GenerateSaveFileError exc) { + throw new StopRequest(exc.mStatus, exc.mMessage); + } + try { + state.mStream = new FileOutputStream(state.mFilename); + } catch (FileNotFoundException exc) { + // make sure the directory exists + File pathFile = new File(Helpers.getSaveFilePath(mService)); + try { + if (pathFile.mkdirs()) { + state.mStream = new FileOutputStream(state.mFilename); + } + } catch (Exception ex) { + throw new StopRequest(DownloaderService.STATUS_FILE_ERROR, + "while opening destination file: " + exc.toString(), exc); + } + } + if (Constants.LOGV) { + Log.v(Constants.TAG, "writing " + mInfo.mUri + " to " + state.mFilename); + } + + updateDatabaseFromHeaders(state, innerState); + // check connectivity again now that we know the total size + checkConnectivity(state); + } + + /** + * Update necessary database fields based on values of HTTP response headers + * that have been read. + */ + private void updateDatabaseFromHeaders(State state, InnerState innerState) { + mInfo.mETag = innerState.mHeaderETag; + mDB.updateDownload(mInfo); + } + + /** + * Read headers from the HTTP response and store them into local state. + */ + private void readResponseHeaders(State state, InnerState innerState, HttpResponse response) + throws StopRequest { + Header header = response.getFirstHeader("Content-Disposition"); + if (header != null) { + innerState.mHeaderContentDisposition = header.getValue(); + } + header = response.getFirstHeader("Content-Location"); + if (header != null) { + innerState.mHeaderContentLocation = header.getValue(); + } + header = response.getFirstHeader("ETag"); + if (header != null) { + innerState.mHeaderETag = header.getValue(); + } + String headerTransferEncoding = null; + header = response.getFirstHeader("Transfer-Encoding"); + if (header != null) { + headerTransferEncoding = header.getValue(); + } + String headerContentType = null; + header = response.getFirstHeader("Content-Type"); + if (header != null) { + headerContentType = header.getValue(); + if (!headerContentType.equals("application/vnd.android.obb")) { + throw new StopRequest(DownloaderService.STATUS_FILE_DELIVERED_INCORRECTLY, + "file delivered with incorrect Mime type"); + } + } + + if (headerTransferEncoding == null) { + header = response.getFirstHeader("Content-Length"); + if (header != null) { + innerState.mHeaderContentLength = header.getValue(); + // this is always set from Market + long contentLength = Long.parseLong(innerState.mHeaderContentLength); + if (contentLength != -1 && contentLength != mInfo.mTotalBytes) { + // we're most likely on a bad wifi connection -- we should + // probably + // also look at the mime type --- but the size mismatch is + // enough + // to tell us that something is wrong here + Log.e(Constants.TAG, "Incorrect file size delivered."); + } + } + } else { + // Ignore content-length with transfer-encoding - 2616 4.4 3 + if (Constants.LOGVV) { + Log.v(Constants.TAG, + "ignoring content-length because of xfer-encoding"); + } + } + if (Constants.LOGVV) { + Log.v(Constants.TAG, "Content-Disposition: " + + innerState.mHeaderContentDisposition); + Log.v(Constants.TAG, "Content-Length: " + innerState.mHeaderContentLength); + Log.v(Constants.TAG, "Content-Location: " + innerState.mHeaderContentLocation); + Log.v(Constants.TAG, "ETag: " + innerState.mHeaderETag); + Log.v(Constants.TAG, "Transfer-Encoding: " + headerTransferEncoding); + } + + boolean noSizeInfo = innerState.mHeaderContentLength == null + && (headerTransferEncoding == null + || !headerTransferEncoding.equalsIgnoreCase("chunked")); + if (noSizeInfo) { + throw new StopRequest(DownloaderService.STATUS_HTTP_DATA_ERROR, + "can't know size of download, giving up"); + } + } + + /** + * Check the HTTP response status and handle anything unusual (e.g. not + * 200/206). + */ + private void handleExceptionalStatus(State state, InnerState innerState, HttpResponse response) + throws StopRequest, RetryDownload { + int statusCode = response.getStatusLine().getStatusCode(); + if (statusCode == 503 && mInfo.mNumFailed < Constants.MAX_RETRIES) { + handleServiceUnavailable(state, response); + } + if (statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307) { + handleRedirect(state, response, statusCode); + } + + int expectedStatus = innerState.mContinuingDownload ? 206 + : DownloaderService.STATUS_SUCCESS; + if (statusCode != expectedStatus) { + handleOtherStatus(state, innerState, statusCode); + } else { + // no longer redirected + state.mRedirectCount = 0; + } + } + + /** + * Handle a status that we don't know how to deal with properly. + */ + private void handleOtherStatus(State state, InnerState innerState, int statusCode) + throws StopRequest { + int finalStatus; + if (DownloaderService.isStatusError(statusCode)) { + finalStatus = statusCode; + } else if (statusCode >= 300 && statusCode < 400) { + finalStatus = DownloaderService.STATUS_UNHANDLED_REDIRECT; + } else if (innerState.mContinuingDownload && statusCode == DownloaderService.STATUS_SUCCESS) { + finalStatus = DownloaderService.STATUS_CANNOT_RESUME; + } else { + finalStatus = DownloaderService.STATUS_UNHANDLED_HTTP_CODE; + } + throw new StopRequest(finalStatus, "http error " + statusCode); + } + + /** + * Handle a 3xx redirect status. + */ + private void handleRedirect(State state, HttpResponse response, int statusCode) + throws StopRequest, RetryDownload { + if (Constants.LOGVV) { + Log.v(Constants.TAG, "got HTTP redirect " + statusCode); + } + if (state.mRedirectCount >= Constants.MAX_REDIRECTS) { + throw new StopRequest(DownloaderService.STATUS_TOO_MANY_REDIRECTS, "too many redirects"); + } + Header header = response.getFirstHeader("Location"); + if (header == null) { + return; + } + if (Constants.LOGVV) { + Log.v(Constants.TAG, "Location :" + header.getValue()); + } + + String newUri; + try { + newUri = new URI(mInfo.mUri).resolve(new URI(header.getValue())).toString(); + } catch (URISyntaxException ex) { + if (Constants.LOGV) { + Log.d(Constants.TAG, "Couldn't resolve redirect URI " + header.getValue() + + " for " + mInfo.mUri); + } + throw new StopRequest(DownloaderService.STATUS_HTTP_DATA_ERROR, + "Couldn't resolve redirect URI"); + } + ++state.mRedirectCount; + state.mRequestUri = newUri; + if (statusCode == 301 || statusCode == 303) { + // use the new URI for all future requests (should a retry/resume be + // necessary) + state.mNewUri = newUri; + } + throw new RetryDownload(); + } + + /** + * Add headers for this download to the HTTP request to allow for resume. + */ + private void addRequestHeaders(InnerState innerState, HttpGet request) { + if (innerState.mContinuingDownload) { + if (innerState.mHeaderETag != null) { + request.addHeader("If-Match", innerState.mHeaderETag); + } + request.addHeader("Range", "bytes=" + innerState.mBytesSoFar + "-"); + } + } + + /** + * Handle a 503 Service Unavailable status by processing the Retry-After + * header. + */ + private void handleServiceUnavailable(State state, HttpResponse response) throws StopRequest { + if (Constants.LOGVV) { + Log.v(Constants.TAG, "got HTTP response code 503"); + } + state.mCountRetry = true; + Header header = response.getFirstHeader("Retry-After"); + if (header != null) { + try { + if (Constants.LOGVV) { + Log.v(Constants.TAG, "Retry-After :" + header.getValue()); + } + state.mRetryAfter = Integer.parseInt(header.getValue()); + if (state.mRetryAfter < 0) { + state.mRetryAfter = 0; + } else { + if (state.mRetryAfter < Constants.MIN_RETRY_AFTER) { + state.mRetryAfter = Constants.MIN_RETRY_AFTER; + } else if (state.mRetryAfter > Constants.MAX_RETRY_AFTER) { + state.mRetryAfter = Constants.MAX_RETRY_AFTER; + } + state.mRetryAfter += Helpers.sRandom.nextInt(Constants.MIN_RETRY_AFTER + 1); + state.mRetryAfter *= 1000; + } + } catch (NumberFormatException ex) { + // ignored - retryAfter stays 0 in this case. + } + } + throw new StopRequest(DownloaderService.STATUS_WAITING_TO_RETRY, + "got 503 Service Unavailable, will retry later"); + } + + /** + * Send the request to the server, handling any I/O exceptions. + */ + private HttpResponse sendRequest(State state, AndroidHttpClient client, HttpGet request) + throws StopRequest { + try { + return client.execute(request); + } catch (IllegalArgumentException ex) { + throw new StopRequest(DownloaderService.STATUS_HTTP_DATA_ERROR, + "while trying to execute request: " + ex.toString(), ex); + } catch (IOException ex) { + logNetworkState(); + throw new StopRequest(getFinalStatusForHttpError(state), + "while trying to execute request: " + ex.toString(), ex); + } + } + + private int getFinalStatusForHttpError(State state) { + if (mService.getNetworkAvailabilityState(mDB) != DownloaderService.NETWORK_OK) { + return DownloaderService.STATUS_WAITING_FOR_NETWORK; + } else if (mInfo.mNumFailed < Constants.MAX_RETRIES) { + state.mCountRetry = true; + return DownloaderService.STATUS_WAITING_TO_RETRY; + } else { + Log.w(Constants.TAG, "reached max retries for " + mInfo.mNumFailed); + return DownloaderService.STATUS_HTTP_DATA_ERROR; + } + } + + /** + * Prepare the destination file to receive data. If the file already exists, + * we'll set up appropriately for resumption. + */ + private void setupDestinationFile(State state, InnerState innerState) + throws StopRequest { + if (state.mFilename != null) { // only true if we've already run a + // thread for this download + if (!Helpers.isFilenameValid(state.mFilename)) { + // this should never happen + throw new StopRequest(DownloaderService.STATUS_FILE_ERROR, + "found invalid internal destination filename"); + } + // We're resuming a download that got interrupted + File f = new File(state.mFilename); + if (f.exists()) { + long fileLength = f.length(); + if (fileLength == 0) { + // The download hadn't actually started, we can restart from + // scratch + f.delete(); + state.mFilename = null; + } else if (mInfo.mETag == null) { + // This should've been caught upon failure + f.delete(); + throw new StopRequest(DownloaderService.STATUS_CANNOT_RESUME, + "Trying to resume a download that can't be resumed"); + } else { + // All right, we'll be able to resume this download + try { + state.mStream = new FileOutputStream(state.mFilename, true); + } catch (FileNotFoundException exc) { + throw new StopRequest(DownloaderService.STATUS_FILE_ERROR, + "while opening destination for resuming: " + exc.toString(), exc); + } + innerState.mBytesSoFar = (int) fileLength; + if (mInfo.mTotalBytes != -1) { + innerState.mHeaderContentLength = Long.toString(mInfo.mTotalBytes); + } + innerState.mHeaderETag = mInfo.mETag; + innerState.mContinuingDownload = true; + } + } + } + + if (state.mStream != null) { + closeDestination(state); + } + } + + /** + * Stores information about the completed download, and notifies the + * initiating application. + */ + private void notifyDownloadCompleted( + int status, boolean countRetry, int retryAfter, int redirectCount, boolean gotData, + String filename) { + updateDownloadDatabase( + status, countRetry, retryAfter, redirectCount, gotData, filename); + if (DownloaderService.isStatusCompleted(status)) { + // TBD: send status update? + } + } + + private void updateDownloadDatabase( + int status, boolean countRetry, int retryAfter, int redirectCount, boolean gotData, + String filename) { + mInfo.mStatus = status; + mInfo.mRetryAfter = retryAfter; + mInfo.mRedirectCount = redirectCount; + mInfo.mLastMod = System.currentTimeMillis(); + if (!countRetry) { + mInfo.mNumFailed = 0; + } else if (gotData) { + mInfo.mNumFailed = 1; + } else { + mInfo.mNumFailed++; + } + mDB.updateDownload(mInfo); + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloaderService.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloaderService.java new file mode 100644 index 000000000..627bf3eed --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloaderService.java @@ -0,0 +1,1341 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import com.google.android.vending.expansion.downloader.Constants; +import com.google.android.vending.expansion.downloader.DownloadProgressInfo; +import com.google.android.vending.expansion.downloader.DownloaderServiceMarshaller; +import com.google.android.vending.expansion.downloader.Helpers; +import com.google.android.vending.expansion.downloader.IDownloaderClient; +import com.google.android.vending.expansion.downloader.IDownloaderService; +import com.google.android.vending.expansion.downloader.IStub; +import com.google.android.vending.licensing.AESObfuscator; +import com.google.android.vending.licensing.APKExpansionPolicy; +import com.google.android.vending.licensing.LicenseChecker; +import com.google.android.vending.licensing.LicenseCheckerCallback; +import com.google.android.vending.licensing.Policy; + +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.app.Service; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ApplicationInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager.NameNotFoundException; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.net.wifi.WifiManager; +import android.os.Handler; +import android.os.IBinder; +import android.os.Messenger; +import android.os.SystemClock; +import android.provider.Settings.Secure; +import android.telephony.TelephonyManager; +import android.util.Log; + +import java.io.File; + +/** + * Performs the background downloads requested by applications that use the + * Downloads provider. This service does not run as a foreground task, so + * Android may kill it off at will, but it will try to restart itself if it can. + * Note that Android by default will kill off any process that has an open file + * handle on the shared (SD Card) partition if the partition is unmounted. + */ +public abstract class DownloaderService extends CustomIntentService implements IDownloaderService { + + public DownloaderService() { + super("LVLDownloadService"); + } + + private static final String LOG_TAG = "LVLDL"; + + // the following NETWORK_* constants are used to indicates specific reasons + // for disallowing a + // download from using a network, since specific causes can require special + // handling + + /** + * The network is usable for the given download. + */ + public static final int NETWORK_OK = 1; + + /** + * There is no network connectivity. + */ + public static final int NETWORK_NO_CONNECTION = 2; + + /** + * The download exceeds the maximum size for this network. + */ + public static final int NETWORK_UNUSABLE_DUE_TO_SIZE = 3; + + /** + * The download exceeds the recommended maximum size for this network, the + * user must confirm for this download to proceed without WiFi. + */ + public static final int NETWORK_RECOMMENDED_UNUSABLE_DUE_TO_SIZE = 4; + + /** + * The current connection is roaming, and the download can't proceed over a + * roaming connection. + */ + public static final int NETWORK_CANNOT_USE_ROAMING = 5; + + /** + * The app requesting the download specific that it can't use the current + * network connection. + */ + public static final int NETWORK_TYPE_DISALLOWED_BY_REQUESTOR = 6; + + /** + * For intents used to notify the user that a download exceeds a size + * threshold, if this extra is true, WiFi is required for this download + * size; otherwise, it is only recommended. + */ + public static final String EXTRA_IS_WIFI_REQUIRED = "isWifiRequired"; + public static final String EXTRA_FILE_NAME = "downloadId"; + + /** + * Used with DOWNLOAD_STATUS + */ + public static final String EXTRA_STATUS_STATE = "ESS"; + public static final String EXTRA_STATUS_TOTAL_SIZE = "ETS"; + public static final String EXTRA_STATUS_CURRENT_FILE_SIZE = "CFS"; + public static final String EXTRA_STATUS_TOTAL_PROGRESS = "TFP"; + public static final String EXTRA_STATUS_CURRENT_PROGRESS = "CFP"; + + public static final String ACTION_DOWNLOADS_CHANGED = "downloadsChanged"; + + /** + * Broadcast intent action sent by the download manager when a download + * completes. + */ + public final static String ACTION_DOWNLOAD_COMPLETE = "lvldownloader.intent.action.DOWNLOAD_COMPLETE"; + + /** + * Broadcast intent action sent by the download manager when download status + * changes. + */ + public final static String ACTION_DOWNLOAD_STATUS = "lvldownloader.intent.action.DOWNLOAD_STATUS"; + + /* + * Lists the states that the download manager can set on a download to + * notify applications of the download progress. The codes follow the HTTP + * families:
1xx: informational
2xx: success
3xx: redirects (not + * used by the download manager)
4xx: client errors
5xx: server + * errors + */ + + /** + * Returns whether the status is informational (i.e. 1xx). + */ + public static boolean isStatusInformational(int status) { + return (status >= 100 && status < 200); + } + + /** + * Returns whether the status is a success (i.e. 2xx). + */ + public static boolean isStatusSuccess(int status) { + return (status >= 200 && status < 300); + } + + /** + * Returns whether the status is an error (i.e. 4xx or 5xx). + */ + public static boolean isStatusError(int status) { + return (status >= 400 && status < 600); + } + + /** + * Returns whether the status is a client error (i.e. 4xx). + */ + public static boolean isStatusClientError(int status) { + return (status >= 400 && status < 500); + } + + /** + * Returns whether the status is a server error (i.e. 5xx). + */ + public static boolean isStatusServerError(int status) { + return (status >= 500 && status < 600); + } + + /** + * Returns whether the download has completed (either with success or + * error). + */ + public static boolean isStatusCompleted(int status) { + return (status >= 200 && status < 300) + || (status >= 400 && status < 600); + } + + /** + * This download hasn't stated yet + */ + public static final int STATUS_PENDING = 190; + + /** + * This download has started + */ + public static final int STATUS_RUNNING = 192; + + /** + * This download has been paused by the owning app. + */ + public static final int STATUS_PAUSED_BY_APP = 193; + + /** + * This download encountered some network error and is waiting before + * retrying the request. + */ + public static final int STATUS_WAITING_TO_RETRY = 194; + + /** + * This download is waiting for network connectivity to proceed. + */ + public static final int STATUS_WAITING_FOR_NETWORK = 195; + + /** + * This download is waiting for a Wi-Fi connection to proceed or for + * permission to download over cellular. + */ + public static final int STATUS_QUEUED_FOR_WIFI_OR_CELLULAR_PERMISSION = 196; + + /** + * This download is waiting for a Wi-Fi connection to proceed. + */ + public static final int STATUS_QUEUED_FOR_WIFI = 197; + + /** + * This download has successfully completed. Warning: there might be other + * status values that indicate success in the future. Use isSucccess() to + * capture the entire category. + * + * @hide + */ + public static final int STATUS_SUCCESS = 200; + + /** + * The requested URL is no longer available + */ + public static final int STATUS_FORBIDDEN = 403; + + /** + * The file was delivered incorrectly + */ + public static final int STATUS_FILE_DELIVERED_INCORRECTLY = 487; + + /** + * The requested destination file already exists. + */ + public static final int STATUS_FILE_ALREADY_EXISTS_ERROR = 488; + + /** + * Some possibly transient error occurred, but we can't resume the download. + */ + public static final int STATUS_CANNOT_RESUME = 489; + + /** + * This download was canceled + * + * @hide + */ + public static final int STATUS_CANCELED = 490; + + /** + * This download has completed with an error. Warning: there will be other + * status values that indicate errors in the future. Use isStatusError() to + * capture the entire category. + */ + public static final int STATUS_UNKNOWN_ERROR = 491; + + /** + * This download couldn't be completed because of a storage issue. + * Typically, that's because the filesystem is missing or full. Use the more + * specific {@link #STATUS_INSUFFICIENT_SPACE_ERROR} and + * {@link #STATUS_DEVICE_NOT_FOUND_ERROR} when appropriate. + * + * @hide + */ + public static final int STATUS_FILE_ERROR = 492; + + /** + * This download couldn't be completed because of an HTTP redirect response + * that the download manager couldn't handle. + * + * @hide + */ + public static final int STATUS_UNHANDLED_REDIRECT = 493; + + /** + * This download couldn't be completed because of an unspecified unhandled + * HTTP code. + * + * @hide + */ + public static final int STATUS_UNHANDLED_HTTP_CODE = 494; + + /** + * This download couldn't be completed because of an error receiving or + * processing data at the HTTP level. + * + * @hide + */ + public static final int STATUS_HTTP_DATA_ERROR = 495; + + /** + * This download couldn't be completed because of an HttpException while + * setting up the request. + * + * @hide + */ + public static final int STATUS_HTTP_EXCEPTION = 496; + + /** + * This download couldn't be completed because there were too many + * redirects. + * + * @hide + */ + public static final int STATUS_TOO_MANY_REDIRECTS = 497; + + /** + * This download couldn't be completed due to insufficient storage space. + * Typically, this is because the SD card is full. + * + * @hide + */ + public static final int STATUS_INSUFFICIENT_SPACE_ERROR = 498; + + /** + * This download couldn't be completed because no external storage device + * was found. Typically, this is because the SD card is not mounted. + * + * @hide + */ + public static final int STATUS_DEVICE_NOT_FOUND_ERROR = 499; + + /** + * This download is allowed to run. + * + * @hide + */ + public static final int CONTROL_RUN = 0; + + /** + * This download must pause at the first opportunity. + * + * @hide + */ + public static final int CONTROL_PAUSED = 1; + + /** + * This download is visible but only shows in the notifications while it's + * in progress. + * + * @hide + */ + public static final int VISIBILITY_VISIBLE = 0; + + /** + * This download is visible and shows in the notifications while in progress + * and after completion. + * + * @hide + */ + public static final int VISIBILITY_VISIBLE_NOTIFY_COMPLETED = 1; + + /** + * This download doesn't show in the UI or in the notifications. + * + * @hide + */ + public static final int VISIBILITY_HIDDEN = 2; + + /** + * Bit flag for {@link #setAllowedNetworkTypes} corresponding to + * {@link ConnectivityManager#TYPE_MOBILE}. + */ + public static final int NETWORK_MOBILE = 1 << 0; + + /** + * Bit flag for {@link #setAllowedNetworkTypes} corresponding to + * {@link ConnectivityManager#TYPE_WIFI}. + */ + public static final int NETWORK_WIFI = 1 << 1; + + private final static String TEMP_EXT = ".tmp"; + + /** + * Service thread status + */ + private static boolean sIsRunning; + + @Override + public IBinder onBind(Intent paramIntent) { + Log.d(Constants.TAG, "Service Bound"); + return this.mServiceMessenger.getBinder(); + } + + /** + * Network state. + */ + private boolean mIsConnected; + private boolean mIsFailover; + private boolean mIsCellularConnection; + private boolean mIsRoaming; + private boolean mIsAtLeast3G; + private boolean mIsAtLeast4G; + private boolean mStateChanged; + + /** + * Download state + */ + private int mControl; + private int mStatus; + + public boolean isWiFi() { + return mIsConnected && !mIsCellularConnection; + } + + /** + * Bindings to important services + */ + private ConnectivityManager mConnectivityManager; + private WifiManager mWifiManager; + + /** + * Package we are downloading for (defaults to package of application) + */ + private PackageInfo mPackageInfo; + + /** + * Byte counts + */ + long mBytesSoFar; + long mTotalLength; + int mFileCount; + + /** + * Used for calculating time remaining and speed + */ + long mBytesAtSample; + long mMillisecondsAtSample; + float mAverageDownloadSpeed; + + /** + * Our binding to the network state broadcasts + */ + private BroadcastReceiver mConnReceiver; + final private IStub mServiceStub = DownloaderServiceMarshaller.CreateStub(this); + final private Messenger mServiceMessenger = mServiceStub.getMessenger(); + private Messenger mClientMessenger; + private DownloadNotification mNotification; + private PendingIntent mPendingIntent; + private PendingIntent mAlarmIntent; + + /** + * Updates the network type based upon the type and subtype returned from + * the connectivity manager. Subtype is only used for cellular signals. + * + * @param type + * @param subType + */ + private void updateNetworkType(int type, int subType) { + switch (type) { + case ConnectivityManager.TYPE_WIFI: + case ConnectivityManager.TYPE_ETHERNET: + case ConnectivityManager.TYPE_BLUETOOTH: + mIsCellularConnection = false; + mIsAtLeast3G = false; + mIsAtLeast4G = false; + break; + case ConnectivityManager.TYPE_WIMAX: + mIsCellularConnection = true; + mIsAtLeast3G = true; + mIsAtLeast4G = true; + break; + case ConnectivityManager.TYPE_MOBILE: + mIsCellularConnection = true; + switch (subType) { + case TelephonyManager.NETWORK_TYPE_1xRTT: + case TelephonyManager.NETWORK_TYPE_CDMA: + case TelephonyManager.NETWORK_TYPE_EDGE: + case TelephonyManager.NETWORK_TYPE_GPRS: + case TelephonyManager.NETWORK_TYPE_IDEN: + mIsAtLeast3G = false; + mIsAtLeast4G = false; + break; + case TelephonyManager.NETWORK_TYPE_HSDPA: + case TelephonyManager.NETWORK_TYPE_HSUPA: + case TelephonyManager.NETWORK_TYPE_HSPA: + case TelephonyManager.NETWORK_TYPE_EVDO_0: + case TelephonyManager.NETWORK_TYPE_EVDO_A: + case TelephonyManager.NETWORK_TYPE_UMTS: + mIsAtLeast3G = true; + mIsAtLeast4G = false; + break; + case TelephonyManager.NETWORK_TYPE_LTE: // 4G + case TelephonyManager.NETWORK_TYPE_EHRPD: // 3G ++ interop + // with 4G + case TelephonyManager.NETWORK_TYPE_HSPAP: // 3G ++ but + // marketed as + // 4G + mIsAtLeast3G = true; + mIsAtLeast4G = true; + break; + default: + mIsCellularConnection = false; + mIsAtLeast3G = false; + mIsAtLeast4G = false; + } + } + } + + private void updateNetworkState(NetworkInfo info) { + boolean isConnected = mIsConnected; + boolean isFailover = mIsFailover; + boolean isCellularConnection = mIsCellularConnection; + boolean isRoaming = mIsRoaming; + boolean isAtLeast3G = mIsAtLeast3G; + if (null != info) { + mIsRoaming = info.isRoaming(); + mIsFailover = info.isFailover(); + mIsConnected = info.isConnected(); + updateNetworkType(info.getType(), info.getSubtype()); + } else { + mIsRoaming = false; + mIsFailover = false; + mIsConnected = false; + updateNetworkType(-1, -1); + } + mStateChanged = (mStateChanged || isConnected != mIsConnected + || isFailover != mIsFailover + || isCellularConnection != mIsCellularConnection + || isRoaming != mIsRoaming || isAtLeast3G != mIsAtLeast3G); + if (Constants.LOGVV) { + if (mStateChanged) { + Log.v(LOG_TAG, "Network state changed: "); + Log.v(LOG_TAG, "Starting State: " + + (isConnected ? "Connected " : "Not Connected ") + + (isCellularConnection ? "Cellular " : "WiFi ") + + (isRoaming ? "Roaming " : "Local ") + + (isAtLeast3G ? "3G+ " : "<3G ")); + Log.v(LOG_TAG, "Ending State: " + + (mIsConnected ? "Connected " : "Not Connected ") + + (mIsCellularConnection ? "Cellular " : "WiFi ") + + (mIsRoaming ? "Roaming " : "Local ") + + (mIsAtLeast3G ? "3G+ " : "<3G ")); + + if (isServiceRunning()) { + if (mIsRoaming) { + mStatus = STATUS_WAITING_FOR_NETWORK; + mControl = CONTROL_PAUSED; + } else if (mIsCellularConnection) { + DownloadsDB db = DownloadsDB.getDB(this); + int flags = db.getFlags(); + if (0 == (flags & FLAGS_DOWNLOAD_OVER_CELLULAR)) { + mStatus = STATUS_QUEUED_FOR_WIFI; + mControl = CONTROL_PAUSED; + } + } + } + + } + } + } + + /** + * Polls the network state, setting the flags appropriately. + */ + void pollNetworkState() { + if (null == mConnectivityManager) { + mConnectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); + } + if (null == mWifiManager) { + mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); + } + if (mConnectivityManager == null) { + Log.w(Constants.TAG, + "couldn't get connectivity manager to poll network state"); + } else { + NetworkInfo activeInfo = mConnectivityManager + .getActiveNetworkInfo(); + updateNetworkState(activeInfo); + } + } + + public static final int NO_DOWNLOAD_REQUIRED = 0; + public static final int LVL_CHECK_REQUIRED = 1; + public static final int DOWNLOAD_REQUIRED = 2; + + public static final String EXTRA_PACKAGE_NAME = "EPN"; + public static final String EXTRA_PENDING_INTENT = "EPI"; + public static final String EXTRA_MESSAGE_HANDLER = "EMH"; + + /** + * Returns true if the LVL check is required + * + * @param db a downloads DB synchronized with the latest state + * @param pi the package info for the project + * @return returns true if the filenames need to be returned + */ + private static boolean isLVLCheckRequired(DownloadsDB db, PackageInfo pi) { + // we need to update the LVL check and get a successful status to + // proceed + if (db.mVersionCode != pi.versionCode) { + return true; + } + return false; + } + + /** + * Careful! Only use this internally. + * + * @return whether we think the service is running + */ + private static synchronized boolean isServiceRunning() { + return sIsRunning; + } + + private static synchronized void setServiceRunning(boolean isRunning) { + sIsRunning = isRunning; + } + + public static int startDownloadServiceIfRequired(Context context, + Intent intent, Class serviceClass) throws NameNotFoundException { + final PendingIntent pendingIntent = (PendingIntent) intent + .getParcelableExtra(EXTRA_PENDING_INTENT); + return startDownloadServiceIfRequired(context, pendingIntent, + serviceClass); + } + + public static int startDownloadServiceIfRequired(Context context, + PendingIntent pendingIntent, Class serviceClass) + throws NameNotFoundException + { + String packageName = context.getPackageName(); + String className = serviceClass.getName(); + + return startDownloadServiceIfRequired(context, pendingIntent, + packageName, className); + } + + /** + * Starts the download if necessary. This function starts a flow that does ` + * many things. 1) Checks to see if the APK version has been checked and the + * metadata database updated 2) If the APK version does not match, checks + * the new LVL status to see if a new download is required 3) If the APK + * version does match, then checks to see if the download(s) have been + * completed 4) If the downloads have been completed, returns + * NO_DOWNLOAD_REQUIRED The idea is that this can be called during the + * startup of an application to quickly ascertain if the application needs + * to wait to hear about any updated APK expansion files. Note that this + * does mean that the application MUST be run for the first time with a + * network connection, even if Market delivers all of the files. + * + * @param context + * @param thisIntent + * @return true if the app should wait for more guidance from the + * downloader, false if the app can continue + * @throws NameNotFoundException + */ + public static int startDownloadServiceIfRequired(Context context, + PendingIntent pendingIntent, String classPackage, String className) + throws NameNotFoundException { + // first: do we need to do an LVL update? + // we begin by getting our APK version from the package manager + final PackageInfo pi = context.getPackageManager().getPackageInfo( + context.getPackageName(), 0); + + int status = NO_DOWNLOAD_REQUIRED; + + // the database automatically reads the metadata for version code + // and download status when the instance is created + DownloadsDB db = DownloadsDB.getDB(context); + + // we need to update the LVL check and get a successful status to + // proceed + if (isLVLCheckRequired(db, pi)) { + status = LVL_CHECK_REQUIRED; + } + // we don't have to update LVL. do we still have a download to start? + if (db.mStatus == 0) { + DownloadInfo[] infos = db.getDownloads(); + if (null != infos) { + for (DownloadInfo info : infos) { + if (!Helpers.doesFileExist(context, info.mFileName, info.mTotalBytes, true)) { + status = DOWNLOAD_REQUIRED; + db.updateStatus(-1); + break; + } + } + } + } else { + status = DOWNLOAD_REQUIRED; + } + switch (status) { + case DOWNLOAD_REQUIRED: + case LVL_CHECK_REQUIRED: + Intent fileIntent = new Intent(); + fileIntent.setClassName(classPackage, className); + fileIntent.putExtra(EXTRA_PENDING_INTENT, pendingIntent); + context.startService(fileIntent); + break; + } + return status; + } + + @Override + public void requestAbortDownload() { + mControl = CONTROL_PAUSED; + mStatus = STATUS_CANCELED; + } + + @Override + public void requestPauseDownload() { + mControl = CONTROL_PAUSED; + mStatus = STATUS_PAUSED_BY_APP; + } + + @Override + public void setDownloadFlags(int flags) { + DownloadsDB.getDB(this).updateFlags(flags); + } + + @Override + public void requestContinueDownload() { + if (mControl == CONTROL_PAUSED) { + mControl = CONTROL_RUN; + } + Intent fileIntent = new Intent(this, this.getClass()); + fileIntent.putExtra(EXTRA_PENDING_INTENT, mPendingIntent); + this.startService(fileIntent); + } + + public abstract String getPublicKey(); + + public abstract byte[] getSALT(); + + public abstract String getAlarmReceiverClassName(); + + private class LVLRunnable implements Runnable { + LVLRunnable(Context context, PendingIntent intent) { + mContext = context; + mPendingIntent = intent; + } + + final Context mContext; + + @Override + public void run() { + setServiceRunning(true); + mNotification.onDownloadStateChanged(IDownloaderClient.STATE_FETCHING_URL); + String deviceId = Secure.getString(mContext.getContentResolver(), + Secure.ANDROID_ID); + + final APKExpansionPolicy aep = new APKExpansionPolicy(mContext, + new AESObfuscator(getSALT(), mContext.getPackageName(), deviceId)); + + // reset our policy back to the start of the world to force a + // re-check + aep.resetPolicy(); + + // let's try and get the OBB file from LVL first + // Construct the LicenseChecker with a Policy. + final LicenseChecker checker = new LicenseChecker(mContext, aep, + getPublicKey() // Your public licensing key. + ); + checker.checkAccess(new LicenseCheckerCallback() { + + @Override + public void allow(int reason) { + try { + int count = aep.getExpansionURLCount(); + DownloadsDB db = DownloadsDB.getDB(mContext); + int status = 0; + if (count != 0) { + for (int i = 0; i < count; i++) { + String currentFileName = aep + .getExpansionFileName(i); + if (null != currentFileName) { + DownloadInfo di = new DownloadInfo(i, + currentFileName, mContext.getPackageName()); + + long fileSize = aep.getExpansionFileSize(i); + if (handleFileUpdated(db, i, currentFileName, + fileSize)) { + status |= -1; + di.resetDownload(); + di.mUri = aep.getExpansionURL(i); + di.mTotalBytes = fileSize; + di.mStatus = status; + db.updateDownload(di); + } else { + // we need to read the download + // information + // from + // the database + DownloadInfo dbdi = db + .getDownloadInfoByFileName(di.mFileName); + if (null == dbdi) { + // the file exists already and is + // the + // correct size + // was delivered by Market or + // through + // another mechanism + Log.d(LOG_TAG, "file " + di.mFileName + + " found. Not downloading."); + di.mStatus = STATUS_SUCCESS; + di.mTotalBytes = fileSize; + di.mCurrentBytes = fileSize; + di.mUri = aep.getExpansionURL(i); + db.updateDownload(di); + } else if (dbdi.mStatus != STATUS_SUCCESS) { + // we just update the URL + dbdi.mUri = aep.getExpansionURL(i); + db.updateDownload(dbdi); + status |= -1; + } + } + } + } + } + // first: do we need to do an LVL update? + // we begin by getting our APK version from the package + // manager + PackageInfo pi; + try { + pi = mContext.getPackageManager().getPackageInfo( + mContext.getPackageName(), 0); + db.updateMetadata(pi.versionCode, status); + Class serviceClass = DownloaderService.this.getClass(); + switch (startDownloadServiceIfRequired(mContext, mPendingIntent, + serviceClass)) { + case NO_DOWNLOAD_REQUIRED: + mNotification + .onDownloadStateChanged(IDownloaderClient.STATE_COMPLETED); + break; + case LVL_CHECK_REQUIRED: + // DANGER WILL ROBINSON! + Log.e(LOG_TAG, "In LVL checking loop!"); + mNotification + .onDownloadStateChanged(IDownloaderClient.STATE_FAILED_UNLICENSED); + throw new RuntimeException( + "Error with LVL checking and database integrity"); + case DOWNLOAD_REQUIRED: + // do nothing. the download will notify the + // application + // when things are done + break; + } + } catch (NameNotFoundException e1) { + e1.printStackTrace(); + throw new RuntimeException( + "Error with getting information from package name"); + } + } finally { + setServiceRunning(false); + } + } + + @Override + public void dontAllow(int reason) { + try + { + switch (reason) { + case Policy.NOT_LICENSED: + mNotification + .onDownloadStateChanged(IDownloaderClient.STATE_FAILED_UNLICENSED); + break; + case Policy.RETRY: + mNotification + .onDownloadStateChanged(IDownloaderClient.STATE_FAILED_FETCHING_URL); + break; + } + } finally { + setServiceRunning(false); + } + + } + + @Override + public void applicationError(int errorCode) { + try { + mNotification + .onDownloadStateChanged(IDownloaderClient.STATE_FAILED_FETCHING_URL); + } finally { + setServiceRunning(false); + } + } + + }); + + } + + }; + + /** + * Updates the LVL information from the server. + * + * @param context + */ + public void updateLVL(final Context context) { + Context c = context.getApplicationContext(); + Handler h = new Handler(c.getMainLooper()); + h.post(new LVLRunnable(c, mPendingIntent)); + } + + /** + * The APK has been updated and a filename has been sent down from the + * Market call. If the file has the same name as the previous file, we do + * nothing as the file is guaranteed to be the same. If the file does not + * have the same name, we download it if it hasn't already been delivered by + * Market. + * + * @param index the index of the file from market (0 = main, 1 = patch) + * @param filename the name of the new file + * @param fileSize the size of the new file + * @return + */ + public boolean handleFileUpdated(DownloadsDB db, int index, + String filename, long fileSize) { + DownloadInfo di = db.getDownloadInfoByFileName(filename); + if (null != di) { + String oldFile = di.mFileName; + // cleanup + if (null != oldFile) { + if (filename.equals(oldFile)) { + return false; + } + + // remove partially downloaded file if it is there + String deleteFile = Helpers.generateSaveFileName(this, oldFile); + File f = new File(deleteFile); + if (f.exists()) + f.delete(); + } + } + return !Helpers.doesFileExist(this, filename, fileSize, true); + } + + private void scheduleAlarm(long wakeUp) { + AlarmManager alarms = (AlarmManager) getSystemService(Context.ALARM_SERVICE); + if (alarms == null) { + Log.e(Constants.TAG, "couldn't get alarm manager"); + return; + } + + if (Constants.LOGV) { + Log.v(Constants.TAG, "scheduling retry in " + wakeUp + "ms"); + } + + String className = getAlarmReceiverClassName(); + Intent intent = new Intent(Constants.ACTION_RETRY); + intent.putExtra(EXTRA_PENDING_INTENT, mPendingIntent); + intent.setClassName(this.getPackageName(), + className); + mAlarmIntent = PendingIntent.getBroadcast(this, 0, intent, + PendingIntent.FLAG_ONE_SHOT); + alarms.set( + AlarmManager.RTC_WAKEUP, + System.currentTimeMillis() + wakeUp, mAlarmIntent + ); + } + + private void cancelAlarms() { + if (null != mAlarmIntent) { + AlarmManager alarms = (AlarmManager) getSystemService(Context.ALARM_SERVICE); + if (alarms == null) { + Log.e(Constants.TAG, "couldn't get alarm manager"); + return; + } + alarms.cancel(mAlarmIntent); + mAlarmIntent = null; + } + } + + /** + * We use this to track network state, such as when WiFi, Cellular, etc. is + * enabled when downloads are paused or in progress. + */ + private class InnerBroadcastReceiver extends BroadcastReceiver { + final Service mService; + + InnerBroadcastReceiver(Service service) { + mService = service; + } + + @Override + public void onReceive(Context context, Intent intent) { + pollNetworkState(); + if (mStateChanged + && !isServiceRunning()) { + Log.d(Constants.TAG, "InnerBroadcastReceiver Called"); + Intent fileIntent = new Intent(context, mService.getClass()); + fileIntent.putExtra(EXTRA_PENDING_INTENT, mPendingIntent); + // send a new intent to the service + context.startService(fileIntent); + } + } + }; + + /** + * This is the main thread for the Downloader. This thread is responsible + * for queuing up downloads and other goodness. + */ + @Override + protected void onHandleIntent(Intent intent) { + setServiceRunning(true); + try { + // the database automatically reads the metadata for version code + // and download status when the instance is created + DownloadsDB db = DownloadsDB.getDB(this); + final PendingIntent pendingIntent = (PendingIntent) intent + .getParcelableExtra(EXTRA_PENDING_INTENT); + + if (null != pendingIntent) + { + mNotification.setClientIntent(pendingIntent); + mPendingIntent = pendingIntent; + } else if (null != mPendingIntent) { + mNotification.setClientIntent(mPendingIntent); + } else { + Log.e(LOG_TAG, "Downloader started in bad state without notification intent."); + return; + } + + // when the LVL check completes, a successful response will update + // the service + if (isLVLCheckRequired(db, mPackageInfo)) { + updateLVL(this); + return; + } + + // get each download + DownloadInfo[] infos = db.getDownloads(); + mBytesSoFar = 0; + mTotalLength = 0; + mFileCount = infos.length; + for (DownloadInfo info : infos) { + // We do an (simple) integrity check on each file, just to make + // sure + if (info.mStatus == STATUS_SUCCESS) { + // verify that the file matches the state + if (!Helpers.doesFileExist(this, info.mFileName, info.mTotalBytes, true)) { + info.mStatus = 0; + info.mCurrentBytes = 0; + } + } + // get aggregate data + mTotalLength += info.mTotalBytes; + mBytesSoFar += info.mCurrentBytes; + } + + // loop through all downloads and fetch them + pollNetworkState(); + if (null == mConnReceiver) { + + /** + * We use this to track network state, such as when WiFi, + * Cellular, etc. is enabled when downloads are paused or in + * progress. + */ + mConnReceiver = new InnerBroadcastReceiver(this); + IntentFilter intentFilter = new IntentFilter( + ConnectivityManager.CONNECTIVITY_ACTION); + intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); + registerReceiver(mConnReceiver, intentFilter); + } + + for (DownloadInfo info : infos) { + long startingCount = info.mCurrentBytes; + + if (info.mStatus != STATUS_SUCCESS) { + DownloadThread dt = new DownloadThread(info, this, mNotification); + cancelAlarms(); + scheduleAlarm(Constants.ACTIVE_THREAD_WATCHDOG); + dt.run(); + cancelAlarms(); + } + db.updateFromDb(info); + boolean setWakeWatchdog = false; + int notifyStatus; + switch (info.mStatus) { + case STATUS_FORBIDDEN: + // the URL is out of date + updateLVL(this); + return; + case STATUS_SUCCESS: + mBytesSoFar += info.mCurrentBytes - startingCount; + db.updateMetadata(mPackageInfo.versionCode, 0); + continue; + case STATUS_FILE_DELIVERED_INCORRECTLY: + // we may be on a network that is returning us a web + // page on redirect + notifyStatus = IDownloaderClient.STATE_PAUSED_NETWORK_SETUP_FAILURE; + info.mCurrentBytes = 0; + db.updateDownload(info); + setWakeWatchdog = true; + break; + case STATUS_PAUSED_BY_APP: + notifyStatus = IDownloaderClient.STATE_PAUSED_BY_REQUEST; + break; + case STATUS_WAITING_FOR_NETWORK: + case STATUS_WAITING_TO_RETRY: + notifyStatus = IDownloaderClient.STATE_PAUSED_NETWORK_UNAVAILABLE; + setWakeWatchdog = true; + break; + case STATUS_QUEUED_FOR_WIFI_OR_CELLULAR_PERMISSION: + case STATUS_QUEUED_FOR_WIFI: + // look for more detail here + if (null != mWifiManager) { + if (!mWifiManager.isWifiEnabled()) { + notifyStatus = IDownloaderClient.STATE_PAUSED_WIFI_DISABLED_NEED_CELLULAR_PERMISSION; + setWakeWatchdog = true; + break; + } + } + notifyStatus = IDownloaderClient.STATE_PAUSED_NEED_CELLULAR_PERMISSION; + setWakeWatchdog = true; + break; + case STATUS_CANCELED: + notifyStatus = IDownloaderClient.STATE_FAILED_CANCELED; + setWakeWatchdog = true; + break; + + case STATUS_INSUFFICIENT_SPACE_ERROR: + notifyStatus = IDownloaderClient.STATE_FAILED_SDCARD_FULL; + setWakeWatchdog = true; + break; + + case STATUS_DEVICE_NOT_FOUND_ERROR: + notifyStatus = IDownloaderClient.STATE_PAUSED_SDCARD_UNAVAILABLE; + setWakeWatchdog = true; + break; + + default: + notifyStatus = IDownloaderClient.STATE_FAILED; + break; + } + if (setWakeWatchdog) { + scheduleAlarm(Constants.WATCHDOG_WAKE_TIMER); + } else { + cancelAlarms(); + } + // failure or pause state + mNotification.onDownloadStateChanged(notifyStatus); + return; + } + + // all downloads complete + mNotification.onDownloadStateChanged(IDownloaderClient.STATE_COMPLETED); + } finally { + setServiceRunning(false); + } + } + + @Override + public void onDestroy() { + if (null != mConnReceiver) { + unregisterReceiver(mConnReceiver); + mConnReceiver = null; + } + mServiceStub.disconnect(this); + super.onDestroy(); + } + + public int getNetworkAvailabilityState(DownloadsDB db) { + if (mIsConnected) { + if (!mIsCellularConnection) + return NETWORK_OK; + int flags = db.mFlags; + if (mIsRoaming) + return NETWORK_CANNOT_USE_ROAMING; + if (0 != (flags & FLAGS_DOWNLOAD_OVER_CELLULAR)) { + return NETWORK_OK; + } else { + return NETWORK_TYPE_DISALLOWED_BY_REQUESTOR; + } + } + return NETWORK_NO_CONNECTION; + } + + @Override + public void onCreate() { + super.onCreate(); + try { + mPackageInfo = getPackageManager().getPackageInfo( + getPackageName(), 0); + ApplicationInfo ai = getApplicationInfo(); + CharSequence applicationLabel = getPackageManager().getApplicationLabel(ai); + mNotification = new DownloadNotification(this, applicationLabel); + + } catch (NameNotFoundException e) { + e.printStackTrace(); + } + } + + /** + * Exception thrown from methods called by generateSaveFile() for any fatal + * error. + */ + public static class GenerateSaveFileError extends Exception { + private static final long serialVersionUID = 3465966015408936540L; + int mStatus; + String mMessage; + + public GenerateSaveFileError(int status, String message) { + mStatus = status; + mMessage = message; + } + } + + /** + * Returns the filename (where the file should be saved) from info about a + * download + */ + public String generateTempSaveFileName(String fileName) { + String path = Helpers.getSaveFilePath(this) + + File.separator + fileName + TEMP_EXT; + return path; + } + + /** + * Creates a filename (where the file should be saved) from info about a + * download. + */ + public String generateSaveFile(String filename, long filesize) + throws GenerateSaveFileError { + String path = generateTempSaveFileName(filename); + File expPath = new File(path); + if (!Helpers.isExternalMediaMounted()) { + Log.d(Constants.TAG, "External media not mounted: " + path); + throw new GenerateSaveFileError(STATUS_DEVICE_NOT_FOUND_ERROR, + "external media is not yet mounted"); + + } + if (expPath.exists()) { + Log.d(Constants.TAG, "File already exists: " + path); + throw new GenerateSaveFileError(STATUS_FILE_ALREADY_EXISTS_ERROR, + "requested destination file already exists"); + } + if (Helpers.getAvailableBytes(Helpers.getFilesystemRoot(path)) < filesize) { + throw new GenerateSaveFileError(STATUS_INSUFFICIENT_SPACE_ERROR, + "insufficient space on external storage"); + } + return path; + } + + /** + * @return a non-localized string appropriate for logging corresponding to + * one of the NETWORK_* constants. + */ + public String getLogMessageForNetworkError(int networkError) { + switch (networkError) { + case NETWORK_RECOMMENDED_UNUSABLE_DUE_TO_SIZE: + return "download size exceeds recommended limit for mobile network"; + + case NETWORK_UNUSABLE_DUE_TO_SIZE: + return "download size exceeds limit for mobile network"; + + case NETWORK_NO_CONNECTION: + return "no network connection available"; + + case NETWORK_CANNOT_USE_ROAMING: + return "download cannot use the current network connection because it is roaming"; + + case NETWORK_TYPE_DISALLOWED_BY_REQUESTOR: + return "download was requested to not use the current network type"; + + default: + return "unknown error with network connectivity"; + } + } + + public int getControl() { + return mControl; + } + + public int getStatus() { + return mStatus; + } + + /** + * Calculating a moving average for the speed so we don't get jumpy + * calculations for time etc. + */ + static private final float SMOOTHING_FACTOR = 0.005f; + + public void notifyUpdateBytes(long totalBytesSoFar) { + long timeRemaining; + long currentTime = SystemClock.uptimeMillis(); + if (0 != mMillisecondsAtSample) { + // we have a sample. + long timePassed = currentTime - mMillisecondsAtSample; + long bytesInSample = totalBytesSoFar - mBytesAtSample; + float currentSpeedSample = (float) bytesInSample / (float) timePassed; + if (0 != mAverageDownloadSpeed) { + mAverageDownloadSpeed = SMOOTHING_FACTOR * currentSpeedSample + + (1 - SMOOTHING_FACTOR) * mAverageDownloadSpeed; + } else { + mAverageDownloadSpeed = currentSpeedSample; + } + timeRemaining = (long) ((mTotalLength - totalBytesSoFar) / mAverageDownloadSpeed); + } else { + timeRemaining = -1; + } + mMillisecondsAtSample = currentTime; + mBytesAtSample = totalBytesSoFar; + mNotification.onDownloadProgress( + new DownloadProgressInfo(mTotalLength, + totalBytesSoFar, + timeRemaining, + mAverageDownloadSpeed) + ); + + } + + @Override + protected boolean shouldStop() { + // the database automatically reads the metadata for version code + // and download status when the instance is created + DownloadsDB db = DownloadsDB.getDB(this); + if (db.mStatus == 0) { + return true; + } + return false; + } + + @Override + public void requestDownloadStatus() { + mNotification.resendState(); + } + + @Override + public void onClientUpdated(Messenger clientMessenger) { + this.mClientMessenger = clientMessenger; + mNotification.setMessenger(mClientMessenger); + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadsDB.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadsDB.java new file mode 100644 index 000000000..250299c40 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/DownloadsDB.java @@ -0,0 +1,510 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import android.content.ContentValues; +import android.content.Context; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteDoneException; +import android.database.sqlite.SQLiteOpenHelper; +import android.database.sqlite.SQLiteStatement; +import android.provider.BaseColumns; +import android.util.Log; + +public class DownloadsDB { + private static final String DATABASE_NAME = "DownloadsDB"; + private static final int DATABASE_VERSION = 7; + public static final String LOG_TAG = DownloadsDB.class.getName(); + final SQLiteOpenHelper mHelper; + SQLiteStatement mGetDownloadByIndex; + SQLiteStatement mUpdateCurrentBytes; + private static DownloadsDB mDownloadsDB; + long mMetadataRowID = -1; + int mVersionCode = -1; + int mStatus = -1; + int mFlags; + + static public synchronized DownloadsDB getDB(Context paramContext) { + if (null == mDownloadsDB) { + return new DownloadsDB(paramContext); + } + return mDownloadsDB; + } + + private SQLiteStatement getDownloadByIndexStatement() { + if (null == mGetDownloadByIndex) { + mGetDownloadByIndex = mHelper.getReadableDatabase().compileStatement( + "SELECT " + BaseColumns._ID + " FROM " + + DownloadColumns.TABLE_NAME + " WHERE " + + DownloadColumns.INDEX + " = ?"); + } + return mGetDownloadByIndex; + } + + private SQLiteStatement getUpdateCurrentBytesStatement() { + if (null == mUpdateCurrentBytes) { + mUpdateCurrentBytes = mHelper.getReadableDatabase().compileStatement( + "UPDATE " + DownloadColumns.TABLE_NAME + " SET " + DownloadColumns.CURRENTBYTES + + " = ?" + + " WHERE " + DownloadColumns.INDEX + " = ?"); + } + return mUpdateCurrentBytes; + } + + private DownloadsDB(Context paramContext) { + this.mHelper = new DownloadsContentDBHelper(paramContext); + final SQLiteDatabase sqldb = mHelper.getReadableDatabase(); + // Query for the version code, the row ID of the metadata (for future + // updating) the status and the flags + Cursor cur = sqldb.rawQuery("SELECT " + + MetadataColumns.APKVERSION + "," + + BaseColumns._ID + "," + + MetadataColumns.DOWNLOAD_STATUS + "," + + MetadataColumns.FLAGS + + " FROM " + + MetadataColumns.TABLE_NAME + " LIMIT 1", null); + if (null != cur && cur.moveToFirst()) { + mVersionCode = cur.getInt(0); + mMetadataRowID = cur.getLong(1); + mStatus = cur.getInt(2); + mFlags = cur.getInt(3); + cur.close(); + } + mDownloadsDB = this; + } + + protected DownloadInfo getDownloadInfoByFileName(String fileName) { + final SQLiteDatabase sqldb = mHelper.getReadableDatabase(); + Cursor itemcur = null; + try { + itemcur = sqldb.query(DownloadColumns.TABLE_NAME, DC_PROJECTION, + DownloadColumns.FILENAME + " = ?", + new String[] { + fileName + }, null, null, null); + if (null != itemcur && itemcur.moveToFirst()) { + return getDownloadInfoFromCursor(itemcur); + } + } finally { + if (null != itemcur) + itemcur.close(); + } + return null; + } + + public long getIDForDownloadInfo(final DownloadInfo di) { + return getIDByIndex(di.mIndex); + } + + public long getIDByIndex(int index) { + SQLiteStatement downloadByIndex = getDownloadByIndexStatement(); + downloadByIndex.clearBindings(); + downloadByIndex.bindLong(1, index); + try { + return downloadByIndex.simpleQueryForLong(); + } catch (SQLiteDoneException e) { + return -1; + } + } + + public void updateDownloadCurrentBytes(final DownloadInfo di) { + SQLiteStatement downloadCurrentBytes = getUpdateCurrentBytesStatement(); + downloadCurrentBytes.clearBindings(); + downloadCurrentBytes.bindLong(1, di.mCurrentBytes); + downloadCurrentBytes.bindLong(2, di.mIndex); + downloadCurrentBytes.execute(); + } + + public void close() { + this.mHelper.close(); + } + + protected static class DownloadsContentDBHelper extends SQLiteOpenHelper { + DownloadsContentDBHelper(Context paramContext) { + super(paramContext, DATABASE_NAME, null, DATABASE_VERSION); + } + + private String createTableQueryFromArray(String paramString, + String[][] paramArrayOfString) { + StringBuilder localStringBuilder = new StringBuilder(); + localStringBuilder.append("CREATE TABLE "); + localStringBuilder.append(paramString); + localStringBuilder.append(" ("); + int i = paramArrayOfString.length; + for (int j = 0;; j++) { + if (j >= i) { + localStringBuilder + .setLength(localStringBuilder.length() - 1); + localStringBuilder.append(");"); + return localStringBuilder.toString(); + } + String[] arrayOfString = paramArrayOfString[j]; + localStringBuilder.append(' '); + localStringBuilder.append(arrayOfString[0]); + localStringBuilder.append(' '); + localStringBuilder.append(arrayOfString[1]); + localStringBuilder.append(','); + } + } + + /** + * These two arrays must match and have the same order. For every Schema + * there must be a corresponding table name. + */ + static final private String[][][] sSchemas = { + DownloadColumns.SCHEMA, MetadataColumns.SCHEMA + }; + + static final private String[] sTables = { + DownloadColumns.TABLE_NAME, MetadataColumns.TABLE_NAME + }; + + /** + * Goes through all of the tables in sTables and drops each table if it + * exists. Altered to no longer make use of reflection. + */ + private void dropTables(SQLiteDatabase paramSQLiteDatabase) { + for (String table : sTables) { + try { + paramSQLiteDatabase.execSQL("DROP TABLE IF EXISTS " + table); + } catch (Exception localException) { + localException.printStackTrace(); + } + } + } + + /** + * Goes through all of the tables in sTables and creates a database with + * the corresponding schema described in sSchemas. Altered to no longer + * make use of reflection. + */ + public void onCreate(SQLiteDatabase paramSQLiteDatabase) { + int numSchemas = sSchemas.length; + for (int i = 0; i < numSchemas; i++) { + try { + String[][] schema = (String[][]) sSchemas[i]; + paramSQLiteDatabase.execSQL(createTableQueryFromArray( + sTables[i], schema)); + } catch (Exception localException) { + while (true) + localException.printStackTrace(); + } + } + } + + public void onUpgrade(SQLiteDatabase paramSQLiteDatabase, + int paramInt1, int paramInt2) { + Log.w(DownloadsContentDBHelper.class.getName(), + "Upgrading database from version " + paramInt1 + " to " + + paramInt2 + ", which will destroy all old data"); + dropTables(paramSQLiteDatabase); + onCreate(paramSQLiteDatabase); + } + } + + public static class MetadataColumns implements BaseColumns { + public static final String APKVERSION = "APKVERSION"; + public static final String DOWNLOAD_STATUS = "DOWNLOADSTATUS"; + public static final String FLAGS = "DOWNLOADFLAGS"; + + public static final String[][] SCHEMA = { + { + BaseColumns._ID, "INTEGER PRIMARY KEY" + }, + { + APKVERSION, "INTEGER" + }, { + DOWNLOAD_STATUS, "INTEGER" + }, + { + FLAGS, "INTEGER" + } + }; + public static final String TABLE_NAME = "MetadataColumns"; + public static final String _ID = "MetadataColumns._id"; + } + + public static class DownloadColumns implements BaseColumns { + public static final String INDEX = "FILEIDX"; + public static final String URI = "URI"; + public static final String FILENAME = "FN"; + public static final String ETAG = "ETAG"; + + public static final String TOTALBYTES = "TOTALBYTES"; + public static final String CURRENTBYTES = "CURRENTBYTES"; + public static final String LASTMOD = "LASTMOD"; + + public static final String STATUS = "STATUS"; + public static final String CONTROL = "CONTROL"; + public static final String NUM_FAILED = "FAILCOUNT"; + public static final String RETRY_AFTER = "RETRYAFTER"; + public static final String REDIRECT_COUNT = "REDIRECTCOUNT"; + + public static final String[][] SCHEMA = { + { + BaseColumns._ID, "INTEGER PRIMARY KEY" + }, + { + INDEX, "INTEGER UNIQUE" + }, { + URI, "TEXT" + }, + { + FILENAME, "TEXT UNIQUE" + }, { + ETAG, "TEXT" + }, + { + TOTALBYTES, "INTEGER" + }, { + CURRENTBYTES, "INTEGER" + }, + { + LASTMOD, "INTEGER" + }, { + STATUS, "INTEGER" + }, + { + CONTROL, "INTEGER" + }, { + NUM_FAILED, "INTEGER" + }, + { + RETRY_AFTER, "INTEGER" + }, { + REDIRECT_COUNT, "INTEGER" + } + }; + public static final String TABLE_NAME = "DownloadColumns"; + public static final String _ID = "DownloadColumns._id"; + } + + private static final String[] DC_PROJECTION = { + DownloadColumns.FILENAME, + DownloadColumns.URI, DownloadColumns.ETAG, + DownloadColumns.TOTALBYTES, DownloadColumns.CURRENTBYTES, + DownloadColumns.LASTMOD, DownloadColumns.STATUS, + DownloadColumns.CONTROL, DownloadColumns.NUM_FAILED, + DownloadColumns.RETRY_AFTER, DownloadColumns.REDIRECT_COUNT, + DownloadColumns.INDEX + }; + + private static final int FILENAME_IDX = 0; + private static final int URI_IDX = 1; + private static final int ETAG_IDX = 2; + private static final int TOTALBYTES_IDX = 3; + private static final int CURRENTBYTES_IDX = 4; + private static final int LASTMOD_IDX = 5; + private static final int STATUS_IDX = 6; + private static final int CONTROL_IDX = 7; + private static final int NUM_FAILED_IDX = 8; + private static final int RETRY_AFTER_IDX = 9; + private static final int REDIRECT_COUNT_IDX = 10; + private static final int INDEX_IDX = 11; + + /** + * This function will add a new file to the database if it does not exist. + * + * @param di DownloadInfo that we wish to store + * @return the row id of the record to be updated/inserted, or -1 + */ + public boolean updateDownload(DownloadInfo di) { + ContentValues cv = new ContentValues(); + cv.put(DownloadColumns.INDEX, di.mIndex); + cv.put(DownloadColumns.FILENAME, di.mFileName); + cv.put(DownloadColumns.URI, di.mUri); + cv.put(DownloadColumns.ETAG, di.mETag); + cv.put(DownloadColumns.TOTALBYTES, di.mTotalBytes); + cv.put(DownloadColumns.CURRENTBYTES, di.mCurrentBytes); + cv.put(DownloadColumns.LASTMOD, di.mLastMod); + cv.put(DownloadColumns.STATUS, di.mStatus); + cv.put(DownloadColumns.CONTROL, di.mControl); + cv.put(DownloadColumns.NUM_FAILED, di.mNumFailed); + cv.put(DownloadColumns.RETRY_AFTER, di.mRetryAfter); + cv.put(DownloadColumns.REDIRECT_COUNT, di.mRedirectCount); + return updateDownload(di, cv); + } + + public boolean updateDownload(DownloadInfo di, ContentValues cv) { + long id = di == null ? -1 : getIDForDownloadInfo(di); + try { + final SQLiteDatabase sqldb = mHelper.getWritableDatabase(); + if (id != -1) { + if (1 != sqldb.update(DownloadColumns.TABLE_NAME, + cv, DownloadColumns._ID + " = " + id, null)) { + return false; + } + } else { + return -1 != sqldb.insert(DownloadColumns.TABLE_NAME, + DownloadColumns.URI, cv); + } + } catch (android.database.sqlite.SQLiteException ex) { + ex.printStackTrace(); + } + return false; + } + + public int getLastCheckedVersionCode() { + return mVersionCode; + } + + public boolean isDownloadRequired() { + final SQLiteDatabase sqldb = mHelper.getReadableDatabase(); + Cursor cur = sqldb.rawQuery("SELECT Count(*) FROM " + + DownloadColumns.TABLE_NAME + " WHERE " + + DownloadColumns.STATUS + " <> 0", null); + try { + if (null != cur && cur.moveToFirst()) { + return 0 == cur.getInt(0); + } + } finally { + if (null != cur) + cur.close(); + } + return true; + } + + public int getFlags() { + return mFlags; + } + + public boolean updateFlags(int flags) { + if (mFlags != flags) { + ContentValues cv = new ContentValues(); + cv.put(MetadataColumns.FLAGS, flags); + if (updateMetadata(cv)) { + mFlags = flags; + return true; + } else { + return false; + } + } else { + return true; + } + }; + + public boolean updateStatus(int status) { + if (mStatus != status) { + ContentValues cv = new ContentValues(); + cv.put(MetadataColumns.DOWNLOAD_STATUS, status); + if (updateMetadata(cv)) { + mStatus = status; + return true; + } else { + return false; + } + } else { + return true; + } + }; + + public boolean updateMetadata(ContentValues cv) { + final SQLiteDatabase sqldb = mHelper.getWritableDatabase(); + if (-1 == this.mMetadataRowID) { + long newID = sqldb.insert(MetadataColumns.TABLE_NAME, + MetadataColumns.APKVERSION, cv); + if (-1 == newID) + return false; + mMetadataRowID = newID; + } else { + if (0 == sqldb.update(MetadataColumns.TABLE_NAME, cv, + BaseColumns._ID + " = " + mMetadataRowID, null)) + return false; + } + return true; + } + + public boolean updateMetadata(int apkVersion, int downloadStatus) { + ContentValues cv = new ContentValues(); + cv.put(MetadataColumns.APKVERSION, apkVersion); + cv.put(MetadataColumns.DOWNLOAD_STATUS, downloadStatus); + if (updateMetadata(cv)) { + mVersionCode = apkVersion; + mStatus = downloadStatus; + return true; + } else { + return false; + } + }; + + public boolean updateFromDb(DownloadInfo di) { + final SQLiteDatabase sqldb = mHelper.getReadableDatabase(); + Cursor cur = null; + try { + cur = sqldb.query(DownloadColumns.TABLE_NAME, DC_PROJECTION, + DownloadColumns.FILENAME + "= ?", + new String[] { + di.mFileName + }, null, null, null); + if (null != cur && cur.moveToFirst()) { + setDownloadInfoFromCursor(di, cur); + return true; + } + return false; + } finally { + if (null != cur) { + cur.close(); + } + } + } + + public void setDownloadInfoFromCursor(DownloadInfo di, Cursor cur) { + di.mUri = cur.getString(URI_IDX); + di.mETag = cur.getString(ETAG_IDX); + di.mTotalBytes = cur.getLong(TOTALBYTES_IDX); + di.mCurrentBytes = cur.getLong(CURRENTBYTES_IDX); + di.mLastMod = cur.getLong(LASTMOD_IDX); + di.mStatus = cur.getInt(STATUS_IDX); + di.mControl = cur.getInt(CONTROL_IDX); + di.mNumFailed = cur.getInt(NUM_FAILED_IDX); + di.mRetryAfter = cur.getInt(RETRY_AFTER_IDX); + di.mRedirectCount = cur.getInt(REDIRECT_COUNT_IDX); + } + + public DownloadInfo getDownloadInfoFromCursor(Cursor cur) { + DownloadInfo di = new DownloadInfo(cur.getInt(INDEX_IDX), + cur.getString(FILENAME_IDX), this.getClass().getPackage() + .getName()); + setDownloadInfoFromCursor(di, cur); + return di; + } + + public DownloadInfo[] getDownloads() { + final SQLiteDatabase sqldb = mHelper.getReadableDatabase(); + Cursor cur = null; + try { + cur = sqldb.query(DownloadColumns.TABLE_NAME, DC_PROJECTION, null, + null, null, null, null); + if (null != cur && cur.moveToFirst()) { + DownloadInfo[] retInfos = new DownloadInfo[cur.getCount()]; + int idx = 0; + do { + DownloadInfo di = getDownloadInfoFromCursor(cur); + retInfos[idx++] = di; + } while (cur.moveToNext()); + return retInfos; + } + return null; + } finally { + if (null != cur) { + cur.close(); + } + } + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/HttpDateTime.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/HttpDateTime.java new file mode 100644 index 000000000..3f440e989 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/HttpDateTime.java @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import android.text.format.Time; + +import java.util.Calendar; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * Helper for parsing an HTTP date. + */ +public final class HttpDateTime { + + /* + * Regular expression for parsing HTTP-date. Wdy, DD Mon YYYY HH:MM:SS GMT + * RFC 822, updated by RFC 1123 Weekday, DD-Mon-YY HH:MM:SS GMT RFC 850, + * obsoleted by RFC 1036 Wdy Mon DD HH:MM:SS YYYY ANSI C's asctime() format + * with following variations Wdy, DD-Mon-YYYY HH:MM:SS GMT Wdy, (SP)D Mon + * YYYY HH:MM:SS GMT Wdy,DD Mon YYYY HH:MM:SS GMT Wdy, DD-Mon-YY HH:MM:SS + * GMT Wdy, DD Mon YYYY HH:MM:SS -HHMM Wdy, DD Mon YYYY HH:MM:SS Wdy Mon + * (SP)D HH:MM:SS YYYY Wdy Mon DD HH:MM:SS YYYY GMT HH can be H if the first + * digit is zero. Mon can be the full name of the month. + */ + private static final String HTTP_DATE_RFC_REGEXP = + "([0-9]{1,2})[- ]([A-Za-z]{3,9})[- ]([0-9]{2,4})[ ]" + + "([0-9]{1,2}:[0-9][0-9]:[0-9][0-9])"; + + private static final String HTTP_DATE_ANSIC_REGEXP = + "[ ]([A-Za-z]{3,9})[ ]+([0-9]{1,2})[ ]" + + "([0-9]{1,2}:[0-9][0-9]:[0-9][0-9])[ ]([0-9]{2,4})"; + + /** + * The compiled version of the HTTP-date regular expressions. + */ + private static final Pattern HTTP_DATE_RFC_PATTERN = + Pattern.compile(HTTP_DATE_RFC_REGEXP); + private static final Pattern HTTP_DATE_ANSIC_PATTERN = + Pattern.compile(HTTP_DATE_ANSIC_REGEXP); + + private static class TimeOfDay { + TimeOfDay(int h, int m, int s) { + this.hour = h; + this.minute = m; + this.second = s; + } + + int hour; + int minute; + int second; + } + + public static long parse(String timeString) + throws IllegalArgumentException { + + int date = 1; + int month = Calendar.JANUARY; + int year = 1970; + TimeOfDay timeOfDay; + + Matcher rfcMatcher = HTTP_DATE_RFC_PATTERN.matcher(timeString); + if (rfcMatcher.find()) { + date = getDate(rfcMatcher.group(1)); + month = getMonth(rfcMatcher.group(2)); + year = getYear(rfcMatcher.group(3)); + timeOfDay = getTime(rfcMatcher.group(4)); + } else { + Matcher ansicMatcher = HTTP_DATE_ANSIC_PATTERN.matcher(timeString); + if (ansicMatcher.find()) { + month = getMonth(ansicMatcher.group(1)); + date = getDate(ansicMatcher.group(2)); + timeOfDay = getTime(ansicMatcher.group(3)); + year = getYear(ansicMatcher.group(4)); + } else { + throw new IllegalArgumentException(); + } + } + + // FIXME: Y2038 BUG! + if (year >= 2038) { + year = 2038; + month = Calendar.JANUARY; + date = 1; + } + + Time time = new Time(Time.TIMEZONE_UTC); + time.set(timeOfDay.second, timeOfDay.minute, timeOfDay.hour, date, + month, year); + return time.toMillis(false /* use isDst */); + } + + private static int getDate(String dateString) { + if (dateString.length() == 2) { + return (dateString.charAt(0) - '0') * 10 + + (dateString.charAt(1) - '0'); + } else { + return (dateString.charAt(0) - '0'); + } + } + + /* + * jan = 9 + 0 + 13 = 22 feb = 5 + 4 + 1 = 10 mar = 12 + 0 + 17 = 29 apr = 0 + * + 15 + 17 = 32 may = 12 + 0 + 24 = 36 jun = 9 + 20 + 13 = 42 jul = 9 + 20 + * + 11 = 40 aug = 0 + 20 + 6 = 26 sep = 18 + 4 + 15 = 37 oct = 14 + 2 + 19 + * = 35 nov = 13 + 14 + 21 = 48 dec = 3 + 4 + 2 = 9 + */ + private static int getMonth(String monthString) { + int hash = Character.toLowerCase(monthString.charAt(0)) + + Character.toLowerCase(monthString.charAt(1)) + + Character.toLowerCase(monthString.charAt(2)) - 3 * 'a'; + switch (hash) { + case 22: + return Calendar.JANUARY; + case 10: + return Calendar.FEBRUARY; + case 29: + return Calendar.MARCH; + case 32: + return Calendar.APRIL; + case 36: + return Calendar.MAY; + case 42: + return Calendar.JUNE; + case 40: + return Calendar.JULY; + case 26: + return Calendar.AUGUST; + case 37: + return Calendar.SEPTEMBER; + case 35: + return Calendar.OCTOBER; + case 48: + return Calendar.NOVEMBER; + case 9: + return Calendar.DECEMBER; + default: + throw new IllegalArgumentException(); + } + } + + private static int getYear(String yearString) { + if (yearString.length() == 2) { + int year = (yearString.charAt(0) - '0') * 10 + + (yearString.charAt(1) - '0'); + if (year >= 70) { + return year + 1900; + } else { + return year + 2000; + } + } else if (yearString.length() == 3) { + // According to RFC 2822, three digit years should be added to 1900. + int year = (yearString.charAt(0) - '0') * 100 + + (yearString.charAt(1) - '0') * 10 + + (yearString.charAt(2) - '0'); + return year + 1900; + } else if (yearString.length() == 4) { + return (yearString.charAt(0) - '0') * 1000 + + (yearString.charAt(1) - '0') * 100 + + (yearString.charAt(2) - '0') * 10 + + (yearString.charAt(3) - '0'); + } else { + return 1970; + } + } + + private static TimeOfDay getTime(String timeString) { + // HH might be H + int i = 0; + int hour = timeString.charAt(i++) - '0'; + if (timeString.charAt(i) != ':') + hour = hour * 10 + (timeString.charAt(i++) - '0'); + // Skip ':' + i++; + + int minute = (timeString.charAt(i++) - '0') * 10 + + (timeString.charAt(i++) - '0'); + // Skip ':' + i++; + + int second = (timeString.charAt(i++) - '0') * 10 + + (timeString.charAt(i++) - '0'); + + return new TimeOfDay(hour, minute, second); + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/V14CustomNotification.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/V14CustomNotification.java new file mode 100644 index 000000000..e736603e2 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/V14CustomNotification.java @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import com.android.vending.expansion.downloader.R; +import com.google.android.vending.expansion.downloader.Helpers; + +import android.app.Notification; +import android.app.PendingIntent; +import android.content.Context; + +public class V14CustomNotification implements DownloadNotification.ICustomNotification { + + CharSequence mTitle; + CharSequence mTicker; + int mIcon; + long mTotalKB = -1; + long mCurrentKB = -1; + long mTimeRemaining; + PendingIntent mPendingIntent; + + @Override + public void setIcon(int icon) { + mIcon = icon; + } + + @Override + public void setTitle(CharSequence title) { + mTitle = title; + } + + @Override + public void setTotalBytes(long totalBytes) { + mTotalKB = totalBytes; + } + + @Override + public void setCurrentBytes(long currentBytes) { + mCurrentKB = currentBytes; + } + + void setProgress(Notification.Builder builder) { + + } + + @Override + public Notification updateNotification(Context c) { + Notification.Builder builder = new Notification.Builder(c); + builder.setContentTitle(mTitle); + if (mTotalKB > 0 && -1 != mCurrentKB) { + builder.setProgress((int) (mTotalKB >> 8), (int) (mCurrentKB >> 8), false); + } else { + builder.setProgress(0, 0, true); + } + builder.setContentText(Helpers.getDownloadProgressString(mCurrentKB, mTotalKB)); + builder.setContentInfo(c.getString(R.string.time_remaining_notification, + Helpers.getTimeRemaining(mTimeRemaining))); + if (mIcon != 0) { + builder.setSmallIcon(mIcon); + } else { + int iconResource = android.R.drawable.stat_sys_download; + builder.setSmallIcon(iconResource); + } + builder.setOngoing(true); + builder.setTicker(mTicker); + builder.setContentIntent(mPendingIntent); + builder.setOnlyAlertOnce(true); + + return builder.getNotification(); + } + + @Override + public void setPendingIntent(PendingIntent contentIntent) { + mPendingIntent = contentIntent; + } + + @Override + public void setTicker(CharSequence ticker) { + mTicker = ticker; + } + + @Override + public void setTimeRemaining(long timeRemaining) { + mTimeRemaining = timeRemaining; + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/V3CustomNotification.java b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/V3CustomNotification.java new file mode 100644 index 000000000..e3666e05b --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/expansion/downloader/impl/V3CustomNotification.java @@ -0,0 +1,116 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.expansion.downloader.impl; + +import com.android.vending.expansion.downloader.R; +import com.google.android.vending.expansion.downloader.Helpers; + +import android.app.Notification; +import android.app.PendingIntent; +import android.content.Context; +import android.graphics.BitmapFactory; +import android.view.View; +import android.widget.RemoteViews; + +public class V3CustomNotification implements DownloadNotification.ICustomNotification { + + CharSequence mTitle; + CharSequence mTicker; + int mIcon; + long mTotalBytes = -1; + long mCurrentBytes = -1; + long mTimeRemaining; + PendingIntent mPendingIntent; + Notification mNotification = new Notification(); + + @Override + public void setIcon(int icon) { + mIcon = icon; + } + + @Override + public void setTitle(CharSequence title) { + mTitle = title; + } + + @Override + public void setTotalBytes(long totalBytes) { + mTotalBytes = totalBytes; + } + + @Override + public void setCurrentBytes(long currentBytes) { + mCurrentBytes = currentBytes; + } + + @Override + public Notification updateNotification(Context c) { + Notification n = mNotification; + + n.icon = mIcon; + + n.flags |= Notification.FLAG_ONGOING_EVENT; + + if (android.os.Build.VERSION.SDK_INT > 10) { + n.flags |= Notification.FLAG_ONLY_ALERT_ONCE; // only matters for + // Honeycomb + } + + // Build the RemoteView object + RemoteViews expandedView = new RemoteViews( + c.getPackageName(), + R.layout.status_bar_ongoing_event_progress_bar); + + expandedView.setTextViewText(R.id.title, mTitle); + // look at strings + expandedView.setViewVisibility(R.id.description, View.VISIBLE); + expandedView.setTextViewText(R.id.description, + Helpers.getDownloadProgressString(mCurrentBytes, mTotalBytes)); + expandedView.setViewVisibility(R.id.progress_bar_frame, View.VISIBLE); + expandedView.setProgressBar(R.id.progress_bar, + (int) (mTotalBytes >> 8), + (int) (mCurrentBytes >> 8), + mTotalBytes <= 0); + expandedView.setViewVisibility(R.id.time_remaining, View.VISIBLE); + expandedView.setTextViewText( + R.id.time_remaining, + c.getString(R.string.time_remaining_notification, + Helpers.getTimeRemaining(mTimeRemaining))); + expandedView.setTextViewText(R.id.progress_text, + Helpers.getDownloadProgressPercent(mCurrentBytes, mTotalBytes)); + expandedView.setImageViewResource(R.id.appIcon, mIcon); + n.contentView = expandedView; + n.contentIntent = mPendingIntent; + return n; + } + + @Override + public void setPendingIntent(PendingIntent contentIntent) { + mPendingIntent = contentIntent; + } + + @Override + public void setTicker(CharSequence ticker) { + mTicker = ticker; + } + + @Override + public void setTimeRemaining(long timeRemaining) { + mTimeRemaining = timeRemaining; + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/AESObfuscator.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/AESObfuscator.java new file mode 100644 index 000000000..ee12c68de --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/AESObfuscator.java @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +import com.google.android.vending.licensing.util.Base64; +import com.google.android.vending.licensing.util.Base64DecoderException; + +import java.io.UnsupportedEncodingException; +import java.security.GeneralSecurityException; +import java.security.spec.KeySpec; + +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * An Obfuscator that uses AES to encrypt data. + */ +public class AESObfuscator implements Obfuscator { + private static final String UTF8 = "UTF-8"; + private static final String KEYGEN_ALGORITHM = "PBEWITHSHAAND256BITAES-CBC-BC"; + private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding"; + private static final byte[] IV = + { 16, 74, 71, -80, 32, 101, -47, 72, 117, -14, 0, -29, 70, 65, -12, 74 }; + private static final String header = "com.android.vending.licensing.AESObfuscator-1|"; + + private Cipher mEncryptor; + private Cipher mDecryptor; + + /** + * @param salt an array of random bytes to use for each (un)obfuscation + * @param applicationId application identifier, e.g. the package name + * @param deviceId device identifier. Use as many sources as possible to + * create this unique identifier. + */ + public AESObfuscator(byte[] salt, String applicationId, String deviceId) { + try { + SecretKeyFactory factory = SecretKeyFactory.getInstance(KEYGEN_ALGORITHM); + KeySpec keySpec = + new PBEKeySpec((applicationId + deviceId).toCharArray(), salt, 1024, 256); + SecretKey tmp = factory.generateSecret(keySpec); + SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES"); + mEncryptor = Cipher.getInstance(CIPHER_ALGORITHM); + mEncryptor.init(Cipher.ENCRYPT_MODE, secret, new IvParameterSpec(IV)); + mDecryptor = Cipher.getInstance(CIPHER_ALGORITHM); + mDecryptor.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(IV)); + } catch (GeneralSecurityException e) { + // This can't happen on a compatible Android device. + throw new RuntimeException("Invalid environment", e); + } + } + + public String obfuscate(String original, String key) { + if (original == null) { + return null; + } + try { + // Header is appended as an integrity check + return Base64.encode(mEncryptor.doFinal((header + key + original).getBytes(UTF8))); + } catch (UnsupportedEncodingException e) { + throw new RuntimeException("Invalid environment", e); + } catch (GeneralSecurityException e) { + throw new RuntimeException("Invalid environment", e); + } + } + + public String unobfuscate(String obfuscated, String key) throws ValidationException { + if (obfuscated == null) { + return null; + } + try { + String result = new String(mDecryptor.doFinal(Base64.decode(obfuscated)), UTF8); + // Check for presence of header. This serves as a final integrity check, for cases + // where the block size is correct during decryption. + int headerIndex = result.indexOf(header+key); + if (headerIndex != 0) { + throw new ValidationException("Header not found (invalid data or key)" + ":" + + obfuscated); + } + return result.substring(header.length()+key.length(), result.length()); + } catch (Base64DecoderException e) { + throw new ValidationException(e.getMessage() + ":" + obfuscated); + } catch (IllegalBlockSizeException e) { + throw new ValidationException(e.getMessage() + ":" + obfuscated); + } catch (BadPaddingException e) { + throw new ValidationException(e.getMessage() + ":" + obfuscated); + } catch (UnsupportedEncodingException e) { + throw new RuntimeException("Invalid environment", e); + } + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/APKExpansionPolicy.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/APKExpansionPolicy.java new file mode 100644 index 000000000..17cc7a7cf --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/APKExpansionPolicy.java @@ -0,0 +1,397 @@ + +package com.google.android.vending.licensing; + +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import org.apache.http.NameValuePair; +import org.apache.http.client.utils.URLEncodedUtils; + +import android.content.Context; +import android.content.SharedPreferences; +import android.util.Log; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Vector; + +/** + * Default policy. All policy decisions are based off of response data received + * from the licensing service. Specifically, the licensing server sends the + * following information: response validity period, error retry period, and + * error retry count. + *

+ * These values will vary based on the the way the application is configured in + * the Android Market publishing console, such as whether the application is + * marked as free or is within its refund period, as well as how often an + * application is checking with the licensing service. + *

+ * Developers who need more fine grained control over their application's + * licensing policy should implement a custom Policy. + */ +public class APKExpansionPolicy implements Policy { + + private static final String TAG = "APKExpansionPolicy"; + private static final String PREFS_FILE = "com.android.vending.licensing.APKExpansionPolicy"; + private static final String PREF_LAST_RESPONSE = "lastResponse"; + private static final String PREF_VALIDITY_TIMESTAMP = "validityTimestamp"; + private static final String PREF_RETRY_UNTIL = "retryUntil"; + private static final String PREF_MAX_RETRIES = "maxRetries"; + private static final String PREF_RETRY_COUNT = "retryCount"; + private static final String DEFAULT_VALIDITY_TIMESTAMP = "0"; + private static final String DEFAULT_RETRY_UNTIL = "0"; + private static final String DEFAULT_MAX_RETRIES = "0"; + private static final String DEFAULT_RETRY_COUNT = "0"; + + private static final long MILLIS_PER_MINUTE = 60 * 1000; + + private long mValidityTimestamp; + private long mRetryUntil; + private long mMaxRetries; + private long mRetryCount; + private long mLastResponseTime = 0; + private int mLastResponse; + private PreferenceObfuscator mPreferences; + private Vector mExpansionURLs = new Vector(); + private Vector mExpansionFileNames = new Vector(); + private Vector mExpansionFileSizes = new Vector(); + + /** + * The design of the protocol supports n files. Currently the market can + * only deliver two files. To accommodate this, we have these two constants, + * but the order is the only relevant thing here. + */ + public static final int MAIN_FILE_URL_INDEX = 0; + public static final int PATCH_FILE_URL_INDEX = 1; + + /** + * @param context The context for the current application + * @param obfuscator An obfuscator to be used with preferences. + */ + public APKExpansionPolicy(Context context, Obfuscator obfuscator) { + // Import old values + SharedPreferences sp = context.getSharedPreferences(PREFS_FILE, Context.MODE_PRIVATE); + mPreferences = new PreferenceObfuscator(sp, obfuscator); + mLastResponse = Integer.parseInt( + mPreferences.getString(PREF_LAST_RESPONSE, Integer.toString(Policy.RETRY))); + mValidityTimestamp = Long.parseLong(mPreferences.getString(PREF_VALIDITY_TIMESTAMP, + DEFAULT_VALIDITY_TIMESTAMP)); + mRetryUntil = Long.parseLong(mPreferences.getString(PREF_RETRY_UNTIL, DEFAULT_RETRY_UNTIL)); + mMaxRetries = Long.parseLong(mPreferences.getString(PREF_MAX_RETRIES, DEFAULT_MAX_RETRIES)); + mRetryCount = Long.parseLong(mPreferences.getString(PREF_RETRY_COUNT, DEFAULT_RETRY_COUNT)); + } + + /** + * We call this to guarantee that we fetch a fresh policy from the server. + * This is to be used if the URL is invalid. + */ + public void resetPolicy() { + mPreferences.putString(PREF_LAST_RESPONSE, Integer.toString(Policy.RETRY)); + setRetryUntil(DEFAULT_RETRY_UNTIL); + setMaxRetries(DEFAULT_MAX_RETRIES); + setRetryCount(Long.parseLong(DEFAULT_RETRY_COUNT)); + setValidityTimestamp(DEFAULT_VALIDITY_TIMESTAMP); + mPreferences.commit(); + } + + /** + * Process a new response from the license server. + *

+ * This data will be used for computing future policy decisions. The + * following parameters are processed: + *

    + *
  • VT: the timestamp that the client should consider the response valid + * until + *
  • GT: the timestamp that the client should ignore retry errors until + *
  • GR: the number of retry errors that the client should ignore + *
+ * + * @param response the result from validating the server response + * @param rawData the raw server response data + */ + public void processServerResponse(int response, + com.google.android.vending.licensing.ResponseData rawData) { + + // Update retry counter + if (response != Policy.RETRY) { + setRetryCount(0); + } else { + setRetryCount(mRetryCount + 1); + } + + if (response == Policy.LICENSED) { + // Update server policy data + Map extras = decodeExtras(rawData.extra); + mLastResponse = response; + setValidityTimestamp(Long.toString(System.currentTimeMillis() + MILLIS_PER_MINUTE)); + Set keys = extras.keySet(); + for (String key : keys) { + if (key.equals("VT")) { + setValidityTimestamp(extras.get(key)); + } else if (key.equals("GT")) { + setRetryUntil(extras.get(key)); + } else if (key.equals("GR")) { + setMaxRetries(extras.get(key)); + } else if (key.startsWith("FILE_URL")) { + int index = Integer.parseInt(key.substring("FILE_URL".length())) - 1; + setExpansionURL(index, extras.get(key)); + } else if (key.startsWith("FILE_NAME")) { + int index = Integer.parseInt(key.substring("FILE_NAME".length())) - 1; + setExpansionFileName(index, extras.get(key)); + } else if (key.startsWith("FILE_SIZE")) { + int index = Integer.parseInt(key.substring("FILE_SIZE".length())) - 1; + setExpansionFileSize(index, Long.parseLong(extras.get(key))); + } + } + } else if (response == Policy.NOT_LICENSED) { + // Clear out stale policy data + setValidityTimestamp(DEFAULT_VALIDITY_TIMESTAMP); + setRetryUntil(DEFAULT_RETRY_UNTIL); + setMaxRetries(DEFAULT_MAX_RETRIES); + } + + setLastResponse(response); + mPreferences.commit(); + } + + /** + * Set the last license response received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param l the response + */ + private void setLastResponse(int l) { + mLastResponseTime = System.currentTimeMillis(); + mLastResponse = l; + mPreferences.putString(PREF_LAST_RESPONSE, Integer.toString(l)); + } + + /** + * Set the current retry count and add to preferences. You must manually + * call PreferenceObfuscator.commit() to commit these changes to disk. + * + * @param c the new retry count + */ + private void setRetryCount(long c) { + mRetryCount = c; + mPreferences.putString(PREF_RETRY_COUNT, Long.toString(c)); + } + + public long getRetryCount() { + return mRetryCount; + } + + /** + * Set the last validity timestamp (VT) received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param validityTimestamp the VT string received + */ + private void setValidityTimestamp(String validityTimestamp) { + Long lValidityTimestamp; + try { + lValidityTimestamp = Long.parseLong(validityTimestamp); + } catch (NumberFormatException e) { + // No response or not parseable, expire in one minute. + Log.w(TAG, "License validity timestamp (VT) missing, caching for a minute"); + lValidityTimestamp = System.currentTimeMillis() + MILLIS_PER_MINUTE; + validityTimestamp = Long.toString(lValidityTimestamp); + } + + mValidityTimestamp = lValidityTimestamp; + mPreferences.putString(PREF_VALIDITY_TIMESTAMP, validityTimestamp); + } + + public long getValidityTimestamp() { + return mValidityTimestamp; + } + + /** + * Set the retry until timestamp (GT) received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param retryUntil the GT string received + */ + private void setRetryUntil(String retryUntil) { + Long lRetryUntil; + try { + lRetryUntil = Long.parseLong(retryUntil); + } catch (NumberFormatException e) { + // No response or not parseable, expire immediately + Log.w(TAG, "License retry timestamp (GT) missing, grace period disabled"); + retryUntil = "0"; + lRetryUntil = 0l; + } + + mRetryUntil = lRetryUntil; + mPreferences.putString(PREF_RETRY_UNTIL, retryUntil); + } + + public long getRetryUntil() { + return mRetryUntil; + } + + /** + * Set the max retries value (GR) as received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param maxRetries the GR string received + */ + private void setMaxRetries(String maxRetries) { + Long lMaxRetries; + try { + lMaxRetries = Long.parseLong(maxRetries); + } catch (NumberFormatException e) { + // No response or not parseable, expire immediately + Log.w(TAG, "Licence retry count (GR) missing, grace period disabled"); + maxRetries = "0"; + lMaxRetries = 0l; + } + + mMaxRetries = lMaxRetries; + mPreferences.putString(PREF_MAX_RETRIES, maxRetries); + } + + public long getMaxRetries() { + return mMaxRetries; + } + + /** + * Gets the count of expansion URLs. Since expansionURLs are not committed + * to preferences, this will return zero if there has been no LVL fetch + * in the current session. + * + * @return the number of expansion URLs. (0,1,2) + */ + public int getExpansionURLCount() { + return mExpansionURLs.size(); + } + + /** + * Gets the expansion URL. Since these URLs are not committed to + * preferences, this will always return null if there has not been an LVL + * fetch in the current session. + * + * @param index the index of the URL to fetch. This value will be either + * MAIN_FILE_URL_INDEX or PATCH_FILE_URL_INDEX + * @param URL the URL to set + */ + public String getExpansionURL(int index) { + if (index < mExpansionURLs.size()) { + return mExpansionURLs.elementAt(index); + } + return null; + } + + /** + * Sets the expansion URL. Expansion URL's are not committed to preferences, + * but are instead intended to be stored when the license response is + * processed by the front-end. + * + * @param index the index of the expansion URL. This value will be either + * MAIN_FILE_URL_INDEX or PATCH_FILE_URL_INDEX + * @param URL the URL to set + */ + public void setExpansionURL(int index, String URL) { + if (index >= mExpansionURLs.size()) { + mExpansionURLs.setSize(index + 1); + } + mExpansionURLs.set(index, URL); + } + + public String getExpansionFileName(int index) { + if (index < mExpansionFileNames.size()) { + return mExpansionFileNames.elementAt(index); + } + return null; + } + + public void setExpansionFileName(int index, String name) { + if (index >= mExpansionFileNames.size()) { + mExpansionFileNames.setSize(index + 1); + } + mExpansionFileNames.set(index, name); + } + + public long getExpansionFileSize(int index) { + if (index < mExpansionFileSizes.size()) { + return mExpansionFileSizes.elementAt(index); + } + return -1; + } + + public void setExpansionFileSize(int index, long size) { + if (index >= mExpansionFileSizes.size()) { + mExpansionFileSizes.setSize(index + 1); + } + mExpansionFileSizes.set(index, size); + } + + /** + * {@inheritDoc} This implementation allows access if either:
+ *
    + *
  1. a LICENSED response was received within the validity period + *
  2. a RETRY response was received in the last minute, and we are under + * the RETRY count or in the RETRY period. + *
+ */ + public boolean allowAccess() { + long ts = System.currentTimeMillis(); + if (mLastResponse == Policy.LICENSED) { + // Check if the LICENSED response occurred within the validity + // timeout. + if (ts <= mValidityTimestamp) { + // Cached LICENSED response is still valid. + return true; + } + } else if (mLastResponse == Policy.RETRY && + ts < mLastResponseTime + MILLIS_PER_MINUTE) { + // Only allow access if we are within the retry period or we haven't + // used up our + // max retries. + return (ts <= mRetryUntil || mRetryCount <= mMaxRetries); + } + return false; + } + + private Map decodeExtras(String extras) { + Map results = new HashMap(); + try { + URI rawExtras = new URI("?" + extras); + List extraList = URLEncodedUtils.parse(rawExtras, "UTF-8"); + for (NameValuePair item : extraList) { + String name = item.getName(); + int i = 0; + while (results.containsKey(name)) { + name = item.getName() + ++i; + } + results.put(name, item.getValue()); + } + } catch (URISyntaxException e) { + Log.w(TAG, "Invalid syntax error while decoding extras data from server."); + } + return results; + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/DeviceLimiter.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/DeviceLimiter.java new file mode 100644 index 000000000..e5c5e2d7c --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/DeviceLimiter.java @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * Allows the developer to limit the number of devices using a single license. + *

+ * The LICENSED response from the server contains a user identifier unique to + * the <application, user> pair. The developer can send this identifier + * to their own server along with some device identifier (a random number + * generated and stored once per application installation, + * {@link android.telephony.TelephonyManager#getDeviceId getDeviceId}, + * {@link android.provider.Settings.Secure#ANDROID_ID ANDROID_ID}, etc). + * The more sources used to identify the device, the harder it will be for an + * attacker to spoof. + *

+ * The server can look at the <application, user, device id> tuple and + * restrict a user's application license to run on at most 10 different devices + * in a week (for example). We recommend not being too restrictive because a + * user might legitimately have multiple devices or be in the process of + * changing phones. This will catch egregious violations of multiple people + * sharing one license. + */ +public interface DeviceLimiter { + + /** + * Checks if this device is allowed to use the given user's license. + * + * @param userId the user whose license the server responded with + * @return LICENSED if the device is allowed, NOT_LICENSED if not, RETRY if an error occurs + */ + int isDeviceAllowed(String userId); +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/ILicenseResultListener.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/ILicenseResultListener.java new file mode 100644 index 000000000..d90d6eac7 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/ILicenseResultListener.java @@ -0,0 +1,99 @@ +/* + * This file is auto-generated. DO NOT MODIFY. + * Original file: aidl/ILicenseResultListener.aidl + */ +package com.google.android.vending.licensing; +import java.lang.String; +import android.os.RemoteException; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Binder; +import android.os.Parcel; +public interface ILicenseResultListener extends android.os.IInterface +{ +/** Local-side IPC implementation stub class. */ +public static abstract class Stub extends android.os.Binder implements com.google.android.vending.licensing.ILicenseResultListener +{ +private static final java.lang.String DESCRIPTOR = "com.android.vending.licensing.ILicenseResultListener"; +/** Construct the stub at attach it to the interface. */ +public Stub() +{ +this.attachInterface(this, DESCRIPTOR); +} +/** + * Cast an IBinder object into an ILicenseResultListener interface, + * generating a proxy if needed. + */ +public static com.google.android.vending.licensing.ILicenseResultListener asInterface(android.os.IBinder obj) +{ +if ((obj==null)) { +return null; +} +android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR); +if (((iin!=null)&&(iin instanceof com.google.android.vending.licensing.ILicenseResultListener))) { +return ((com.google.android.vending.licensing.ILicenseResultListener)iin); +} +return new com.google.android.vending.licensing.ILicenseResultListener.Stub.Proxy(obj); +} +public android.os.IBinder asBinder() +{ +return this; +} +public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException +{ +switch (code) +{ +case INTERFACE_TRANSACTION: +{ +reply.writeString(DESCRIPTOR); +return true; +} +case TRANSACTION_verifyLicense: +{ +data.enforceInterface(DESCRIPTOR); +int _arg0; +_arg0 = data.readInt(); +java.lang.String _arg1; +_arg1 = data.readString(); +java.lang.String _arg2; +_arg2 = data.readString(); +this.verifyLicense(_arg0, _arg1, _arg2); +return true; +} +} +return super.onTransact(code, data, reply, flags); +} +private static class Proxy implements com.google.android.vending.licensing.ILicenseResultListener +{ +private android.os.IBinder mRemote; +Proxy(android.os.IBinder remote) +{ +mRemote = remote; +} +public android.os.IBinder asBinder() +{ +return mRemote; +} +public java.lang.String getInterfaceDescriptor() +{ +return DESCRIPTOR; +} +public void verifyLicense(int responseCode, java.lang.String signedData, java.lang.String signature) throws android.os.RemoteException +{ +android.os.Parcel _data = android.os.Parcel.obtain(); +try { +_data.writeInterfaceToken(DESCRIPTOR); +_data.writeInt(responseCode); +_data.writeString(signedData); +_data.writeString(signature); +mRemote.transact(Stub.TRANSACTION_verifyLicense, _data, null, IBinder.FLAG_ONEWAY); +} +finally { +_data.recycle(); +} +} +} +static final int TRANSACTION_verifyLicense = (IBinder.FIRST_CALL_TRANSACTION + 0); +} +public void verifyLicense(int responseCode, java.lang.String signedData, java.lang.String signature) throws android.os.RemoteException; +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/ILicensingService.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/ILicensingService.java new file mode 100644 index 000000000..95599544e --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/ILicensingService.java @@ -0,0 +1,99 @@ +/* + * This file is auto-generated. DO NOT MODIFY. + * Original file: aidl/ILicensingService.aidl + */ +package com.google.android.vending.licensing; +import java.lang.String; +import android.os.RemoteException; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Binder; +import android.os.Parcel; +public interface ILicensingService extends android.os.IInterface +{ +/** Local-side IPC implementation stub class. */ +public static abstract class Stub extends android.os.Binder implements com.google.android.vending.licensing.ILicensingService +{ +private static final java.lang.String DESCRIPTOR = "com.android.vending.licensing.ILicensingService"; +/** Construct the stub at attach it to the interface. */ +public Stub() +{ +this.attachInterface(this, DESCRIPTOR); +} +/** + * Cast an IBinder object into an ILicensingService interface, + * generating a proxy if needed. + */ +public static com.google.android.vending.licensing.ILicensingService asInterface(android.os.IBinder obj) +{ +if ((obj==null)) { +return null; +} +android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR); +if (((iin!=null)&&(iin instanceof com.google.android.vending.licensing.ILicensingService))) { +return ((com.google.android.vending.licensing.ILicensingService)iin); +} +return new com.google.android.vending.licensing.ILicensingService.Stub.Proxy(obj); +} +public android.os.IBinder asBinder() +{ +return this; +} +public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException +{ +switch (code) +{ +case INTERFACE_TRANSACTION: +{ +reply.writeString(DESCRIPTOR); +return true; +} +case TRANSACTION_checkLicense: +{ +data.enforceInterface(DESCRIPTOR); +long _arg0; +_arg0 = data.readLong(); +java.lang.String _arg1; +_arg1 = data.readString(); +com.google.android.vending.licensing.ILicenseResultListener _arg2; +_arg2 = com.google.android.vending.licensing.ILicenseResultListener.Stub.asInterface(data.readStrongBinder()); +this.checkLicense(_arg0, _arg1, _arg2); +return true; +} +} +return super.onTransact(code, data, reply, flags); +} +private static class Proxy implements com.google.android.vending.licensing.ILicensingService +{ +private android.os.IBinder mRemote; +Proxy(android.os.IBinder remote) +{ +mRemote = remote; +} +public android.os.IBinder asBinder() +{ +return mRemote; +} +public java.lang.String getInterfaceDescriptor() +{ +return DESCRIPTOR; +} +public void checkLicense(long nonce, java.lang.String packageName, com.google.android.vending.licensing.ILicenseResultListener listener) throws android.os.RemoteException +{ +android.os.Parcel _data = android.os.Parcel.obtain(); +try { +_data.writeInterfaceToken(DESCRIPTOR); +_data.writeLong(nonce); +_data.writeString(packageName); +_data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null))); +mRemote.transact(Stub.TRANSACTION_checkLicense, _data, null, IBinder.FLAG_ONEWAY); +} +finally { +_data.recycle(); +} +} +} +static final int TRANSACTION_checkLicense = (IBinder.FIRST_CALL_TRANSACTION + 0); +} +public void checkLicense(long nonce, java.lang.String packageName, com.google.android.vending.licensing.ILicenseResultListener listener) throws android.os.RemoteException; +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseChecker.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseChecker.java new file mode 100644 index 000000000..0b1c4b6cc --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseChecker.java @@ -0,0 +1,351 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +import com.google.android.vending.licensing.util.Base64; +import com.google.android.vending.licensing.util.Base64DecoderException; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.content.pm.PackageManager.NameNotFoundException; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.RemoteException; +import android.provider.Settings.Secure; +import android.util.Log; + +import java.security.KeyFactory; +import java.security.NoSuchAlgorithmException; +import java.security.PublicKey; +import java.security.SecureRandom; +import java.security.spec.InvalidKeySpecException; +import java.security.spec.X509EncodedKeySpec; +import java.util.Date; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.Queue; +import java.util.Set; + +/** + * Client library for Android Market license verifications. + *

+ * The LicenseChecker is configured via a {@link Policy} which contains the + * logic to determine whether a user should have access to the application. For + * example, the Policy can define a threshold for allowable number of server or + * client failures before the library reports the user as not having access. + *

+ * Must also provide the Base64-encoded RSA public key associated with your + * developer account. The public key is obtainable from the publisher site. + */ +public class LicenseChecker implements ServiceConnection { + private static final String TAG = "LicenseChecker"; + + private static final String KEY_FACTORY_ALGORITHM = "RSA"; + + // Timeout value (in milliseconds) for calls to service. + private static final int TIMEOUT_MS = 10 * 1000; + + private static final SecureRandom RANDOM = new SecureRandom(); + private static final boolean DEBUG_LICENSE_ERROR = false; + + private ILicensingService mService; + + private PublicKey mPublicKey; + private final Context mContext; + private final Policy mPolicy; + /** + * A handler for running tasks on a background thread. We don't want license + * processing to block the UI thread. + */ + private Handler mHandler; + private final String mPackageName; + private final String mVersionCode; + private final Set mChecksInProgress = new HashSet(); + private final Queue mPendingChecks = new LinkedList(); + + /** + * @param context a Context + * @param policy implementation of Policy + * @param encodedPublicKey Base64-encoded RSA public key + * @throws IllegalArgumentException if encodedPublicKey is invalid + */ + public LicenseChecker(Context context, Policy policy, String encodedPublicKey) { + mContext = context; + mPolicy = policy; + mPublicKey = generatePublicKey(encodedPublicKey); + mPackageName = mContext.getPackageName(); + mVersionCode = getVersionCode(context, mPackageName); + HandlerThread handlerThread = new HandlerThread("background thread"); + handlerThread.start(); + mHandler = new Handler(handlerThread.getLooper()); + } + + /** + * Generates a PublicKey instance from a string containing the + * Base64-encoded public key. + * + * @param encodedPublicKey Base64-encoded public key + * @throws IllegalArgumentException if encodedPublicKey is invalid + */ + private static PublicKey generatePublicKey(String encodedPublicKey) { + try { + byte[] decodedKey = Base64.decode(encodedPublicKey); + KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM); + + return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey)); + } catch (NoSuchAlgorithmException e) { + // This won't happen in an Android-compatible environment. + throw new RuntimeException(e); + } catch (Base64DecoderException e) { + Log.e(TAG, "Could not decode from Base64."); + throw new IllegalArgumentException(e); + } catch (InvalidKeySpecException e) { + Log.e(TAG, "Invalid key specification."); + throw new IllegalArgumentException(e); + } + } + + /** + * Checks if the user should have access to the app. Binds the service if necessary. + *

+ * NOTE: This call uses a trivially obfuscated string (base64-encoded). For best security, + * we recommend obfuscating the string that is passed into bindService using another method + * of your own devising. + *

+ * source string: "com.android.vending.licensing.ILicensingService" + *

+ * @param callback + */ + public synchronized void checkAccess(LicenseCheckerCallback callback) { + // If we have a valid recent LICENSED response, we can skip asking + // Market. + if (mPolicy.allowAccess()) { + Log.i(TAG, "Using cached license response"); + callback.allow(Policy.LICENSED); + } else { + LicenseValidator validator = new LicenseValidator(mPolicy, new NullDeviceLimiter(), + callback, generateNonce(), mPackageName, mVersionCode); + + if (mService == null) { + Log.i(TAG, "Binding to licensing service."); + try { + boolean bindResult = mContext + .bindService( + new Intent( + new String( + Base64.decode("Y29tLmFuZHJvaWQudmVuZGluZy5saWNlbnNpbmcuSUxpY2Vuc2luZ1NlcnZpY2U="))), + this, // ServiceConnection. + Context.BIND_AUTO_CREATE); + + if (bindResult) { + mPendingChecks.offer(validator); + } else { + Log.e(TAG, "Could not bind to service."); + handleServiceConnectionError(validator); + } + } catch (SecurityException e) { + callback.applicationError(LicenseCheckerCallback.ERROR_MISSING_PERMISSION); + } catch (Base64DecoderException e) { + e.printStackTrace(); + } + } else { + mPendingChecks.offer(validator); + runChecks(); + } + } + } + + private void runChecks() { + LicenseValidator validator; + while ((validator = mPendingChecks.poll()) != null) { + try { + Log.i(TAG, "Calling checkLicense on service for " + validator.getPackageName()); + mService.checkLicense( + validator.getNonce(), validator.getPackageName(), + new ResultListener(validator)); + mChecksInProgress.add(validator); + } catch (RemoteException e) { + Log.w(TAG, "RemoteException in checkLicense call.", e); + handleServiceConnectionError(validator); + } + } + } + + private synchronized void finishCheck(LicenseValidator validator) { + mChecksInProgress.remove(validator); + if (mChecksInProgress.isEmpty()) { + cleanupService(); + } + } + + private class ResultListener extends ILicenseResultListener.Stub { + private final LicenseValidator mValidator; + private Runnable mOnTimeout; + + public ResultListener(LicenseValidator validator) { + mValidator = validator; + mOnTimeout = new Runnable() { + public void run() { + Log.i(TAG, "Check timed out."); + handleServiceConnectionError(mValidator); + finishCheck(mValidator); + } + }; + startTimeout(); + } + + private static final int ERROR_CONTACTING_SERVER = 0x101; + private static final int ERROR_INVALID_PACKAGE_NAME = 0x102; + private static final int ERROR_NON_MATCHING_UID = 0x103; + + // Runs in IPC thread pool. Post it to the Handler, so we can guarantee + // either this or the timeout runs. + public void verifyLicense(final int responseCode, final String signedData, + final String signature) { + mHandler.post(new Runnable() { + public void run() { + Log.i(TAG, "Received response."); + // Make sure it hasn't already timed out. + if (mChecksInProgress.contains(mValidator)) { + clearTimeout(); + mValidator.verify(mPublicKey, responseCode, signedData, signature); + finishCheck(mValidator); + } + if (DEBUG_LICENSE_ERROR) { + boolean logResponse; + String stringError = null; + switch (responseCode) { + case ERROR_CONTACTING_SERVER: + logResponse = true; + stringError = "ERROR_CONTACTING_SERVER"; + break; + case ERROR_INVALID_PACKAGE_NAME: + logResponse = true; + stringError = "ERROR_INVALID_PACKAGE_NAME"; + break; + case ERROR_NON_MATCHING_UID: + logResponse = true; + stringError = "ERROR_NON_MATCHING_UID"; + break; + default: + logResponse = false; + } + + if (logResponse) { + String android_id = Secure.getString(mContext.getContentResolver(), + Secure.ANDROID_ID); + Date date = new Date(); + Log.d(TAG, "Server Failure: " + stringError); + Log.d(TAG, "Android ID: " + android_id); + Log.d(TAG, "Time: " + date.toGMTString()); + } + } + + } + }); + } + + private void startTimeout() { + Log.i(TAG, "Start monitoring timeout."); + mHandler.postDelayed(mOnTimeout, TIMEOUT_MS); + } + + private void clearTimeout() { + Log.i(TAG, "Clearing timeout."); + mHandler.removeCallbacks(mOnTimeout); + } + } + + public synchronized void onServiceConnected(ComponentName name, IBinder service) { + mService = ILicensingService.Stub.asInterface(service); + runChecks(); + } + + public synchronized void onServiceDisconnected(ComponentName name) { + // Called when the connection with the service has been + // unexpectedly disconnected. That is, Market crashed. + // If there are any checks in progress, the timeouts will handle them. + Log.w(TAG, "Service unexpectedly disconnected."); + mService = null; + } + + /** + * Generates policy response for service connection errors, as a result of + * disconnections or timeouts. + */ + private synchronized void handleServiceConnectionError(LicenseValidator validator) { + mPolicy.processServerResponse(Policy.RETRY, null); + + if (mPolicy.allowAccess()) { + validator.getCallback().allow(Policy.RETRY); + } else { + validator.getCallback().dontAllow(Policy.RETRY); + } + } + + /** Unbinds service if necessary and removes reference to it. */ + private void cleanupService() { + if (mService != null) { + try { + mContext.unbindService(this); + } catch (IllegalArgumentException e) { + // Somehow we've already been unbound. This is a non-fatal + // error. + Log.e(TAG, "Unable to unbind from licensing service (already unbound)"); + } + mService = null; + } + } + + /** + * Inform the library that the context is about to be destroyed, so that any + * open connections can be cleaned up. + *

+ * Failure to call this method can result in a crash under certain + * circumstances, such as during screen rotation if an Activity requests the + * license check or when the user exits the application. + */ + public synchronized void onDestroy() { + cleanupService(); + mHandler.getLooper().quit(); + } + + /** Generates a nonce (number used once). */ + private int generateNonce() { + return RANDOM.nextInt(); + } + + /** + * Get version code for the application package name. + * + * @param context + * @param packageName application package name + * @return the version code or empty string if package not found + */ + private static String getVersionCode(Context context, String packageName) { + try { + return String.valueOf(context.getPackageManager().getPackageInfo(packageName, 0). + versionCode); + } catch (NameNotFoundException e) { + Log.e(TAG, "Package not found. could not get version code."); + return ""; + } + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseCheckerCallback.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseCheckerCallback.java new file mode 100644 index 000000000..b250a7147 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseCheckerCallback.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * Callback for the license checker library. + *

+ * Upon checking with the Market server and conferring with the {@link Policy}, + * the library calls the appropriate callback method to communicate the result. + *

+ * The callback does not occur in the original checking thread. Your + * application should post to the appropriate handling thread or lock + * accordingly. + *

+ * The reason that is passed back with allow/dontAllow is the base status handed + * to the policy for allowed/disallowing the license. Policy.RETRY will call + * allow or dontAllow depending on other statistics associated with the policy, + * while in most cases Policy.NOT_LICENSED will call dontAllow and + * Policy.LICENSED will Allow. + */ +public interface LicenseCheckerCallback { + + /** + * Allow use. App should proceed as normal. + * + * @param reason Policy.LICENSED or Policy.RETRY typically. (although in + * theory the policy can return Policy.NOT_LICENSED here as well) + */ + public void allow(int reason); + + /** + * Don't allow use. App should inform user and take appropriate action. + * + * @param reason Policy.NOT_LICENSED or Policy.RETRY. (although in theory + * the policy can return Policy.LICENSED here as well --- + * perhaps the call to the LVL took too long, for example) + */ + public void dontAllow(int reason); + + /** Application error codes. */ + public static final int ERROR_INVALID_PACKAGE_NAME = 1; + public static final int ERROR_NON_MATCHING_UID = 2; + public static final int ERROR_NOT_MARKET_MANAGED = 3; + public static final int ERROR_CHECK_IN_PROGRESS = 4; + public static final int ERROR_INVALID_PUBLIC_KEY = 5; + public static final int ERROR_MISSING_PERMISSION = 6; + + /** + * Error in application code. Caller did not call or set up license checker + * correctly. Should be considered fatal. + */ + public void applicationError(int errorCode); +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseValidator.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseValidator.java new file mode 100644 index 000000000..61d3c7e79 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/LicenseValidator.java @@ -0,0 +1,224 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +import com.google.android.vending.licensing.util.Base64; +import com.google.android.vending.licensing.util.Base64DecoderException; + +import android.text.TextUtils; +import android.util.Log; + +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.PublicKey; +import java.security.Signature; +import java.security.SignatureException; + +/** + * Contains data related to a licensing request and methods to verify + * and process the response. + */ +class LicenseValidator { + private static final String TAG = "LicenseValidator"; + + // Server response codes. + private static final int LICENSED = 0x0; + private static final int NOT_LICENSED = 0x1; + private static final int LICENSED_OLD_KEY = 0x2; + private static final int ERROR_NOT_MARKET_MANAGED = 0x3; + private static final int ERROR_SERVER_FAILURE = 0x4; + private static final int ERROR_OVER_QUOTA = 0x5; + + private static final int ERROR_CONTACTING_SERVER = 0x101; + private static final int ERROR_INVALID_PACKAGE_NAME = 0x102; + private static final int ERROR_NON_MATCHING_UID = 0x103; + + private final Policy mPolicy; + private final LicenseCheckerCallback mCallback; + private final int mNonce; + private final String mPackageName; + private final String mVersionCode; + private final DeviceLimiter mDeviceLimiter; + + LicenseValidator(Policy policy, DeviceLimiter deviceLimiter, LicenseCheckerCallback callback, + int nonce, String packageName, String versionCode) { + mPolicy = policy; + mDeviceLimiter = deviceLimiter; + mCallback = callback; + mNonce = nonce; + mPackageName = packageName; + mVersionCode = versionCode; + } + + public LicenseCheckerCallback getCallback() { + return mCallback; + } + + public int getNonce() { + return mNonce; + } + + public String getPackageName() { + return mPackageName; + } + + private static final String SIGNATURE_ALGORITHM = "SHA1withRSA"; + + /** + * Verifies the response from server and calls appropriate callback method. + * + * @param publicKey public key associated with the developer account + * @param responseCode server response code + * @param signedData signed data from server + * @param signature server signature + */ + public void verify(PublicKey publicKey, int responseCode, String signedData, String signature) { + String userId = null; + // Skip signature check for unsuccessful requests + ResponseData data = null; + if (responseCode == LICENSED || responseCode == NOT_LICENSED || + responseCode == LICENSED_OLD_KEY) { + // Verify signature. + try { + Signature sig = Signature.getInstance(SIGNATURE_ALGORITHM); + sig.initVerify(publicKey); + sig.update(signedData.getBytes()); + + if (!sig.verify(Base64.decode(signature))) { + Log.e(TAG, "Signature verification failed."); + handleInvalidResponse(); + return; + } + } catch (NoSuchAlgorithmException e) { + // This can't happen on an Android compatible device. + throw new RuntimeException(e); + } catch (InvalidKeyException e) { + handleApplicationError(LicenseCheckerCallback.ERROR_INVALID_PUBLIC_KEY); + return; + } catch (SignatureException e) { + throw new RuntimeException(e); + } catch (Base64DecoderException e) { + Log.e(TAG, "Could not Base64-decode signature."); + handleInvalidResponse(); + return; + } + + // Parse and validate response. + try { + data = ResponseData.parse(signedData); + } catch (IllegalArgumentException e) { + Log.e(TAG, "Could not parse response."); + handleInvalidResponse(); + return; + } + + if (data.responseCode != responseCode) { + Log.e(TAG, "Response codes don't match."); + handleInvalidResponse(); + return; + } + + if (data.nonce != mNonce) { + Log.e(TAG, "Nonce doesn't match."); + handleInvalidResponse(); + return; + } + + if (!data.packageName.equals(mPackageName)) { + Log.e(TAG, "Package name doesn't match."); + handleInvalidResponse(); + return; + } + + if (!data.versionCode.equals(mVersionCode)) { + Log.e(TAG, "Version codes don't match."); + handleInvalidResponse(); + return; + } + + // Application-specific user identifier. + userId = data.userId; + if (TextUtils.isEmpty(userId)) { + Log.e(TAG, "User identifier is empty."); + handleInvalidResponse(); + return; + } + } + + switch (responseCode) { + case LICENSED: + case LICENSED_OLD_KEY: + int limiterResponse = mDeviceLimiter.isDeviceAllowed(userId); + handleResponse(limiterResponse, data); + break; + case NOT_LICENSED: + handleResponse(Policy.NOT_LICENSED, data); + break; + case ERROR_CONTACTING_SERVER: + Log.w(TAG, "Error contacting licensing server."); + handleResponse(Policy.RETRY, data); + break; + case ERROR_SERVER_FAILURE: + Log.w(TAG, "An error has occurred on the licensing server."); + handleResponse(Policy.RETRY, data); + break; + case ERROR_OVER_QUOTA: + Log.w(TAG, "Licensing server is refusing to talk to this device, over quota."); + handleResponse(Policy.RETRY, data); + break; + case ERROR_INVALID_PACKAGE_NAME: + handleApplicationError(LicenseCheckerCallback.ERROR_INVALID_PACKAGE_NAME); + break; + case ERROR_NON_MATCHING_UID: + handleApplicationError(LicenseCheckerCallback.ERROR_NON_MATCHING_UID); + break; + case ERROR_NOT_MARKET_MANAGED: + handleApplicationError(LicenseCheckerCallback.ERROR_NOT_MARKET_MANAGED); + break; + default: + Log.e(TAG, "Unknown response code for license check."); + handleInvalidResponse(); + } + } + + /** + * Confers with policy and calls appropriate callback method. + * + * @param response + * @param rawData + */ + private void handleResponse(int response, ResponseData rawData) { + // Update policy data and increment retry counter (if needed) + mPolicy.processServerResponse(response, rawData); + + // Given everything we know, including cached data, ask the policy if we should grant + // access. + if (mPolicy.allowAccess()) { + mCallback.allow(response); + } else { + mCallback.dontAllow(response); + } + } + + private void handleApplicationError(int code) { + mCallback.applicationError(code); + } + + private void handleInvalidResponse() { + mCallback.dontAllow(Policy.NOT_LICENSED); + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/NullDeviceLimiter.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/NullDeviceLimiter.java new file mode 100644 index 000000000..d87af3153 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/NullDeviceLimiter.java @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * A DeviceLimiter that doesn't limit the number of devices that can use a + * given user's license. + *

+ * Unless you have reason to believe that your application is being pirated + * by multiple users using the same license (signing in to Market as the same + * user), we recommend you use this implementation. + */ +public class NullDeviceLimiter implements DeviceLimiter { + + public int isDeviceAllowed(String userId) { + return Policy.LICENSED; + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/Obfuscator.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/Obfuscator.java new file mode 100644 index 000000000..b5d510d72 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/Obfuscator.java @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * Interface used as part of a {@link Policy} to allow application authors to obfuscate + * licensing data that will be stored into a SharedPreferences file. + *

+ * Any transformation scheme must be reversable. Implementing classes may optionally implement an + * integrity check to further prevent modification to preference data. Implementing classes + * should use device-specific information as a key in the obfuscation algorithm to prevent + * obfuscated preferences from being shared among devices. + */ +public interface Obfuscator { + + /** + * Obfuscate a string that is being stored into shared preferences. + * + * @param original The data that is to be obfuscated. + * @param key The key for the data that is to be obfuscated. + * @return A transformed version of the original data. + */ + String obfuscate(String original, String key); + + /** + * Undo the transformation applied to data by the obfuscate() method. + * + * @param original The data that is to be obfuscated. + * @param key The key for the data that is to be obfuscated. + * @return A transformed version of the original data. + * @throws ValidationException Optionally thrown if a data integrity check fails. + */ + String unobfuscate(String obfuscated, String key) throws ValidationException; +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/Policy.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/Policy.java new file mode 100644 index 000000000..fa267fc71 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/Policy.java @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * Policy used by {@link LicenseChecker} to determine whether a user should have + * access to the application. + */ +public interface Policy { + + /** + * Change these values to make it more difficult for tools to automatically + * strip LVL protection from your APK. + */ + + /** + * LICENSED means that the server returned back a valid license response + */ + public static final int LICENSED = 0x0100; + /** + * NOT_LICENSED means that the server returned back a valid license response + * that indicated that the user definitively is not licensed + */ + public static final int NOT_LICENSED = 0x0231; + /** + * RETRY means that the license response was unable to be determined --- + * perhaps as a result of faulty networking + */ + public static final int RETRY = 0x0123; + + /** + * Provide results from contact with the license server. Retry counts are + * incremented if the current value of response is RETRY. Results will be + * used for any future policy decisions. + * + * @param response the result from validating the server response + * @param rawData the raw server response data, can be null for RETRY + */ + void processServerResponse(int response, ResponseData rawData); + + /** + * Check if the user should be allowed access to the application. + */ + boolean allowAccess(); +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/PreferenceObfuscator.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/PreferenceObfuscator.java new file mode 100644 index 000000000..7c42bfc28 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/PreferenceObfuscator.java @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +import android.content.SharedPreferences; +import android.util.Log; + +/** + * An wrapper for SharedPreferences that transparently performs data obfuscation. + */ +public class PreferenceObfuscator { + + private static final String TAG = "PreferenceObfuscator"; + + private final SharedPreferences mPreferences; + private final Obfuscator mObfuscator; + private SharedPreferences.Editor mEditor; + + /** + * Constructor. + * + * @param sp A SharedPreferences instance provided by the system. + * @param o The Obfuscator to use when reading or writing data. + */ + public PreferenceObfuscator(SharedPreferences sp, Obfuscator o) { + mPreferences = sp; + mObfuscator = o; + mEditor = null; + } + + public void putString(String key, String value) { + if (mEditor == null) { + mEditor = mPreferences.edit(); + } + String obfuscatedValue = mObfuscator.obfuscate(value, key); + mEditor.putString(key, obfuscatedValue); + } + + public String getString(String key, String defValue) { + String result; + String value = mPreferences.getString(key, null); + if (value != null) { + try { + result = mObfuscator.unobfuscate(value, key); + } catch (ValidationException e) { + // Unable to unobfuscate, data corrupt or tampered + Log.w(TAG, "Validation error while reading preference: " + key); + result = defValue; + } + } else { + // Preference not found + result = defValue; + } + return result; + } + + public void commit() { + if (mEditor != null) { + mEditor.commit(); + mEditor = null; + } + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/ResponseData.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/ResponseData.java new file mode 100644 index 000000000..2adef3709 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/ResponseData.java @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +import java.util.regex.Pattern; + +import android.text.TextUtils; + +/** + * ResponseData from licensing server. + */ +public class ResponseData { + + public int responseCode; + public int nonce; + public String packageName; + public String versionCode; + public String userId; + public long timestamp; + /** Response-specific data. */ + public String extra; + + /** + * Parses response string into ResponseData. + * + * @param responseData response data string + * @throws IllegalArgumentException upon parsing error + * @return ResponseData object + */ + public static ResponseData parse(String responseData) { + // Must parse out main response data and response-specific data. + int index = responseData.indexOf(':'); + String mainData, extraData; + if ( -1 == index ) { + mainData = responseData; + extraData = ""; + } else { + mainData = responseData.substring(0, index); + extraData = index >= responseData.length() ? "" : responseData.substring(index+1); + } + + String [] fields = TextUtils.split(mainData, Pattern.quote("|")); + if (fields.length < 6) { + throw new IllegalArgumentException("Wrong number of fields."); + } + + ResponseData data = new ResponseData(); + data.extra = extraData; + data.responseCode = Integer.parseInt(fields[0]); + data.nonce = Integer.parseInt(fields[1]); + data.packageName = fields[2]; + data.versionCode = fields[3]; + // Application-specific user identifier. + data.userId = fields[4]; + data.timestamp = Long.parseLong(fields[5]); + + return data; + } + + @Override + public String toString() { + return TextUtils.join("|", new Object [] { responseCode, nonce, packageName, versionCode, + userId, timestamp }); + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/ServerManagedPolicy.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/ServerManagedPolicy.java new file mode 100644 index 000000000..fbf8cf6d0 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/ServerManagedPolicy.java @@ -0,0 +1,276 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +import org.apache.http.NameValuePair; +import org.apache.http.client.utils.URLEncodedUtils; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import android.content.Context; +import android.content.SharedPreferences; +import android.util.Log; + +/** + * Default policy. All policy decisions are based off of response data received + * from the licensing service. Specifically, the licensing server sends the + * following information: response validity period, error retry period, and + * error retry count. + *

+ * These values will vary based on the the way the application is configured in + * the Android Market publishing console, such as whether the application is + * marked as free or is within its refund period, as well as how often an + * application is checking with the licensing service. + *

+ * Developers who need more fine grained control over their application's + * licensing policy should implement a custom Policy. + */ +public class ServerManagedPolicy implements Policy { + + private static final String TAG = "ServerManagedPolicy"; + private static final String PREFS_FILE = "com.android.vending.licensing.ServerManagedPolicy"; + private static final String PREF_LAST_RESPONSE = "lastResponse"; + private static final String PREF_VALIDITY_TIMESTAMP = "validityTimestamp"; + private static final String PREF_RETRY_UNTIL = "retryUntil"; + private static final String PREF_MAX_RETRIES = "maxRetries"; + private static final String PREF_RETRY_COUNT = "retryCount"; + private static final String DEFAULT_VALIDITY_TIMESTAMP = "0"; + private static final String DEFAULT_RETRY_UNTIL = "0"; + private static final String DEFAULT_MAX_RETRIES = "0"; + private static final String DEFAULT_RETRY_COUNT = "0"; + + private static final long MILLIS_PER_MINUTE = 60 * 1000; + + private long mValidityTimestamp; + private long mRetryUntil; + private long mMaxRetries; + private long mRetryCount; + private long mLastResponseTime = 0; + private int mLastResponse; + private PreferenceObfuscator mPreferences; + + /** + * @param context The context for the current application + * @param obfuscator An obfuscator to be used with preferences. + */ + public ServerManagedPolicy(Context context, Obfuscator obfuscator) { + // Import old values + SharedPreferences sp = context.getSharedPreferences(PREFS_FILE, Context.MODE_PRIVATE); + mPreferences = new PreferenceObfuscator(sp, obfuscator); + mLastResponse = Integer.parseInt( + mPreferences.getString(PREF_LAST_RESPONSE, Integer.toString(Policy.RETRY))); + mValidityTimestamp = Long.parseLong(mPreferences.getString(PREF_VALIDITY_TIMESTAMP, + DEFAULT_VALIDITY_TIMESTAMP)); + mRetryUntil = Long.parseLong(mPreferences.getString(PREF_RETRY_UNTIL, DEFAULT_RETRY_UNTIL)); + mMaxRetries = Long.parseLong(mPreferences.getString(PREF_MAX_RETRIES, DEFAULT_MAX_RETRIES)); + mRetryCount = Long.parseLong(mPreferences.getString(PREF_RETRY_COUNT, DEFAULT_RETRY_COUNT)); + } + + /** + * Process a new response from the license server. + *

+ * This data will be used for computing future policy decisions. The + * following parameters are processed: + *

    + *
  • VT: the timestamp that the client should consider the response + * valid until + *
  • GT: the timestamp that the client should ignore retry errors until + *
  • GR: the number of retry errors that the client should ignore + *
+ * + * @param response the result from validating the server response + * @param rawData the raw server response data + */ + public void processServerResponse(int response, ResponseData rawData) { + + // Update retry counter + if (response != Policy.RETRY) { + setRetryCount(0); + } else { + setRetryCount(mRetryCount + 1); + } + + if (response == Policy.LICENSED) { + // Update server policy data + Map extras = decodeExtras(rawData.extra); + mLastResponse = response; + setValidityTimestamp(extras.get("VT")); + setRetryUntil(extras.get("GT")); + setMaxRetries(extras.get("GR")); + } else if (response == Policy.NOT_LICENSED) { + // Clear out stale policy data + setValidityTimestamp(DEFAULT_VALIDITY_TIMESTAMP); + setRetryUntil(DEFAULT_RETRY_UNTIL); + setMaxRetries(DEFAULT_MAX_RETRIES); + } + + setLastResponse(response); + mPreferences.commit(); + } + + /** + * Set the last license response received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param l the response + */ + private void setLastResponse(int l) { + mLastResponseTime = System.currentTimeMillis(); + mLastResponse = l; + mPreferences.putString(PREF_LAST_RESPONSE, Integer.toString(l)); + } + + /** + * Set the current retry count and add to preferences. You must manually + * call PreferenceObfuscator.commit() to commit these changes to disk. + * + * @param c the new retry count + */ + private void setRetryCount(long c) { + mRetryCount = c; + mPreferences.putString(PREF_RETRY_COUNT, Long.toString(c)); + } + + public long getRetryCount() { + return mRetryCount; + } + + /** + * Set the last validity timestamp (VT) received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param validityTimestamp the VT string received + */ + private void setValidityTimestamp(String validityTimestamp) { + Long lValidityTimestamp; + try { + lValidityTimestamp = Long.parseLong(validityTimestamp); + } catch (NumberFormatException e) { + // No response or not parsable, expire in one minute. + Log.w(TAG, "License validity timestamp (VT) missing, caching for a minute"); + lValidityTimestamp = System.currentTimeMillis() + MILLIS_PER_MINUTE; + validityTimestamp = Long.toString(lValidityTimestamp); + } + + mValidityTimestamp = lValidityTimestamp; + mPreferences.putString(PREF_VALIDITY_TIMESTAMP, validityTimestamp); + } + + public long getValidityTimestamp() { + return mValidityTimestamp; + } + + /** + * Set the retry until timestamp (GT) received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param retryUntil the GT string received + */ + private void setRetryUntil(String retryUntil) { + Long lRetryUntil; + try { + lRetryUntil = Long.parseLong(retryUntil); + } catch (NumberFormatException e) { + // No response or not parsable, expire immediately + Log.w(TAG, "License retry timestamp (GT) missing, grace period disabled"); + retryUntil = "0"; + lRetryUntil = 0l; + } + + mRetryUntil = lRetryUntil; + mPreferences.putString(PREF_RETRY_UNTIL, retryUntil); + } + + public long getRetryUntil() { + return mRetryUntil; + } + + /** + * Set the max retries value (GR) as received from the server and add to + * preferences. You must manually call PreferenceObfuscator.commit() to + * commit these changes to disk. + * + * @param maxRetries the GR string received + */ + private void setMaxRetries(String maxRetries) { + Long lMaxRetries; + try { + lMaxRetries = Long.parseLong(maxRetries); + } catch (NumberFormatException e) { + // No response or not parsable, expire immediately + Log.w(TAG, "Licence retry count (GR) missing, grace period disabled"); + maxRetries = "0"; + lMaxRetries = 0l; + } + + mMaxRetries = lMaxRetries; + mPreferences.putString(PREF_MAX_RETRIES, maxRetries); + } + + public long getMaxRetries() { + return mMaxRetries; + } + + /** + * {@inheritDoc} + * + * This implementation allows access if either:
+ *
    + *
  1. a LICENSED response was received within the validity period + *
  2. a RETRY response was received in the last minute, and we are under + * the RETRY count or in the RETRY period. + *
+ */ + public boolean allowAccess() { + long ts = System.currentTimeMillis(); + if (mLastResponse == Policy.LICENSED) { + // Check if the LICENSED response occurred within the validity timeout. + if (ts <= mValidityTimestamp) { + // Cached LICENSED response is still valid. + return true; + } + } else if (mLastResponse == Policy.RETRY && + ts < mLastResponseTime + MILLIS_PER_MINUTE) { + // Only allow access if we are within the retry period or we haven't used up our + // max retries. + return (ts <= mRetryUntil || mRetryCount <= mMaxRetries); + } + return false; + } + + private Map decodeExtras(String extras) { + Map results = new HashMap(); + try { + URI rawExtras = new URI("?" + extras); + List extraList = URLEncodedUtils.parse(rawExtras, "UTF-8"); + for (NameValuePair item : extraList) { + results.put(item.getName(), item.getValue()); + } + } catch (URISyntaxException e) { + Log.w(TAG, "Invalid syntax error while decoding extras data from server."); + } + return results; + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/StrictPolicy.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/StrictPolicy.java new file mode 100644 index 000000000..d8d83b4e4 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/StrictPolicy.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * Non-caching policy. All requests will be sent to the licensing service, + * and no local caching is performed. + *

+ * Using a non-caching policy ensures that there is no local preference data + * for malicious users to tamper with. As a side effect, applications + * will not be permitted to run while offline. Developers should carefully + * weigh the risks of using this Policy over one which implements caching, + * such as ServerManagedPolicy. + *

+ * Access to the application is only allowed if a LICESNED response is. + * received. All other responses (including RETRY) will deny access. + */ +public class StrictPolicy implements Policy { + + private int mLastResponse; + + public StrictPolicy() { + // Set default policy. This will force the application to check the policy on launch. + mLastResponse = Policy.RETRY; + } + + /** + * Process a new response from the license server. Since we aren't + * performing any caching, this equates to reading the LicenseResponse. + * Any ResponseData provided is ignored. + * + * @param response the result from validating the server response + * @param rawData the raw server response data + */ + public void processServerResponse(int response, ResponseData rawData) { + mLastResponse = response; + } + + /** + * {@inheritDoc} + * + * This implementation allows access if and only if a LICENSED response + * was received the last time the server was contacted. + */ + public boolean allowAccess() { + return (mLastResponse == Policy.LICENSED); + } + +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/ValidationException.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/ValidationException.java new file mode 100644 index 000000000..ee4df47c6 --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/ValidationException.java @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.android.vending.licensing; + +/** + * Indicates that an error occurred while validating the integrity of data managed by an + * {@link Obfuscator}.} + */ +public class ValidationException extends Exception { + public ValidationException() { + super(); + } + + public ValidationException(String s) { + super(s); + } + + private static final long serialVersionUID = 1L; +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/util/Base64.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/util/Base64.java new file mode 100644 index 000000000..a0d2779af --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/util/Base64.java @@ -0,0 +1,570 @@ +// Portions copyright 2002, Google, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package com.google.android.vending.licensing.util; + +// This code was converted from code at http://iharder.sourceforge.net/base64/ +// Lots of extraneous features were removed. +/* The original code said: + *

+ * I am placing this code in the Public Domain. Do with it as you will. + * This software comes with no guarantees or warranties but with + * plenty of well-wishing instead! + * Please visit + * http://iharder.net/xmlizable + * periodically to check for updates or to contribute improvements. + *

+ * + * @author Robert Harder + * @author rharder@usa.net + * @version 1.3 + */ + +/** + * Base64 converter class. This code is not a full-blown MIME encoder; + * it simply converts binary data to base64 data and back. + * + *

Note {@link CharBase64} is a GWT-compatible implementation of this + * class. + */ +public class Base64 { + /** Specify encoding (value is {@code true}). */ + public final static boolean ENCODE = true; + + /** Specify decoding (value is {@code false}). */ + public final static boolean DECODE = false; + + /** The equals sign (=) as a byte. */ + private final static byte EQUALS_SIGN = (byte) '='; + + /** The new line character (\n) as a byte. */ + private final static byte NEW_LINE = (byte) '\n'; + + /** + * The 64 valid Base64 values. + */ + private final static byte[] ALPHABET = + {(byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F', + (byte) 'G', (byte) 'H', (byte) 'I', (byte) 'J', (byte) 'K', + (byte) 'L', (byte) 'M', (byte) 'N', (byte) 'O', (byte) 'P', + (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', (byte) 'U', + (byte) 'V', (byte) 'W', (byte) 'X', (byte) 'Y', (byte) 'Z', + (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e', + (byte) 'f', (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j', + (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n', (byte) 'o', + (byte) 'p', (byte) 'q', (byte) 'r', (byte) 's', (byte) 't', + (byte) 'u', (byte) 'v', (byte) 'w', (byte) 'x', (byte) 'y', + (byte) 'z', (byte) '0', (byte) '1', (byte) '2', (byte) '3', + (byte) '4', (byte) '5', (byte) '6', (byte) '7', (byte) '8', + (byte) '9', (byte) '+', (byte) '/'}; + + /** + * The 64 valid web safe Base64 values. + */ + private final static byte[] WEBSAFE_ALPHABET = + {(byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F', + (byte) 'G', (byte) 'H', (byte) 'I', (byte) 'J', (byte) 'K', + (byte) 'L', (byte) 'M', (byte) 'N', (byte) 'O', (byte) 'P', + (byte) 'Q', (byte) 'R', (byte) 'S', (byte) 'T', (byte) 'U', + (byte) 'V', (byte) 'W', (byte) 'X', (byte) 'Y', (byte) 'Z', + (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e', + (byte) 'f', (byte) 'g', (byte) 'h', (byte) 'i', (byte) 'j', + (byte) 'k', (byte) 'l', (byte) 'm', (byte) 'n', (byte) 'o', + (byte) 'p', (byte) 'q', (byte) 'r', (byte) 's', (byte) 't', + (byte) 'u', (byte) 'v', (byte) 'w', (byte) 'x', (byte) 'y', + (byte) 'z', (byte) '0', (byte) '1', (byte) '2', (byte) '3', + (byte) '4', (byte) '5', (byte) '6', (byte) '7', (byte) '8', + (byte) '9', (byte) '-', (byte) '_'}; + + /** + * Translates a Base64 value to either its 6-bit reconstruction value + * or a negative number indicating some other meaning. + **/ + private final static byte[] DECODABET = {-9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 0 - 8 + -5, -5, // Whitespace: Tab and Linefeed + -9, -9, // Decimal 11 - 12 + -5, // Whitespace: Carriage Return + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 14 - 26 + -9, -9, -9, -9, -9, // Decimal 27 - 31 + -5, // Whitespace: Space + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 33 - 42 + 62, // Plus sign at decimal 43 + -9, -9, -9, // Decimal 44 - 46 + 63, // Slash at decimal 47 + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // Numbers zero through nine + -9, -9, -9, // Decimal 58 - 60 + -1, // Equals sign at decimal 61 + -9, -9, -9, // Decimal 62 - 64 + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, // Letters 'A' through 'N' + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // Letters 'O' through 'Z' + -9, -9, -9, -9, -9, -9, // Decimal 91 - 96 + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // Letters 'a' through 'm' + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // Letters 'n' through 'z' + -9, -9, -9, -9, -9 // Decimal 123 - 127 + /* ,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 128 - 139 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 140 - 152 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 153 - 165 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 166 - 178 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 179 - 191 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 192 - 204 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 205 - 217 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 218 - 230 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 231 - 243 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9 // Decimal 244 - 255 */ + }; + + /** The web safe decodabet */ + private final static byte[] WEBSAFE_DECODABET = + {-9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 0 - 8 + -5, -5, // Whitespace: Tab and Linefeed + -9, -9, // Decimal 11 - 12 + -5, // Whitespace: Carriage Return + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 14 - 26 + -9, -9, -9, -9, -9, // Decimal 27 - 31 + -5, // Whitespace: Space + -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, // Decimal 33 - 44 + 62, // Dash '-' sign at decimal 45 + -9, -9, // Decimal 46-47 + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // Numbers zero through nine + -9, -9, -9, // Decimal 58 - 60 + -1, // Equals sign at decimal 61 + -9, -9, -9, // Decimal 62 - 64 + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, // Letters 'A' through 'N' + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // Letters 'O' through 'Z' + -9, -9, -9, -9, // Decimal 91-94 + 63, // Underscore '_' at decimal 95 + -9, // Decimal 96 + 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // Letters 'a' through 'm' + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // Letters 'n' through 'z' + -9, -9, -9, -9, -9 // Decimal 123 - 127 + /* ,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 128 - 139 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 140 - 152 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 153 - 165 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 166 - 178 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 179 - 191 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 192 - 204 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 205 - 217 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 218 - 230 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9, // Decimal 231 - 243 + -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9 // Decimal 244 - 255 */ + }; + + // Indicates white space in encoding + private final static byte WHITE_SPACE_ENC = -5; + // Indicates equals sign in encoding + private final static byte EQUALS_SIGN_ENC = -1; + + /** Defeats instantiation. */ + private Base64() { + } + + /* ******** E N C O D I N G M E T H O D S ******** */ + + /** + * Encodes up to three bytes of the array source + * and writes the resulting four Base64 bytes to destination. + * The source and destination arrays can be manipulated + * anywhere along their length by specifying + * srcOffset and destOffset. + * This method does not check to make sure your arrays + * are large enough to accommodate srcOffset + 3 for + * the source array or destOffset + 4 for + * the destination array. + * The actual number of significant bytes in your array is + * given by numSigBytes. + * + * @param source the array to convert + * @param srcOffset the index where conversion begins + * @param numSigBytes the number of significant bytes in your array + * @param destination the array to hold the conversion + * @param destOffset the index where output will be put + * @param alphabet is the encoding alphabet + * @return the destination array + * @since 1.3 + */ + private static byte[] encode3to4(byte[] source, int srcOffset, + int numSigBytes, byte[] destination, int destOffset, byte[] alphabet) { + // 1 2 3 + // 01234567890123456789012345678901 Bit position + // --------000000001111111122222222 Array position from threeBytes + // --------| || || || | Six bit groups to index alphabet + // >>18 >>12 >> 6 >> 0 Right shift necessary + // 0x3f 0x3f 0x3f Additional AND + + // Create buffer with zero-padding if there are only one or two + // significant bytes passed in the array. + // We have to shift left 24 in order to flush out the 1's that appear + // when Java treats a value as negative that is cast from a byte to an int. + int inBuff = + (numSigBytes > 0 ? ((source[srcOffset] << 24) >>> 8) : 0) + | (numSigBytes > 1 ? ((source[srcOffset + 1] << 24) >>> 16) : 0) + | (numSigBytes > 2 ? ((source[srcOffset + 2] << 24) >>> 24) : 0); + + switch (numSigBytes) { + case 3: + destination[destOffset] = alphabet[(inBuff >>> 18)]; + destination[destOffset + 1] = alphabet[(inBuff >>> 12) & 0x3f]; + destination[destOffset + 2] = alphabet[(inBuff >>> 6) & 0x3f]; + destination[destOffset + 3] = alphabet[(inBuff) & 0x3f]; + return destination; + case 2: + destination[destOffset] = alphabet[(inBuff >>> 18)]; + destination[destOffset + 1] = alphabet[(inBuff >>> 12) & 0x3f]; + destination[destOffset + 2] = alphabet[(inBuff >>> 6) & 0x3f]; + destination[destOffset + 3] = EQUALS_SIGN; + return destination; + case 1: + destination[destOffset] = alphabet[(inBuff >>> 18)]; + destination[destOffset + 1] = alphabet[(inBuff >>> 12) & 0x3f]; + destination[destOffset + 2] = EQUALS_SIGN; + destination[destOffset + 3] = EQUALS_SIGN; + return destination; + default: + return destination; + } // end switch + } // end encode3to4 + + /** + * Encodes a byte array into Base64 notation. + * Equivalent to calling + * {@code encodeBytes(source, 0, source.length)} + * + * @param source The data to convert + * @since 1.4 + */ + public static String encode(byte[] source) { + return encode(source, 0, source.length, ALPHABET, true); + } + + /** + * Encodes a byte array into web safe Base64 notation. + * + * @param source The data to convert + * @param doPadding is {@code true} to pad result with '=' chars + * if it does not fall on 3 byte boundaries + */ + public static String encodeWebSafe(byte[] source, boolean doPadding) { + return encode(source, 0, source.length, WEBSAFE_ALPHABET, doPadding); + } + + /** + * Encodes a byte array into Base64 notation. + * + * @param source The data to convert + * @param off Offset in array where conversion should begin + * @param len Length of data to convert + * @param alphabet is the encoding alphabet + * @param doPadding is {@code true} to pad result with '=' chars + * if it does not fall on 3 byte boundaries + * @since 1.4 + */ + public static String encode(byte[] source, int off, int len, byte[] alphabet, + boolean doPadding) { + byte[] outBuff = encode(source, off, len, alphabet, Integer.MAX_VALUE); + int outLen = outBuff.length; + + // If doPadding is false, set length to truncate '=' + // padding characters + while (doPadding == false && outLen > 0) { + if (outBuff[outLen - 1] != '=') { + break; + } + outLen -= 1; + } + + return new String(outBuff, 0, outLen); + } + + /** + * Encodes a byte array into Base64 notation. + * + * @param source The data to convert + * @param off Offset in array where conversion should begin + * @param len Length of data to convert + * @param alphabet is the encoding alphabet + * @param maxLineLength maximum length of one line. + * @return the BASE64-encoded byte array + */ + public static byte[] encode(byte[] source, int off, int len, byte[] alphabet, + int maxLineLength) { + int lenDiv3 = (len + 2) / 3; // ceil(len / 3) + int len43 = lenDiv3 * 4; + byte[] outBuff = new byte[len43 // Main 4:3 + + (len43 / maxLineLength)]; // New lines + + int d = 0; + int e = 0; + int len2 = len - 2; + int lineLength = 0; + for (; d < len2; d += 3, e += 4) { + + // The following block of code is the same as + // encode3to4( source, d + off, 3, outBuff, e, alphabet ); + // but inlined for faster encoding (~20% improvement) + int inBuff = + ((source[d + off] << 24) >>> 8) + | ((source[d + 1 + off] << 24) >>> 16) + | ((source[d + 2 + off] << 24) >>> 24); + outBuff[e] = alphabet[(inBuff >>> 18)]; + outBuff[e + 1] = alphabet[(inBuff >>> 12) & 0x3f]; + outBuff[e + 2] = alphabet[(inBuff >>> 6) & 0x3f]; + outBuff[e + 3] = alphabet[(inBuff) & 0x3f]; + + lineLength += 4; + if (lineLength == maxLineLength) { + outBuff[e + 4] = NEW_LINE; + e++; + lineLength = 0; + } // end if: end of line + } // end for: each piece of array + + if (d < len) { + encode3to4(source, d + off, len - d, outBuff, e, alphabet); + + lineLength += 4; + if (lineLength == maxLineLength) { + // Add a last newline + outBuff[e + 4] = NEW_LINE; + e++; + } + e += 4; + } + + assert (e == outBuff.length); + return outBuff; + } + + + /* ******** D E C O D I N G M E T H O D S ******** */ + + + /** + * Decodes four bytes from array source + * and writes the resulting bytes (up to three of them) + * to destination. + * The source and destination arrays can be manipulated + * anywhere along their length by specifying + * srcOffset and destOffset. + * This method does not check to make sure your arrays + * are large enough to accommodate srcOffset + 4 for + * the source array or destOffset + 3 for + * the destination array. + * This method returns the actual number of bytes that + * were converted from the Base64 encoding. + * + * + * @param source the array to convert + * @param srcOffset the index where conversion begins + * @param destination the array to hold the conversion + * @param destOffset the index where output will be put + * @param decodabet the decodabet for decoding Base64 content + * @return the number of decoded bytes converted + * @since 1.3 + */ + private static int decode4to3(byte[] source, int srcOffset, + byte[] destination, int destOffset, byte[] decodabet) { + // Example: Dk== + if (source[srcOffset + 2] == EQUALS_SIGN) { + int outBuff = + ((decodabet[source[srcOffset]] << 24) >>> 6) + | ((decodabet[source[srcOffset + 1]] << 24) >>> 12); + + destination[destOffset] = (byte) (outBuff >>> 16); + return 1; + } else if (source[srcOffset + 3] == EQUALS_SIGN) { + // Example: DkL= + int outBuff = + ((decodabet[source[srcOffset]] << 24) >>> 6) + | ((decodabet[source[srcOffset + 1]] << 24) >>> 12) + | ((decodabet[source[srcOffset + 2]] << 24) >>> 18); + + destination[destOffset] = (byte) (outBuff >>> 16); + destination[destOffset + 1] = (byte) (outBuff >>> 8); + return 2; + } else { + // Example: DkLE + int outBuff = + ((decodabet[source[srcOffset]] << 24) >>> 6) + | ((decodabet[source[srcOffset + 1]] << 24) >>> 12) + | ((decodabet[source[srcOffset + 2]] << 24) >>> 18) + | ((decodabet[source[srcOffset + 3]] << 24) >>> 24); + + destination[destOffset] = (byte) (outBuff >> 16); + destination[destOffset + 1] = (byte) (outBuff >> 8); + destination[destOffset + 2] = (byte) (outBuff); + return 3; + } + } // end decodeToBytes + + + /** + * Decodes data from Base64 notation. + * + * @param s the string to decode (decoded in default encoding) + * @return the decoded data + * @since 1.4 + */ + public static byte[] decode(String s) throws Base64DecoderException { + byte[] bytes = s.getBytes(); + return decode(bytes, 0, bytes.length); + } + + /** + * Decodes data from web safe Base64 notation. + * Web safe encoding uses '-' instead of '+', '_' instead of '/' + * + * @param s the string to decode (decoded in default encoding) + * @return the decoded data + */ + public static byte[] decodeWebSafe(String s) throws Base64DecoderException { + byte[] bytes = s.getBytes(); + return decodeWebSafe(bytes, 0, bytes.length); + } + + /** + * Decodes Base64 content in byte array format and returns + * the decoded byte array. + * + * @param source The Base64 encoded data + * @return decoded data + * @since 1.3 + * @throws Base64DecoderException + */ + public static byte[] decode(byte[] source) throws Base64DecoderException { + return decode(source, 0, source.length); + } + + /** + * Decodes web safe Base64 content in byte array format and returns + * the decoded data. + * Web safe encoding uses '-' instead of '+', '_' instead of '/' + * + * @param source the string to decode (decoded in default encoding) + * @return the decoded data + */ + public static byte[] decodeWebSafe(byte[] source) + throws Base64DecoderException { + return decodeWebSafe(source, 0, source.length); + } + + /** + * Decodes Base64 content in byte array format and returns + * the decoded byte array. + * + * @param source The Base64 encoded data + * @param off The offset of where to begin decoding + * @param len The length of characters to decode + * @return decoded data + * @since 1.3 + * @throws Base64DecoderException + */ + public static byte[] decode(byte[] source, int off, int len) + throws Base64DecoderException { + return decode(source, off, len, DECODABET); + } + + /** + * Decodes web safe Base64 content in byte array format and returns + * the decoded byte array. + * Web safe encoding uses '-' instead of '+', '_' instead of '/' + * + * @param source The Base64 encoded data + * @param off The offset of where to begin decoding + * @param len The length of characters to decode + * @return decoded data + */ + public static byte[] decodeWebSafe(byte[] source, int off, int len) + throws Base64DecoderException { + return decode(source, off, len, WEBSAFE_DECODABET); + } + + /** + * Decodes Base64 content using the supplied decodabet and returns + * the decoded byte array. + * + * @param source The Base64 encoded data + * @param off The offset of where to begin decoding + * @param len The length of characters to decode + * @param decodabet the decodabet for decoding Base64 content + * @return decoded data + */ + public static byte[] decode(byte[] source, int off, int len, byte[] decodabet) + throws Base64DecoderException { + int len34 = len * 3 / 4; + byte[] outBuff = new byte[2 + len34]; // Upper limit on size of output + int outBuffPosn = 0; + + byte[] b4 = new byte[4]; + int b4Posn = 0; + int i = 0; + byte sbiCrop = 0; + byte sbiDecode = 0; + for (i = 0; i < len; i++) { + sbiCrop = (byte) (source[i + off] & 0x7f); // Only the low seven bits + sbiDecode = decodabet[sbiCrop]; + + if (sbiDecode >= WHITE_SPACE_ENC) { // White space Equals sign or better + if (sbiDecode >= EQUALS_SIGN_ENC) { + // An equals sign (for padding) must not occur at position 0 or 1 + // and must be the last byte[s] in the encoded value + if (sbiCrop == EQUALS_SIGN) { + int bytesLeft = len - i; + byte lastByte = (byte) (source[len - 1 + off] & 0x7f); + if (b4Posn == 0 || b4Posn == 1) { + throw new Base64DecoderException( + "invalid padding byte '=' at byte offset " + i); + } else if ((b4Posn == 3 && bytesLeft > 2) + || (b4Posn == 4 && bytesLeft > 1)) { + throw new Base64DecoderException( + "padding byte '=' falsely signals end of encoded value " + + "at offset " + i); + } else if (lastByte != EQUALS_SIGN && lastByte != NEW_LINE) { + throw new Base64DecoderException( + "encoded value has invalid trailing byte"); + } + break; + } + + b4[b4Posn++] = sbiCrop; + if (b4Posn == 4) { + outBuffPosn += decode4to3(b4, 0, outBuff, outBuffPosn, decodabet); + b4Posn = 0; + } + } + } else { + throw new Base64DecoderException("Bad Base64 input character at " + i + + ": " + source[i + off] + "(decimal)"); + } + } + + // Because web safe encoding allows non padding base64 encodes, we + // need to pad the rest of the b4 buffer with equal signs when + // b4Posn != 0. There can be at most 2 equal signs at the end of + // four characters, so the b4 buffer must have two or three + // characters. This also catches the case where the input is + // padded with EQUALS_SIGN + if (b4Posn != 0) { + if (b4Posn == 1) { + throw new Base64DecoderException("single trailing character at offset " + + (len - 1)); + } + b4[b4Posn++] = EQUALS_SIGN; + outBuffPosn += decode4to3(b4, 0, outBuff, outBuffPosn, decodabet); + } + + byte[] out = new byte[outBuffPosn]; + System.arraycopy(outBuff, 0, out, 0, outBuffPosn); + return out; + } +} diff --git a/resources/html5app/_android/lib/com/google/android/vending/licensing/util/Base64DecoderException.java b/resources/html5app/_android/lib/com/google/android/vending/licensing/util/Base64DecoderException.java new file mode 100644 index 000000000..1aef1b54b --- /dev/null +++ b/resources/html5app/_android/lib/com/google/android/vending/licensing/util/Base64DecoderException.java @@ -0,0 +1,32 @@ +// Copyright 2002, Google, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package com.google.android.vending.licensing.util; + +/** + * Exception thrown when encountering an invalid Base64 input character. + * + * @author nelson + */ +public class Base64DecoderException extends Exception { + public Base64DecoderException() { + super(); + } + + public Base64DecoderException(String s) { + super(s); + } + + private static final long serialVersionUID = 1L; +} diff --git a/resources/html5app/_android/release-signing.properties b/resources/html5app/_android/release-signing.properties new file mode 100644 index 000000000..f245a0299 --- /dev/null +++ b/resources/html5app/_android/release-signing.properties @@ -0,0 +1,5 @@ +storeFile=H:/Works/cles/Certificats/Android/Google_Play_Cubedesigners +storeType=jks +keyAlias=mainkey +keyPassword=atacama +storePassword=atacama \ No newline at end of file diff --git a/resources/html5app/_android/res/drawable-hdpi/notify_panel_notification_icon_bg.png b/resources/html5app/_android/res/drawable-hdpi/notify_panel_notification_icon_bg.png new file mode 100644 index 000000000..f5b762ecf Binary files /dev/null and b/resources/html5app/_android/res/drawable-hdpi/notify_panel_notification_icon_bg.png differ diff --git a/resources/html5app/_android/res/drawable-mdpi/notify_panel_notification_icon_bg.png b/resources/html5app/_android/res/drawable-mdpi/notify_panel_notification_icon_bg.png new file mode 100644 index 000000000..9ecb8af06 Binary files /dev/null and b/resources/html5app/_android/res/drawable-mdpi/notify_panel_notification_icon_bg.png differ diff --git a/resources/html5app/_android/res/layout/status_bar_ongoing_event_progress_bar.xml b/resources/html5app/_android/res/layout/status_bar_ongoing_event_progress_bar.xml new file mode 100644 index 000000000..23bac0229 --- /dev/null +++ b/resources/html5app/_android/res/layout/status_bar_ongoing_event_progress_bar.xml @@ -0,0 +1,104 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/resources/html5app/_android/res/values-v11/styles.xml b/resources/html5app/_android/res/values-v11/styles.xml new file mode 100644 index 000000000..f2013bc0b --- /dev/null +++ b/resources/html5app/_android/res/values-v11/styles.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/resources/html5app/_android/res/values-v9/styles.xml b/resources/html5app/_android/res/values-v9/styles.xml new file mode 100644 index 000000000..736e77a5d --- /dev/null +++ b/resources/html5app/_android/res/values-v9/styles.xml @@ -0,0 +1,5 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/resources/html5app/css/app.css b/resources/html5app/css/app.css new file mode 100644 index 000000000..6f9a9bdd4 --- /dev/null +++ b/resources/html5app/css/app.css @@ -0,0 +1,247 @@ +html, body { + min-height: 100%; +} + +* { + margin: 0; + padding: 0; + -webkit-user-select: none !important; + -webkit-touch-callout: none !important; +} + +a { + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); +} + +body { + background-size: 100% 100%; + background-repeat: no-repeat; + font-family: Arial, Helvetica, sans-serif; +} + +.publication { + color: #666; + display: inline-block; + text-align: center; + -moz-box-sizing: border-box; + -webkit-box-sizing: border-box; + -ms-box-sizing: border-box; + -o-box-sizing: border-box; + box-sizing: border-box; + text-decoration: none; + font-weight: bold; + position: relative; +} + +.publication a { + color: #666; + text-decoration: none; +} + +.offline .publication a img { + -webkit-filter: grayscale(1); +} + +.offline .publication a.offline img { + -webkit-filter: grayscale(0); +} + +.publication img { + position: absolute; + left: 0; + bottom: 0; + display: block; + width: 100%; + z-index: 4; +} + +.publication .label { + display: block; + position: absolute; + left: 0; + z-index: 4; + text-decoration: none; +} + +.publication.offline .label { + color: #00ff33; +} + +.publication .shade { + background-image: url("../images/shade.png"); + position: absolute; + background-size: 100% 100%; +} + +#loader { + top: 0; + left: 0; + width: 100%; + height: 100%; + z-index: 1000000; +} + +#coquillette { + position: fixed; + z-index: 1000000; +} + +#shelves { + background-size: 100% auto; + top: -3.4rem; + position: relative; +} + +#bar { + position: absolute; + top: 0; + left: 0; + z-index: 10; + width: 100%; + box-sizing: border-box; + text-align: center; + height: 4.5rem; +} + +#bar, .mview .caption { + padding: 1rem 2rem; + font-size: 2rem; +} + +#bar h1 { + font-size: 100%; + display: inline-block; + text-shadow: 0 -0.1rem rgba(0, 0, 0, 0.35); +} + +#bar, #shelves { + opacity: 0; +} + +#settings { + display: block; + background-image: url("../images/settings.png"); + background-size: 2.5rem 2.45rem; + background-position: 50% 50%; + background-repeat: no-repeat; + float: right; + width: 2.5rem; + height: 2.45rem; + padding: 1rem; + position: relative; + top: -1rem; + left: 1rem; +} + +#view { + min-height: 100%; +} + +#view .caption { + width: 100%; + box-sizing: border-box; + text-align: center; +} + +#view .caption h2 { + font-size: 100%; + display: inline-block; + text-shadow: 0 -0.1rem rgba(0, 0, 0, 0.35); +} + +#view .mview { + top: 0; + left: 0; + z-index: 20; + width: 100%; + min-height: 100%; + position: absolute; +} + +.content.about { + padding: 1.8rem; + font-size: 2rem; + text-shadow: 0 0.1rem rgba(0, 0, 0, 0.25); +} + +.content.about p { + margin: 1rem 0; +} + +#view .mview li a, #view .mview li span { + display: block; + text-decoration: none; + font-size: 2rem; + padding: 1.8rem; + text-shadow: 0 -0.1rem rgba(0, 0, 0, 0.25); + font-weight: bold; + position: relative; +} + +#languagesList, #pushEnabled { + opacity: 0; + top: 0; + left: 0; + width: 100%; + height: 100%; + position: absolute; +} + +#corner { + position: absolute; + top: 0px; + right: 0px; + width: 100px; + height: 100px; + z-index: 11; + display: block; +} + +.mview .caption a.back { + background-image: url("../images/interface-back-arrow.svg"); + background-size: auto 1.7rem; + left: 1.2rem; + padding: 0 1.3rem 0 2.7rem; + position: absolute; + top: .9rem; + text-decoration: none; +} + +.mview .caption a { + border: 0.1rem solid rgba(5, 102, 178, 0.6); +} + +.mview .caption a { + background-size: auto 1.7rem; + padding: 0 1.3rem 0 3.3rem; +} + +.mview .caption a { + background-position: 1rem .4rem; + background-repeat: no-repeat; + border-radius: .5rem; + box-shadow: .1rem .1rem 0 rgba(255, 255, 255, 0.3) inset; + display: block; + font-size: 1.6rem; + font-weight: 600; + height: 2.7rem; + line-height: 2.5rem; +} + +#ad { + width: 100%; + position: relative; + text-align: center; +} + +#ad img { + display: block; + width: 100%; + position: absolute; + left: 0; + bottom: 0; +} + +#htmlalt { + transition: opacity 1s; +} \ No newline at end of file diff --git a/resources/html5app/images/settings.png b/resources/html5app/images/settings.png new file mode 100644 index 000000000..01ac705ea Binary files /dev/null and b/resources/html5app/images/settings.png differ diff --git a/resources/html5app/images/shade.png b/resources/html5app/images/shade.png new file mode 100644 index 000000000..a5e8e483b Binary files /dev/null and b/resources/html5app/images/shade.png differ diff --git a/resources/html5app/index.html b/resources/html5app/index.html new file mode 100644 index 000000000..8be9afe2a --- /dev/null +++ b/resources/html5app/index.html @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/resources/html5app/js/app.js b/resources/html5app/js/app.js new file mode 100644 index 000000000..2b68db5a8 --- /dev/null +++ b/resources/html5app/js/app.js @@ -0,0 +1,1069 @@ +var READY_BEFORE_JQUERY = false; +var JQUERY_READY = false; +var HANDLE_ORIENTATION = true; + +document.addEventListener("deviceready", _onDeviceReady, false); + +function _onDeviceReady() { + console.log('_device ready'); + if (JQUERY_READY) { + onDeviceReady(); + } else { + READY_BEFORE_JQUERY = true; + } +} + +var COLLECTION; +var WAIT_CONNECTION_BEFORE_LOADING = false; +var PLATFORM; +var LOCALE = ''; +var ONLINE; +var GAL; +var COQUILLETTE; +var UPDATING = false; +var GET = parseGet(); +var RESOLUTION = 150; +var FSPREFIX = ''; +var NOTIFICATIONS = true; +var IAB = null; +var PUBLICATIONS = []; +var OFFLINEAPP = false; +var READY = false; +var PERLINE = 3; + +function init() { + console.log('init'); + try { + if (COLLECTION === null) { + navigator.notification.alert(__('To complete the installation of the application, an internet connection is required for the first launch'), function () { + }, __('An internet connection is required'), 'Ok'); + WAIT_CONNECTION_BEFORE_LOADING = true; + } else { + WAIT_CONNECTION_BEFORE_LOADING = false; + start(); + } + } catch (err) { + console.error(err); + } +} + +function createGAL(m) { + if (OFFLINEAPP) { + return; + } + console.log('create gal'); + var res; + if (m == undefined) { + checkCollection(); + m = COLLECTION.manifest; + } + if (PLATFORM == 'android') { + FSPREFIX = 'Android/data/' + COLLECTION.ns; + } else if (PLATFORM = 'ios') { + FSPREFIX = ''; + } + window.localStorage.setItem('galfsprefix', FSPREFIX); + try { + res = new GameAssetLoader(m, FSPREFIX); + window.localStorage.setItem('topmanifest', JSON.stringify(m)); + } catch (err) { + console.error('failed to create gal'); + } + + return res; +} + +function checkCollection() { + console.log('check collection'); + if (COLLECTION == null) { + COLLECTION = getCurrentCollection(); + } +} + +function setCollection(data) { + console.log('set collection'); + try { + COLLECTION = data; + if (data) { + window.localStorage.setItem('collection', JSON.stringify(data)); + } + PERLINE = parseInt(data.settings.perline); + checkLanguage(); + updateBar(); + + } catch (err) { + console.error(err); + } +} + +function initDatas(data, cb, basic) { + console.log('init datas'); + if (basic === undefined) { + basic = false; + } + + if (!basic && (cb == undefined || cb == null)) { + cb = init; + } + + + setCollection(data, basic); + if (OFFLINEAPP) { + if (cb) { + cb(); + } + } else { + clearOfflineFlags(); + GAL = createGAL(); + GAL.clear(cb); + } +} + +function clearCache(cb) { + console.log('clear cache'); + initDatas(COLLECTION, cb); +} + +function initDatasAndPutOffline(data) { + UPDATING = true; + + var offlines = getOfflinePublications(); + initDatas(data, function () { + preStart(); + init(); + putOffline(data, offlines, function () { + + }); + }); +} + +function putOffline(data, offlines, cb) { + if (offlines.length == 0) { + cb(); + return; + } + + var id = offlines.shift(); + var g = createGAL(data.manifestPub[id]); + g.init(function () { + g.onLoaded('extras', function () { + window.localStorage.setItem('offline.' + id, '1'); + putOffline(data, offlines, cb); + }); + }); +} + +function onDeviceReady() { + console.log('device ready'); + if (window.device === undefined) { + + setTimeout(function () { + onDeviceReady(); + }, 2500); + return; + } + + if (READY) { + return; + } + displayLoader(); + READY = true; + console.log('ready'); + ONLINE = navigator.onLine; + OFFLINEAPP = DATAS.offline; + if (DATAS.htmlAlt == undefined || DATAS.htmlAlt == null) { + DATAS.htmlAlt = ''; + } + window.localStorage.setItem('offlineapp', OFFLINEAPP ? '1' : '0'); + + var cordovaPath; + var location = window.location.href.split('/'); + location.pop(); + cordovaPath = location.join('/') + '/cordova.js'; + + window.localStorage.setItem('cordova', cordovaPath); + + console.log(cordovaPath); + + if (window.device == undefined || window.device.platform === null) { + PLATFORM = 'android'; + } else { + PLATFORM = window.device.platform.toString().toLowerCase(); + } + document.addEventListener("online", onDeviceOnline, false); + document.addEventListener("offline", onDeviceOffline, false); + findLanguage(function () { + loadCollection(); + }); + + $(document).on('click', '[data-fluidbook]', function () { + var id = $(this).data('fluidbook'); + console.log('tap'); + displayLoader(); + setTimeout(function () { + loadAndGoto(id, function () { + }); + }, 100); + + return false; + }); + $(document).on('click', 'a[target="_blank"]', function () { + displayLoader(); + cordova.InAppBrowser.open($(this).attr('href'), '_blank', 'location=no'); + setTimeout(function () { + hideLoader(); + }, 3000) + return false; + }); + + $(document).on('click', '.iab', function () { + var target = $(this).attr('target') || $(this).data('target'); + if (!target) { + target = "_blank"; + } + var href = $(this).attr('href') || $(this).data('href'); + displayLoader(); + cordova.InAppBrowser.open(href, target, 'location=no'); + setTimeout(function () { + hideLoader(); + }, 3000) + return false; + }); + + $(window).on('orientationchange', orientationchange); +} + +function findLanguage(callback) { + console.log('find language'); + // Locale is already set in storage + l = window.localStorage.getItem('locale'); + if (l) { + languageFound(l, callback); + return; + } + + if (GET.lang == undefined) { + // If not defined in url try to guess with device prefered language + navigator.globalization.getPreferredLanguage(function (locale) { + languageFound(locale.value, callback); + }, function () { + languageFound(null, callback); + }); + } else { + // If not, check if it is in the url + languageFound(GET.lang, callback); + } +} + +function languageFound(l, callback) { + console.log('language found ' + l); + + l = l.replace(/\-/g, '_'); + if (COLLECTION === undefined) { + loadCollection(true); + } + if (COLLECTION.langs.indexOf(l) === -1) { + var e = l.split('_'); + var lang = e[0]; + var found = ''; + $.each(COLLECTION.langs, function (k, v) { + var ee = v.split('_'); + if (ee[0] === lang) { + found = v; + return true; + } + }); + + if (found !== '') { + LOCALE = found; + } else { + LOCALE = COLLECTION.langs[0]; + } + } else { + LOCALE = l; + } + console.log('Language selected ' + l) + if (callback) { + callback(); + } +} + +function updateLocale(l) { + console.log('update locale'); + window.localStorage.setItem('locale', l); + LOCALE = l; + updateContents(); + refreshSettings(); +} + +function refreshSettings() { + console.log('refresh settings'); + closeView(undefined, 0); + openSettings(0); +} + +function displayLoader() { + console.log('display loader'); + initLoader(); + COQUILLETTE.show(); + $("#loader").show(); + resizeLoader(); +} + +function initLoader() { + console.log('init loader'); + if ($("#loader").length == 0) { + $("body").append('

'); + } + if (COQUILLETTE == null) { + COQUILLETTE = new Coquillette({back: DATAS.couleurA, front: DATAS.couleurB}); + COQUILLETTE.init(); + } +} + +function hideLoader() { + console.log('hide loader'); + initLoader(); + $("#loader").fadeOut(500); + + COQUILLETTE.hide(); +} + +function onAppResume() { + console.log('app resume'); + if (UPDATING) { + return; + } + loadCollection(); +} + +function loadCollection(basic) { + if (basic === undefined) { + basic = false; + } + console.log('load collection'); + if (OFFLINEAPP) { + console.log('offline app'); + window.localStorage.setItem('apphome', window.location); + initDatas(DATAS.collection, null, basic); + return; + } + + if (!ONLINE) { + noNetworkOnInit(); + return; + } + if (OFFLINEAPP) { + RESOLUTION = 150; + } else { + RESOLUTION = Modernizr.mq('(-webkit-min-device-pixel-ratio: 2)') ? 300 : 150; + } + + if (basic) { + return; + } + + displayLoader(); + + var currentCollection = getCurrentCollection(); + + var params = DATAS.id; + params += "/" + PLATFORM; + params += '/' + RESOLUTION; + if (currentCollection !== null) { + params += "/" + currentCollection.time; + } else { + params += '/0'; + } + params += '/' + DATAS.appver; + + var url = 'http://workshop.fluidbook.com/services/collection/' + params; + + + $.ajax({ + url: url, + dataType: 'json', + cache: false, + success: function (data) { + if (data === false && currentCollection != null) { + COLLECTION = currentCollection; + init(); + } else { + if (currentCollection !== null) { + updateDatas(data); + } else { + initDatas(data); + } + } + }, + error: function (error) { + noNetworkOnInit(); + } + }); +} + +function onDeviceOnline() { + ONLINE = true; + if (WAIT_CONNECTION_BEFORE_LOADING) { + WAIT_CONNECTION_BEFORE_LOADING = false; + loadCollection(); + } + $('html').addClass('online').removeClass('offline'); +} + +function onDeviceOffline() { + ONLINE = false; + $('html').addClass('offline').removeClass('online'); +} + +function noNetworkOnInit() { + COLLECTION = getCurrentCollection(); + init(); +} + +function getCurrentCollection() { + console.log('get current collection'); + var c = window.localStorage.getItem('collection'); + window.localStorage.setItem('apphome', window.location); + + var res; + if (c !== null) { + try { + res = JSON.parse(c); + } catch (err) { + res = null; + } + } else { + res = null; + } + return res; +} + +function updateDatas(data) { + console.log('update data'); + if (data.forceUpdate) { + initDatasAndPutOffline(data); + return; + } + + var callback = function (buttonIndex) { + try { + if (buttonIndex == 2) { + // Cancel + init(); + } else if (buttonIndex == 1) { + // OK + initDatasAndPutOffline(data); + } + } catch (err) { + console.error(err); + } + }; + + navigator.notification.confirm(__('Do you want to update contents ? Publications available offline will be updated too.'), callback, __('An update is available'), [__('Ok'), __('Later')]); +} + +function start() { + console.log('start'); + if (OFFLINEAPP) { + loaderInited(); + return; + } + try { + GAL = createGAL(); + GAL.init(function () { + loaderInited(); + }); + + } catch (err) { + console.error(err); + } +} + +function loaderInited() { + console.log('loader inited'); + checkLanguage(); + updateContents(); + preStart(); +} + +function preloadDisplayed() { + console.log('preload displayed'); + if (OFFLINEAPP) { + return; + } + + for (var i in PUBLICATIONS) { + preloadPublication(PUBLICATIONS[i]); + } +} + +function preStart() { + console.log('prestart'); + if (PUBLICATIONS.length == 0 && DATAS.htmlAlt == '') { + return; + } + if (PUBLICATIONS.length == 1 && DATAS.htmlAlt == '') { + console.log("only one publication, let's redirect to it"); + setTimeout(function () { + loadAndGoto(PUBLICATIONS[0], function () { + }); + }, 100); + } +} + +function updateContents() { + console.log('update contents'); + + updateBar(); + updateShelves(); + + if (DATAS.htmlAlt != '') { + $("#bar,#shelves").hide(); + if ($('#htmlalt').length == 0) { + $('body').prepend('
'); + $("#htmlalt").html(DATAS.htmlAlt); + $("#htmlalt").css('opacity', 1); + $(document).trigger('fluidbookappinitalt'); + } + } else { + console.log('no html alt'); + $("#bar,#shelves").show().css('opacity', 1); + } +} + +function updateBar() { + if (DATAS.htmlAlt !== '') { + return; + } + if ($("#bar").length == 0) { + $("body").append('

'); + } + console.log('update bar'); + $("#bar h1").text(COLLECTION.contents[LOCALE].titre); +} + +function checkLanguage() { + console.log('check language'); + try { + if (COLLECTION.langs.indexOf(LOCALE) == -1) { + LOCALE = COLLECTION.langs[0]; + } + } catch (err) { + LOCALE = 'fr'; + } + + window.localStorage.setItem('locale', LOCALE); +} + +function userStart() { + console.log('user start'); + navigator.splashscreen.hide(); +} + +function getPublicationsFlat() { + console.log('get pub flat'); + var res = []; + checkCollection(); + for (var i in COLLECTION.datas) { + for (var j in COLLECTION.datas[i].publications) { + var p = COLLECTION.datas[i].publications[j]; + res.push(p); + } + } + return res; +} + +function getPublicationsId() { + console.log('get publications id'); + var res = []; + checkCollection(); + if (COLLECTION == null) { + return res; + } + for (var i in COLLECTION.datas) { + for (var j in COLLECTION.datas[i].publications) { + var p = COLLECTION.datas[i].publications[j]; + res.push(p.id); + } + } + return res; + +} + +function getLangsPublications() { + console.log('get langs publications'); + var publications = getPublicationsFlat(); + var res = {}; + for (var i in publications) { + var p = publications[i]; + if (p.completelang === undefined) { + continue; + } + if (res[p.completelang] == undefined) { + res[p.completelang] = []; + } + res[p.completelang].push(p.id); + } + return res; +} + +function clearOfflineFlags() { + console.log('clear offline flags'); + var ids = getPublicationsId(); + for (var i in ids) { + var id = ids[i]; + window.localStorage.setItem('offline.' + id, '0'); + } +} + +function updateShelves() { + console.log('update shelves'); + if (PUBLICATIONS.length == 0) { + console.log('not publications in shelves'); + } + + UPDATING = false; + + window.localStorage.removeItem('home'); + window.localStorage.removeItem('locales'); + + $("#shelves").remove(); + $("body").append('
'); + + for (var i in COLLECTION.datas) { + for (var j in COLLECTION.datas[i].publications) { + var p = COLLECTION.datas[i].publications[j]; + if (p.label == '|') { + addSeparator(); + } + if (p.completelang !== LOCALE) { + continue; + } + + addPublication(p); + } + } + + if (COLLECTION.contents[LOCALE].ad != undefined && COLLECTION.contents[LOCALE].ad) { + addAd(COLLECTION.contents[LOCALE].ad, COLLECTION.contents[LOCALE].adlink); + } + + if (PUBLICATIONS.length === 1 && DATAS.htmlAlt == '') { + window.localStorage.setItem('home', '0'); + if (COLLECTION.langs.length > 1) { + window.localStorage.setItem('locales', JSON.stringify(getLangsPublications())); + } + preStart(); + } else { + window.localStorage.setItem('home', '1'); + } + + + resize(); + hideLoader(); + setTimeout(function () { + userStart(); + }, 3000); + preloadDisplayed(); +} + +function addAd(image, url) { + console.log('add ad'); + var ad = ''; + if (url != undefined && url) { + ad = '' + ad + ''; + } + ad = ''; + $("#pubcontainer").append(ad); +} + +function addPublication(p) { + console.log('add publication ' + p.id); + PUBLICATIONS.push(p.id); + var publication = '
' + p.label.replace('|', '
') + '
'; + $("#pubcontainer").append(publication); + var offlineKey = 'offline.' + p.id; + + if (window.localStorage.getItem(offlineKey) === '1') { + $("#pubcontainer .publication a[data-id='" + p.id + "']").addClass('offline'); + } else { + window.localStorage.setItem(offlineKey, '0'); + } +} + +function addSeparator() { + console.log('add separator'); + $("#pubcontainer").append('
'); +} + +function getOfflinePublications() { + console.log('get offline pubs'); + var res = []; + var ids = getPublicationsId(); + if (OFFLINEAPP) { + return ids; + } + for (var i in ids) { + var id = ids[i]; + if (window.localStorage.getItem('offline.' + id) == '1') { + //res.push(id); + } + } + return res; +} + +function __(str) { + var res; + try { + res = COLLECTION.traductions[LOCALE][str]; + } catch (err) { + + } + + if (!res) { + return str; + } + return res; +} + +function resize() { + console.log('resize'); + var ww = $(window).width(); + var wh = $(window).height(); + if (DATAS.htmlAlt != '') { + $("#shelves,#bar,#view").hide().remove(); + } + + if ($("#shelves").length > 0) { + resizeShelves(ww, wh); + } + + + if (PUBLICATIONS.length <= 1 && DATAS.htmlAlt == '') { + $("#shelves").hide(); + $('body').hide(); + } else { + if (DATAS.htmlAlt == '') { + $("#shelves").show(); + $(".mview").css('min-height', wh); + } + $('body').show(); + } + + resizeLoader(ww, wh); +} + +function resizeLoader(ww, wh) { + console.log('resize loader'); + if (COQUILLETTE) { + COQUILLETTE.resize(ww, wh); + } +} + +function resizeShelves(ww, wh) { + console.log('resize shelves'); + + if (DATAS.htmlAlt != '') { + return; + } + + var piw = 249; + var sh = 776; + + var pw = (1536 - 20) / PERLINE; + + var s = ww / 1536; + + $("#shelves").show(); + + $("html").css('fontSize', (20 * s) + 'px'); + + $(".publication").css({ + fontSize: 30 * s, + width: pw * s, + height: sh * s, + textAlign: 'center', + }); + + $("#ad").css({ + width: 1536 * s, + height: sh * s + }); + + $("#pubcontainer").css({ + paddingTop: 52 * s + }); + + $(".publication img").css({ + width: piw * s, + left: s * (pw - piw) / 2 + }); + + $(".publication").each(function () { + var shade = $(this).find('.shade'); + var label = $(this).find('.label'); + + var ow = parseFloat($(this).data('width')); + var oh = parseFloat($(this).data('height')); + var r = ow / oh; + var ch = (piw / r); + + var w = 328 * s; + var h = ((piw + 6) / r) * s; + var left = ((pw * s) - w) / 2; + var bottom = -((h - (ch * s)) / 2); + + $(shade).css({ + width: w, + height: h, + bottom: bottom, + left: left + }); + + bottom = (ch + 20) * s; + + $(label).css({ + bottom: bottom, + width: (pw + 30) * s, + left: -15 * s + }); + }); + + var lines = Math.ceil($(".publication").length / PERLINE); + if ($("#ad").length == 1) { + lines++; + } + + $("#shelves").css({ + minHeight: ((lines + 0.8) * sh) * s + }); +} + +function gotoPublication(id) { + console.log('goto publication ' + id); + if (OFFLINEAPP) { + url = 'publications/' + id + '/index.html'; + } else { + url = GAL.getRootNativeURL() + '/' + id + '/index.html'; + } + + displayLoader(); + $("#htmlalt").css('opacity', 0); + setTimeout(function () { + window.location = url; + }, 100); + + setTimeout(function () { + hideLoader(); + }, 10000); +} + +function openSettings() { + console.log('open settings'); + var view = createView(__('Settings')); + + var settings = '
    '; + if (COLLECTION.contents[LOCALE].apropos != '') { + settings += '
  • ' + __('About') + '
    • '; + } + if (!OFFLINEAPP) { + settings += '
  • ' + __('Clear offline cache') + '
    • '; + } + if (COLLECTION.langs.length > 1) { + settings += '
  • ' + __('Languages'); + settings += '' + settings += '
    • '; + } + if (PLATFORM == 'android') { + var s0, s1; + if (NOTIFICATIONS) { + s1 = ' selected="selected"'; + s0 = ''; + } else { + s0 = ' selected="selected"'; + s1 = ''; + } + settings += '
  • ' + __('Notifications') + '
    • '; + } + settings += '
'; + + $(view).find('.content').append(settings); + resize(); +} + +function openAbout() { + console.log('open about'); + var view = createView(__('About'), 'about'); + $(view).find('.content').append(COLLECTION.contents[LOCALE].apropos); + $(view).find('.content a').click(function () { + window.open($(this).attr('href'), '_blank'); + return false; + }); +} + +function createView(titre, contentClass) { + console.log('create view ' + titre); + if (contentClass == undefined) { + contentClass = ""; + } + if ($("#view").length == '0') { + $('body').append('
'); + } + var mview = $('
' + __('Back') + '

' + titre + '

'); + $("#view").append(mview); + return mview; +} + +function closeView(view) { + console.log('close view'); + if (view == undefined) { + view = $(".mview:last()"); + } + + $(view).remove(); + hideLoader(); +} + + +$(function () { + console.log('jquery ready'); + $(window).on('resize', resize); + + document.addEventListener("resume", onAppResume, false); + JQUERY_READY = true; + + window.onerror = function (msg, url, line) { + console.log(url + ':' + line + ' :: ' + msg, 'error'); + }; + + $('#settings,#corner').on('click', function () { + openSettings(); + return false; + }); + + $(document).on('click', '#about', function () { + openAbout(); + return false; + }); + + $(document).on('click', '.mview .back', function () { + closeView($(this).parents('.mview')); + return false; + }); + + $(document).on('change', '#languagesList', function () { + updateLocale($(this).val()); + return true; + }); + + $(document).on('click', '#clearcache', function () { + navigator.notification.confirm(__("You are about to empty the publications cache. You won't be able to read publications that are currently available offline without an internet connection."), function (button) { + if (button == 1) { + displayLoader(); + clearCache( + function () { + try { + GAL = createGAL(COLLECTION.manifest); + GAL.init(function () { + updateShelves(); + closeView(); + }); + } catch (err) { + console.error(err); + } + } + ); + + } + }, __('Clear offline cache'), [__('Ok'), __('Cancel')]); + return false; + }); + + $(document).on('click', '.publication a', function () { + if (!ONLINE && !$(this).hasClass('offline')) { + navigator.notification.alert(__('This publication is not available offline. To read it, an internet connection is required'), + function () { + + }, __('An internet connection is required')); + return false; + } + + loadAndGoto($(this).data('id')); + return false; + }); + + $(document).on('click', "#ad a", function () { + window.open($(this).attr('href'), '_blank'); + return false; + }); + + resize(); + + if (READY_BEFORE_JQUERY) { + onDeviceReady(); + } +}); + +function preloadPublication(id) { + console.log('preload publication ' + id); + if (OFFLINEAPP) { + return; + } + var b = 'p_' + id; + GAL.download(b); +} + +function loadAndGoto(id, callback) { + console.log('load and goto ' + id); + var cb = function () { + if (callback) { + callback(); + } + setTimeout(function () { + gotoPublication(id); + }, 100); + }; + + if (OFFLINEAPP) { + cb(); + } else { + if (window.localStorage.getItem('offline.' + id) == '1') { + cb(); + } else { + var b = 'p_' + id; + displayLoader(); + GAL.downloadAndCall(b, cb); + } + } +} + +function parseGet() { + console.log('parse get'); + var couples = window.location.search.substr(1).split('&'); + var res = new Array(); + var couple = new Array(); + for (var i = 0; i < couples.length; i++) { + couple = couples[i].split('='); + res[couple[0]] = couple[1]; + } + return res; +} + +function orientationchange() { + if (!HANDLE_ORIENTATION) { + return true; + } + console.log('orientation change'); + if (Modernizr.mq('screen and (orientation: portrait)')) { + $("[name='viewport']").attr("content", "width=1280"); + } else { + $("[name='viewport']").attr("content", "width=1536"); + } +} diff --git a/resources/html5app/js/coquillette.js b/resources/html5app/js/coquillette.js new file mode 100644 index 000000000..debe4ada1 --- /dev/null +++ b/resources/html5app/js/coquillette.js @@ -0,0 +1,67 @@ +function Coquillette(datas) { + this.datas = datas; + this.size = 120; + this.element = $("#coquillette"); + this.rotation = 0; + this.speed = 1; // 1/2 tours / sec + this.deg360 = Math.PI * 2; + this.init(); +} + +Coquillette.prototype = { + init: function() { + var $this = this; + this.element.append(''); + var canvas = this.element.find('canvas').get(0); + this.ctx = canvas.getContext('2d'); + return this; + }, + show: function() { + this.element.show(); + this.resume(); + return this; + }, + hide: function() { + this.element.hide(); + this.pause(); + return this; + }, + resume: function() { + var $this = this; + this.rotation = 0; + TweenMax.to(this, 1 / this.speed, {rotation: this.deg360, repeat: -1, ease: Linear.easeNone, onUpdate: $.proxy(this.step, this)}); + //TweenMax.to(this.element, 0, {z: -1}); + }, + step: function() { + var radius = this.size / 2; + + // Clear the whole canvas + this.ctx.clearRect(0, 0, this.size, this.size); + // Set the background + this.ctx.fillStyle = this.datas.back; + this.ctx.beginPath(); + this.ctx.arc(radius, radius, radius, 0, this.deg360, false); + this.ctx.closePath(); + this.ctx.fill(); + // Set stroke style + this.ctx.strokeStyle = this.datas.front; + this.ctx.lineWidth = Math.round(this.size * 0.13); + this.ctx.lineCap = 'round'; + this.ctx.lineJoin = 'mitter'; + this.ctx.beginPath(); + this.ctx.arc(radius, radius, radius * 0.65, this.rotation, this.rotation + Math.PI * 1.4, false); + + // Apply the stroke + this.ctx.stroke(); + }, + pause: function() { + TweenMax.killTweensOf(this); + }, + resize: function(ww, hh) { + this.element.css({ + left: (ww - this.size) / 2, + top: (hh - this.size) / 2 + }); + } +}; + diff --git a/resources/html5app/js/fastclick/fastclick.js b/resources/html5app/js/fastclick/fastclick.js new file mode 100644 index 000000000..3af4f9d6f --- /dev/null +++ b/resources/html5app/js/fastclick/fastclick.js @@ -0,0 +1,841 @@ +;(function () { + 'use strict'; + + /** + * @preserve FastClick: polyfill to remove click delays on browsers with touch UIs. + * + * @codingstandard ftlabs-jsv2 + * @copyright The Financial Times Limited [All Rights Reserved] + * @license MIT License (see LICENSE.txt) + */ + + /*jslint browser:true, node:true*/ + /*global define, Event, Node*/ + + + /** + * Instantiate fast-clicking listeners on the specified layer. + * + * @constructor + * @param {Element} layer The layer to listen on + * @param {Object} [options={}] The options to override the defaults + */ + function FastClick(layer, options) { + var oldOnClick; + + options = options || {}; + + /** + * Whether a click is currently being tracked. + * + * @type boolean + */ + this.trackingClick = false; + + + /** + * Timestamp for when click tracking started. + * + * @type number + */ + this.trackingClickStart = 0; + + + /** + * The element being tracked for a click. + * + * @type EventTarget + */ + this.targetElement = null; + + + /** + * X-coordinate of touch start event. + * + * @type number + */ + this.touchStartX = 0; + + + /** + * Y-coordinate of touch start event. + * + * @type number + */ + this.touchStartY = 0; + + + /** + * ID of the last touch, retrieved from Touch.identifier. + * + * @type number + */ + this.lastTouchIdentifier = 0; + + + /** + * Touchmove boundary, beyond which a click will be cancelled. + * + * @type number + */ + this.touchBoundary = options.touchBoundary || 10; + + + /** + * The FastClick layer. + * + * @type Element + */ + this.layer = layer; + + /** + * The minimum time between tap(touchstart and touchend) events + * + * @type number + */ + this.tapDelay = options.tapDelay || 200; + + /** + * The maximum time for a tap + * + * @type number + */ + this.tapTimeout = options.tapTimeout || 700; + + if (FastClick.notNeeded(layer)) { + return; + } + + // Some old versions of Android don't have Function.prototype.bind + function bind(method, context) { + return function() { return method.apply(context, arguments); }; + } + + + var methods = ['onMouse', 'onClick', 'onTouchStart', 'onTouchMove', 'onTouchEnd', 'onTouchCancel']; + var context = this; + for (var i = 0, l = methods.length; i < l; i++) { + context[methods[i]] = bind(context[methods[i]], context); + } + + // Set up event handlers as required + if (deviceIsAndroid) { + layer.addEventListener('mouseover', this.onMouse, true); + layer.addEventListener('mousedown', this.onMouse, true); + layer.addEventListener('mouseup', this.onMouse, true); + } + + layer.addEventListener('click', this.onClick, true); + layer.addEventListener('touchstart', this.onTouchStart, false); + layer.addEventListener('touchmove', this.onTouchMove, false); + layer.addEventListener('touchend', this.onTouchEnd, false); + layer.addEventListener('touchcancel', this.onTouchCancel, false); + + // Hack is required for browsers that don't support Event#stopImmediatePropagation (e.g. Android 2) + // which is how FastClick normally stops click events bubbling to callbacks registered on the FastClick + // layer when they are cancelled. + if (!Event.prototype.stopImmediatePropagation) { + layer.removeEventListener = function(type, callback, capture) { + var rmv = Node.prototype.removeEventListener; + if (type === 'click') { + rmv.call(layer, type, callback.hijacked || callback, capture); + } else { + rmv.call(layer, type, callback, capture); + } + }; + + layer.addEventListener = function(type, callback, capture) { + var adv = Node.prototype.addEventListener; + if (type === 'click') { + adv.call(layer, type, callback.hijacked || (callback.hijacked = function(event) { + if (!event.propagationStopped) { + callback(event); + } + }), capture); + } else { + adv.call(layer, type, callback, capture); + } + }; + } + + // If a handler is already declared in the element's onclick attribute, it will be fired before + // FastClick's onClick handler. Fix this by pulling out the user-defined handler function and + // adding it as listener. + if (typeof layer.onclick === 'function') { + + // Android browser on at least 3.2 requires a new reference to the function in layer.onclick + // - the old one won't work if passed to addEventListener directly. + oldOnClick = layer.onclick; + layer.addEventListener('click', function(event) { + oldOnClick(event); + }, false); + layer.onclick = null; + } + } + + /** + * Windows Phone 8.1 fakes user agent string to look like Android and iPhone. + * + * @type boolean + */ + var deviceIsWindowsPhone = navigator.userAgent.indexOf("Windows Phone") >= 0; + + /** + * Android requires exceptions. + * + * @type boolean + */ + var deviceIsAndroid = navigator.userAgent.indexOf('Android') > 0 && !deviceIsWindowsPhone; + + + /** + * iOS requires exceptions. + * + * @type boolean + */ + var deviceIsIOS = /iP(ad|hone|od)/.test(navigator.userAgent) && !deviceIsWindowsPhone; + + + /** + * iOS 4 requires an exception for select elements. + * + * @type boolean + */ + var deviceIsIOS4 = deviceIsIOS && (/OS 4_\d(_\d)?/).test(navigator.userAgent); + + + /** + * iOS 6.0-7.* requires the target element to be manually derived + * + * @type boolean + */ + var deviceIsIOSWithBadTarget = deviceIsIOS && (/OS [6-7]_\d/).test(navigator.userAgent); + + /** + * BlackBerry requires exceptions. + * + * @type boolean + */ + var deviceIsBlackBerry10 = navigator.userAgent.indexOf('BB10') > 0; + + /** + * Determine whether a given element requires a native click. + * + * @param {EventTarget|Element} target Target DOM element + * @returns {boolean} Returns true if the element needs a native click + */ + FastClick.prototype.needsClick = function(target) { + switch (target.nodeName.toLowerCase()) { + + // Don't send a synthetic click to disabled inputs (issue #62) + case 'button': + case 'select': + case 'textarea': + if (target.disabled) { + return true; + } + + break; + case 'input': + + // File inputs need real clicks on iOS 6 due to a browser bug (issue #68) + if ((deviceIsIOS && target.type === 'file') || target.disabled) { + return true; + } + + break; + case 'label': + case 'iframe': // iOS8 homescreen apps can prevent events bubbling into frames + case 'video': + return true; + } + + return (/\bneedsclick\b/).test(target.className); + }; + + + /** + * Determine whether a given element requires a call to focus to simulate click into element. + * + * @param {EventTarget|Element} target Target DOM element + * @returns {boolean} Returns true if the element requires a call to focus to simulate native click. + */ + FastClick.prototype.needsFocus = function(target) { + switch (target.nodeName.toLowerCase()) { + case 'textarea': + return true; + case 'select': + return !deviceIsAndroid; + case 'input': + switch (target.type) { + case 'button': + case 'checkbox': + case 'file': + case 'image': + case 'radio': + case 'submit': + return false; + } + + // No point in attempting to focus disabled inputs + return !target.disabled && !target.readOnly; + default: + return (/\bneedsfocus\b/).test(target.className); + } + }; + + + /** + * Send a click event to the specified element. + * + * @param {EventTarget|Element} targetElement + * @param {Event} event + */ + FastClick.prototype.sendClick = function(targetElement, event) { + var clickEvent, touch; + + // On some Android devices activeElement needs to be blurred otherwise the synthetic click will have no effect (#24) + if (document.activeElement && document.activeElement !== targetElement) { + document.activeElement.blur(); + } + + touch = event.changedTouches[0]; + + // Synthesise a click event, with an extra attribute so it can be tracked + clickEvent = document.createEvent('MouseEvents'); + clickEvent.initMouseEvent(this.determineEventType(targetElement), true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null); + clickEvent.forwardedTouchEvent = true; + targetElement.dispatchEvent(clickEvent); + }; + + FastClick.prototype.determineEventType = function(targetElement) { + + //Issue #159: Android Chrome Select Box does not open with a synthetic click event + if (deviceIsAndroid && targetElement.tagName.toLowerCase() === 'select') { + return 'mousedown'; + } + + return 'click'; + }; + + + /** + * @param {EventTarget|Element} targetElement + */ + FastClick.prototype.focus = function(targetElement) { + var length; + + // Issue #160: on iOS 7, some input elements (e.g. date datetime month) throw a vague TypeError on setSelectionRange. These elements don't have an integer value for the selectionStart and selectionEnd properties, but unfortunately that can't be used for detection because accessing the properties also throws a TypeError. Just check the type instead. Filed as Apple bug #15122724. + if (deviceIsIOS && targetElement.setSelectionRange && targetElement.type.indexOf('date') !== 0 && targetElement.type !== 'time' && targetElement.type !== 'month') { + length = targetElement.value.length; + targetElement.setSelectionRange(length, length); + } else { + targetElement.focus(); + } + }; + + + /** + * Check whether the given target element is a child of a scrollable layer and if so, set a flag on it. + * + * @param {EventTarget|Element} targetElement + */ + FastClick.prototype.updateScrollParent = function(targetElement) { + var scrollParent, parentElement; + + scrollParent = targetElement.fastClickScrollParent; + + // Attempt to discover whether the target element is contained within a scrollable layer. Re-check if the + // target element was moved to another parent. + if (!scrollParent || !scrollParent.contains(targetElement)) { + parentElement = targetElement; + do { + if (parentElement.scrollHeight > parentElement.offsetHeight) { + scrollParent = parentElement; + targetElement.fastClickScrollParent = parentElement; + break; + } + + parentElement = parentElement.parentElement; + } while (parentElement); + } + + // Always update the scroll top tracker if possible. + if (scrollParent) { + scrollParent.fastClickLastScrollTop = scrollParent.scrollTop; + } + }; + + + /** + * @param {EventTarget} targetElement + * @returns {Element|EventTarget} + */ + FastClick.prototype.getTargetElementFromEventTarget = function(eventTarget) { + + // On some older browsers (notably Safari on iOS 4.1 - see issue #56) the event target may be a text node. + if (eventTarget.nodeType === Node.TEXT_NODE) { + return eventTarget.parentNode; + } + + return eventTarget; + }; + + + /** + * On touch start, record the position and scroll offset. + * + * @param {Event} event + * @returns {boolean} + */ + FastClick.prototype.onTouchStart = function(event) { + var targetElement, touch, selection; + + // Ignore multiple touches, otherwise pinch-to-zoom is prevented if both fingers are on the FastClick element (issue #111). + if (event.targetTouches.length > 1) { + return true; + } + + targetElement = this.getTargetElementFromEventTarget(event.target); + touch = event.targetTouches[0]; + + if (deviceIsIOS) { + + // Only trusted events will deselect text on iOS (issue #49) + selection = window.getSelection(); + if (selection.rangeCount && !selection.isCollapsed) { + return true; + } + + if (!deviceIsIOS4) { + + // Weird things happen on iOS when an alert or confirm dialog is opened from a click event callback (issue #23): + // when the user next taps anywhere else on the page, new touchstart and touchend events are dispatched + // with the same identifier as the touch event that previously triggered the click that triggered the alert. + // Sadly, there is an issue on iOS 4 that causes some normal touch events to have the same identifier as an + // immediately preceeding touch event (issue #52), so this fix is unavailable on that platform. + // Issue 120: touch.identifier is 0 when Chrome dev tools 'Emulate touch events' is set with an iOS device UA string, + // which causes all touch events to be ignored. As this block only applies to iOS, and iOS identifiers are always long, + // random integers, it's safe to to continue if the identifier is 0 here. + if (touch.identifier && touch.identifier === this.lastTouchIdentifier) { + event.preventDefault(); + return false; + } + + this.lastTouchIdentifier = touch.identifier; + + // If the target element is a child of a scrollable layer (using -webkit-overflow-scrolling: touch) and: + // 1) the user does a fling scroll on the scrollable layer + // 2) the user stops the fling scroll with another tap + // then the event.target of the last 'touchend' event will be the element that was under the user's finger + // when the fling scroll was started, causing FastClick to send a click event to that layer - unless a check + // is made to ensure that a parent layer was not scrolled before sending a synthetic click (issue #42). + this.updateScrollParent(targetElement); + } + } + + this.trackingClick = true; + this.trackingClickStart = event.timeStamp; + this.targetElement = targetElement; + + this.touchStartX = touch.pageX; + this.touchStartY = touch.pageY; + + // Prevent phantom clicks on fast double-tap (issue #36) + if ((event.timeStamp - this.lastClickTime) < this.tapDelay) { + event.preventDefault(); + } + + return true; + }; + + + /** + * Based on a touchmove event object, check whether the touch has moved past a boundary since it started. + * + * @param {Event} event + * @returns {boolean} + */ + FastClick.prototype.touchHasMoved = function(event) { + var touch = event.changedTouches[0], boundary = this.touchBoundary; + + if (Math.abs(touch.pageX - this.touchStartX) > boundary || Math.abs(touch.pageY - this.touchStartY) > boundary) { + return true; + } + + return false; + }; + + + /** + * Update the last position. + * + * @param {Event} event + * @returns {boolean} + */ + FastClick.prototype.onTouchMove = function(event) { + if (!this.trackingClick) { + return true; + } + + // If the touch has moved, cancel the click tracking + if (this.targetElement !== this.getTargetElementFromEventTarget(event.target) || this.touchHasMoved(event)) { + this.trackingClick = false; + this.targetElement = null; + } + + return true; + }; + + + /** + * Attempt to find the labelled control for the given label element. + * + * @param {EventTarget|HTMLLabelElement} labelElement + * @returns {Element|null} + */ + FastClick.prototype.findControl = function(labelElement) { + + // Fast path for newer browsers supporting the HTML5 control attribute + if (labelElement.control !== undefined) { + return labelElement.control; + } + + // All browsers under test that support touch events also support the HTML5 htmlFor attribute + if (labelElement.htmlFor) { + return document.getElementById(labelElement.htmlFor); + } + + // If no for attribute exists, attempt to retrieve the first labellable descendant element + // the list of which is defined here: http://www.w3.org/TR/html5/forms.html#category-label + return labelElement.querySelector('button, input:not([type=hidden]), keygen, meter, output, progress, select, textarea'); + }; + + + /** + * On touch end, determine whether to send a click event at once. + * + * @param {Event} event + * @returns {boolean} + */ + FastClick.prototype.onTouchEnd = function(event) { + var forElement, trackingClickStart, targetTagName, scrollParent, touch, targetElement = this.targetElement; + + if (!this.trackingClick) { + return true; + } + + // Prevent phantom clicks on fast double-tap (issue #36) + if ((event.timeStamp - this.lastClickTime) < this.tapDelay) { + this.cancelNextClick = true; + return true; + } + + if ((event.timeStamp - this.trackingClickStart) > this.tapTimeout) { + return true; + } + + // Reset to prevent wrong click cancel on input (issue #156). + this.cancelNextClick = false; + + this.lastClickTime = event.timeStamp; + + trackingClickStart = this.trackingClickStart; + this.trackingClick = false; + this.trackingClickStart = 0; + + // On some iOS devices, the targetElement supplied with the event is invalid if the layer + // is performing a transition or scroll, and has to be re-detected manually. Note that + // for this to function correctly, it must be called *after* the event target is checked! + // See issue #57; also filed as rdar://13048589 . + if (deviceIsIOSWithBadTarget) { + touch = event.changedTouches[0]; + + // In certain cases arguments of elementFromPoint can be negative, so prevent setting targetElement to null + targetElement = document.elementFromPoint(touch.pageX - window.pageXOffset, touch.pageY - window.pageYOffset) || targetElement; + targetElement.fastClickScrollParent = this.targetElement.fastClickScrollParent; + } + + targetTagName = targetElement.tagName.toLowerCase(); + if (targetTagName === 'label') { + forElement = this.findControl(targetElement); + if (forElement) { + this.focus(targetElement); + if (deviceIsAndroid) { + return false; + } + + targetElement = forElement; + } + } else if (this.needsFocus(targetElement)) { + + // Case 1: If the touch started a while ago (best guess is 100ms based on tests for issue #36) then focus will be triggered anyway. Return early and unset the target element reference so that the subsequent click will be allowed through. + // Case 2: Without this exception for input elements tapped when the document is contained in an iframe, then any inputted text won't be visible even though the value attribute is updated as the user types (issue #37). + if ((event.timeStamp - trackingClickStart) > 100 || (deviceIsIOS && window.top !== window && targetTagName === 'input')) { + this.targetElement = null; + return false; + } + + this.focus(targetElement); + this.sendClick(targetElement, event); + + // Select elements need the event to go through on iOS 4, otherwise the selector menu won't open. + // Also this breaks opening selects when VoiceOver is active on iOS6, iOS7 (and possibly others) + if (!deviceIsIOS || targetTagName !== 'select') { + this.targetElement = null; + event.preventDefault(); + } + + return false; + } + + if (deviceIsIOS && !deviceIsIOS4) { + + // Don't send a synthetic click event if the target element is contained within a parent layer that was scrolled + // and this tap is being used to stop the scrolling (usually initiated by a fling - issue #42). + scrollParent = targetElement.fastClickScrollParent; + if (scrollParent && scrollParent.fastClickLastScrollTop !== scrollParent.scrollTop) { + return true; + } + } + + // Prevent the actual click from going though - unless the target node is marked as requiring + // real clicks or if it is in the whitelist in which case only non-programmatic clicks are permitted. + if (!this.needsClick(targetElement)) { + event.preventDefault(); + this.sendClick(targetElement, event); + } + + return false; + }; + + + /** + * On touch cancel, stop tracking the click. + * + * @returns {void} + */ + FastClick.prototype.onTouchCancel = function() { + this.trackingClick = false; + this.targetElement = null; + }; + + + /** + * Determine mouse events which should be permitted. + * + * @param {Event} event + * @returns {boolean} + */ + FastClick.prototype.onMouse = function(event) { + + // If a target element was never set (because a touch event was never fired) allow the event + if (!this.targetElement) { + return true; + } + + if (event.forwardedTouchEvent) { + return true; + } + + // Programmatically generated events targeting a specific element should be permitted + if (!event.cancelable) { + return true; + } + + // Derive and check the target element to see whether the mouse event needs to be permitted; + // unless explicitly enabled, prevent non-touch click events from triggering actions, + // to prevent ghost/doubleclicks. + if (!this.needsClick(this.targetElement) || this.cancelNextClick) { + + // Prevent any user-added listeners declared on FastClick element from being fired. + if (event.stopImmediatePropagation) { + event.stopImmediatePropagation(); + } else { + + // Part of the hack for browsers that don't support Event#stopImmediatePropagation (e.g. Android 2) + event.propagationStopped = true; + } + + // Cancel the event + event.stopPropagation(); + event.preventDefault(); + + return false; + } + + // If the mouse event is permitted, return true for the action to go through. + return true; + }; + + + /** + * On actual clicks, determine whether this is a touch-generated click, a click action occurring + * naturally after a delay after a touch (which needs to be cancelled to avoid duplication), or + * an actual click which should be permitted. + * + * @param {Event} event + * @returns {boolean} + */ + FastClick.prototype.onClick = function(event) { + var permitted; + + // It's possible for another FastClick-like library delivered with third-party code to fire a click event before FastClick does (issue #44). In that case, set the click-tracking flag back to false and return early. This will cause onTouchEnd to return early. + if (this.trackingClick) { + this.targetElement = null; + this.trackingClick = false; + return true; + } + + // Very odd behaviour on iOS (issue #18): if a submit element is present inside a form and the user hits enter in the iOS simulator or clicks the Go button on the pop-up OS keyboard the a kind of 'fake' click event will be triggered with the submit-type input element as the target. + if (event.target.type === 'submit' && event.detail === 0) { + return true; + } + + permitted = this.onMouse(event); + + // Only unset targetElement if the click is not permitted. This will ensure that the check for !targetElement in onMouse fails and the browser's click doesn't go through. + if (!permitted) { + this.targetElement = null; + } + + // If clicks are permitted, return true for the action to go through. + return permitted; + }; + + + /** + * Remove all FastClick's event listeners. + * + * @returns {void} + */ + FastClick.prototype.destroy = function() { + var layer = this.layer; + + if (deviceIsAndroid) { + layer.removeEventListener('mouseover', this.onMouse, true); + layer.removeEventListener('mousedown', this.onMouse, true); + layer.removeEventListener('mouseup', this.onMouse, true); + } + + layer.removeEventListener('click', this.onClick, true); + layer.removeEventListener('touchstart', this.onTouchStart, false); + layer.removeEventListener('touchmove', this.onTouchMove, false); + layer.removeEventListener('touchend', this.onTouchEnd, false); + layer.removeEventListener('touchcancel', this.onTouchCancel, false); + }; + + + /** + * Check whether FastClick is needed. + * + * @param {Element} layer The layer to listen on + */ + FastClick.notNeeded = function(layer) { + var metaViewport; + var chromeVersion; + var blackberryVersion; + var firefoxVersion; + + // Devices that don't support touch don't need FastClick + if (typeof window.ontouchstart === 'undefined') { + return true; + } + + // Chrome version - zero for other browsers + chromeVersion = +(/Chrome\/([0-9]+)/.exec(navigator.userAgent) || [,0])[1]; + + if (chromeVersion) { + + if (deviceIsAndroid) { + metaViewport = document.querySelector('meta[name=viewport]'); + + if (metaViewport) { + // Chrome on Android with user-scalable="no" doesn't need FastClick (issue #89) + if (metaViewport.content.indexOf('user-scalable=no') !== -1) { + return true; + } + // Chrome 32 and above with width=device-width or less don't need FastClick + if (chromeVersion > 31 && document.documentElement.scrollWidth <= window.outerWidth) { + return true; + } + } + + // Chrome desktop doesn't need FastClick (issue #15) + } else { + return true; + } + } + + if (deviceIsBlackBerry10) { + blackberryVersion = navigator.userAgent.match(/Version\/([0-9]*)\.([0-9]*)/); + + // BlackBerry 10.3+ does not require Fastclick library. + // https://github.com/ftlabs/fastclick/issues/251 + if (blackberryVersion[1] >= 10 && blackberryVersion[2] >= 3) { + metaViewport = document.querySelector('meta[name=viewport]'); + + if (metaViewport) { + // user-scalable=no eliminates click delay. + if (metaViewport.content.indexOf('user-scalable=no') !== -1) { + return true; + } + // width=device-width (or less than device-width) eliminates click delay. + if (document.documentElement.scrollWidth <= window.outerWidth) { + return true; + } + } + } + } + + // IE10 with -ms-touch-action: none or manipulation, which disables double-tap-to-zoom (issue #97) + if (layer.style.msTouchAction === 'none' || layer.style.touchAction === 'manipulation') { + return true; + } + + // Firefox version - zero for other browsers + firefoxVersion = +(/Firefox\/([0-9]+)/.exec(navigator.userAgent) || [,0])[1]; + + if (firefoxVersion >= 27) { + // Firefox 27+ does not have tap delay if the content is not zoomable - https://bugzilla.mozilla.org/show_bug.cgi?id=922896 + + metaViewport = document.querySelector('meta[name=viewport]'); + if (metaViewport && (metaViewport.content.indexOf('user-scalable=no') !== -1 || document.documentElement.scrollWidth <= window.outerWidth)) { + return true; + } + } + + // IE11: prefixed -ms-touch-action is no longer supported and it's recomended to use non-prefixed version + // http://msdn.microsoft.com/en-us/library/windows/apps/Hh767313.aspx + if (layer.style.touchAction === 'none' || layer.style.touchAction === 'manipulation') { + return true; + } + + return false; + }; + + + /** + * Factory method for creating a FastClick object + * + * @param {Element} layer The layer to listen on + * @param {Object} [options={}] The options to override the defaults + */ + FastClick.attach = function(layer, options) { + return new FastClick(layer, options); + }; + + + if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) { + + // AMD. Register as an anonymous module. + define(function() { + return FastClick; + }); + } else if (typeof module !== 'undefined' && module.exports) { + module.exports = FastClick.attach; + module.exports.FastClick = FastClick; + } else { + window.FastClick = FastClick; + } +}()); diff --git a/resources/html5app/js/gal/gal.filesystem.js b/resources/html5app/js/gal/gal.filesystem.js new file mode 100644 index 000000000..4dc0e3663 --- /dev/null +++ b/resources/html5app/js/gal/gal.filesystem.js @@ -0,0 +1,288 @@ +/* + * Copyright 2011 Google Inc. All Rights Reserved. + + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview The filesystem adapter used by Game Asset Loader. + * @author smus@google.com (Boris Smus) + */ + +(function (gal) { + var ROOT_DIR; + var DEFAULT_QUOTA = 1024 * 1024 * 100; + + function onError(error) { + var message = 'unknown'; + switch (error.code) { + case FileError.NOT_FOUND_ERR: + message = 'not found'; + break; + case FileError.SECURITY_ERR: + message = 'security'; + break; + case FileError.ABORT_ERR: + message = 'abort'; + break; + case FileError.NOT_READABLE_ERR: + message = 'not readable'; + break; + case FileError.ENCODING_ERR: + message = 'encoding'; + break; + case FileError.NO_MODIFICATION_ALLOWED_ERR: + message = 'no modification allowed'; + break; + case FileError.INVALID_STATE_ERR: + message = 'invalid state'; + break; + case FileError.SYNTAX_ERR: + message = 'syntax'; + break; + case FileError.INVALID_MODIFICATION_ERR: + message = 'invalid modification'; + break; + case FileError.QUOTA_EXCEEDED_ERR: + message = 'quota exceeded'; + break; + case FileError.TYPE_MISMATCH_ERR: + message = 'type mismatch'; + break; + case FileError.PATH_EXISTS_ERR: + message = 'path exists'; + break; + } + fb('Filesystem error:', error.code + ' :: ' + message); + } + + + /** + * @private + * Helper to create file at path, as well as intermediate directories in the + * path. Behaves roughly like `mkdir -p` + * @param {DirectoryEntry} root Directory at the root of the gal. + * @param {array} folders Folder heirarchy to create. + * @param {function} callback Called when the directory structure is created + * @return DirectoryEntry to the directory that was just created. + */ + function createDir_(root, folders, callback) { + fb('createDir_ :: ' + root.toURL() + " ;; " + folders.join('/')); + // Throw out './' or '/' and move on to prevent something like '/foo/.//bar'. + if (folders.length && (folders[0] === '.' || folders[0] === '')) { + folders = folders.slice(1); + } + + if (!folders.length) { + root.setMetadata(function () { + }, function () { + }, {'com.apple.MobileBackup': 1}); + callback(root); + } + + + var f = folders.shift(); + + var timeout = setTimeout(function () { + window.location.reload(true); + }, 1000); + + root.getDirectory(f, {create: true}, function (dirEntry) { + fb('dirCreated !! ' + folders.join('/') + ' :: ' + folders.length); + clearTimeout(timeout); + if (folders.length > 0) { + createDir_(dirEntry, folders, callback); + } else { + callback(dirEntry); + } + }, onError); + } + ; + + /** + * @private + * Utility tools to emulate UNIX dirname. + * @param {string} path The path whose basename to get. + * @return {string} The contents of the path before the file name. + */ + function dirname_(path) { + var match = path.match(/(.*)\//); + return match && match[1] || ''; + } + ; + + /** + * @private + * Utility tools to emulate UNIX basename. + * @param {string} path The path whose basename to get. + * @return {string} The contents of the path after the file name. + */ + function basename_(path) { + return path.replace(/.*\//, ''); + } + ; + + + /** + * Class for serializing game assets (for GAL) using the filesystem API. + * @constructor + */ + function GALFS() { + // Table to store lookups from file path fragment to filesystem URL + this.lookupTable = {}; + } + ; + + /** + * Initializes the adapter. + * @param {function} callback The callback to call once the adapter has been + * initialized. + * @param {string} opt_quota The quota (in bytes) to request (optional). + */ + GALFS.prototype.init = function (fsprefix, callback, opt_quota) { + fb('gal fs init'); + if (fsprefix == undefined) { + fsprefix = ''; + } + if (fsprefix != '') { + fsprefix += '/'; + } + ROOT_DIR = fsprefix + "gal"; + // requestFileSystem and storageInfo shims + var requestFileSystem = window.requestFileSystem || + window.webkitRequestFileSystem; + var storageInfo = window.storageInfo || window.webkitStorageInfo; + + var quota = opt_quota || DEFAULT_QUOTA; + + var that = this; + // Callback when the filesystem has been initialized + var onInitFs = function (fs) { + fb('fs inited'); + that.fs = fs; + that.regenerate(callback); + }; + + fb('request file system'); + requestFileSystem(LocalFileSystem.PERSISTENT, 0, onInitFs, onError); + var interval = setInterval(function () { + if (that.fs) { + clearInterval(interval); + } else { + fb('request file system again'); + requestFileSystem(LocalFileSystem.PERSISTENT, 0, onInitFs, onError); + } + }, 500); + }; + + /** + * Saves an asset at the given URL to the filesystem API callback when + * successfully saved. + * @param {string} key The key path to use for storing the asset. + * @param {string} url The URL to the asset. + * @param {function} callback The function to call when the asset was saved. + * @param {function} failCallback The function to call when an error occurred. + */ + GALFS.prototype.saveAsset = function (key, url, callback, failCallback) { + // BlobBuilder shim + var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder; + + var root = this.root; + var lookupTable = this.lookupTable; + + createDir_(root, dirname_(key).split('/'), function (dir) { + var file = basename_(key); + dir.getFile(file, {create: true}, function (fileEntry) { + var fileTransfer = new FileTransfer(); + + var u = fileEntry.toURL(); + if (PLATFORM == 'ios') { + u = cordova.file.dataDirectory + fileEntry.fullPath; + } + + fb('download to ' + u) + + fileTransfer.download(url, u, function (entry) { + var e = entry.toURL(); + if (PLATFORM == 'ios') { + e = cordova.file.dataDirectory + entry.fullPath; + } + lookupTable[key] = e; + entry.setMetadata(function (entry) { + }, failCallback, {'com.apple.MobileBackup': 1}); + callback(); + }, failCallback); + }, failCallback); + }); + + }; + + /** + * Gets the filesystem path for the asset stored at the given URL. + * @param {string} key The key path to the asset. + * @return {string} URL to the filesystem. + */ + GALFS.prototype.getAssetUrl = function (key) { + return this.lookupTable[key]; + }; + + /** + * Checks if a file with the specified key exists in the filesystem. + * @param {string} key The key path to the asset. + * @param {function} callback The callback to call if the file exists. + * @param {function} failCallback The callback to call if the file + * doesn't exist. + */ + GALFS.prototype.checkAsset = function (key, callback, failCallback) { + var lookupTable = this.lookupTable; + this.root.getFile(key, {}, function (fileEntry) { + // Save the file in the lookup table. + lookupTable[key] = fileEntry.toURL(); + callback(); + }, failCallback); + }; + + /** + * Clears everything out of the root directory. Mostly for unit testing. + */ + GALFS.prototype.clear = function (cb) { + var $this = this; + // Remove the root directory + this.root.removeRecursively(function () { + $this.regenerate(cb); + }, onError); + }; + + GALFS.prototype.regenerate = function (callback) { + fb('gal fs regenerate'); + var that = this; + // And then recreate it + var fs = this.fs; + + createDir_(fs.root, ROOT_DIR.split('/'), function (res) { + fb('root dir created :: ' + res.toURL()); + // Create a directory for the root of the GAL + that.root = res; + callback(); + }); + + } + + if (!gal) { + throw 'Game asset loader needs to be loaded before loading the fs adapter'; + } + + gal.adapterClass = GALFS; + +}(GameAssetLoader)); diff --git a/resources/html5app/js/gal/gal.js b/resources/html5app/js/gal/gal.js new file mode 100644 index 000000000..44634e0e4 --- /dev/null +++ b/resources/html5app/js/gal/gal.js @@ -0,0 +1,405 @@ +/* + * Copyright 2011 Google Inc. All Rights Reserved. + + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Asset loader library. + * @author smus@google.com (Boris Smus) + */ +(function (exports) { + + /** + * @constructor + * @param {Object} manifest URL to manifest file. + */ + var GAL = function (manifest, fsprefix) { + if (fsprefix == undefined) { + fsprefix = ''; + } + + this._fsprefix = fsprefix; + this._manifest = manifest; + // Dictionary of arrays of all of the bundles contained in the manifest. + this.bundles = {}; + // Array of bundle names in the order that they appear in the manifest. + this.bundleOrder = []; + // Table of callbacks, per bundle. + this.loaded = {}; + this.progress = {}; + this.error = {}; + this.adapter = null; + }; + + /** + * Initializes loader. + * @param {Function} callback called when the library finishes loading the + * manifest. + */ + GAL.prototype.init = function (callback) { + fb('gal init'); + var that = this; + fb(this._manifest); + finishInit_.call(that, this._manifest, callback) + }; + + /** + * Downloads assets contained in the named bundle. + * @param {string} bundleName name of single bundle to download. + */ + GAL.prototype.download = function (bundleName, callback) { + var bundle = this.bundles[bundleName]; + if (callback == undefined) { + callback = function () { + }; + } + + + if (!bundle) { + // Attempting to download invalid bundle. + throw "Invalid bundle specified :: " + bundleName; + } + var that = this; + + + // If offline, check for downloaded resources, and if they exist, callback. + this.check(bundleName, function (result) { + if (result.success) { + // Already downloaded. Success! + fireCallback_(that.loaded, bundleName, { + success: true, + cached: true, + bundleName: bundleName + }); + callback(); + + } else { + if (!that.online()) { + // Otherwise, since we're offline, error out. + fireCallback_(that.error, bundleName, { + error: 'Missing resources cant be downloaded while offline' + }); + callback(); + } else { + // Setup a loop via callback chaining. + (function loop(index) { + // If we've finished loading all of the assets in the bundle. + if (index == bundle.length) { + fireCallback_(that.loaded, bundleName, { + bundleName: bundleName, + success: true + }); + callback(); + return; + } + + var key = bundle[index]; + // Get the full url to the asset. + var url = encodeURI(that.manifest.assetRoot + key); + + var cb = function () { + fireCallback_(that.progress, bundleName, { + current: index + 1, + total: bundle.length + }); + // Iterate to the next file. + loop(index + 1); + }; + + // Fetch full url and store it locally. + + that.adapter.saveAsset(key, url, cb, function () { + + }); + + })(0); + } + } + }); + }; + + + + + /** + * Adds a callback to fire when a bundle has been loaded. + * @param {string} opt_bundleName Name of bundle to monitor (if none specified, + * monitor all bundles). + * @param {function} callback Called after bundle was downloaded. + */ + GAL.prototype.onLoaded = function (opt_bundleName, callback) { + addCallback_(this.loaded, opt_bundleName, callback); + }; + + /** + * Adds a callback to fire when a bundle's downloading has progressed. + * @param {string} opt_bundleName Name of bundle to monitor (if none specified, + * monitor all bundles). + * @param {function} callback Called after bundle download progressed. + */ + GAL.prototype.onProgress = function (opt_bundleName, callback) { + addCallback_(this.progress, opt_bundleName, callback); + }; + + /** + * Adds a callback to fire when a bundle's downloading has failed + * @param {string} opt_bundleName Name of bundle to monitor (if none specified, + * monitor all bundles). + * @param {function} callback Called after bundle download failed. + */ + GAL.prototype.onError = function (opt_bundleName, callback) { + addCallback_(this.error, opt_bundleName, callback); + }; + + GAL.prototype.downloadAndCall = function (bundleName, callback) { + fb('download and call ' + bundleName); + var $this = this; + var timeout = setTimeout(function () { + $this.downloadAndCall(bundleName, callback) + }, 1000); + this.check(bundleName, function (info) { + clearTimeout(timeout); + if (info.success) { + fb('already downloaded'); + callback(); + } else { + fb('i download'); + $this.download(bundleName, callback); + } + }); + }; + + /** + * Checks if a bundle is already downloaded. + * @param {string} bundleName Name of bundle to check. + * @param {function} callback Called with the result. + */ + GAL.prototype.check = function (bundleName, callback) { + var bundle = this.bundles[bundleName]; + if (!bundle) { + callback({success: false}); + return; + } + + var adapter = this.adapter; + (function loop(index) { + // If we've finished loading all of the assets in the bundle. + if (index == bundle.length) { + callback({success: true}); + return; + } + var key = bundle[index]; + adapter.checkAsset(key, function () { + + // Iterate to the next file. + loop(index + 1); + }, function () { + // Failure. + callback({success: false}); + }); + + })(0); + }; + + /** + * Gets URL to loaded asset. + * @param {string} assetPath path of the asset relative to the manifest + * root. + * @return {string} url to the asset in the local filesystem. + * @throws {exception} if the asset doesn't actually exist. + */ + GAL.prototype.get = function (assetPath) { + return this.adapter.getAssetUrl(assetPath) || null; + }; + + /** + * Gets the last cached time for an asset at a given path. + * @param {string} assetPath relative path of asset. + * @return {number} UNIX time of the last time the asset was cached. + */ + GAL.prototype.cacheTime = function (assetPath) { + // TODO(smus): implement me! + return Math.random(); + }; + + /** + * @return {Boolean} true iff the browser is online. + */ + GAL.prototype.online = function () { + return navigator.onLine; + }; + + GAL.prototype.getRootURL = function () { + return this.adapter.root.toURL(); + }; + + GAL.prototype.getRootNativeURL = function () { + try { + if (PLATFORM === 'ios') { + return cordova.file.dataDirectory + "/gal/"; + } else { + return this.adapter.root.toNativeURL(); + } + } catch (err) { + return this.getRootURL(); + } + }; + + GAL.prototype.initAdapter = function (callback) { + if (null == this.adapter) { + this.initAdapter_(callback); + } else { + callback(this.adapter); + } + }; + GAL.prototype.downloadAll = function () { + downloadAll_.call(this); + }; + + GAL.prototype.clear = function (callback) { + var $this = this; + + this.initAdapter( + function (adapter) { + adapter.clear(callback); + } + ); + }; + + GAL.prototype.initAdapter_ = function (callback) { + fb('gal init adapter'); + var $this = this; + + if (this.adapter != null) { + callback(this.adapter); + return; + } + + this.adapter = new GAL.adapterClass(); + this.adapter.init(this._fsprefix, function () { + fb('gal adapter inited'); + callback($this.adapter); + }); + }; + + /** + * @private + * Fetches JSON at a URL and calls the callback with the parsed object. + * @param {object} manifest The manifest object. + */ + function setManifest_(manifest) { + fb('gal set manifest'); + this.manifest = manifest; + // Set this.bundles object and this.bundleOrder array + for (var i = 0, bundle; bundle = manifest.bundles[i]; ++i) { + this.bundles[bundle.name] = bundle.contents; + this.bundleOrder.push(bundle.name); + } + } + + /** + * @private + * Initializes the adapter and assigns the manifest. + * Starts downloading assets if the manifest is set to autoDownload. + * @param {object} manifest The manifest object. + * @param {function} callback Called when the initialization is finished. + */ + function finishInit_(manifest, callback) { + fb('gal finish init'); + var context = this; + this.initAdapter_.call(context, function () { + fb('gal set manifest'); + setManifest_.call(context, manifest); + // Optionally, start auto-download. + if (manifest.autoDownload) { + downloadAll_.call(context); + } + callback(); + }); + } + + /** + * @private + * Adds a callback associated with a bundle name. + * @param {object} callbacks an object associated with an event type + * (ex. bundle loaded, bundle load progress updated, bundle failed). + * @param {string} bundleName the name of the bundle to monitor. If set + * to "*", all bundles will be monitored. + * @param {function} callback the function to call. + */ + function addCallback_(callbacks, bundleName, callback) { + if (typeof bundleName == "function") { + // bundleName is optional, and may be a callback instead. + callback = bundleName; + bundleName = '*'; + } + if (!callbacks[bundleName]) { + // Add an empty array. + callbacks[bundleName] = []; + } + + callbacks[bundleName].push(callback); + } + + /** + * @private + * Fires callbacks of a given type for a certain bundle. + * @param {object} object dictionary of callbacks. + * @param {string} bundleName string with the name of the bundle. + * @param {object} params to call the callback with. + */ + function fireCallback_(callbacks, bundleName, params) { + // Fire the principle callbacks, indexed by given bundleName. + fireCallbackHelper_(callbacks, bundleName, params); + // Also fire all * callbacks. + fireCallbackHelper_(callbacks, '*', params); + } + function fireCallbackHelper_(object, bundleName, params) { + var callbacks = object[bundleName]; + if (callbacks) { + for (var i = 0, callback; callback = callbacks[i]; ++i) { + callbacks[i](params); + } + } + } + + /** + * @private + * Starts downloading all of the assets in the manifest, in order. + */ + function downloadAll_() { + var that = this; + // Start by downloading the first bundle, then download subsequent ones. + (function loop(bundleIndex) { + + if (bundleIndex == that.bundleOrder.length) { + // We're done downloading stuff! + return; + } + + + var bundleName = that.bundleOrder[bundleIndex]; + that.onLoaded(bundleName, function () { + // Once bundle is loaded, load the next bundle. + loop(bundleIndex + 1); + }); + that.download(bundleName); + })(0); + } + + exports.GameAssetLoader = GAL; + +})(window); + diff --git a/resources/html5app/js/gsap/TimelineLite.js b/resources/html5app/js/gsap/TimelineLite.js new file mode 100644 index 000000000..7233f0a32 --- /dev/null +++ b/resources/html5app/js/gsap/TimelineLite.js @@ -0,0 +1,781 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine("TimelineLite", ["core.Animation","core.SimpleTimeline","TweenLite"], function(Animation, SimpleTimeline, TweenLite) { + + var TimelineLite = function(vars) { + SimpleTimeline.call(this, vars); + this._labels = {}; + this.autoRemoveChildren = (this.vars.autoRemoveChildren === true); + this.smoothChildTiming = (this.vars.smoothChildTiming === true); + this._sortChildren = true; + this._onUpdate = this.vars.onUpdate; + var v = this.vars, + val, p; + for (p in v) { + val = v[p]; + if (_isArray(val)) if (val.join("").indexOf("{self}") !== -1) { + v[p] = this._swapSelfInParams(val); + } + } + if (_isArray(v.tweens)) { + this.add(v.tweens, 0, v.align, v.stagger); + } + }, + _tinyNum = 0.0000000001, + TweenLiteInternals = TweenLite._internals, + _internals = TimelineLite._internals = {}, + _isSelector = TweenLiteInternals.isSelector, + _isArray = TweenLiteInternals.isArray, + _lazyTweens = TweenLiteInternals.lazyTweens, + _lazyRender = TweenLiteInternals.lazyRender, + _globals = _gsScope._gsDefine.globals, + _copy = function(vars) { + var copy = {}, p; + for (p in vars) { + copy[p] = vars[p]; + } + return copy; + }, + _applyCycle = function(vars, targets, i) { + var alt = vars.cycle, + p, val; + for (p in alt) { + val = alt[p]; + vars[p] = (typeof(val) === "function") ? val.call(targets[i], i) : val[i % val.length]; + } + delete vars.cycle; + }, + _pauseCallback = _internals.pauseCallback = function() {}, + _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() + var b = [], + l = a.length, + i; + for (i = 0; i !== l; b.push(a[i++])); + return b; + }, + p = TimelineLite.prototype = new SimpleTimeline(); + + TimelineLite.version = "1.18.5"; + p.constructor = TimelineLite; + p.kill()._gc = p._forcingPlayhead = p._hasPause = false; + + /* might use later... + //translates a local time inside an animation to the corresponding time on the root/global timeline, factoring in all nesting and timeScales. + function localToGlobal(time, animation) { + while (animation) { + time = (time / animation._timeScale) + animation._startTime; + animation = animation.timeline; + } + return time; + } + + //translates the supplied time on the root/global timeline into the corresponding local time inside a particular animation, factoring in all nesting and timeScales + function globalToLocal(time, animation) { + var scale = 1; + time -= localToGlobal(0, animation); + while (animation) { + scale *= animation._timeScale; + animation = animation.timeline; + } + return time * scale; + } + */ + + p.to = function(target, duration, vars, position) { + var Engine = (vars.repeat && _globals.TweenMax) || TweenLite; + return duration ? this.add( new Engine(target, duration, vars), position) : this.set(target, vars, position); + }; + + p.from = function(target, duration, vars, position) { + return this.add( ((vars.repeat && _globals.TweenMax) || TweenLite).from(target, duration, vars), position); + }; + + p.fromTo = function(target, duration, fromVars, toVars, position) { + var Engine = (toVars.repeat && _globals.TweenMax) || TweenLite; + return duration ? this.add( Engine.fromTo(target, duration, fromVars, toVars), position) : this.set(target, toVars, position); + }; + + p.staggerTo = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { + var tl = new TimelineLite({onComplete:onCompleteAll, onCompleteParams:onCompleteAllParams, callbackScope:onCompleteAllScope, smoothChildTiming:this.smoothChildTiming}), + cycle = vars.cycle, + copy, i; + if (typeof(targets) === "string") { + targets = TweenLite.selector(targets) || targets; + } + targets = targets || []; + if (_isSelector(targets)) { //senses if the targets object is a selector. If it is, we should translate it into an array. + targets = _slice(targets); + } + stagger = stagger || 0; + if (stagger < 0) { + targets = _slice(targets); + targets.reverse(); + stagger *= -1; + } + for (i = 0; i < targets.length; i++) { + copy = _copy(vars); + if (copy.startAt) { + copy.startAt = _copy(copy.startAt); + if (copy.startAt.cycle) { + _applyCycle(copy.startAt, targets, i); + } + } + if (cycle) { + _applyCycle(copy, targets, i); + if (copy.duration != null) { + duration = copy.duration; + delete copy.duration; + } + } + tl.to(targets[i], duration, copy, i * stagger); + } + return this.add(tl, position); + }; + + p.staggerFrom = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { + vars.immediateRender = (vars.immediateRender != false); + vars.runBackwards = true; + return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); + }; + + p.staggerFromTo = function(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { + toVars.startAt = fromVars; + toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); + return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); + }; + + p.call = function(callback, params, scope, position) { + return this.add( TweenLite.delayedCall(0, callback, params, scope), position); + }; + + p.set = function(target, vars, position) { + position = this._parseTimeOrLabel(position, 0, true); + if (vars.immediateRender == null) { + vars.immediateRender = (position === this._time && !this._paused); + } + return this.add( new TweenLite(target, 0, vars), position); + }; + + TimelineLite.exportRoot = function(vars, ignoreDelayedCalls) { + vars = vars || {}; + if (vars.smoothChildTiming == null) { + vars.smoothChildTiming = true; + } + var tl = new TimelineLite(vars), + root = tl._timeline, + tween, next; + if (ignoreDelayedCalls == null) { + ignoreDelayedCalls = true; + } + root._remove(tl, true); + tl._startTime = 0; + tl._rawPrevTime = tl._time = tl._totalTime = root._time; + tween = root._first; + while (tween) { + next = tween._next; + if (!ignoreDelayedCalls || !(tween instanceof TweenLite && tween.target === tween.vars.onComplete)) { + tl.add(tween, tween._startTime - tween._delay); + } + tween = next; + } + root.add(tl, 0); + return tl; + }; + + p.add = function(value, position, align, stagger) { + var curTime, l, i, child, tl, beforeRawTime; + if (typeof(position) !== "number") { + position = this._parseTimeOrLabel(position, 0, true, value); + } + if (!(value instanceof Animation)) { + if ((value instanceof Array) || (value && value.push && _isArray(value))) { + align = align || "normal"; + stagger = stagger || 0; + curTime = position; + l = value.length; + for (i = 0; i < l; i++) { + if (_isArray(child = value[i])) { + child = new TimelineLite({tweens:child}); + } + this.add(child, curTime); + if (typeof(child) !== "string" && typeof(child) !== "function") { + if (align === "sequence") { + curTime = child._startTime + (child.totalDuration() / child._timeScale); + } else if (align === "start") { + child._startTime -= child.delay(); + } + } + curTime += stagger; + } + return this._uncache(true); + } else if (typeof(value) === "string") { + return this.addLabel(value, position); + } else if (typeof(value) === "function") { + value = TweenLite.delayedCall(0, value); + } else { + throw("Cannot add " + value + " into the timeline; it is not a tween, timeline, function, or string."); + } + } + + SimpleTimeline.prototype.add.call(this, value, position); + + //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate. + if (this._gc || this._time === this._duration) if (!this._paused) if (this._duration < this.duration()) { + //in case any of the ancestors had completed but should now be enabled... + tl = this; + beforeRawTime = (tl.rawTime() > value._startTime); //if the tween is placed on the timeline so that it starts BEFORE the current rawTime, we should align the playhead (move the timeline). This is because sometimes users will create a timeline, let it finish, and much later append a tween and expect it to run instead of jumping to its end state. While technically one could argue that it should jump to its end state, that's not what users intuitively expect. + while (tl._timeline) { + if (beforeRawTime && tl._timeline.smoothChildTiming) { + tl.totalTime(tl._totalTime, true); //moves the timeline (shifts its startTime) if necessary, and also enables it. + } else if (tl._gc) { + tl._enabled(true, false); + } + tl = tl._timeline; + } + } + + return this; + }; + + p.remove = function(value) { + if (value instanceof Animation) { + this._remove(value, false); + var tl = value._timeline = value.vars.useFrames ? Animation._rootFramesTimeline : Animation._rootTimeline; //now that it's removed, default it to the root timeline so that if it gets played again, it doesn't jump back into this timeline. + value._startTime = (value._paused ? value._pauseTime : tl._time) - ((!value._reversed ? value._totalTime : value.totalDuration() - value._totalTime) / value._timeScale); //ensure that if it gets played again, the timing is correct. + return this; + } else if (value instanceof Array || (value && value.push && _isArray(value))) { + var i = value.length; + while (--i > -1) { + this.remove(value[i]); + } + return this; + } else if (typeof(value) === "string") { + return this.removeLabel(value); + } + return this.kill(null, value); + }; + + p._remove = function(tween, skipDisable) { + SimpleTimeline.prototype._remove.call(this, tween, skipDisable); + var last = this._last; + if (!last) { + this._time = this._totalTime = this._duration = this._totalDuration = 0; + } else if (this._time > last._startTime + last._totalDuration / last._timeScale) { + this._time = this.duration(); + this._totalTime = this._totalDuration; + } + return this; + }; + + p.append = function(value, offsetOrLabel) { + return this.add(value, this._parseTimeOrLabel(null, offsetOrLabel, true, value)); + }; + + p.insert = p.insertMultiple = function(value, position, align, stagger) { + return this.add(value, position || 0, align, stagger); + }; + + p.appendMultiple = function(tweens, offsetOrLabel, align, stagger) { + return this.add(tweens, this._parseTimeOrLabel(null, offsetOrLabel, true, tweens), align, stagger); + }; + + p.addLabel = function(label, position) { + this._labels[label] = this._parseTimeOrLabel(position); + return this; + }; + + p.addPause = function(position, callback, params, scope) { + var t = TweenLite.delayedCall(0, _pauseCallback, params, scope || this); + t.vars.onComplete = t.vars.onReverseComplete = callback; + t.data = "isPause"; + this._hasPause = true; + return this.add(t, position); + }; + + p.removeLabel = function(label) { + delete this._labels[label]; + return this; + }; + + p.getLabelTime = function(label) { + return (this._labels[label] != null) ? this._labels[label] : -1; + }; + + p._parseTimeOrLabel = function(timeOrLabel, offsetOrLabel, appendIfAbsent, ignore) { + var i; + //if we're about to add a tween/timeline (or an array of them) that's already a child of this timeline, we should remove it first so that it doesn't contaminate the duration(). + if (ignore instanceof Animation && ignore.timeline === this) { + this.remove(ignore); + } else if (ignore && ((ignore instanceof Array) || (ignore.push && _isArray(ignore)))) { + i = ignore.length; + while (--i > -1) { + if (ignore[i] instanceof Animation && ignore[i].timeline === this) { + this.remove(ignore[i]); + } + } + } + if (typeof(offsetOrLabel) === "string") { + return this._parseTimeOrLabel(offsetOrLabel, (appendIfAbsent && typeof(timeOrLabel) === "number" && this._labels[offsetOrLabel] == null) ? timeOrLabel - this.duration() : 0, appendIfAbsent); + } + offsetOrLabel = offsetOrLabel || 0; + if (typeof(timeOrLabel) === "string" && (isNaN(timeOrLabel) || this._labels[timeOrLabel] != null)) { //if the string is a number like "1", check to see if there's a label with that name, otherwise interpret it as a number (absolute value). + i = timeOrLabel.indexOf("="); + if (i === -1) { + if (this._labels[timeOrLabel] == null) { + return appendIfAbsent ? (this._labels[timeOrLabel] = this.duration() + offsetOrLabel) : offsetOrLabel; + } + return this._labels[timeOrLabel] + offsetOrLabel; + } + offsetOrLabel = parseInt(timeOrLabel.charAt(i-1) + "1", 10) * Number(timeOrLabel.substr(i+1)); + timeOrLabel = (i > 1) ? this._parseTimeOrLabel(timeOrLabel.substr(0, i-1), 0, appendIfAbsent) : this.duration(); + } else if (timeOrLabel == null) { + timeOrLabel = this.duration(); + } + return Number(timeOrLabel) + offsetOrLabel; + }; + + p.seek = function(position, suppressEvents) { + return this.totalTime((typeof(position) === "number") ? position : this._parseTimeOrLabel(position), (suppressEvents !== false)); + }; + + p.stop = function() { + return this.paused(true); + }; + + p.gotoAndPlay = function(position, suppressEvents) { + return this.play(position, suppressEvents); + }; + + p.gotoAndStop = function(position, suppressEvents) { + return this.pause(position, suppressEvents); + }; + + p.render = function(time, suppressEvents, force) { + if (this._gc) { + this._enabled(true, false); + } + var totalDur = (!this._dirty) ? this._totalDuration : this.totalDuration(), + prevTime = this._time, + prevStart = this._startTime, + prevTimeScale = this._timeScale, + prevPaused = this._paused, + tween, isComplete, next, callback, internalForce, pauseTween, curTime; + if (time >= totalDur - 0.0000001) { //to work around occasional floating point math artifacts. + this._totalTime = this._time = totalDur; + if (!this._reversed) if (!this._hasPausedChild()) { + isComplete = true; + callback = "onComplete"; + internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. + if (this._duration === 0) if ((time <= 0 && time >= -0.0000001) || this._rawPrevTime < 0 || this._rawPrevTime === _tinyNum) if (this._rawPrevTime !== time && this._first) { + internalForce = true; + if (this._rawPrevTime > _tinyNum) { + callback = "onReverseComplete"; + } + } + } + this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + time = totalDur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. + + } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. + this._totalTime = this._time = 0; + if (prevTime !== 0 || (this._duration === 0 && this._rawPrevTime !== _tinyNum && (this._rawPrevTime > 0 || (time < 0 && this._rawPrevTime >= 0)))) { + callback = "onReverseComplete"; + isComplete = this._reversed; + } + if (time < 0) { + this._active = false; + if (this._timeline.autoRemoveChildren && this._reversed) { //ensures proper GC if a timeline is resumed after it's finished reversing. + internalForce = isComplete = true; + callback = "onReverseComplete"; + } else if (this._rawPrevTime >= 0 && this._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. + internalForce = true; + } + this._rawPrevTime = time; + } else { + this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). + tween = this._first; + while (tween && tween._startTime === 0) { + if (!tween._duration) { + isComplete = false; + } + tween = tween._next; + } + } + time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) + if (!this._initted) { + internalForce = true; + } + } + + } else { + + if (this._hasPause && !this._forcingPlayhead && !suppressEvents) { + if (time >= prevTime) { + tween = this._first; + while (tween && tween._startTime <= time && !pauseTween) { + if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) { + pauseTween = tween; + } + tween = tween._next; + } + } else { + tween = this._last; + while (tween && tween._startTime >= time && !pauseTween) { + if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { + pauseTween = tween; + } + tween = tween._prev; + } + } + if (pauseTween) { + this._time = time = pauseTween._startTime; + this._totalTime = time + (this._cycle * (this._totalDuration + this._repeatDelay)); + } + } + + this._totalTime = this._time = this._rawPrevTime = time; + } + if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) { + return; + } else if (!this._initted) { + this._initted = true; + } + + if (!this._active) if (!this._paused && this._time !== prevTime && time > 0) { + this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. + } + + if (prevTime === 0) if (this.vars.onStart) if (this._time !== 0 || !this._duration) if (!suppressEvents) { + this._callback("onStart"); + } + + curTime = this._time; + if (curTime >= prevTime) { + tween = this._first; + while (tween) { + next = tween._next; //record it here because the value could change after rendering... + if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete + break; + } else if (tween._active || (tween._startTime <= curTime && !tween._paused && !tween._gc)) { + if (pauseTween === tween) { + this.pause(); + } + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + } else { + tween = this._last; + while (tween) { + next = tween._prev; //record it here because the value could change after rendering... + if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete + break; + } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { + if (pauseTween === tween) { + pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. + while (pauseTween && pauseTween.endTime() > this._time) { + pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); + pauseTween = pauseTween._prev; + } + pauseTween = null; + this.pause(); + } + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + } + + if (this._onUpdate) if (!suppressEvents) { + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. + _lazyRender(); + } + this._callback("onUpdate"); + } + + if (callback) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate + if (isComplete) { + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. + _lazyRender(); + } + if (this._timeline.autoRemoveChildren) { + this._enabled(false, false); + } + this._active = false; + } + if (!suppressEvents && this.vars[callback]) { + this._callback(callback); + } + } + }; + + p._hasPausedChild = function() { + var tween = this._first; + while (tween) { + if (tween._paused || ((tween instanceof TimelineLite) && tween._hasPausedChild())) { + return true; + } + tween = tween._next; + } + return false; + }; + + p.getChildren = function(nested, tweens, timelines, ignoreBeforeTime) { + ignoreBeforeTime = ignoreBeforeTime || -9999999999; + var a = [], + tween = this._first, + cnt = 0; + while (tween) { + if (tween._startTime < ignoreBeforeTime) { + //do nothing + } else if (tween instanceof TweenLite) { + if (tweens !== false) { + a[cnt++] = tween; + } + } else { + if (timelines !== false) { + a[cnt++] = tween; + } + if (nested !== false) { + a = a.concat(tween.getChildren(true, tweens, timelines)); + cnt = a.length; + } + } + tween = tween._next; + } + return a; + }; + + p.getTweensOf = function(target, nested) { + var disabled = this._gc, + a = [], + cnt = 0, + tweens, i; + if (disabled) { + this._enabled(true, true); //getTweensOf() filters out disabled tweens, and we have to mark them as _gc = true when the timeline completes in order to allow clean garbage collection, so temporarily re-enable the timeline here. + } + tweens = TweenLite.getTweensOf(target); + i = tweens.length; + while (--i > -1) { + if (tweens[i].timeline === this || (nested && this._contains(tweens[i]))) { + a[cnt++] = tweens[i]; + } + } + if (disabled) { + this._enabled(false, true); + } + return a; + }; + + p.recent = function() { + return this._recent; + }; + + p._contains = function(tween) { + var tl = tween.timeline; + while (tl) { + if (tl === this) { + return true; + } + tl = tl.timeline; + } + return false; + }; + + p.shiftChildren = function(amount, adjustLabels, ignoreBeforeTime) { + ignoreBeforeTime = ignoreBeforeTime || 0; + var tween = this._first, + labels = this._labels, + p; + while (tween) { + if (tween._startTime >= ignoreBeforeTime) { + tween._startTime += amount; + } + tween = tween._next; + } + if (adjustLabels) { + for (p in labels) { + if (labels[p] >= ignoreBeforeTime) { + labels[p] += amount; + } + } + } + return this._uncache(true); + }; + + p._kill = function(vars, target) { + if (!vars && !target) { + return this._enabled(false, false); + } + var tweens = (!target) ? this.getChildren(true, true, false) : this.getTweensOf(target), + i = tweens.length, + changed = false; + while (--i > -1) { + if (tweens[i]._kill(vars, target)) { + changed = true; + } + } + return changed; + }; + + p.clear = function(labels) { + var tweens = this.getChildren(false, true, true), + i = tweens.length; + this._time = this._totalTime = 0; + while (--i > -1) { + tweens[i]._enabled(false, false); + } + if (labels !== false) { + this._labels = {}; + } + return this._uncache(true); + }; + + p.invalidate = function() { + var tween = this._first; + while (tween) { + tween.invalidate(); + tween = tween._next; + } + return Animation.prototype.invalidate.call(this);; + }; + + p._enabled = function(enabled, ignoreTimeline) { + if (enabled === this._gc) { + var tween = this._first; + while (tween) { + tween._enabled(enabled, true); + tween = tween._next; + } + } + return SimpleTimeline.prototype._enabled.call(this, enabled, ignoreTimeline); + }; + + p.totalTime = function(time, suppressEvents, uncapped) { + this._forcingPlayhead = true; + var val = Animation.prototype.totalTime.apply(this, arguments); + this._forcingPlayhead = false; + return val; + }; + + p.duration = function(value) { + if (!arguments.length) { + if (this._dirty) { + this.totalDuration(); //just triggers recalculation + } + return this._duration; + } + if (this.duration() !== 0 && value !== 0) { + this.timeScale(this._duration / value); + } + return this; + }; + + p.totalDuration = function(value) { + if (!arguments.length) { + if (this._dirty) { + var max = 0, + tween = this._last, + prevStart = 999999999999, + prev, end; + while (tween) { + prev = tween._prev; //record it here in case the tween changes position in the sequence... + if (tween._dirty) { + tween.totalDuration(); //could change the tween._startTime, so make sure the tween's cache is clean before analyzing it. + } + if (tween._startTime > prevStart && this._sortChildren && !tween._paused) { //in case one of the tweens shifted out of order, it needs to be re-inserted into the correct position in the sequence + this.add(tween, tween._startTime - tween._delay); + } else { + prevStart = tween._startTime; + } + if (tween._startTime < 0 && !tween._paused) { //children aren't allowed to have negative startTimes unless smoothChildTiming is true, so adjust here if one is found. + max -= tween._startTime; + if (this._timeline.smoothChildTiming) { + this._startTime += tween._startTime / this._timeScale; + } + this.shiftChildren(-tween._startTime, false, -9999999999); + prevStart = 0; + } + end = tween._startTime + (tween._totalDuration / tween._timeScale); + if (end > max) { + max = end; + } + tween = prev; + } + this._duration = this._totalDuration = max; + this._dirty = false; + } + return this._totalDuration; + } + return (value && this.totalDuration()) ? this.timeScale(this._totalDuration / value) : this; + }; + + p.paused = function(value) { + if (!value) { //if there's a pause directly at the spot from where we're unpausing, skip it. + var tween = this._first, + time = this._time; + while (tween) { + if (tween._startTime === time && tween.data === "isPause") { + tween._rawPrevTime = 0; //remember, _rawPrevTime is how zero-duration tweens/callbacks sense directionality and determine whether or not to fire. If _rawPrevTime is the same as _startTime on the next render, it won't fire. + } + tween = tween._next; + } + } + return Animation.prototype.paused.apply(this, arguments); + }; + + p.usesFrames = function() { + var tl = this._timeline; + while (tl._timeline) { + tl = tl._timeline; + } + return (tl === Animation._rootFramesTimeline); + }; + + p.rawTime = function() { + return this._paused ? this._totalTime : (this._timeline.rawTime() - this._startTime) * this._timeScale; + }; + + return TimelineLite; + + }, true); + + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } + +//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date) +(function(name) { + "use strict"; + var getGlobal = function() { + return (_gsScope.GreenSockGlobals || _gsScope)[name]; + }; + if (typeof(define) === "function" && define.amd) { //AMD + define(["./TweenLite"], getGlobal); + } else if (typeof(module) !== "undefined" && module.exports) { //node + require("./TweenLite.js"); //dependency + module.exports = getGlobal(); + } +}("TimelineLite")); diff --git a/resources/html5app/js/gsap/TimelineLite.min.js b/resources/html5app/js/gsap/TimelineLite.min.js new file mode 100644 index 000000000..f6e45f632 --- /dev/null +++ b/resources/html5app/js/gsap/TimelineLite.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine("TimelineLite",["core.Animation","core.SimpleTimeline","TweenLite"],function(a,b,c){var d=function(a){b.call(this,a),this._labels={},this.autoRemoveChildren=this.vars.autoRemoveChildren===!0,this.smoothChildTiming=this.vars.smoothChildTiming===!0,this._sortChildren=!0,this._onUpdate=this.vars.onUpdate;var c,d,e=this.vars;for(d in e)c=e[d],i(c)&&-1!==c.join("").indexOf("{self}")&&(e[d]=this._swapSelfInParams(c));i(e.tweens)&&this.add(e.tweens,0,e.align,e.stagger)},e=1e-10,f=c._internals,g=d._internals={},h=f.isSelector,i=f.isArray,j=f.lazyTweens,k=f.lazyRender,l=_gsScope._gsDefine.globals,m=function(a){var b,c={};for(b in a)c[b]=a[b];return c},n=function(a,b,c){var d,e,f=a.cycle;for(d in f)e=f[d],a[d]="function"==typeof e?e.call(b[c],c):e[c%e.length];delete a.cycle},o=g.pauseCallback=function(){},p=function(a){var b,c=[],d=a.length;for(b=0;b!==d;c.push(a[b++]));return c},q=d.prototype=new b;return d.version="1.18.5",q.constructor=d,q.kill()._gc=q._forcingPlayhead=q._hasPause=!1,q.to=function(a,b,d,e){var f=d.repeat&&l.TweenMax||c;return b?this.add(new f(a,b,d),e):this.set(a,d,e)},q.from=function(a,b,d,e){return this.add((d.repeat&&l.TweenMax||c).from(a,b,d),e)},q.fromTo=function(a,b,d,e,f){var g=e.repeat&&l.TweenMax||c;return b?this.add(g.fromTo(a,b,d,e),f):this.set(a,e,f)},q.staggerTo=function(a,b,e,f,g,i,j,k){var l,o,q=new d({onComplete:i,onCompleteParams:j,callbackScope:k,smoothChildTiming:this.smoothChildTiming}),r=e.cycle;for("string"==typeof a&&(a=c.selector(a)||a),a=a||[],h(a)&&(a=p(a)),f=f||0,0>f&&(a=p(a),a.reverse(),f*=-1),o=0;ol;l++)i(m=e[l])&&(m=new d({tweens:m})),this.add(m,j),"string"!=typeof m&&"function"!=typeof m&&("sequence"===g?j=m._startTime+m.totalDuration()/m._timeScale:"start"===g&&(m._startTime-=m.delay())),j+=h;return this._uncache(!0)}if("string"==typeof e)return this.addLabel(e,f);if("function"!=typeof e)throw"Cannot add "+e+" into the timeline; it is not a tween, timeline, function, or string.";e=c.delayedCall(0,e)}if(b.prototype.add.call(this,e,f),(this._gc||this._time===this._duration)&&!this._paused&&this._duratione._startTime;n._timeline;)o&&n._timeline.smoothChildTiming?n.totalTime(n._totalTime,!0):n._gc&&n._enabled(!0,!1),n=n._timeline;return this},q.remove=function(b){if(b instanceof a){this._remove(b,!1);var c=b._timeline=b.vars.useFrames?a._rootFramesTimeline:a._rootTimeline;return b._startTime=(b._paused?b._pauseTime:c._time)-(b._reversed?b.totalDuration()-b._totalTime:b._totalTime)/b._timeScale,this}if(b instanceof Array||b&&b.push&&i(b)){for(var d=b.length;--d>-1;)this.remove(b[d]);return this}return"string"==typeof b?this.removeLabel(b):this.kill(null,b)},q._remove=function(a,c){b.prototype._remove.call(this,a,c);var d=this._last;return d?this._time>d._startTime+d._totalDuration/d._timeScale&&(this._time=this.duration(),this._totalTime=this._totalDuration):this._time=this._totalTime=this._duration=this._totalDuration=0,this},q.append=function(a,b){return this.add(a,this._parseTimeOrLabel(null,b,!0,a))},q.insert=q.insertMultiple=function(a,b,c,d){return this.add(a,b||0,c,d)},q.appendMultiple=function(a,b,c,d){return this.add(a,this._parseTimeOrLabel(null,b,!0,a),c,d)},q.addLabel=function(a,b){return this._labels[a]=this._parseTimeOrLabel(b),this},q.addPause=function(a,b,d,e){var f=c.delayedCall(0,o,d,e||this);return f.vars.onComplete=f.vars.onReverseComplete=b,f.data="isPause",this._hasPause=!0,this.add(f,a)},q.removeLabel=function(a){return delete this._labels[a],this},q.getLabelTime=function(a){return null!=this._labels[a]?this._labels[a]:-1},q._parseTimeOrLabel=function(b,c,d,e){var f;if(e instanceof a&&e.timeline===this)this.remove(e);else if(e&&(e instanceof Array||e.push&&i(e)))for(f=e.length;--f>-1;)e[f]instanceof a&&e[f].timeline===this&&this.remove(e[f]);if("string"==typeof c)return this._parseTimeOrLabel(c,d&&"number"==typeof b&&null==this._labels[c]?b-this.duration():0,d);if(c=c||0,"string"!=typeof b||!isNaN(b)&&null==this._labels[b])null==b&&(b=this.duration());else{if(f=b.indexOf("="),-1===f)return null==this._labels[b]?d?this._labels[b]=this.duration()+c:c:this._labels[b]+c;c=parseInt(b.charAt(f-1)+"1",10)*Number(b.substr(f+1)),b=f>1?this._parseTimeOrLabel(b.substr(0,f-1),0,d):this.duration()}return Number(b)+c},q.seek=function(a,b){return this.totalTime("number"==typeof a?a:this._parseTimeOrLabel(a),b!==!1)},q.stop=function(){return this.paused(!0)},q.gotoAndPlay=function(a,b){return this.play(a,b)},q.gotoAndStop=function(a,b){return this.pause(a,b)},q.render=function(a,b,c){this._gc&&this._enabled(!0,!1);var d,f,g,h,i,l,m,n=this._dirty?this.totalDuration():this._totalDuration,o=this._time,p=this._startTime,q=this._timeScale,r=this._paused;if(a>=n-1e-7)this._totalTime=this._time=n,this._reversed||this._hasPausedChild()||(f=!0,h="onComplete",i=!!this._timeline.autoRemoveChildren,0===this._duration&&(0>=a&&a>=-1e-7||this._rawPrevTime<0||this._rawPrevTime===e)&&this._rawPrevTime!==a&&this._first&&(i=!0,this._rawPrevTime>e&&(h="onReverseComplete"))),this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,a=n+1e-4;else if(1e-7>a)if(this._totalTime=this._time=0,(0!==o||0===this._duration&&this._rawPrevTime!==e&&(this._rawPrevTime>0||0>a&&this._rawPrevTime>=0))&&(h="onReverseComplete",f=this._reversed),0>a)this._active=!1,this._timeline.autoRemoveChildren&&this._reversed?(i=f=!0,h="onReverseComplete"):this._rawPrevTime>=0&&this._first&&(i=!0),this._rawPrevTime=a;else{if(this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,0===a&&f)for(d=this._first;d&&0===d._startTime;)d._duration||(f=!1),d=d._next;a=0,this._initted||(i=!0)}else{if(this._hasPause&&!this._forcingPlayhead&&!b){if(a>=o)for(d=this._first;d&&d._startTime<=a&&!l;)d._duration||"isPause"!==d.data||d.ratio||0===d._startTime&&0===this._rawPrevTime||(l=d),d=d._next;else for(d=this._last;d&&d._startTime>=a&&!l;)d._duration||"isPause"===d.data&&d._rawPrevTime>0&&(l=d),d=d._prev;l&&(this._time=a=l._startTime,this._totalTime=a+this._cycle*(this._totalDuration+this._repeatDelay))}this._totalTime=this._time=this._rawPrevTime=a}if(this._time!==o&&this._first||c||i||l){if(this._initted||(this._initted=!0),this._active||!this._paused&&this._time!==o&&a>0&&(this._active=!0),0===o&&this.vars.onStart&&(0===this._time&&this._duration||b||this._callback("onStart")),m=this._time,m>=o)for(d=this._first;d&&(g=d._next,m===this._time&&(!this._paused||r));)(d._active||d._startTime<=m&&!d._paused&&!d._gc)&&(l===d&&this.pause(),d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)),d=g;else for(d=this._last;d&&(g=d._prev,m===this._time&&(!this._paused||r));){if(d._active||d._startTime<=o&&!d._paused&&!d._gc){if(l===d){for(l=d._prev;l&&l.endTime()>this._time;)l.render(l._reversed?l.totalDuration()-(a-l._startTime)*l._timeScale:(a-l._startTime)*l._timeScale,b,c),l=l._prev;l=null,this.pause()}d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)}d=g}this._onUpdate&&(b||(j.length&&k(),this._callback("onUpdate"))),h&&(this._gc||(p===this._startTime||q!==this._timeScale)&&(0===this._time||n>=this.totalDuration())&&(f&&(j.length&&k(),this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[h]&&this._callback(h)))}},q._hasPausedChild=function(){for(var a=this._first;a;){if(a._paused||a instanceof d&&a._hasPausedChild())return!0;a=a._next}return!1},q.getChildren=function(a,b,d,e){e=e||-9999999999;for(var f=[],g=this._first,h=0;g;)g._startTime-1;)(d[e].timeline===this||b&&this._contains(d[e]))&&(g[h++]=d[e]);return f&&this._enabled(!1,!0),g},q.recent=function(){return this._recent},q._contains=function(a){for(var b=a.timeline;b;){if(b===this)return!0;b=b.timeline}return!1},q.shiftChildren=function(a,b,c){c=c||0;for(var d,e=this._first,f=this._labels;e;)e._startTime>=c&&(e._startTime+=a),e=e._next;if(b)for(d in f)f[d]>=c&&(f[d]+=a);return this._uncache(!0)},q._kill=function(a,b){if(!a&&!b)return this._enabled(!1,!1);for(var c=b?this.getTweensOf(b):this.getChildren(!0,!0,!1),d=c.length,e=!1;--d>-1;)c[d]._kill(a,b)&&(e=!0);return e},q.clear=function(a){var b=this.getChildren(!1,!0,!0),c=b.length;for(this._time=this._totalTime=0;--c>-1;)b[c]._enabled(!1,!1);return a!==!1&&(this._labels={}),this._uncache(!0)},q.invalidate=function(){for(var b=this._first;b;)b.invalidate(),b=b._next;return a.prototype.invalidate.call(this)},q._enabled=function(a,c){if(a===this._gc)for(var d=this._first;d;)d._enabled(a,!0),d=d._next;return b.prototype._enabled.call(this,a,c)},q.totalTime=function(b,c,d){this._forcingPlayhead=!0;var e=a.prototype.totalTime.apply(this,arguments);return this._forcingPlayhead=!1,e},q.duration=function(a){return arguments.length?(0!==this.duration()&&0!==a&&this.timeScale(this._duration/a),this):(this._dirty&&this.totalDuration(),this._duration)},q.totalDuration=function(a){if(!arguments.length){if(this._dirty){for(var b,c,d=0,e=this._last,f=999999999999;e;)b=e._prev,e._dirty&&e.totalDuration(),e._startTime>f&&this._sortChildren&&!e._paused?this.add(e,e._startTime-e._delay):f=e._startTime,e._startTime<0&&!e._paused&&(d-=e._startTime,this._timeline.smoothChildTiming&&(this._startTime+=e._startTime/this._timeScale),this.shiftChildren(-e._startTime,!1,-9999999999),f=0),c=e._startTime+e._totalDuration/e._timeScale,c>d&&(d=c),e=b;this._duration=this._totalDuration=d,this._dirty=!1}return this._totalDuration}return a&&this.totalDuration()?this.timeScale(this._totalDuration/a):this},q.paused=function(b){if(!b)for(var c=this._first,d=this._time;c;)c._startTime===d&&"isPause"===c.data&&(c._rawPrevTime=0),c=c._next;return a.prototype.paused.apply(this,arguments)},q.usesFrames=function(){for(var b=this._timeline;b._timeline;)b=b._timeline;return b===a._rootFramesTimeline},q.rawTime=function(){return this._paused?this._totalTime:(this._timeline.rawTime()-this._startTime)*this._timeScale},d},!0)}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(),function(a){"use strict";var b=function(){return(_gsScope.GreenSockGlobals||_gsScope)[a]};"function"==typeof define&&define.amd?define(["./TweenLite"],b):"undefined"!=typeof module&&module.exports&&(require("./TweenLite.js"),module.exports=b())}("TimelineLite"); \ No newline at end of file diff --git a/resources/html5app/js/gsap/TimelineMax.js b/resources/html5app/js/gsap/TimelineMax.js new file mode 100644 index 000000000..fe99622c4 --- /dev/null +++ b/resources/html5app/js/gsap/TimelineMax.js @@ -0,0 +1,1284 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine("TimelineMax", ["TimelineLite","TweenLite","easing.Ease"], function(TimelineLite, TweenLite, Ease) { + + var TimelineMax = function(vars) { + TimelineLite.call(this, vars); + this._repeat = this.vars.repeat || 0; + this._repeatDelay = this.vars.repeatDelay || 0; + this._cycle = 0; + this._yoyo = (this.vars.yoyo === true); + this._dirty = true; + }, + _tinyNum = 0.0000000001, + TweenLiteInternals = TweenLite._internals, + _lazyTweens = TweenLiteInternals.lazyTweens, + _lazyRender = TweenLiteInternals.lazyRender, + _easeNone = new Ease(null, null, 1, 0), + p = TimelineMax.prototype = new TimelineLite(); + + p.constructor = TimelineMax; + p.kill()._gc = false; + TimelineMax.version = "1.18.5"; + + p.invalidate = function() { + this._yoyo = (this.vars.yoyo === true); + this._repeat = this.vars.repeat || 0; + this._repeatDelay = this.vars.repeatDelay || 0; + this._uncache(true); + return TimelineLite.prototype.invalidate.call(this); + }; + + p.addCallback = function(callback, position, params, scope) { + return this.add( TweenLite.delayedCall(0, callback, params, scope), position); + }; + + p.removeCallback = function(callback, position) { + if (callback) { + if (position == null) { + this._kill(null, callback); + } else { + var a = this.getTweensOf(callback, false), + i = a.length, + time = this._parseTimeOrLabel(position); + while (--i > -1) { + if (a[i]._startTime === time) { + a[i]._enabled(false, false); + } + } + } + } + return this; + }; + + p.removePause = function(position) { + return this.removeCallback(TimelineLite._internals.pauseCallback, position); + }; + + p.tweenTo = function(position, vars) { + vars = vars || {}; + var copy = {ease:_easeNone, useFrames:this.usesFrames(), immediateRender:false}, + duration, p, t; + for (p in vars) { + copy[p] = vars[p]; + } + copy.time = this._parseTimeOrLabel(position); + duration = (Math.abs(Number(copy.time) - this._time) / this._timeScale) || 0.001; + t = new TweenLite(this, duration, copy); + copy.onStart = function() { + t.target.paused(true); + if (t.vars.time !== t.target.time() && duration === t.duration()) { //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all. + t.duration( Math.abs( t.vars.time - t.target.time()) / t.target._timeScale ); + } + if (vars.onStart) { //in case the user had an onStart in the vars - we don't want to overwrite it. + t._callback("onStart"); + } + }; + return t; + }; + + p.tweenFromTo = function(fromPosition, toPosition, vars) { + vars = vars || {}; + fromPosition = this._parseTimeOrLabel(fromPosition); + vars.startAt = {onComplete:this.seek, onCompleteParams:[fromPosition], callbackScope:this}; + vars.immediateRender = (vars.immediateRender !== false); + var t = this.tweenTo(toPosition, vars); + return t.duration((Math.abs( t.vars.time - fromPosition) / this._timeScale) || 0.001); + }; + + p.render = function(time, suppressEvents, force) { + if (this._gc) { + this._enabled(true, false); + } + var totalDur = (!this._dirty) ? this._totalDuration : this.totalDuration(), + dur = this._duration, + prevTime = this._time, + prevTotalTime = this._totalTime, + prevStart = this._startTime, + prevTimeScale = this._timeScale, + prevRawPrevTime = this._rawPrevTime, + prevPaused = this._paused, + prevCycle = this._cycle, + tween, isComplete, next, callback, internalForce, cycleDuration, pauseTween, curTime; + if (time >= totalDur - 0.0000001) { //to work around occasional floating point math artifacts. + if (!this._locked) { + this._totalTime = totalDur; + this._cycle = this._repeat; + } + if (!this._reversed) if (!this._hasPausedChild()) { + isComplete = true; + callback = "onComplete"; + internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. + if (this._duration === 0) if ((time <= 0 && time >= -0.0000001) || prevRawPrevTime < 0 || prevRawPrevTime === _tinyNum) if (prevRawPrevTime !== time && this._first) { + internalForce = true; + if (prevRawPrevTime > _tinyNum) { + callback = "onReverseComplete"; + } + } + } + this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + if (this._yoyo && (this._cycle & 1) !== 0) { + this._time = time = 0; + } else { + this._time = dur; + time = dur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. We cannot do less then 0.0001 because the same issue can occur when the duration is extremely large like 999999999999 in which case adding 0.00000001, for example, causes it to act like nothing was added. + } + + } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. + if (!this._locked) { + this._totalTime = this._cycle = 0; + } + this._time = 0; + if (prevTime !== 0 || (dur === 0 && prevRawPrevTime !== _tinyNum && (prevRawPrevTime > 0 || (time < 0 && prevRawPrevTime >= 0)) && !this._locked)) { //edge case for checking time < 0 && prevRawPrevTime >= 0: a zero-duration fromTo() tween inside a zero-duration timeline (yeah, very rare) + callback = "onReverseComplete"; + isComplete = this._reversed; + } + if (time < 0) { + this._active = false; + if (this._timeline.autoRemoveChildren && this._reversed) { + internalForce = isComplete = true; + callback = "onReverseComplete"; + } else if (prevRawPrevTime >= 0 && this._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. + internalForce = true; + } + this._rawPrevTime = time; + } else { + this._rawPrevTime = (dur || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). + tween = this._first; + while (tween && tween._startTime === 0) { + if (!tween._duration) { + isComplete = false; + } + tween = tween._next; + } + } + time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) + if (!this._initted) { + internalForce = true; + } + } + + } else { + if (dur === 0 && prevRawPrevTime < 0) { //without this, zero-duration repeating timelines (like with a simple callback nested at the very beginning and a repeatDelay) wouldn't render the first time through. + internalForce = true; + } + this._time = this._rawPrevTime = time; + if (!this._locked) { + this._totalTime = time; + if (this._repeat !== 0) { + cycleDuration = dur + this._repeatDelay; + this._cycle = (this._totalTime / cycleDuration) >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but it gets reported as 0.79999999!) + if (this._cycle !== 0) if (this._cycle === this._totalTime / cycleDuration && prevTotalTime <= time) { + this._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning) + } + this._time = this._totalTime - (this._cycle * cycleDuration); + if (this._yoyo) if ((this._cycle & 1) !== 0) { + this._time = dur - this._time; + } + if (this._time > dur) { + this._time = dur; + time = dur + 0.0001; //to avoid occasional floating point rounding error + } else if (this._time < 0) { + this._time = time = 0; + } else { + time = this._time; + } + } + } + + if (this._hasPause && !this._forcingPlayhead && !suppressEvents) { + time = this._time; + if (time >= prevTime) { + tween = this._first; + while (tween && tween._startTime <= time && !pauseTween) { + if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) { + pauseTween = tween; + } + tween = tween._next; + } + } else { + tween = this._last; + while (tween && tween._startTime >= time && !pauseTween) { + if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { + pauseTween = tween; + } + tween = tween._prev; + } + } + if (pauseTween) { + this._time = time = pauseTween._startTime; + this._totalTime = time + (this._cycle * (this._totalDuration + this._repeatDelay)); + } + } + + } + + if (this._cycle !== prevCycle) if (!this._locked) { + /* + make sure children at the end/beginning of the timeline are rendered properly. If, for example, + a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which + would get transated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there + could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So + we need to push the timeline to the end (and/or beginning depending on its yoyo value). Also we must + ensure that zero-duration tweens at the very beginning or end of the TimelineMax work. + */ + var backwards = (this._yoyo && (prevCycle & 1) !== 0), + wrap = (backwards === (this._yoyo && (this._cycle & 1) !== 0)), + recTotalTime = this._totalTime, + recCycle = this._cycle, + recRawPrevTime = this._rawPrevTime, + recTime = this._time; + + this._totalTime = prevCycle * dur; + if (this._cycle < prevCycle) { + backwards = !backwards; + } else { + this._totalTime += dur; + } + this._time = prevTime; //temporarily revert _time so that render() renders the children in the correct order. Without this, tweens won't rewind correctly. We could arhictect things in a "cleaner" way by splitting out the rendering queue into a separate method but for performance reasons, we kept it all inside this method. + + this._rawPrevTime = (dur === 0) ? prevRawPrevTime - 0.0001 : prevRawPrevTime; + this._cycle = prevCycle; + this._locked = true; //prevents changes to totalTime and skips repeat/yoyo behavior when we recursively call render() + prevTime = (backwards) ? 0 : dur; + this.render(prevTime, suppressEvents, (dur === 0)); + if (!suppressEvents) if (!this._gc) { + if (this.vars.onRepeat) { + this._callback("onRepeat"); + } + } + if (prevTime !== this._time) { //in case there's a callback like onComplete in a nested tween/timeline that changes the playhead position, like via seek(), we should just abort. + return; + } + if (wrap) { + prevTime = (backwards) ? dur + 0.0001 : -0.0001; + this.render(prevTime, true, false); + } + this._locked = false; + if (this._paused && !prevPaused) { //if the render() triggered callback that paused this timeline, we should abort (very rare, but possible) + return; + } + this._time = recTime; + this._totalTime = recTotalTime; + this._cycle = recCycle; + this._rawPrevTime = recRawPrevTime; + } + + if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) { + if (prevTotalTime !== this._totalTime) if (this._onUpdate) if (!suppressEvents) { //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate. + this._callback("onUpdate"); + } + return; + } else if (!this._initted) { + this._initted = true; + } + + if (!this._active) if (!this._paused && this._totalTime !== prevTotalTime && time > 0) { + this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. + } + + if (prevTotalTime === 0) if (this.vars.onStart) if (this._totalTime !== 0 || !this._totalDuration) if (!suppressEvents) { + this._callback("onStart"); + } + + curTime = this._time; + if (curTime >= prevTime) { + tween = this._first; + while (tween) { + next = tween._next; //record it here because the value could change after rendering... + if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete + break; + } else if (tween._active || (tween._startTime <= this._time && !tween._paused && !tween._gc)) { + if (pauseTween === tween) { + this.pause(); + } + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + } else { + tween = this._last; + while (tween) { + next = tween._prev; //record it here because the value could change after rendering... + if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete + break; + } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { + if (pauseTween === tween) { + pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. + while (pauseTween && pauseTween.endTime() > this._time) { + pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); + pauseTween = pauseTween._prev; + } + pauseTween = null; + this.pause(); + } + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + } + + if (this._onUpdate) if (!suppressEvents) { + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. + _lazyRender(); + } + this._callback("onUpdate"); + } + if (callback) if (!this._locked) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate + if (isComplete) { + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. + _lazyRender(); + } + if (this._timeline.autoRemoveChildren) { + this._enabled(false, false); + } + this._active = false; + } + if (!suppressEvents && this.vars[callback]) { + this._callback(callback); + } + } + }; + + p.getActive = function(nested, tweens, timelines) { + if (nested == null) { + nested = true; + } + if (tweens == null) { + tweens = true; + } + if (timelines == null) { + timelines = false; + } + var a = [], + all = this.getChildren(nested, tweens, timelines), + cnt = 0, + l = all.length, + i, tween; + for (i = 0; i < l; i++) { + tween = all[i]; + if (tween.isActive()) { + a[cnt++] = tween; + } + } + return a; + }; + + + p.getLabelAfter = function(time) { + if (!time) if (time !== 0) { //faster than isNan() + time = this._time; + } + var labels = this.getLabelsArray(), + l = labels.length, + i; + for (i = 0; i < l; i++) { + if (labels[i].time > time) { + return labels[i].name; + } + } + return null; + }; + + p.getLabelBefore = function(time) { + if (time == null) { + time = this._time; + } + var labels = this.getLabelsArray(), + i = labels.length; + while (--i > -1) { + if (labels[i].time < time) { + return labels[i].name; + } + } + return null; + }; + + p.getLabelsArray = function() { + var a = [], + cnt = 0, + p; + for (p in this._labels) { + a[cnt++] = {time:this._labels[p], name:p}; + } + a.sort(function(a,b) { + return a.time - b.time; + }); + return a; + }; + + +//---- GETTERS / SETTERS ------------------------------------------------------------------------------------------------------- + + p.progress = function(value, suppressEvents) { + return (!arguments.length) ? this._time / this.duration() : this.totalTime( this.duration() * ((this._yoyo && (this._cycle & 1) !== 0) ? 1 - value : value) + (this._cycle * (this._duration + this._repeatDelay)), suppressEvents); + }; + + p.totalProgress = function(value, suppressEvents) { + return (!arguments.length) ? this._totalTime / this.totalDuration() : this.totalTime( this.totalDuration() * value, suppressEvents); + }; + + p.totalDuration = function(value) { + if (!arguments.length) { + if (this._dirty) { + TimelineLite.prototype.totalDuration.call(this); //just forces refresh + //Instead of Infinity, we use 999999999999 so that we can accommodate reverses. + this._totalDuration = (this._repeat === -1) ? 999999999999 : this._duration * (this._repeat + 1) + (this._repeatDelay * this._repeat); + } + return this._totalDuration; + } + return (this._repeat === -1 || !value) ? this : this.timeScale( this.totalDuration() / value ); + }; + + p.time = function(value, suppressEvents) { + if (!arguments.length) { + return this._time; + } + if (this._dirty) { + this.totalDuration(); + } + if (value > this._duration) { + value = this._duration; + } + if (this._yoyo && (this._cycle & 1) !== 0) { + value = (this._duration - value) + (this._cycle * (this._duration + this._repeatDelay)); + } else if (this._repeat !== 0) { + value += this._cycle * (this._duration + this._repeatDelay); + } + return this.totalTime(value, suppressEvents); + }; + + p.repeat = function(value) { + if (!arguments.length) { + return this._repeat; + } + this._repeat = value; + return this._uncache(true); + }; + + p.repeatDelay = function(value) { + if (!arguments.length) { + return this._repeatDelay; + } + this._repeatDelay = value; + return this._uncache(true); + }; + + p.yoyo = function(value) { + if (!arguments.length) { + return this._yoyo; + } + this._yoyo = value; + return this; + }; + + p.currentLabel = function(value) { + if (!arguments.length) { + return this.getLabelBefore(this._time + 0.00000001); + } + return this.seek(value, true); + }; + + return TimelineMax; + + }, true); + + + + + + + +/* + * ---------------------------------------------------------------- + * TimelineLite + * ---------------------------------------------------------------- + */ + + _gsScope._gsDefine("TimelineLite", ["core.Animation","core.SimpleTimeline","TweenLite"], function(Animation, SimpleTimeline, TweenLite) { + + var TimelineLite = function(vars) { + SimpleTimeline.call(this, vars); + this._labels = {}; + this.autoRemoveChildren = (this.vars.autoRemoveChildren === true); + this.smoothChildTiming = (this.vars.smoothChildTiming === true); + this._sortChildren = true; + this._onUpdate = this.vars.onUpdate; + var v = this.vars, + val, p; + for (p in v) { + val = v[p]; + if (_isArray(val)) if (val.join("").indexOf("{self}") !== -1) { + v[p] = this._swapSelfInParams(val); + } + } + if (_isArray(v.tweens)) { + this.add(v.tweens, 0, v.align, v.stagger); + } + }, + _tinyNum = 0.0000000001, + TweenLiteInternals = TweenLite._internals, + _internals = TimelineLite._internals = {}, + _isSelector = TweenLiteInternals.isSelector, + _isArray = TweenLiteInternals.isArray, + _lazyTweens = TweenLiteInternals.lazyTweens, + _lazyRender = TweenLiteInternals.lazyRender, + _globals = _gsScope._gsDefine.globals, + _copy = function(vars) { + var copy = {}, p; + for (p in vars) { + copy[p] = vars[p]; + } + return copy; + }, + _applyCycle = function(vars, targets, i) { + var alt = vars.cycle, + p, val; + for (p in alt) { + val = alt[p]; + vars[p] = (typeof(val) === "function") ? val.call(targets[i], i) : val[i % val.length]; + } + delete vars.cycle; + }, + _pauseCallback = _internals.pauseCallback = function() {}, + _slice = function(a) { //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() + var b = [], + l = a.length, + i; + for (i = 0; i !== l; b.push(a[i++])); + return b; + }, + p = TimelineLite.prototype = new SimpleTimeline(); + + TimelineLite.version = "1.18.5"; + p.constructor = TimelineLite; + p.kill()._gc = p._forcingPlayhead = p._hasPause = false; + + /* might use later... + //translates a local time inside an animation to the corresponding time on the root/global timeline, factoring in all nesting and timeScales. + function localToGlobal(time, animation) { + while (animation) { + time = (time / animation._timeScale) + animation._startTime; + animation = animation.timeline; + } + return time; + } + + //translates the supplied time on the root/global timeline into the corresponding local time inside a particular animation, factoring in all nesting and timeScales + function globalToLocal(time, animation) { + var scale = 1; + time -= localToGlobal(0, animation); + while (animation) { + scale *= animation._timeScale; + animation = animation.timeline; + } + return time * scale; + } + */ + + p.to = function(target, duration, vars, position) { + var Engine = (vars.repeat && _globals.TweenMax) || TweenLite; + return duration ? this.add( new Engine(target, duration, vars), position) : this.set(target, vars, position); + }; + + p.from = function(target, duration, vars, position) { + return this.add( ((vars.repeat && _globals.TweenMax) || TweenLite).from(target, duration, vars), position); + }; + + p.fromTo = function(target, duration, fromVars, toVars, position) { + var Engine = (toVars.repeat && _globals.TweenMax) || TweenLite; + return duration ? this.add( Engine.fromTo(target, duration, fromVars, toVars), position) : this.set(target, toVars, position); + }; + + p.staggerTo = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { + var tl = new TimelineLite({onComplete:onCompleteAll, onCompleteParams:onCompleteAllParams, callbackScope:onCompleteAllScope, smoothChildTiming:this.smoothChildTiming}), + cycle = vars.cycle, + copy, i; + if (typeof(targets) === "string") { + targets = TweenLite.selector(targets) || targets; + } + targets = targets || []; + if (_isSelector(targets)) { //senses if the targets object is a selector. If it is, we should translate it into an array. + targets = _slice(targets); + } + stagger = stagger || 0; + if (stagger < 0) { + targets = _slice(targets); + targets.reverse(); + stagger *= -1; + } + for (i = 0; i < targets.length; i++) { + copy = _copy(vars); + if (copy.startAt) { + copy.startAt = _copy(copy.startAt); + if (copy.startAt.cycle) { + _applyCycle(copy.startAt, targets, i); + } + } + if (cycle) { + _applyCycle(copy, targets, i); + if (copy.duration != null) { + duration = copy.duration; + delete copy.duration; + } + } + tl.to(targets[i], duration, copy, i * stagger); + } + return this.add(tl, position); + }; + + p.staggerFrom = function(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { + vars.immediateRender = (vars.immediateRender != false); + vars.runBackwards = true; + return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); + }; + + p.staggerFromTo = function(targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) { + toVars.startAt = fromVars; + toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); + return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope); + }; + + p.call = function(callback, params, scope, position) { + return this.add( TweenLite.delayedCall(0, callback, params, scope), position); + }; + + p.set = function(target, vars, position) { + position = this._parseTimeOrLabel(position, 0, true); + if (vars.immediateRender == null) { + vars.immediateRender = (position === this._time && !this._paused); + } + return this.add( new TweenLite(target, 0, vars), position); + }; + + TimelineLite.exportRoot = function(vars, ignoreDelayedCalls) { + vars = vars || {}; + if (vars.smoothChildTiming == null) { + vars.smoothChildTiming = true; + } + var tl = new TimelineLite(vars), + root = tl._timeline, + tween, next; + if (ignoreDelayedCalls == null) { + ignoreDelayedCalls = true; + } + root._remove(tl, true); + tl._startTime = 0; + tl._rawPrevTime = tl._time = tl._totalTime = root._time; + tween = root._first; + while (tween) { + next = tween._next; + if (!ignoreDelayedCalls || !(tween instanceof TweenLite && tween.target === tween.vars.onComplete)) { + tl.add(tween, tween._startTime - tween._delay); + } + tween = next; + } + root.add(tl, 0); + return tl; + }; + + p.add = function(value, position, align, stagger) { + var curTime, l, i, child, tl, beforeRawTime; + if (typeof(position) !== "number") { + position = this._parseTimeOrLabel(position, 0, true, value); + } + if (!(value instanceof Animation)) { + if ((value instanceof Array) || (value && value.push && _isArray(value))) { + align = align || "normal"; + stagger = stagger || 0; + curTime = position; + l = value.length; + for (i = 0; i < l; i++) { + if (_isArray(child = value[i])) { + child = new TimelineLite({tweens:child}); + } + this.add(child, curTime); + if (typeof(child) !== "string" && typeof(child) !== "function") { + if (align === "sequence") { + curTime = child._startTime + (child.totalDuration() / child._timeScale); + } else if (align === "start") { + child._startTime -= child.delay(); + } + } + curTime += stagger; + } + return this._uncache(true); + } else if (typeof(value) === "string") { + return this.addLabel(value, position); + } else if (typeof(value) === "function") { + value = TweenLite.delayedCall(0, value); + } else { + throw("Cannot add " + value + " into the timeline; it is not a tween, timeline, function, or string."); + } + } + + SimpleTimeline.prototype.add.call(this, value, position); + + //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate. + if (this._gc || this._time === this._duration) if (!this._paused) if (this._duration < this.duration()) { + //in case any of the ancestors had completed but should now be enabled... + tl = this; + beforeRawTime = (tl.rawTime() > value._startTime); //if the tween is placed on the timeline so that it starts BEFORE the current rawTime, we should align the playhead (move the timeline). This is because sometimes users will create a timeline, let it finish, and much later append a tween and expect it to run instead of jumping to its end state. While technically one could argue that it should jump to its end state, that's not what users intuitively expect. + while (tl._timeline) { + if (beforeRawTime && tl._timeline.smoothChildTiming) { + tl.totalTime(tl._totalTime, true); //moves the timeline (shifts its startTime) if necessary, and also enables it. + } else if (tl._gc) { + tl._enabled(true, false); + } + tl = tl._timeline; + } + } + + return this; + }; + + p.remove = function(value) { + if (value instanceof Animation) { + this._remove(value, false); + var tl = value._timeline = value.vars.useFrames ? Animation._rootFramesTimeline : Animation._rootTimeline; //now that it's removed, default it to the root timeline so that if it gets played again, it doesn't jump back into this timeline. + value._startTime = (value._paused ? value._pauseTime : tl._time) - ((!value._reversed ? value._totalTime : value.totalDuration() - value._totalTime) / value._timeScale); //ensure that if it gets played again, the timing is correct. + return this; + } else if (value instanceof Array || (value && value.push && _isArray(value))) { + var i = value.length; + while (--i > -1) { + this.remove(value[i]); + } + return this; + } else if (typeof(value) === "string") { + return this.removeLabel(value); + } + return this.kill(null, value); + }; + + p._remove = function(tween, skipDisable) { + SimpleTimeline.prototype._remove.call(this, tween, skipDisable); + var last = this._last; + if (!last) { + this._time = this._totalTime = this._duration = this._totalDuration = 0; + } else if (this._time > last._startTime + last._totalDuration / last._timeScale) { + this._time = this.duration(); + this._totalTime = this._totalDuration; + } + return this; + }; + + p.append = function(value, offsetOrLabel) { + return this.add(value, this._parseTimeOrLabel(null, offsetOrLabel, true, value)); + }; + + p.insert = p.insertMultiple = function(value, position, align, stagger) { + return this.add(value, position || 0, align, stagger); + }; + + p.appendMultiple = function(tweens, offsetOrLabel, align, stagger) { + return this.add(tweens, this._parseTimeOrLabel(null, offsetOrLabel, true, tweens), align, stagger); + }; + + p.addLabel = function(label, position) { + this._labels[label] = this._parseTimeOrLabel(position); + return this; + }; + + p.addPause = function(position, callback, params, scope) { + var t = TweenLite.delayedCall(0, _pauseCallback, params, scope || this); + t.vars.onComplete = t.vars.onReverseComplete = callback; + t.data = "isPause"; + this._hasPause = true; + return this.add(t, position); + }; + + p.removeLabel = function(label) { + delete this._labels[label]; + return this; + }; + + p.getLabelTime = function(label) { + return (this._labels[label] != null) ? this._labels[label] : -1; + }; + + p._parseTimeOrLabel = function(timeOrLabel, offsetOrLabel, appendIfAbsent, ignore) { + var i; + //if we're about to add a tween/timeline (or an array of them) that's already a child of this timeline, we should remove it first so that it doesn't contaminate the duration(). + if (ignore instanceof Animation && ignore.timeline === this) { + this.remove(ignore); + } else if (ignore && ((ignore instanceof Array) || (ignore.push && _isArray(ignore)))) { + i = ignore.length; + while (--i > -1) { + if (ignore[i] instanceof Animation && ignore[i].timeline === this) { + this.remove(ignore[i]); + } + } + } + if (typeof(offsetOrLabel) === "string") { + return this._parseTimeOrLabel(offsetOrLabel, (appendIfAbsent && typeof(timeOrLabel) === "number" && this._labels[offsetOrLabel] == null) ? timeOrLabel - this.duration() : 0, appendIfAbsent); + } + offsetOrLabel = offsetOrLabel || 0; + if (typeof(timeOrLabel) === "string" && (isNaN(timeOrLabel) || this._labels[timeOrLabel] != null)) { //if the string is a number like "1", check to see if there's a label with that name, otherwise interpret it as a number (absolute value). + i = timeOrLabel.indexOf("="); + if (i === -1) { + if (this._labels[timeOrLabel] == null) { + return appendIfAbsent ? (this._labels[timeOrLabel] = this.duration() + offsetOrLabel) : offsetOrLabel; + } + return this._labels[timeOrLabel] + offsetOrLabel; + } + offsetOrLabel = parseInt(timeOrLabel.charAt(i-1) + "1", 10) * Number(timeOrLabel.substr(i+1)); + timeOrLabel = (i > 1) ? this._parseTimeOrLabel(timeOrLabel.substr(0, i-1), 0, appendIfAbsent) : this.duration(); + } else if (timeOrLabel == null) { + timeOrLabel = this.duration(); + } + return Number(timeOrLabel) + offsetOrLabel; + }; + + p.seek = function(position, suppressEvents) { + return this.totalTime((typeof(position) === "number") ? position : this._parseTimeOrLabel(position), (suppressEvents !== false)); + }; + + p.stop = function() { + return this.paused(true); + }; + + p.gotoAndPlay = function(position, suppressEvents) { + return this.play(position, suppressEvents); + }; + + p.gotoAndStop = function(position, suppressEvents) { + return this.pause(position, suppressEvents); + }; + + p.render = function(time, suppressEvents, force) { + if (this._gc) { + this._enabled(true, false); + } + var totalDur = (!this._dirty) ? this._totalDuration : this.totalDuration(), + prevTime = this._time, + prevStart = this._startTime, + prevTimeScale = this._timeScale, + prevPaused = this._paused, + tween, isComplete, next, callback, internalForce, pauseTween, curTime; + if (time >= totalDur - 0.0000001) { //to work around occasional floating point math artifacts. + this._totalTime = this._time = totalDur; + if (!this._reversed) if (!this._hasPausedChild()) { + isComplete = true; + callback = "onComplete"; + internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. + if (this._duration === 0) if ((time <= 0 && time >= -0.0000001) || this._rawPrevTime < 0 || this._rawPrevTime === _tinyNum) if (this._rawPrevTime !== time && this._first) { + internalForce = true; + if (this._rawPrevTime > _tinyNum) { + callback = "onReverseComplete"; + } + } + } + this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + time = totalDur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. + + } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. + this._totalTime = this._time = 0; + if (prevTime !== 0 || (this._duration === 0 && this._rawPrevTime !== _tinyNum && (this._rawPrevTime > 0 || (time < 0 && this._rawPrevTime >= 0)))) { + callback = "onReverseComplete"; + isComplete = this._reversed; + } + if (time < 0) { + this._active = false; + if (this._timeline.autoRemoveChildren && this._reversed) { //ensures proper GC if a timeline is resumed after it's finished reversing. + internalForce = isComplete = true; + callback = "onReverseComplete"; + } else if (this._rawPrevTime >= 0 && this._first) { //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state. + internalForce = true; + } + this._rawPrevTime = time; + } else { + this._rawPrevTime = (this._duration || !suppressEvents || time || this._rawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + if (time === 0 && isComplete) { //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good). + tween = this._first; + while (tween && tween._startTime === 0) { + if (!tween._duration) { + isComplete = false; + } + tween = tween._next; + } + } + time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline) + if (!this._initted) { + internalForce = true; + } + } + + } else { + + if (this._hasPause && !this._forcingPlayhead && !suppressEvents) { + if (time >= prevTime) { + tween = this._first; + while (tween && tween._startTime <= time && !pauseTween) { + if (!tween._duration) if (tween.data === "isPause" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) { + pauseTween = tween; + } + tween = tween._next; + } + } else { + tween = this._last; + while (tween && tween._startTime >= time && !pauseTween) { + if (!tween._duration) if (tween.data === "isPause" && tween._rawPrevTime > 0) { + pauseTween = tween; + } + tween = tween._prev; + } + } + if (pauseTween) { + this._time = time = pauseTween._startTime; + this._totalTime = time + (this._cycle * (this._totalDuration + this._repeatDelay)); + } + } + + this._totalTime = this._time = this._rawPrevTime = time; + } + if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) { + return; + } else if (!this._initted) { + this._initted = true; + } + + if (!this._active) if (!this._paused && this._time !== prevTime && time > 0) { + this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example. + } + + if (prevTime === 0) if (this.vars.onStart) if (this._time !== 0 || !this._duration) if (!suppressEvents) { + this._callback("onStart"); + } + + curTime = this._time; + if (curTime >= prevTime) { + tween = this._first; + while (tween) { + next = tween._next; //record it here because the value could change after rendering... + if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete + break; + } else if (tween._active || (tween._startTime <= curTime && !tween._paused && !tween._gc)) { + if (pauseTween === tween) { + this.pause(); + } + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + } else { + tween = this._last; + while (tween) { + next = tween._prev; //record it here because the value could change after rendering... + if (curTime !== this._time || (this._paused && !prevPaused)) { //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete + break; + } else if (tween._active || (tween._startTime <= prevTime && !tween._paused && !tween._gc)) { + if (pauseTween === tween) { + pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse. + while (pauseTween && pauseTween.endTime() > this._time) { + pauseTween.render( (pauseTween._reversed ? pauseTween.totalDuration() - ((time - pauseTween._startTime) * pauseTween._timeScale) : (time - pauseTween._startTime) * pauseTween._timeScale), suppressEvents, force); + pauseTween = pauseTween._prev; + } + pauseTween = null; + this.pause(); + } + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + } + + if (this._onUpdate) if (!suppressEvents) { + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values. + _lazyRender(); + } + this._callback("onUpdate"); + } + + if (callback) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) { //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate + if (isComplete) { + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values. + _lazyRender(); + } + if (this._timeline.autoRemoveChildren) { + this._enabled(false, false); + } + this._active = false; + } + if (!suppressEvents && this.vars[callback]) { + this._callback(callback); + } + } + }; + + p._hasPausedChild = function() { + var tween = this._first; + while (tween) { + if (tween._paused || ((tween instanceof TimelineLite) && tween._hasPausedChild())) { + return true; + } + tween = tween._next; + } + return false; + }; + + p.getChildren = function(nested, tweens, timelines, ignoreBeforeTime) { + ignoreBeforeTime = ignoreBeforeTime || -9999999999; + var a = [], + tween = this._first, + cnt = 0; + while (tween) { + if (tween._startTime < ignoreBeforeTime) { + //do nothing + } else if (tween instanceof TweenLite) { + if (tweens !== false) { + a[cnt++] = tween; + } + } else { + if (timelines !== false) { + a[cnt++] = tween; + } + if (nested !== false) { + a = a.concat(tween.getChildren(true, tweens, timelines)); + cnt = a.length; + } + } + tween = tween._next; + } + return a; + }; + + p.getTweensOf = function(target, nested) { + var disabled = this._gc, + a = [], + cnt = 0, + tweens, i; + if (disabled) { + this._enabled(true, true); //getTweensOf() filters out disabled tweens, and we have to mark them as _gc = true when the timeline completes in order to allow clean garbage collection, so temporarily re-enable the timeline here. + } + tweens = TweenLite.getTweensOf(target); + i = tweens.length; + while (--i > -1) { + if (tweens[i].timeline === this || (nested && this._contains(tweens[i]))) { + a[cnt++] = tweens[i]; + } + } + if (disabled) { + this._enabled(false, true); + } + return a; + }; + + p.recent = function() { + return this._recent; + }; + + p._contains = function(tween) { + var tl = tween.timeline; + while (tl) { + if (tl === this) { + return true; + } + tl = tl.timeline; + } + return false; + }; + + p.shiftChildren = function(amount, adjustLabels, ignoreBeforeTime) { + ignoreBeforeTime = ignoreBeforeTime || 0; + var tween = this._first, + labels = this._labels, + p; + while (tween) { + if (tween._startTime >= ignoreBeforeTime) { + tween._startTime += amount; + } + tween = tween._next; + } + if (adjustLabels) { + for (p in labels) { + if (labels[p] >= ignoreBeforeTime) { + labels[p] += amount; + } + } + } + return this._uncache(true); + }; + + p._kill = function(vars, target) { + if (!vars && !target) { + return this._enabled(false, false); + } + var tweens = (!target) ? this.getChildren(true, true, false) : this.getTweensOf(target), + i = tweens.length, + changed = false; + while (--i > -1) { + if (tweens[i]._kill(vars, target)) { + changed = true; + } + } + return changed; + }; + + p.clear = function(labels) { + var tweens = this.getChildren(false, true, true), + i = tweens.length; + this._time = this._totalTime = 0; + while (--i > -1) { + tweens[i]._enabled(false, false); + } + if (labels !== false) { + this._labels = {}; + } + return this._uncache(true); + }; + + p.invalidate = function() { + var tween = this._first; + while (tween) { + tween.invalidate(); + tween = tween._next; + } + return Animation.prototype.invalidate.call(this);; + }; + + p._enabled = function(enabled, ignoreTimeline) { + if (enabled === this._gc) { + var tween = this._first; + while (tween) { + tween._enabled(enabled, true); + tween = tween._next; + } + } + return SimpleTimeline.prototype._enabled.call(this, enabled, ignoreTimeline); + }; + + p.totalTime = function(time, suppressEvents, uncapped) { + this._forcingPlayhead = true; + var val = Animation.prototype.totalTime.apply(this, arguments); + this._forcingPlayhead = false; + return val; + }; + + p.duration = function(value) { + if (!arguments.length) { + if (this._dirty) { + this.totalDuration(); //just triggers recalculation + } + return this._duration; + } + if (this.duration() !== 0 && value !== 0) { + this.timeScale(this._duration / value); + } + return this; + }; + + p.totalDuration = function(value) { + if (!arguments.length) { + if (this._dirty) { + var max = 0, + tween = this._last, + prevStart = 999999999999, + prev, end; + while (tween) { + prev = tween._prev; //record it here in case the tween changes position in the sequence... + if (tween._dirty) { + tween.totalDuration(); //could change the tween._startTime, so make sure the tween's cache is clean before analyzing it. + } + if (tween._startTime > prevStart && this._sortChildren && !tween._paused) { //in case one of the tweens shifted out of order, it needs to be re-inserted into the correct position in the sequence + this.add(tween, tween._startTime - tween._delay); + } else { + prevStart = tween._startTime; + } + if (tween._startTime < 0 && !tween._paused) { //children aren't allowed to have negative startTimes unless smoothChildTiming is true, so adjust here if one is found. + max -= tween._startTime; + if (this._timeline.smoothChildTiming) { + this._startTime += tween._startTime / this._timeScale; + } + this.shiftChildren(-tween._startTime, false, -9999999999); + prevStart = 0; + } + end = tween._startTime + (tween._totalDuration / tween._timeScale); + if (end > max) { + max = end; + } + tween = prev; + } + this._duration = this._totalDuration = max; + this._dirty = false; + } + return this._totalDuration; + } + return (value && this.totalDuration()) ? this.timeScale(this._totalDuration / value) : this; + }; + + p.paused = function(value) { + if (!value) { //if there's a pause directly at the spot from where we're unpausing, skip it. + var tween = this._first, + time = this._time; + while (tween) { + if (tween._startTime === time && tween.data === "isPause") { + tween._rawPrevTime = 0; //remember, _rawPrevTime is how zero-duration tweens/callbacks sense directionality and determine whether or not to fire. If _rawPrevTime is the same as _startTime on the next render, it won't fire. + } + tween = tween._next; + } + } + return Animation.prototype.paused.apply(this, arguments); + }; + + p.usesFrames = function() { + var tl = this._timeline; + while (tl._timeline) { + tl = tl._timeline; + } + return (tl === Animation._rootFramesTimeline); + }; + + p.rawTime = function() { + return this._paused ? this._totalTime : (this._timeline.rawTime() - this._startTime) * this._timeScale; + }; + + return TimelineLite; + + }, true); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } + +//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date) +(function(name) { + "use strict"; + var getGlobal = function() { + return (_gsScope.GreenSockGlobals || _gsScope)[name]; + }; + if (typeof(define) === "function" && define.amd) { //AMD + define(["./TweenLite"], getGlobal); + } else if (typeof(module) !== "undefined" && module.exports) { //node + require("./TweenLite.js"); //dependency + module.exports = getGlobal(); + } +}("TimelineMax")); \ No newline at end of file diff --git a/resources/html5app/js/gsap/TimelineMax.min.js b/resources/html5app/js/gsap/TimelineMax.min.js new file mode 100644 index 000000000..9993a1c06 --- /dev/null +++ b/resources/html5app/js/gsap/TimelineMax.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine("TimelineMax",["TimelineLite","TweenLite","easing.Ease"],function(a,b,c){var d=function(b){a.call(this,b),this._repeat=this.vars.repeat||0,this._repeatDelay=this.vars.repeatDelay||0,this._cycle=0,this._yoyo=this.vars.yoyo===!0,this._dirty=!0},e=1e-10,f=b._internals,g=f.lazyTweens,h=f.lazyRender,i=new c(null,null,1,0),j=d.prototype=new a;return j.constructor=d,j.kill()._gc=!1,d.version="1.18.5",j.invalidate=function(){return this._yoyo=this.vars.yoyo===!0,this._repeat=this.vars.repeat||0,this._repeatDelay=this.vars.repeatDelay||0,this._uncache(!0),a.prototype.invalidate.call(this)},j.addCallback=function(a,c,d,e){return this.add(b.delayedCall(0,a,d,e),c)},j.removeCallback=function(a,b){if(a)if(null==b)this._kill(null,a);else for(var c=this.getTweensOf(a,!1),d=c.length,e=this._parseTimeOrLabel(b);--d>-1;)c[d]._startTime===e&&c[d]._enabled(!1,!1);return this},j.removePause=function(b){return this.removeCallback(a._internals.pauseCallback,b)},j.tweenTo=function(a,c){c=c||{};var d,e,f,g={ease:i,useFrames:this.usesFrames(),immediateRender:!1};for(e in c)g[e]=c[e];return g.time=this._parseTimeOrLabel(a),d=Math.abs(Number(g.time)-this._time)/this._timeScale||.001,f=new b(this,d,g),g.onStart=function(){f.target.paused(!0),f.vars.time!==f.target.time()&&d===f.duration()&&f.duration(Math.abs(f.vars.time-f.target.time())/f.target._timeScale),c.onStart&&f._callback("onStart")},f},j.tweenFromTo=function(a,b,c){c=c||{},a=this._parseTimeOrLabel(a),c.startAt={onComplete:this.seek,onCompleteParams:[a],callbackScope:this},c.immediateRender=c.immediateRender!==!1;var d=this.tweenTo(b,c);return d.duration(Math.abs(d.vars.time-a)/this._timeScale||.001)},j.render=function(a,b,c){this._gc&&this._enabled(!0,!1);var d,f,i,j,k,l,m,n,o=this._dirty?this.totalDuration():this._totalDuration,p=this._duration,q=this._time,r=this._totalTime,s=this._startTime,t=this._timeScale,u=this._rawPrevTime,v=this._paused,w=this._cycle;if(a>=o-1e-7)this._locked||(this._totalTime=o,this._cycle=this._repeat),this._reversed||this._hasPausedChild()||(f=!0,j="onComplete",k=!!this._timeline.autoRemoveChildren,0===this._duration&&(0>=a&&a>=-1e-7||0>u||u===e)&&u!==a&&this._first&&(k=!0,u>e&&(j="onReverseComplete"))),this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,this._yoyo&&0!==(1&this._cycle)?this._time=a=0:(this._time=p,a=p+1e-4);else if(1e-7>a)if(this._locked||(this._totalTime=this._cycle=0),this._time=0,(0!==q||0===p&&u!==e&&(u>0||0>a&&u>=0)&&!this._locked)&&(j="onReverseComplete",f=this._reversed),0>a)this._active=!1,this._timeline.autoRemoveChildren&&this._reversed?(k=f=!0,j="onReverseComplete"):u>=0&&this._first&&(k=!0),this._rawPrevTime=a;else{if(this._rawPrevTime=p||!b||a||this._rawPrevTime===a?a:e,0===a&&f)for(d=this._first;d&&0===d._startTime;)d._duration||(f=!1),d=d._next;a=0,this._initted||(k=!0)}else if(0===p&&0>u&&(k=!0),this._time=this._rawPrevTime=a,this._locked||(this._totalTime=a,0!==this._repeat&&(l=p+this._repeatDelay,this._cycle=this._totalTime/l>>0,0!==this._cycle&&this._cycle===this._totalTime/l&&a>=r&&this._cycle--,this._time=this._totalTime-this._cycle*l,this._yoyo&&0!==(1&this._cycle)&&(this._time=p-this._time),this._time>p?(this._time=p,a=p+1e-4):this._time<0?this._time=a=0:a=this._time)),this._hasPause&&!this._forcingPlayhead&&!b){if(a=this._time,a>=q)for(d=this._first;d&&d._startTime<=a&&!m;)d._duration||"isPause"!==d.data||d.ratio||0===d._startTime&&0===this._rawPrevTime||(m=d),d=d._next;else for(d=this._last;d&&d._startTime>=a&&!m;)d._duration||"isPause"===d.data&&d._rawPrevTime>0&&(m=d),d=d._prev;m&&(this._time=a=m._startTime,this._totalTime=a+this._cycle*(this._totalDuration+this._repeatDelay))}if(this._cycle!==w&&!this._locked){var x=this._yoyo&&0!==(1&w),y=x===(this._yoyo&&0!==(1&this._cycle)),z=this._totalTime,A=this._cycle,B=this._rawPrevTime,C=this._time;if(this._totalTime=w*p,this._cycle0&&(this._active=!0),0===r&&this.vars.onStart&&(0===this._totalTime&&this._totalDuration||b||this._callback("onStart")),n=this._time,n>=q)for(d=this._first;d&&(i=d._next,n===this._time&&(!this._paused||v));)(d._active||d._startTime<=this._time&&!d._paused&&!d._gc)&&(m===d&&this.pause(),d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)),d=i;else for(d=this._last;d&&(i=d._prev,n===this._time&&(!this._paused||v));){if(d._active||d._startTime<=q&&!d._paused&&!d._gc){if(m===d){for(m=d._prev;m&&m.endTime()>this._time;)m.render(m._reversed?m.totalDuration()-(a-m._startTime)*m._timeScale:(a-m._startTime)*m._timeScale,b,c),m=m._prev;m=null,this.pause()}d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)}d=i}this._onUpdate&&(b||(g.length&&h(),this._callback("onUpdate"))),j&&(this._locked||this._gc||(s===this._startTime||t!==this._timeScale)&&(0===this._time||o>=this.totalDuration())&&(f&&(g.length&&h(),this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[j]&&this._callback(j)))},j.getActive=function(a,b,c){null==a&&(a=!0),null==b&&(b=!0),null==c&&(c=!1);var d,e,f=[],g=this.getChildren(a,b,c),h=0,i=g.length;for(d=0;i>d;d++)e=g[d],e.isActive()&&(f[h++]=e);return f},j.getLabelAfter=function(a){a||0!==a&&(a=this._time);var b,c=this.getLabelsArray(),d=c.length;for(b=0;d>b;b++)if(c[b].time>a)return c[b].name;return null},j.getLabelBefore=function(a){null==a&&(a=this._time);for(var b=this.getLabelsArray(),c=b.length;--c>-1;)if(b[c].timethis._duration&&(a=this._duration),this._yoyo&&0!==(1&this._cycle)?a=this._duration-a+this._cycle*(this._duration+this._repeatDelay):0!==this._repeat&&(a+=this._cycle*(this._duration+this._repeatDelay)),this.totalTime(a,b)):this._time},j.repeat=function(a){return arguments.length?(this._repeat=a,this._uncache(!0)):this._repeat},j.repeatDelay=function(a){return arguments.length?(this._repeatDelay=a,this._uncache(!0)):this._repeatDelay},j.yoyo=function(a){return arguments.length?(this._yoyo=a,this):this._yoyo},j.currentLabel=function(a){return arguments.length?this.seek(a,!0):this.getLabelBefore(this._time+1e-8)},d},!0),_gsScope._gsDefine("TimelineLite",["core.Animation","core.SimpleTimeline","TweenLite"],function(a,b,c){var d=function(a){b.call(this,a),this._labels={},this.autoRemoveChildren=this.vars.autoRemoveChildren===!0,this.smoothChildTiming=this.vars.smoothChildTiming===!0,this._sortChildren=!0,this._onUpdate=this.vars.onUpdate;var c,d,e=this.vars;for(d in e)c=e[d],i(c)&&-1!==c.join("").indexOf("{self}")&&(e[d]=this._swapSelfInParams(c));i(e.tweens)&&this.add(e.tweens,0,e.align,e.stagger)},e=1e-10,f=c._internals,g=d._internals={},h=f.isSelector,i=f.isArray,j=f.lazyTweens,k=f.lazyRender,l=_gsScope._gsDefine.globals,m=function(a){var b,c={};for(b in a)c[b]=a[b];return c},n=function(a,b,c){var d,e,f=a.cycle;for(d in f)e=f[d],a[d]="function"==typeof e?e.call(b[c],c):e[c%e.length];delete a.cycle},o=g.pauseCallback=function(){},p=function(a){var b,c=[],d=a.length;for(b=0;b!==d;c.push(a[b++]));return c},q=d.prototype=new b;return d.version="1.18.5",q.constructor=d,q.kill()._gc=q._forcingPlayhead=q._hasPause=!1,q.to=function(a,b,d,e){var f=d.repeat&&l.TweenMax||c;return b?this.add(new f(a,b,d),e):this.set(a,d,e)},q.from=function(a,b,d,e){return this.add((d.repeat&&l.TweenMax||c).from(a,b,d),e)},q.fromTo=function(a,b,d,e,f){var g=e.repeat&&l.TweenMax||c;return b?this.add(g.fromTo(a,b,d,e),f):this.set(a,e,f)},q.staggerTo=function(a,b,e,f,g,i,j,k){var l,o,q=new d({onComplete:i,onCompleteParams:j,callbackScope:k,smoothChildTiming:this.smoothChildTiming}),r=e.cycle;for("string"==typeof a&&(a=c.selector(a)||a),a=a||[],h(a)&&(a=p(a)),f=f||0,0>f&&(a=p(a),a.reverse(),f*=-1),o=0;ol;l++)i(m=e[l])&&(m=new d({tweens:m})),this.add(m,j),"string"!=typeof m&&"function"!=typeof m&&("sequence"===g?j=m._startTime+m.totalDuration()/m._timeScale:"start"===g&&(m._startTime-=m.delay())),j+=h;return this._uncache(!0)}if("string"==typeof e)return this.addLabel(e,f);if("function"!=typeof e)throw"Cannot add "+e+" into the timeline; it is not a tween, timeline, function, or string.";e=c.delayedCall(0,e)}if(b.prototype.add.call(this,e,f),(this._gc||this._time===this._duration)&&!this._paused&&this._duratione._startTime;n._timeline;)o&&n._timeline.smoothChildTiming?n.totalTime(n._totalTime,!0):n._gc&&n._enabled(!0,!1),n=n._timeline;return this},q.remove=function(b){if(b instanceof a){this._remove(b,!1);var c=b._timeline=b.vars.useFrames?a._rootFramesTimeline:a._rootTimeline;return b._startTime=(b._paused?b._pauseTime:c._time)-(b._reversed?b.totalDuration()-b._totalTime:b._totalTime)/b._timeScale,this}if(b instanceof Array||b&&b.push&&i(b)){for(var d=b.length;--d>-1;)this.remove(b[d]);return this}return"string"==typeof b?this.removeLabel(b):this.kill(null,b)},q._remove=function(a,c){b.prototype._remove.call(this,a,c);var d=this._last;return d?this._time>d._startTime+d._totalDuration/d._timeScale&&(this._time=this.duration(),this._totalTime=this._totalDuration):this._time=this._totalTime=this._duration=this._totalDuration=0,this},q.append=function(a,b){return this.add(a,this._parseTimeOrLabel(null,b,!0,a))},q.insert=q.insertMultiple=function(a,b,c,d){return this.add(a,b||0,c,d)},q.appendMultiple=function(a,b,c,d){return this.add(a,this._parseTimeOrLabel(null,b,!0,a),c,d)},q.addLabel=function(a,b){return this._labels[a]=this._parseTimeOrLabel(b),this},q.addPause=function(a,b,d,e){var f=c.delayedCall(0,o,d,e||this);return f.vars.onComplete=f.vars.onReverseComplete=b,f.data="isPause",this._hasPause=!0,this.add(f,a)},q.removeLabel=function(a){return delete this._labels[a],this},q.getLabelTime=function(a){return null!=this._labels[a]?this._labels[a]:-1},q._parseTimeOrLabel=function(b,c,d,e){var f;if(e instanceof a&&e.timeline===this)this.remove(e);else if(e&&(e instanceof Array||e.push&&i(e)))for(f=e.length;--f>-1;)e[f]instanceof a&&e[f].timeline===this&&this.remove(e[f]);if("string"==typeof c)return this._parseTimeOrLabel(c,d&&"number"==typeof b&&null==this._labels[c]?b-this.duration():0,d);if(c=c||0,"string"!=typeof b||!isNaN(b)&&null==this._labels[b])null==b&&(b=this.duration());else{if(f=b.indexOf("="),-1===f)return null==this._labels[b]?d?this._labels[b]=this.duration()+c:c:this._labels[b]+c;c=parseInt(b.charAt(f-1)+"1",10)*Number(b.substr(f+1)),b=f>1?this._parseTimeOrLabel(b.substr(0,f-1),0,d):this.duration()}return Number(b)+c},q.seek=function(a,b){return this.totalTime("number"==typeof a?a:this._parseTimeOrLabel(a),b!==!1)},q.stop=function(){return this.paused(!0)},q.gotoAndPlay=function(a,b){return this.play(a,b)},q.gotoAndStop=function(a,b){return this.pause(a,b)},q.render=function(a,b,c){this._gc&&this._enabled(!0,!1);var d,f,g,h,i,l,m,n=this._dirty?this.totalDuration():this._totalDuration,o=this._time,p=this._startTime,q=this._timeScale,r=this._paused;if(a>=n-1e-7)this._totalTime=this._time=n,this._reversed||this._hasPausedChild()||(f=!0,h="onComplete",i=!!this._timeline.autoRemoveChildren,0===this._duration&&(0>=a&&a>=-1e-7||this._rawPrevTime<0||this._rawPrevTime===e)&&this._rawPrevTime!==a&&this._first&&(i=!0,this._rawPrevTime>e&&(h="onReverseComplete"))),this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,a=n+1e-4;else if(1e-7>a)if(this._totalTime=this._time=0,(0!==o||0===this._duration&&this._rawPrevTime!==e&&(this._rawPrevTime>0||0>a&&this._rawPrevTime>=0))&&(h="onReverseComplete",f=this._reversed),0>a)this._active=!1,this._timeline.autoRemoveChildren&&this._reversed?(i=f=!0,h="onReverseComplete"):this._rawPrevTime>=0&&this._first&&(i=!0),this._rawPrevTime=a;else{if(this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,0===a&&f)for(d=this._first;d&&0===d._startTime;)d._duration||(f=!1),d=d._next;a=0,this._initted||(i=!0)}else{if(this._hasPause&&!this._forcingPlayhead&&!b){if(a>=o)for(d=this._first;d&&d._startTime<=a&&!l;)d._duration||"isPause"!==d.data||d.ratio||0===d._startTime&&0===this._rawPrevTime||(l=d),d=d._next;else for(d=this._last;d&&d._startTime>=a&&!l;)d._duration||"isPause"===d.data&&d._rawPrevTime>0&&(l=d),d=d._prev;l&&(this._time=a=l._startTime,this._totalTime=a+this._cycle*(this._totalDuration+this._repeatDelay))}this._totalTime=this._time=this._rawPrevTime=a}if(this._time!==o&&this._first||c||i||l){if(this._initted||(this._initted=!0),this._active||!this._paused&&this._time!==o&&a>0&&(this._active=!0),0===o&&this.vars.onStart&&(0===this._time&&this._duration||b||this._callback("onStart")),m=this._time,m>=o)for(d=this._first;d&&(g=d._next,m===this._time&&(!this._paused||r));)(d._active||d._startTime<=m&&!d._paused&&!d._gc)&&(l===d&&this.pause(),d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)),d=g;else for(d=this._last;d&&(g=d._prev,m===this._time&&(!this._paused||r));){if(d._active||d._startTime<=o&&!d._paused&&!d._gc){if(l===d){for(l=d._prev;l&&l.endTime()>this._time;)l.render(l._reversed?l.totalDuration()-(a-l._startTime)*l._timeScale:(a-l._startTime)*l._timeScale,b,c),l=l._prev;l=null,this.pause()}d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)}d=g}this._onUpdate&&(b||(j.length&&k(),this._callback("onUpdate"))),h&&(this._gc||(p===this._startTime||q!==this._timeScale)&&(0===this._time||n>=this.totalDuration())&&(f&&(j.length&&k(),this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[h]&&this._callback(h)))}},q._hasPausedChild=function(){for(var a=this._first;a;){if(a._paused||a instanceof d&&a._hasPausedChild())return!0;a=a._next}return!1},q.getChildren=function(a,b,d,e){e=e||-9999999999;for(var f=[],g=this._first,h=0;g;)g._startTime-1;)(d[e].timeline===this||b&&this._contains(d[e]))&&(g[h++]=d[e]);return f&&this._enabled(!1,!0),g},q.recent=function(){return this._recent},q._contains=function(a){for(var b=a.timeline;b;){if(b===this)return!0;b=b.timeline}return!1},q.shiftChildren=function(a,b,c){c=c||0;for(var d,e=this._first,f=this._labels;e;)e._startTime>=c&&(e._startTime+=a),e=e._next;if(b)for(d in f)f[d]>=c&&(f[d]+=a);return this._uncache(!0)},q._kill=function(a,b){if(!a&&!b)return this._enabled(!1,!1);for(var c=b?this.getTweensOf(b):this.getChildren(!0,!0,!1),d=c.length,e=!1;--d>-1;)c[d]._kill(a,b)&&(e=!0);return e},q.clear=function(a){var b=this.getChildren(!1,!0,!0),c=b.length;for(this._time=this._totalTime=0;--c>-1;)b[c]._enabled(!1,!1);return a!==!1&&(this._labels={}),this._uncache(!0)},q.invalidate=function(){for(var b=this._first;b;)b.invalidate(),b=b._next;return a.prototype.invalidate.call(this)},q._enabled=function(a,c){if(a===this._gc)for(var d=this._first;d;)d._enabled(a,!0),d=d._next;return b.prototype._enabled.call(this,a,c)},q.totalTime=function(b,c,d){this._forcingPlayhead=!0;var e=a.prototype.totalTime.apply(this,arguments);return this._forcingPlayhead=!1,e},q.duration=function(a){return arguments.length?(0!==this.duration()&&0!==a&&this.timeScale(this._duration/a),this):(this._dirty&&this.totalDuration(),this._duration)},q.totalDuration=function(a){if(!arguments.length){if(this._dirty){for(var b,c,d=0,e=this._last,f=999999999999;e;)b=e._prev,e._dirty&&e.totalDuration(),e._startTime>f&&this._sortChildren&&!e._paused?this.add(e,e._startTime-e._delay):f=e._startTime,e._startTime<0&&!e._paused&&(d-=e._startTime,this._timeline.smoothChildTiming&&(this._startTime+=e._startTime/this._timeScale),this.shiftChildren(-e._startTime,!1,-9999999999),f=0),c=e._startTime+e._totalDuration/e._timeScale,c>d&&(d=c),e=b;this._duration=this._totalDuration=d,this._dirty=!1}return this._totalDuration}return a&&this.totalDuration()?this.timeScale(this._totalDuration/a):this},q.paused=function(b){if(!b)for(var c=this._first,d=this._time;c;)c._startTime===d&&"isPause"===c.data&&(c._rawPrevTime=0),c=c._next;return a.prototype.paused.apply(this,arguments)},q.usesFrames=function(){for(var b=this._timeline;b._timeline;)b=b._timeline;return b===a._rootFramesTimeline},q.rawTime=function(){return this._paused?this._totalTime:(this._timeline.rawTime()-this._startTime)*this._timeScale},d},!0)}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(),function(a){"use strict";var b=function(){return(_gsScope.GreenSockGlobals||_gsScope)[a]};"function"==typeof define&&define.amd?define(["./TweenLite"],b):"undefined"!=typeof module&&module.exports&&(require("./TweenLite.js"),module.exports=b())}("TimelineMax"); \ No newline at end of file diff --git a/resources/html5app/js/gsap/TweenLite.js b/resources/html5app/js/gsap/TweenLite.js new file mode 100644 index 000000000..5a4bc04f0 --- /dev/null +++ b/resources/html5app/js/gsap/TweenLite.js @@ -0,0 +1,1896 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +(function(window, moduleName) { + + "use strict"; + var _exports = {}, + _globals = window.GreenSockGlobals = window.GreenSockGlobals || window; + if (_globals.TweenLite) { + return; //in case the core set of classes is already loaded, don't instantiate twice. + } + var _namespace = function(ns) { + var a = ns.split("."), + p = _globals, i; + for (i = 0; i < a.length; i++) { + p[a[i]] = p = p[a[i]] || {}; + } + return p; + }, + gs = _namespace("com.greensock"), + _tinyNum = 0.0000000001, + _slice = function(a) { //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() + var b = [], + l = a.length, + i; + for (i = 0; i !== l; b.push(a[i++])) {} + return b; + }, + _emptyFunc = function() {}, + _isArray = (function() { //works around issues in iframe environments where the Array global isn't shared, thus if the object originates in a different window/iframe, "(obj instanceof Array)" will evaluate false. We added some speed optimizations to avoid Object.prototype.toString.call() unless it's absolutely necessary because it's VERY slow (like 20x slower) + var toString = Object.prototype.toString, + array = toString.call([]); + return function(obj) { + return obj != null && (obj instanceof Array || (typeof(obj) === "object" && !!obj.push && toString.call(obj) === array)); + }; + }()), + a, i, p, _ticker, _tickerActive, + _defLookup = {}, + + /** + * @constructor + * Defines a GreenSock class, optionally with an array of dependencies that must be instantiated first and passed into the definition. + * This allows users to load GreenSock JS files in any order even if they have interdependencies (like CSSPlugin extends TweenPlugin which is + * inside TweenLite.js, but if CSSPlugin is loaded first, it should wait to run its code until TweenLite.js loads and instantiates TweenPlugin + * and then pass TweenPlugin to CSSPlugin's definition). This is all done automatically and internally. + * + * Every definition will be added to a "com.greensock" global object (typically window, but if a window.GreenSockGlobals object is found, + * it will go there as of v1.7). For example, TweenLite will be found at window.com.greensock.TweenLite and since it's a global class that should be available anywhere, + * it is ALSO referenced at window.TweenLite. However some classes aren't considered global, like the base com.greensock.core.Animation class, so + * those will only be at the package like window.com.greensock.core.Animation. Again, if you define a GreenSockGlobals object on the window, everything + * gets tucked neatly inside there instead of on the window directly. This allows you to do advanced things like load multiple versions of GreenSock + * files and put them into distinct objects (imagine a banner ad uses a newer version but the main site uses an older one). In that case, you could + * sandbox the banner one like: + * + * + * + * + * + * + * + * @param {!string} ns The namespace of the class definition, leaving off "com.greensock." as that's assumed. For example, "TweenLite" or "plugins.CSSPlugin" or "easing.Back". + * @param {!Array.} dependencies An array of dependencies (described as their namespaces minus "com.greensock." prefix). For example ["TweenLite","plugins.TweenPlugin","core.Animation"] + * @param {!function():Object} func The function that should be called and passed the resolved dependencies which will return the actual class for this definition. + * @param {boolean=} global If true, the class will be added to the global scope (typically window unless you define a window.GreenSockGlobals object) + */ + Definition = function(ns, dependencies, func, global) { + this.sc = (_defLookup[ns]) ? _defLookup[ns].sc : []; //subclasses + _defLookup[ns] = this; + this.gsClass = null; + this.func = func; + var _classes = []; + this.check = function(init) { + var i = dependencies.length, + missing = i, + cur, a, n, cl, hasModule; + while (--i > -1) { + if ((cur = _defLookup[dependencies[i]] || new Definition(dependencies[i], [])).gsClass) { + _classes[i] = cur.gsClass; + missing--; + } else if (init) { + cur.sc.push(this); + } + } + if (missing === 0 && func) { + a = ("com.greensock." + ns).split("."); + n = a.pop(); + cl = _namespace(a.join("."))[n] = this.gsClass = func.apply(func, _classes); + + //exports to multiple environments + if (global) { + _globals[n] = cl; //provides a way to avoid global namespace pollution. By default, the main classes like TweenLite, Power1, Strong, etc. are added to window unless a GreenSockGlobals is defined. So if you want to have things added to a custom object instead, just do something like window.GreenSockGlobals = {} before loading any GreenSock files. You can even set up an alias like window.GreenSockGlobals = windows.gs = {} so that you can access everything like gs.TweenLite. Also remember that ALL classes are added to the window.com.greensock object (in their respective packages, like com.greensock.easing.Power1, com.greensock.TweenLite, etc.) + hasModule = (typeof(module) !== "undefined" && module.exports); + if (!hasModule && typeof(define) === "function" && define.amd){ //AMD + define((window.GreenSockAMDPath ? window.GreenSockAMDPath + "/" : "") + ns.split(".").pop(), [], function() { return cl; }); + } else if (hasModule){ //node + if (ns === moduleName) { + module.exports = _exports[moduleName] = cl; + for (i in _exports) { + cl[i] = _exports[i]; + } + } else if (_exports[moduleName]) { + _exports[moduleName][n] = cl; + } + } + } + for (i = 0; i < this.sc.length; i++) { + this.sc[i].check(); + } + } + }; + this.check(true); + }, + + //used to create Definition instances (which basically registers a class that has dependencies). + _gsDefine = window._gsDefine = function(ns, dependencies, func, global) { + return new Definition(ns, dependencies, func, global); + }, + + //a quick way to create a class that doesn't have any dependencies. Returns the class, but first registers it in the GreenSock namespace so that other classes can grab it (other classes might be dependent on the class). + _class = gs._class = function(ns, func, global) { + func = func || function() {}; + _gsDefine(ns, [], function(){ return func; }, global); + return func; + }; + + _gsDefine.globals = _globals; + + + +/* + * ---------------------------------------------------------------- + * Ease + * ---------------------------------------------------------------- + */ + var _baseParams = [0, 0, 1, 1], + _blankArray = [], + Ease = _class("easing.Ease", function(func, extraParams, type, power) { + this._func = func; + this._type = type || 0; + this._power = power || 0; + this._params = extraParams ? _baseParams.concat(extraParams) : _baseParams; + }, true), + _easeMap = Ease.map = {}, + _easeReg = Ease.register = function(ease, names, types, create) { + var na = names.split(","), + i = na.length, + ta = (types || "easeIn,easeOut,easeInOut").split(","), + e, name, j, type; + while (--i > -1) { + name = na[i]; + e = create ? _class("easing."+name, null, true) : gs.easing[name] || {}; + j = ta.length; + while (--j > -1) { + type = ta[j]; + _easeMap[name + "." + type] = _easeMap[type + name] = e[type] = ease.getRatio ? ease : ease[type] || new ease(); + } + } + }; + + p = Ease.prototype; + p._calcEnd = false; + p.getRatio = function(p) { + if (this._func) { + this._params[0] = p; + return this._func.apply(null, this._params); + } + var t = this._type, + pw = this._power, + r = (t === 1) ? 1 - p : (t === 2) ? p : (p < 0.5) ? p * 2 : (1 - p) * 2; + if (pw === 1) { + r *= r; + } else if (pw === 2) { + r *= r * r; + } else if (pw === 3) { + r *= r * r * r; + } else if (pw === 4) { + r *= r * r * r * r; + } + return (t === 1) ? 1 - r : (t === 2) ? r : (p < 0.5) ? r / 2 : 1 - (r / 2); + }; + + //create all the standard eases like Linear, Quad, Cubic, Quart, Quint, Strong, Power0, Power1, Power2, Power3, and Power4 (each with easeIn, easeOut, and easeInOut) + a = ["Linear","Quad","Cubic","Quart","Quint,Strong"]; + i = a.length; + while (--i > -1) { + p = a[i]+",Power"+i; + _easeReg(new Ease(null,null,1,i), p, "easeOut", true); + _easeReg(new Ease(null,null,2,i), p, "easeIn" + ((i === 0) ? ",easeNone" : "")); + _easeReg(new Ease(null,null,3,i), p, "easeInOut"); + } + _easeMap.linear = gs.easing.Linear.easeIn; + _easeMap.swing = gs.easing.Quad.easeInOut; //for jQuery folks + + +/* + * ---------------------------------------------------------------- + * EventDispatcher + * ---------------------------------------------------------------- + */ + var EventDispatcher = _class("events.EventDispatcher", function(target) { + this._listeners = {}; + this._eventTarget = target || this; + }); + p = EventDispatcher.prototype; + + p.addEventListener = function(type, callback, scope, useParam, priority) { + priority = priority || 0; + var list = this._listeners[type], + index = 0, + listener, i; + if (this === _ticker && !_tickerActive) { + _ticker.wake(); + } + if (list == null) { + this._listeners[type] = list = []; + } + i = list.length; + while (--i > -1) { + listener = list[i]; + if (listener.c === callback && listener.s === scope) { + list.splice(i, 1); + } else if (index === 0 && listener.pr < priority) { + index = i + 1; + } + } + list.splice(index, 0, {c:callback, s:scope, up:useParam, pr:priority}); + }; + + p.removeEventListener = function(type, callback) { + var list = this._listeners[type], i; + if (list) { + i = list.length; + while (--i > -1) { + if (list[i].c === callback) { + list.splice(i, 1); + return; + } + } + } + }; + + p.dispatchEvent = function(type) { + var list = this._listeners[type], + i, t, listener; + if (list) { + i = list.length; + t = this._eventTarget; + while (--i > -1) { + listener = list[i]; + if (listener) { + if (listener.up) { + listener.c.call(listener.s || t, {type:type, target:t}); + } else { + listener.c.call(listener.s || t); + } + } + } + } + }; + + +/* + * ---------------------------------------------------------------- + * Ticker + * ---------------------------------------------------------------- + */ + var _reqAnimFrame = window.requestAnimationFrame, + _cancelAnimFrame = window.cancelAnimationFrame, + _getTime = Date.now || function() {return new Date().getTime();}, + _lastUpdate = _getTime(); + + //now try to determine the requestAnimationFrame and cancelAnimationFrame functions and if none are found, we'll use a setTimeout()/clearTimeout() polyfill. + a = ["ms","moz","webkit","o"]; + i = a.length; + while (--i > -1 && !_reqAnimFrame) { + _reqAnimFrame = window[a[i] + "RequestAnimationFrame"]; + _cancelAnimFrame = window[a[i] + "CancelAnimationFrame"] || window[a[i] + "CancelRequestAnimationFrame"]; + } + + _class("Ticker", function(fps, useRAF) { + var _self = this, + _startTime = _getTime(), + _useRAF = (useRAF !== false && _reqAnimFrame) ? "auto" : false, + _lagThreshold = 500, + _adjustedLag = 33, + _tickWord = "tick", //helps reduce gc burden + _fps, _req, _id, _gap, _nextTime, + _tick = function(manual) { + var elapsed = _getTime() - _lastUpdate, + overlap, dispatch; + if (elapsed > _lagThreshold) { + _startTime += elapsed - _adjustedLag; + } + _lastUpdate += elapsed; + _self.time = (_lastUpdate - _startTime) / 1000; + overlap = _self.time - _nextTime; + if (!_fps || overlap > 0 || manual === true) { + _self.frame++; + _nextTime += overlap + (overlap >= _gap ? 0.004 : _gap - overlap); + dispatch = true; + } + if (manual !== true) { //make sure the request is made before we dispatch the "tick" event so that timing is maintained. Otherwise, if processing the "tick" requires a bunch of time (like 15ms) and we're using a setTimeout() that's based on 16.7ms, it'd technically take 31.7ms between frames otherwise. + _id = _req(_tick); + } + if (dispatch) { + _self.dispatchEvent(_tickWord); + } + }; + + EventDispatcher.call(_self); + _self.time = _self.frame = 0; + _self.tick = function() { + _tick(true); + }; + + _self.lagSmoothing = function(threshold, adjustedLag) { + _lagThreshold = threshold || (1 / _tinyNum); //zero should be interpreted as basically unlimited + _adjustedLag = Math.min(adjustedLag, _lagThreshold, 0); + }; + + _self.sleep = function() { + if (_id == null) { + return; + } + if (!_useRAF || !_cancelAnimFrame) { + clearTimeout(_id); + } else { + _cancelAnimFrame(_id); + } + _req = _emptyFunc; + _id = null; + if (_self === _ticker) { + _tickerActive = false; + } + }; + + _self.wake = function(seamless) { + if (_id !== null) { + _self.sleep(); + } else if (seamless) { + _startTime += -_lastUpdate + (_lastUpdate = _getTime()); + } else if (_self.frame > 10) { //don't trigger lagSmoothing if we're just waking up, and make sure that at least 10 frames have elapsed because of the iOS bug that we work around below with the 1.5-second setTimout(). + _lastUpdate = _getTime() - _lagThreshold + 5; + } + _req = (_fps === 0) ? _emptyFunc : (!_useRAF || !_reqAnimFrame) ? function(f) { return setTimeout(f, ((_nextTime - _self.time) * 1000 + 1) | 0); } : _reqAnimFrame; + if (_self === _ticker) { + _tickerActive = true; + } + _tick(2); + }; + + _self.fps = function(value) { + if (!arguments.length) { + return _fps; + } + _fps = value; + _gap = 1 / (_fps || 60); + _nextTime = this.time + _gap; + _self.wake(); + }; + + _self.useRAF = function(value) { + if (!arguments.length) { + return _useRAF; + } + _self.sleep(); + _useRAF = value; + _self.fps(_fps); + }; + _self.fps(fps); + + //a bug in iOS 6 Safari occasionally prevents the requestAnimationFrame from working initially, so we use a 1.5-second timeout that automatically falls back to setTimeout() if it senses this condition. + setTimeout(function() { + if (_useRAF === "auto" && _self.frame < 5 && document.visibilityState !== "hidden") { + _self.useRAF(false); + } + }, 1500); + }); + + p = gs.Ticker.prototype = new gs.events.EventDispatcher(); + p.constructor = gs.Ticker; + + +/* + * ---------------------------------------------------------------- + * Animation + * ---------------------------------------------------------------- + */ + var Animation = _class("core.Animation", function(duration, vars) { + this.vars = vars = vars || {}; + this._duration = this._totalDuration = duration || 0; + this._delay = Number(vars.delay) || 0; + this._timeScale = 1; + this._active = (vars.immediateRender === true); + this.data = vars.data; + this._reversed = (vars.reversed === true); + + if (!_rootTimeline) { + return; + } + if (!_tickerActive) { //some browsers (like iOS 6 Safari) shut down JavaScript execution when the tab is disabled and they [occasionally] neglect to start up requestAnimationFrame again when returning - this code ensures that the engine starts up again properly. + _ticker.wake(); + } + + var tl = this.vars.useFrames ? _rootFramesTimeline : _rootTimeline; + tl.add(this, tl._time); + + if (this.vars.paused) { + this.paused(true); + } + }); + + _ticker = Animation.ticker = new gs.Ticker(); + p = Animation.prototype; + p._dirty = p._gc = p._initted = p._paused = false; + p._totalTime = p._time = 0; + p._rawPrevTime = -1; + p._next = p._last = p._onUpdate = p._timeline = p.timeline = null; + p._paused = false; + + + //some browsers (like iOS) occasionally drop the requestAnimationFrame event when the user switches to a different tab and then comes back again, so we use a 2-second setTimeout() to sense if/when that condition occurs and then wake() the ticker. + var _checkTimeout = function() { + if (_tickerActive && _getTime() - _lastUpdate > 2000) { + _ticker.wake(); + } + setTimeout(_checkTimeout, 2000); + }; + _checkTimeout(); + + + p.play = function(from, suppressEvents) { + if (from != null) { + this.seek(from, suppressEvents); + } + return this.reversed(false).paused(false); + }; + + p.pause = function(atTime, suppressEvents) { + if (atTime != null) { + this.seek(atTime, suppressEvents); + } + return this.paused(true); + }; + + p.resume = function(from, suppressEvents) { + if (from != null) { + this.seek(from, suppressEvents); + } + return this.paused(false); + }; + + p.seek = function(time, suppressEvents) { + return this.totalTime(Number(time), suppressEvents !== false); + }; + + p.restart = function(includeDelay, suppressEvents) { + return this.reversed(false).paused(false).totalTime(includeDelay ? -this._delay : 0, (suppressEvents !== false), true); + }; + + p.reverse = function(from, suppressEvents) { + if (from != null) { + this.seek((from || this.totalDuration()), suppressEvents); + } + return this.reversed(true).paused(false); + }; + + p.render = function(time, suppressEvents, force) { + //stub - we override this method in subclasses. + }; + + p.invalidate = function() { + this._time = this._totalTime = 0; + this._initted = this._gc = false; + this._rawPrevTime = -1; + if (this._gc || !this.timeline) { + this._enabled(true); + } + return this; + }; + + p.isActive = function() { + var tl = this._timeline, //the 2 root timelines won't have a _timeline; they're always active. + startTime = this._startTime, + rawTime; + return (!tl || (!this._gc && !this._paused && tl.isActive() && (rawTime = tl.rawTime()) >= startTime && rawTime < startTime + this.totalDuration() / this._timeScale)); + }; + + p._enabled = function (enabled, ignoreTimeline) { + if (!_tickerActive) { + _ticker.wake(); + } + this._gc = !enabled; + this._active = this.isActive(); + if (ignoreTimeline !== true) { + if (enabled && !this.timeline) { + this._timeline.add(this, this._startTime - this._delay); + } else if (!enabled && this.timeline) { + this._timeline._remove(this, true); + } + } + return false; + }; + + + p._kill = function(vars, target) { + return this._enabled(false, false); + }; + + p.kill = function(vars, target) { + this._kill(vars, target); + return this; + }; + + p._uncache = function(includeSelf) { + var tween = includeSelf ? this : this.timeline; + while (tween) { + tween._dirty = true; + tween = tween.timeline; + } + return this; + }; + + p._swapSelfInParams = function(params) { + var i = params.length, + copy = params.concat(); + while (--i > -1) { + if (params[i] === "{self}") { + copy[i] = this; + } + } + return copy; + }; + + p._callback = function(type) { + var v = this.vars; + v[type].apply(v[type + "Scope"] || v.callbackScope || this, v[type + "Params"] || _blankArray); + }; + +//----Animation getters/setters -------------------------------------------------------- + + p.eventCallback = function(type, callback, params, scope) { + if ((type || "").substr(0,2) === "on") { + var v = this.vars; + if (arguments.length === 1) { + return v[type]; + } + if (callback == null) { + delete v[type]; + } else { + v[type] = callback; + v[type + "Params"] = (_isArray(params) && params.join("").indexOf("{self}") !== -1) ? this._swapSelfInParams(params) : params; + v[type + "Scope"] = scope; + } + if (type === "onUpdate") { + this._onUpdate = callback; + } + } + return this; + }; + + p.delay = function(value) { + if (!arguments.length) { + return this._delay; + } + if (this._timeline.smoothChildTiming) { + this.startTime( this._startTime + value - this._delay ); + } + this._delay = value; + return this; + }; + + p.duration = function(value) { + if (!arguments.length) { + this._dirty = false; + return this._duration; + } + this._duration = this._totalDuration = value; + this._uncache(true); //true in case it's a TweenMax or TimelineMax that has a repeat - we'll need to refresh the totalDuration. + if (this._timeline.smoothChildTiming) if (this._time > 0) if (this._time < this._duration) if (value !== 0) { + this.totalTime(this._totalTime * (value / this._duration), true); + } + return this; + }; + + p.totalDuration = function(value) { + this._dirty = false; + return (!arguments.length) ? this._totalDuration : this.duration(value); + }; + + p.time = function(value, suppressEvents) { + if (!arguments.length) { + return this._time; + } + if (this._dirty) { + this.totalDuration(); + } + return this.totalTime((value > this._duration) ? this._duration : value, suppressEvents); + }; + + p.totalTime = function(time, suppressEvents, uncapped) { + if (!_tickerActive) { + _ticker.wake(); + } + if (!arguments.length) { + return this._totalTime; + } + if (this._timeline) { + if (time < 0 && !uncapped) { + time += this.totalDuration(); + } + if (this._timeline.smoothChildTiming) { + if (this._dirty) { + this.totalDuration(); + } + var totalDuration = this._totalDuration, + tl = this._timeline; + if (time > totalDuration && !uncapped) { + time = totalDuration; + } + this._startTime = (this._paused ? this._pauseTime : tl._time) - ((!this._reversed ? time : totalDuration - time) / this._timeScale); + if (!tl._dirty) { //for performance improvement. If the parent's cache is already dirty, it already took care of marking the ancestors as dirty too, so skip the function call here. + this._uncache(false); + } + //in case any of the ancestor timelines had completed but should now be enabled, we should reset their totalTime() which will also ensure that they're lined up properly and enabled. Skip for animations that are on the root (wasteful). Example: a TimelineLite.exportRoot() is performed when there's a paused tween on the root, the export will not complete until that tween is unpaused, but imagine a child gets restarted later, after all [unpaused] tweens have completed. The startTime of that child would get pushed out, but one of the ancestors may have completed. + if (tl._timeline) { + while (tl._timeline) { + if (tl._timeline._time !== (tl._startTime + tl._totalTime) / tl._timeScale) { + tl.totalTime(tl._totalTime, true); + } + tl = tl._timeline; + } + } + } + if (this._gc) { + this._enabled(true, false); + } + if (this._totalTime !== time || this._duration === 0) { + if (_lazyTweens.length) { + _lazyRender(); + } + this.render(time, suppressEvents, false); + if (_lazyTweens.length) { //in case rendering caused any tweens to lazy-init, we should render them because typically when someone calls seek() or time() or progress(), they expect an immediate render. + _lazyRender(); + } + } + } + return this; + }; + + p.progress = p.totalProgress = function(value, suppressEvents) { + var duration = this.duration(); + return (!arguments.length) ? (duration ? this._time / duration : this.ratio) : this.totalTime(duration * value, suppressEvents); + }; + + p.startTime = function(value) { + if (!arguments.length) { + return this._startTime; + } + if (value !== this._startTime) { + this._startTime = value; + if (this.timeline) if (this.timeline._sortChildren) { + this.timeline.add(this, value - this._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct. + } + } + return this; + }; + + p.endTime = function(includeRepeats) { + return this._startTime + ((includeRepeats != false) ? this.totalDuration() : this.duration()) / this._timeScale; + }; + + p.timeScale = function(value) { + if (!arguments.length) { + return this._timeScale; + } + value = value || _tinyNum; //can't allow zero because it'll throw the math off + if (this._timeline && this._timeline.smoothChildTiming) { + var pauseTime = this._pauseTime, + t = (pauseTime || pauseTime === 0) ? pauseTime : this._timeline.totalTime(); + this._startTime = t - ((t - this._startTime) * this._timeScale / value); + } + this._timeScale = value; + return this._uncache(false); + }; + + p.reversed = function(value) { + if (!arguments.length) { + return this._reversed; + } + if (value != this._reversed) { + this._reversed = value; + this.totalTime(((this._timeline && !this._timeline.smoothChildTiming) ? this.totalDuration() - this._totalTime : this._totalTime), true); + } + return this; + }; + + p.paused = function(value) { + if (!arguments.length) { + return this._paused; + } + var tl = this._timeline, + raw, elapsed; + if (value != this._paused) if (tl) { + if (!_tickerActive && !value) { + _ticker.wake(); + } + raw = tl.rawTime(); + elapsed = raw - this._pauseTime; + if (!value && tl.smoothChildTiming) { + this._startTime += elapsed; + this._uncache(false); + } + this._pauseTime = value ? raw : null; + this._paused = value; + this._active = this.isActive(); + if (!value && elapsed !== 0 && this._initted && this.duration()) { + raw = tl.smoothChildTiming ? this._totalTime : (raw - this._startTime) / this._timeScale; + this.render(raw, (raw === this._totalTime), true); //in case the target's properties changed via some other tween or manual update by the user, we should force a render. + } + } + if (this._gc && !value) { + this._enabled(true, false); + } + return this; + }; + + +/* + * ---------------------------------------------------------------- + * SimpleTimeline + * ---------------------------------------------------------------- + */ + var SimpleTimeline = _class("core.SimpleTimeline", function(vars) { + Animation.call(this, 0, vars); + this.autoRemoveChildren = this.smoothChildTiming = true; + }); + + p = SimpleTimeline.prototype = new Animation(); + p.constructor = SimpleTimeline; + p.kill()._gc = false; + p._first = p._last = p._recent = null; + p._sortChildren = false; + + p.add = p.insert = function(child, position, align, stagger) { + var prevTween, st; + child._startTime = Number(position || 0) + child._delay; + if (child._paused) if (this !== child._timeline) { //we only adjust the _pauseTime if it wasn't in this timeline already. Remember, sometimes a tween will be inserted again into the same timeline when its startTime is changed so that the tweens in the TimelineLite/Max are re-ordered properly in the linked list (so everything renders in the proper order). + child._pauseTime = child._startTime + ((this.rawTime() - child._startTime) / child._timeScale); + } + if (child.timeline) { + child.timeline._remove(child, true); //removes from existing timeline so that it can be properly added to this one. + } + child.timeline = child._timeline = this; + if (child._gc) { + child._enabled(true, true); + } + prevTween = this._last; + if (this._sortChildren) { + st = child._startTime; + while (prevTween && prevTween._startTime > st) { + prevTween = prevTween._prev; + } + } + if (prevTween) { + child._next = prevTween._next; + prevTween._next = child; + } else { + child._next = this._first; + this._first = child; + } + if (child._next) { + child._next._prev = child; + } else { + this._last = child; + } + child._prev = prevTween; + this._recent = child; + if (this._timeline) { + this._uncache(true); + } + return this; + }; + + p._remove = function(tween, skipDisable) { + if (tween.timeline === this) { + if (!skipDisable) { + tween._enabled(false, true); + } + + if (tween._prev) { + tween._prev._next = tween._next; + } else if (this._first === tween) { + this._first = tween._next; + } + if (tween._next) { + tween._next._prev = tween._prev; + } else if (this._last === tween) { + this._last = tween._prev; + } + tween._next = tween._prev = tween.timeline = null; + if (tween === this._recent) { + this._recent = this._last; + } + + if (this._timeline) { + this._uncache(true); + } + } + return this; + }; + + p.render = function(time, suppressEvents, force) { + var tween = this._first, + next; + this._totalTime = this._time = this._rawPrevTime = time; + while (tween) { + next = tween._next; //record it here because the value could change after rendering... + if (tween._active || (time >= tween._startTime && !tween._paused)) { + if (!tween._reversed) { + tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force); + } else { + tween.render(((!tween._dirty) ? tween._totalDuration : tween.totalDuration()) - ((time - tween._startTime) * tween._timeScale), suppressEvents, force); + } + } + tween = next; + } + }; + + p.rawTime = function() { + if (!_tickerActive) { + _ticker.wake(); + } + return this._totalTime; + }; + +/* + * ---------------------------------------------------------------- + * TweenLite + * ---------------------------------------------------------------- + */ + var TweenLite = _class("TweenLite", function(target, duration, vars) { + Animation.call(this, duration, vars); + this.render = TweenLite.prototype.render; //speed optimization (avoid prototype lookup on this "hot" method) + + if (target == null) { + throw "Cannot tween a null target."; + } + + this.target = target = (typeof(target) !== "string") ? target : TweenLite.selector(target) || target; + + var isSelector = (target.jquery || (target.length && target !== window && target[0] && (target[0] === window || (target[0].nodeType && target[0].style && !target.nodeType)))), + overwrite = this.vars.overwrite, + i, targ, targets; + + this._overwrite = overwrite = (overwrite == null) ? _overwriteLookup[TweenLite.defaultOverwrite] : (typeof(overwrite) === "number") ? overwrite >> 0 : _overwriteLookup[overwrite]; + + if ((isSelector || target instanceof Array || (target.push && _isArray(target))) && typeof(target[0]) !== "number") { + this._targets = targets = _slice(target); //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() + this._propLookup = []; + this._siblings = []; + for (i = 0; i < targets.length; i++) { + targ = targets[i]; + if (!targ) { + targets.splice(i--, 1); + continue; + } else if (typeof(targ) === "string") { + targ = targets[i--] = TweenLite.selector(targ); //in case it's an array of strings + if (typeof(targ) === "string") { + targets.splice(i+1, 1); //to avoid an endless loop (can't imagine why the selector would return a string, but just in case) + } + continue; + } else if (targ.length && targ !== window && targ[0] && (targ[0] === window || (targ[0].nodeType && targ[0].style && !targ.nodeType))) { //in case the user is passing in an array of selector objects (like jQuery objects), we need to check one more level and pull things out if necessary. Also note that elements pass all the criteria regarding length and the first child having style, so we must also check to ensure the target isn't an HTML node itself. + targets.splice(i--, 1); + this._targets = targets = targets.concat(_slice(targ)); + continue; + } + this._siblings[i] = _register(targ, this, false); + if (overwrite === 1) if (this._siblings[i].length > 1) { + _applyOverwrite(targ, this, null, 1, this._siblings[i]); + } + } + + } else { + this._propLookup = {}; + this._siblings = _register(target, this, false); + if (overwrite === 1) if (this._siblings.length > 1) { + _applyOverwrite(target, this, null, 1, this._siblings); + } + } + if (this.vars.immediateRender || (duration === 0 && this._delay === 0 && this.vars.immediateRender !== false)) { + this._time = -_tinyNum; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render) + this.render(Math.min(0, -this._delay)); //in case delay is negative + } + }, true), + _isSelector = function(v) { + return (v && v.length && v !== window && v[0] && (v[0] === window || (v[0].nodeType && v[0].style && !v.nodeType))); //we cannot check "nodeType" if the target is window from within an iframe, otherwise it will trigger a security error in some browsers like Firefox. + }, + _autoCSS = function(vars, target) { + var css = {}, + p; + for (p in vars) { + if (!_reservedProps[p] && (!(p in target) || p === "transform" || p === "x" || p === "y" || p === "width" || p === "height" || p === "className" || p === "border") && (!_plugins[p] || (_plugins[p] && _plugins[p]._autoCSS))) { //note: elements contain read-only "x" and "y" properties. We should also prioritize editing css width/height rather than the element's properties. + css[p] = vars[p]; + delete vars[p]; + } + } + vars.css = css; + }; + + p = TweenLite.prototype = new Animation(); + p.constructor = TweenLite; + p.kill()._gc = false; + +//----TweenLite defaults, overwrite management, and root updates ---------------------------------------------------- + + p.ratio = 0; + p._firstPT = p._targets = p._overwrittenProps = p._startAt = null; + p._notifyPluginsOfEnabled = p._lazy = false; + + TweenLite.version = "1.18.5"; + TweenLite.defaultEase = p._ease = new Ease(null, null, 1, 1); + TweenLite.defaultOverwrite = "auto"; + TweenLite.ticker = _ticker; + TweenLite.autoSleep = 120; + TweenLite.lagSmoothing = function(threshold, adjustedLag) { + _ticker.lagSmoothing(threshold, adjustedLag); + }; + + TweenLite.selector = window.$ || window.jQuery || function(e) { + var selector = window.$ || window.jQuery; + if (selector) { + TweenLite.selector = selector; + return selector(e); + } + return (typeof(document) === "undefined") ? e : (document.querySelectorAll ? document.querySelectorAll(e) : document.getElementById((e.charAt(0) === "#") ? e.substr(1) : e)); + }; + + var _lazyTweens = [], + _lazyLookup = {}, + _numbersExp = /(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig, + //_nonNumbersExp = /(?:([\-+](?!(\d|=)))|[^\d\-+=e]|(e(?![\-+][\d])))+/ig, + _setRatio = function(v) { + var pt = this._firstPT, + min = 0.000001, + val; + while (pt) { + val = !pt.blob ? pt.c * v + pt.s : v ? this.join("") : this.start; + if (pt.r) { + val = Math.round(val); + } else if (val < min) if (val > -min) { //prevents issues with converting very small numbers to strings in the browser + val = 0; + } + if (!pt.f) { + pt.t[pt.p] = val; + } else if (pt.fp) { + pt.t[pt.p](pt.fp, val); + } else { + pt.t[pt.p](val); + } + pt = pt._next; + } + }, + //compares two strings (start/end), finds the numbers that are different and spits back an array representing the whole value but with the changing values isolated as elements. For example, "rgb(0,0,0)" and "rgb(100,50,0)" would become ["rgb(", 0, ",", 50, ",0)"]. Notice it merges the parts that are identical (performance optimization). The array also has a linked list of PropTweens attached starting with _firstPT that contain the tweening data (t, p, s, c, f, etc.). It also stores the starting value as a "start" property so that we can revert to it if/when necessary, like when a tween rewinds fully. If the quantity of numbers differs between the start and end, it will always prioritize the end value(s). The pt parameter is optional - it's for a PropTween that will be appended to the end of the linked list and is typically for actually setting the value after all of the elements have been updated (with array.join("")). + _blobDif = function(start, end, filter, pt) { + var a = [start, end], + charIndex = 0, + s = "", + color = 0, + startNums, endNums, num, i, l, nonNumbers, currentNum; + a.start = start; + if (filter) { + filter(a); //pass an array with the starting and ending values and let the filter do whatever it needs to the values. + start = a[0]; + end = a[1]; + } + a.length = 0; + startNums = start.match(_numbersExp) || []; + endNums = end.match(_numbersExp) || []; + if (pt) { + pt._next = null; + pt.blob = 1; + a._firstPT = pt; //apply last in the linked list (which means inserting it first) + } + l = endNums.length; + for (i = 0; i < l; i++) { + currentNum = endNums[i]; + nonNumbers = end.substr(charIndex, end.indexOf(currentNum, charIndex)-charIndex); + s += (nonNumbers || !i) ? nonNumbers : ","; //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case. + charIndex += nonNumbers.length; + if (color) { //sense rgba() values and round them. + color = (color + 1) % 5; + } else if (nonNumbers.substr(-5) === "rgba(") { + color = 1; + } + if (currentNum === startNums[i] || startNums.length <= i) { + s += currentNum; + } else { + if (s) { + a.push(s); + s = ""; + } + num = parseFloat(startNums[i]); + a.push(num); + a._firstPT = {_next: a._firstPT, t:a, p: a.length-1, s:num, c:((currentNum.charAt(1) === "=") ? parseInt(currentNum.charAt(0) + "1", 10) * parseFloat(currentNum.substr(2)) : (parseFloat(currentNum) - num)) || 0, f:0, r:(color && color < 4)}; + //note: we don't set _prev because we'll never need to remove individual PropTweens from this list. + } + charIndex += currentNum.length; + } + s += end.substr(charIndex); + if (s) { + a.push(s); + } + a.setRatio = _setRatio; + return a; + }, + //note: "funcParam" is only necessary for function-based getters/setters that require an extra parameter like getAttribute("width") and setAttribute("width", value). In this example, funcParam would be "width". Used by AttrPlugin for example. + _addPropTween = function(target, prop, start, end, overwriteProp, round, funcParam, stringFilter) { + var s = (start === "get") ? target[prop] : start, + type = typeof(target[prop]), + isRelative = (typeof(end) === "string" && end.charAt(1) === "="), + pt = {t:target, p:prop, s:s, f:(type === "function"), pg:0, n:overwriteProp || prop, r:round, pr:0, c:isRelative ? parseInt(end.charAt(0) + "1", 10) * parseFloat(end.substr(2)) : (parseFloat(end) - s) || 0}, + blob, getterName; + if (type !== "number") { + if (type === "function" && start === "get") { + getterName = ((prop.indexOf("set") || typeof(target["get" + prop.substr(3)]) !== "function") ? prop : "get" + prop.substr(3)); + pt.s = s = funcParam ? target[getterName](funcParam) : target[getterName](); + } + if (typeof(s) === "string" && (funcParam || isNaN(s))) { + //a blob (string that has multiple numbers in it) + pt.fp = funcParam; + blob = _blobDif(s, end, stringFilter || TweenLite.defaultStringFilter, pt); + pt = {t:blob, p:"setRatio", s:0, c:1, f:2, pg:0, n:overwriteProp || prop, pr:0}; //"2" indicates it's a Blob property tween. Needed for RoundPropsPlugin for example. + } else if (!isRelative) { + pt.s = parseFloat(s); + pt.c = (parseFloat(end) - pt.s) || 0; + } + } + if (pt.c) { //only add it to the linked list if there's a change. + if ((pt._next = this._firstPT)) { + pt._next._prev = pt; + } + this._firstPT = pt; + return pt; + } + }, + _internals = TweenLite._internals = {isArray:_isArray, isSelector:_isSelector, lazyTweens:_lazyTweens, blobDif:_blobDif}, //gives us a way to expose certain private values to other GreenSock classes without contaminating tha main TweenLite object. + _plugins = TweenLite._plugins = {}, + _tweenLookup = _internals.tweenLookup = {}, + _tweenLookupNum = 0, + _reservedProps = _internals.reservedProps = {ease:1, delay:1, overwrite:1, onComplete:1, onCompleteParams:1, onCompleteScope:1, useFrames:1, runBackwards:1, startAt:1, onUpdate:1, onUpdateParams:1, onUpdateScope:1, onStart:1, onStartParams:1, onStartScope:1, onReverseComplete:1, onReverseCompleteParams:1, onReverseCompleteScope:1, onRepeat:1, onRepeatParams:1, onRepeatScope:1, easeParams:1, yoyo:1, immediateRender:1, repeat:1, repeatDelay:1, data:1, paused:1, reversed:1, autoCSS:1, lazy:1, onOverwrite:1, callbackScope:1, stringFilter:1, id:1}, + _overwriteLookup = {none:0, all:1, auto:2, concurrent:3, allOnStart:4, preexisting:5, "true":1, "false":0}, + _rootFramesTimeline = Animation._rootFramesTimeline = new SimpleTimeline(), + _rootTimeline = Animation._rootTimeline = new SimpleTimeline(), + _nextGCFrame = 30, + _lazyRender = _internals.lazyRender = function() { + var i = _lazyTweens.length, + tween; + _lazyLookup = {}; + while (--i > -1) { + tween = _lazyTweens[i]; + if (tween && tween._lazy !== false) { + tween.render(tween._lazy[0], tween._lazy[1], true); + tween._lazy = false; + } + } + _lazyTweens.length = 0; + }; + + _rootTimeline._startTime = _ticker.time; + _rootFramesTimeline._startTime = _ticker.frame; + _rootTimeline._active = _rootFramesTimeline._active = true; + setTimeout(_lazyRender, 1); //on some mobile devices, there isn't a "tick" before code runs which means any lazy renders wouldn't run before the next official "tick". + + Animation._updateRoot = TweenLite.render = function() { + var i, a, p; + if (_lazyTweens.length) { //if code is run outside of the requestAnimationFrame loop, there may be tweens queued AFTER the engine refreshed, so we need to ensure any pending renders occur before we refresh again. + _lazyRender(); + } + _rootTimeline.render((_ticker.time - _rootTimeline._startTime) * _rootTimeline._timeScale, false, false); + _rootFramesTimeline.render((_ticker.frame - _rootFramesTimeline._startTime) * _rootFramesTimeline._timeScale, false, false); + if (_lazyTweens.length) { + _lazyRender(); + } + if (_ticker.frame >= _nextGCFrame) { //dump garbage every 120 frames or whatever the user sets TweenLite.autoSleep to + _nextGCFrame = _ticker.frame + (parseInt(TweenLite.autoSleep, 10) || 120); + for (p in _tweenLookup) { + a = _tweenLookup[p].tweens; + i = a.length; + while (--i > -1) { + if (a[i]._gc) { + a.splice(i, 1); + } + } + if (a.length === 0) { + delete _tweenLookup[p]; + } + } + //if there are no more tweens in the root timelines, or if they're all paused, make the _timer sleep to reduce load on the CPU slightly + p = _rootTimeline._first; + if (!p || p._paused) if (TweenLite.autoSleep && !_rootFramesTimeline._first && _ticker._listeners.tick.length === 1) { + while (p && p._paused) { + p = p._next; + } + if (!p) { + _ticker.sleep(); + } + } + } + }; + + _ticker.addEventListener("tick", Animation._updateRoot); + + var _register = function(target, tween, scrub) { + var id = target._gsTweenID, a, i; + if (!_tweenLookup[id || (target._gsTweenID = id = "t" + (_tweenLookupNum++))]) { + _tweenLookup[id] = {target:target, tweens:[]}; + } + if (tween) { + a = _tweenLookup[id].tweens; + a[(i = a.length)] = tween; + if (scrub) { + while (--i > -1) { + if (a[i] === tween) { + a.splice(i, 1); + } + } + } + } + return _tweenLookup[id].tweens; + }, + _onOverwrite = function(overwrittenTween, overwritingTween, target, killedProps) { + var func = overwrittenTween.vars.onOverwrite, r1, r2; + if (func) { + r1 = func(overwrittenTween, overwritingTween, target, killedProps); + } + func = TweenLite.onOverwrite; + if (func) { + r2 = func(overwrittenTween, overwritingTween, target, killedProps); + } + return (r1 !== false && r2 !== false); + }, + _applyOverwrite = function(target, tween, props, mode, siblings) { + var i, changed, curTween, l; + if (mode === 1 || mode >= 4) { + l = siblings.length; + for (i = 0; i < l; i++) { + if ((curTween = siblings[i]) !== tween) { + if (!curTween._gc) { + if (curTween._kill(null, target, tween)) { + changed = true; + } + } + } else if (mode === 5) { + break; + } + } + return changed; + } + //NOTE: Add 0.0000000001 to overcome floating point errors that can cause the startTime to be VERY slightly off (when a tween's time() is set for example) + var startTime = tween._startTime + _tinyNum, + overlaps = [], + oCount = 0, + zeroDur = (tween._duration === 0), + globalStart; + i = siblings.length; + while (--i > -1) { + if ((curTween = siblings[i]) === tween || curTween._gc || curTween._paused) { + //ignore + } else if (curTween._timeline !== tween._timeline) { + globalStart = globalStart || _checkOverlap(tween, 0, zeroDur); + if (_checkOverlap(curTween, globalStart, zeroDur) === 0) { + overlaps[oCount++] = curTween; + } + } else if (curTween._startTime <= startTime) if (curTween._startTime + curTween.totalDuration() / curTween._timeScale > startTime) if (!((zeroDur || !curTween._initted) && startTime - curTween._startTime <= 0.0000000002)) { + overlaps[oCount++] = curTween; + } + } + + i = oCount; + while (--i > -1) { + curTween = overlaps[i]; + if (mode === 2) if (curTween._kill(props, target, tween)) { + changed = true; + } + if (mode !== 2 || (!curTween._firstPT && curTween._initted)) { + if (mode !== 2 && !_onOverwrite(curTween, tween)) { + continue; + } + if (curTween._enabled(false, false)) { //if all property tweens have been overwritten, kill the tween. + changed = true; + } + } + } + return changed; + }, + _checkOverlap = function(tween, reference, zeroDur) { + var tl = tween._timeline, + ts = tl._timeScale, + t = tween._startTime; + while (tl._timeline) { + t += tl._startTime; + ts *= tl._timeScale; + if (tl._paused) { + return -100; + } + tl = tl._timeline; + } + t /= ts; + return (t > reference) ? t - reference : ((zeroDur && t === reference) || (!tween._initted && t - reference < 2 * _tinyNum)) ? _tinyNum : ((t += tween.totalDuration() / tween._timeScale / ts) > reference + _tinyNum) ? 0 : t - reference - _tinyNum; + }; + + +//---- TweenLite instance methods ----------------------------------------------------------------------------- + + p._init = function() { + var v = this.vars, + op = this._overwrittenProps, + dur = this._duration, + immediate = !!v.immediateRender, + ease = v.ease, + i, initPlugins, pt, p, startVars; + if (v.startAt) { + if (this._startAt) { + this._startAt.render(-1, true); //if we've run a startAt previously (when the tween instantiated), we should revert it so that the values re-instantiate correctly particularly for relative tweens. Without this, a TweenLite.fromTo(obj, 1, {x:"+=100"}, {x:"-=100"}), for example, would actually jump to +=200 because the startAt would run twice, doubling the relative change. + this._startAt.kill(); + } + startVars = {}; + for (p in v.startAt) { //copy the properties/values into a new object to avoid collisions, like var to = {x:0}, from = {x:500}; timeline.fromTo(e, 1, from, to).fromTo(e, 1, to, from); + startVars[p] = v.startAt[p]; + } + startVars.overwrite = false; + startVars.immediateRender = true; + startVars.lazy = (immediate && v.lazy !== false); + startVars.startAt = startVars.delay = null; //no nesting of startAt objects allowed (otherwise it could cause an infinite loop). + this._startAt = TweenLite.to(this.target, 0, startVars); + if (immediate) { + if (this._time > 0) { + this._startAt = null; //tweens that render immediately (like most from() and fromTo() tweens) shouldn't revert when their parent timeline's playhead goes backward past the startTime because the initial render could have happened anytime and it shouldn't be directly correlated to this tween's startTime. Imagine setting up a complex animation where the beginning states of various objects are rendered immediately but the tween doesn't happen for quite some time - if we revert to the starting values as soon as the playhead goes backward past the tween's startTime, it will throw things off visually. Reversion should only happen in TimelineLite/Max instances where immediateRender was false (which is the default in the convenience methods like from()). + } else if (dur !== 0) { + return; //we skip initialization here so that overwriting doesn't occur until the tween actually begins. Otherwise, if you create several immediateRender:true tweens of the same target/properties to drop into a TimelineLite or TimelineMax, the last one created would overwrite the first ones because they didn't get placed into the timeline yet before the first render occurs and kicks in overwriting. + } + } + } else if (v.runBackwards && dur !== 0) { + //from() tweens must be handled uniquely: their beginning values must be rendered but we don't want overwriting to occur yet (when time is still 0). Wait until the tween actually begins before doing all the routines like overwriting. At that time, we should render at the END of the tween to ensure that things initialize correctly (remember, from() tweens go backwards) + if (this._startAt) { + this._startAt.render(-1, true); + this._startAt.kill(); + this._startAt = null; + } else { + if (this._time !== 0) { //in rare cases (like if a from() tween runs and then is invalidate()-ed), immediateRender could be true but the initial forced-render gets skipped, so there's no need to force the render in this context when the _time is greater than 0 + immediate = false; + } + pt = {}; + for (p in v) { //copy props into a new object and skip any reserved props, otherwise onComplete or onUpdate or onStart could fire. We should, however, permit autoCSS to go through. + if (!_reservedProps[p] || p === "autoCSS") { + pt[p] = v[p]; + } + } + pt.overwrite = 0; + pt.data = "isFromStart"; //we tag the tween with as "isFromStart" so that if [inside a plugin] we need to only do something at the very END of a tween, we have a way of identifying this tween as merely the one that's setting the beginning values for a "from()" tween. For example, clearProps in CSSPlugin should only get applied at the very END of a tween and without this tag, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in. + pt.lazy = (immediate && v.lazy !== false); + pt.immediateRender = immediate; //zero-duration tweens render immediately by default, but if we're not specifically instructed to render this tween immediately, we should skip this and merely _init() to record the starting values (rendering them immediately would push them to completion which is wasteful in that case - we'd have to render(-1) immediately after) + this._startAt = TweenLite.to(this.target, 0, pt); + if (!immediate) { + this._startAt._init(); //ensures that the initial values are recorded + this._startAt._enabled(false); //no need to have the tween render on the next cycle. Disable it because we'll always manually control the renders of the _startAt tween. + if (this.vars.immediateRender) { + this._startAt = null; + } + } else if (this._time === 0) { + return; + } + } + } + this._ease = ease = (!ease) ? TweenLite.defaultEase : (ease instanceof Ease) ? ease : (typeof(ease) === "function") ? new Ease(ease, v.easeParams) : _easeMap[ease] || TweenLite.defaultEase; + if (v.easeParams instanceof Array && ease.config) { + this._ease = ease.config.apply(ease, v.easeParams); + } + this._easeType = this._ease._type; + this._easePower = this._ease._power; + this._firstPT = null; + + if (this._targets) { + i = this._targets.length; + while (--i > -1) { + if ( this._initProps( this._targets[i], (this._propLookup[i] = {}), this._siblings[i], (op ? op[i] : null)) ) { + initPlugins = true; + } + } + } else { + initPlugins = this._initProps(this.target, this._propLookup, this._siblings, op); + } + + if (initPlugins) { + TweenLite._onPluginEvent("_onInitAllProps", this); //reorders the array in order of priority. Uses a static TweenPlugin method in order to minimize file size in TweenLite + } + if (op) if (!this._firstPT) if (typeof(this.target) !== "function") { //if all tweening properties have been overwritten, kill the tween. If the target is a function, it's probably a delayedCall so let it live. + this._enabled(false, false); + } + if (v.runBackwards) { + pt = this._firstPT; + while (pt) { + pt.s += pt.c; + pt.c = -pt.c; + pt = pt._next; + } + } + this._onUpdate = v.onUpdate; + this._initted = true; + }; + + p._initProps = function(target, propLookup, siblings, overwrittenProps) { + var p, i, initPlugins, plugin, pt, v; + if (target == null) { + return false; + } + + if (_lazyLookup[target._gsTweenID]) { + _lazyRender(); //if other tweens of the same target have recently initted but haven't rendered yet, we've got to force the render so that the starting values are correct (imagine populating a timeline with a bunch of sequential tweens and then jumping to the end) + } + + if (!this.vars.css) if (target.style) if (target !== window && target.nodeType) if (_plugins.css) if (this.vars.autoCSS !== false) { //it's so common to use TweenLite/Max to animate the css of DOM elements, we assume that if the target is a DOM element, that's what is intended (a convenience so that users don't have to wrap things in css:{}, although we still recommend it for a slight performance boost and better specificity). Note: we cannot check "nodeType" on the window inside an iframe. + _autoCSS(this.vars, target); + } + for (p in this.vars) { + v = this.vars[p]; + if (_reservedProps[p]) { + if (v) if ((v instanceof Array) || (v.push && _isArray(v))) if (v.join("").indexOf("{self}") !== -1) { + this.vars[p] = v = this._swapSelfInParams(v, this); + } + + } else if (_plugins[p] && (plugin = new _plugins[p]())._onInitTween(target, this.vars[p], this)) { + + //t - target [object] + //p - property [string] + //s - start [number] + //c - change [number] + //f - isFunction [boolean] + //n - name [string] + //pg - isPlugin [boolean] + //pr - priority [number] + this._firstPT = pt = {_next:this._firstPT, t:plugin, p:"setRatio", s:0, c:1, f:1, n:p, pg:1, pr:plugin._priority}; + i = plugin._overwriteProps.length; + while (--i > -1) { + propLookup[plugin._overwriteProps[i]] = this._firstPT; + } + if (plugin._priority || plugin._onInitAllProps) { + initPlugins = true; + } + if (plugin._onDisable || plugin._onEnable) { + this._notifyPluginsOfEnabled = true; + } + if (pt._next) { + pt._next._prev = pt; + } + + } else { + propLookup[p] = _addPropTween.call(this, target, p, "get", v, p, 0, null, this.vars.stringFilter); + } + } + + if (overwrittenProps) if (this._kill(overwrittenProps, target)) { //another tween may have tried to overwrite properties of this tween before init() was called (like if two tweens start at the same time, the one created second will run first) + return this._initProps(target, propLookup, siblings, overwrittenProps); + } + if (this._overwrite > 1) if (this._firstPT) if (siblings.length > 1) if (_applyOverwrite(target, this, propLookup, this._overwrite, siblings)) { + this._kill(propLookup, target); + return this._initProps(target, propLookup, siblings, overwrittenProps); + } + if (this._firstPT) if ((this.vars.lazy !== false && this._duration) || (this.vars.lazy && !this._duration)) { //zero duration tweens don't lazy render by default; everything else does. + _lazyLookup[target._gsTweenID] = true; + } + return initPlugins; + }; + + p.render = function(time, suppressEvents, force) { + var prevTime = this._time, + duration = this._duration, + prevRawPrevTime = this._rawPrevTime, + isComplete, callback, pt, rawPrevTime; + if (time >= duration - 0.0000001) { //to work around occasional floating point math artifacts. + this._totalTime = this._time = duration; + this.ratio = this._ease._calcEnd ? this._ease.getRatio(1) : 1; + if (!this._reversed ) { + isComplete = true; + callback = "onComplete"; + force = (force || this._timeline.autoRemoveChildren); //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline. + } + if (duration === 0) if (this._initted || !this.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. + if (this._startTime === this._timeline._duration) { //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent rounding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate. + time = 0; + } + if (prevRawPrevTime < 0 || (time <= 0 && time >= -0.0000001) || (prevRawPrevTime === _tinyNum && this.data !== "isPause")) if (prevRawPrevTime !== time) { //note: when this.data is "isPause", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause. + force = true; + if (prevRawPrevTime > _tinyNum) { + callback = "onReverseComplete"; + } + } + this._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + } + + } else if (time < 0.0000001) { //to work around occasional floating point math artifacts, round super small values to 0. + this._totalTime = this._time = 0; + this.ratio = this._ease._calcEnd ? this._ease.getRatio(0) : 0; + if (prevTime !== 0 || (duration === 0 && prevRawPrevTime > 0)) { + callback = "onReverseComplete"; + isComplete = this._reversed; + } + if (time < 0) { + this._active = false; + if (duration === 0) if (this._initted || !this.vars.lazy || force) { //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the "playhead" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's "playhead" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered. + if (prevRawPrevTime >= 0 && !(prevRawPrevTime === _tinyNum && this.data === "isPause")) { + force = true; + } + this._rawPrevTime = rawPrevTime = (!suppressEvents || time || prevRawPrevTime === time) ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient. + } + } + if (!this._initted) { //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately. + force = true; + } + } else { + this._totalTime = this._time = time; + + if (this._easeType) { + var r = time / duration, type = this._easeType, pow = this._easePower; + if (type === 1 || (type === 3 && r >= 0.5)) { + r = 1 - r; + } + if (type === 3) { + r *= 2; + } + if (pow === 1) { + r *= r; + } else if (pow === 2) { + r *= r * r; + } else if (pow === 3) { + r *= r * r * r; + } else if (pow === 4) { + r *= r * r * r * r; + } + + if (type === 1) { + this.ratio = 1 - r; + } else if (type === 2) { + this.ratio = r; + } else if (time / duration < 0.5) { + this.ratio = r / 2; + } else { + this.ratio = 1 - (r / 2); + } + + } else { + this.ratio = this._ease.getRatio(time / duration); + } + } + + if (this._time === prevTime && !force) { + return; + } else if (!this._initted) { + this._init(); + if (!this._initted || this._gc) { //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that overwriting occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example. + return; + } else if (!force && this._firstPT && ((this.vars.lazy !== false && this._duration) || (this.vars.lazy && !this._duration))) { + this._time = this._totalTime = prevTime; + this._rawPrevTime = prevRawPrevTime; + _lazyTweens.push(this); + this._lazy = [time, suppressEvents]; + return; + } + //_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently. + if (this._time && !isComplete) { + this.ratio = this._ease.getRatio(this._time / duration); + } else if (isComplete && this._ease._calcEnd) { + this.ratio = this._ease.getRatio((this._time === 0) ? 0 : 1); + } + } + if (this._lazy !== false) { //in case a lazy render is pending, we should flush it because the new render is occurring now (imagine a lazy tween instantiating and then immediately the user calls tween.seek(tween.duration()), skipping to the end - the end render would be forced, and then if we didn't flush the lazy render, it'd fire AFTER the seek(), rendering it at the wrong time. + this._lazy = false; + } + if (!this._active) if (!this._paused && this._time !== prevTime && time >= 0) { + this._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done. + } + if (prevTime === 0) { + if (this._startAt) { + if (time >= 0) { + this._startAt.render(time, suppressEvents, force); + } else if (!callback) { + callback = "_dummyGS"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area. + } + } + if (this.vars.onStart) if (this._time !== 0 || duration === 0) if (!suppressEvents) { + this._callback("onStart"); + } + } + pt = this._firstPT; + while (pt) { + if (pt.f) { + pt.t[pt.p](pt.c * this.ratio + pt.s); + } else { + pt.t[pt.p] = pt.c * this.ratio + pt.s; + } + pt = pt._next; + } + + if (this._onUpdate) { + if (time < 0) if (this._startAt && time !== -0.0001) { //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values. + this._startAt.render(time, suppressEvents, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete. + } + if (!suppressEvents) if (this._time !== prevTime || isComplete || force) { + this._callback("onUpdate"); + } + } + if (callback) if (!this._gc || force) { //check _gc because there's a chance that kill() could be called in an onUpdate + if (time < 0 && this._startAt && !this._onUpdate && time !== -0.0001) { //-0.0001 is a special value that we use when looping back to the beginning of a repeated TimelineMax, in which case we shouldn't render the _startAt values. + this._startAt.render(time, suppressEvents, force); + } + if (isComplete) { + if (this._timeline.autoRemoveChildren) { + this._enabled(false, false); + } + this._active = false; + } + if (!suppressEvents && this.vars[callback]) { + this._callback(callback); + } + if (duration === 0 && this._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) { //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the "time" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon scenario, but possible nonetheless. + this._rawPrevTime = 0; + } + } + }; + + p._kill = function(vars, target, overwritingTween) { + if (vars === "all") { + vars = null; + } + if (vars == null) if (target == null || target === this.target) { + this._lazy = false; + return this._enabled(false, false); + } + target = (typeof(target) !== "string") ? (target || this._targets || this.target) : TweenLite.selector(target) || target; + var simultaneousOverwrite = (overwritingTween && this._time && overwritingTween._startTime === this._startTime && this._timeline === overwritingTween._timeline), + i, overwrittenProps, p, pt, propLookup, changed, killProps, record, killed; + if ((_isArray(target) || _isSelector(target)) && typeof(target[0]) !== "number") { + i = target.length; + while (--i > -1) { + if (this._kill(vars, target[i], overwritingTween)) { + changed = true; + } + } + } else { + if (this._targets) { + i = this._targets.length; + while (--i > -1) { + if (target === this._targets[i]) { + propLookup = this._propLookup[i] || {}; + this._overwrittenProps = this._overwrittenProps || []; + overwrittenProps = this._overwrittenProps[i] = vars ? this._overwrittenProps[i] || {} : "all"; + break; + } + } + } else if (target !== this.target) { + return false; + } else { + propLookup = this._propLookup; + overwrittenProps = this._overwrittenProps = vars ? this._overwrittenProps || {} : "all"; + } + + if (propLookup) { + killProps = vars || propLookup; + record = (vars !== overwrittenProps && overwrittenProps !== "all" && vars !== propLookup && (typeof(vars) !== "object" || !vars._tempKill)); //_tempKill is a super-secret way to delete a particular tweening property but NOT have it remembered as an official overwritten property (like in BezierPlugin) + if (overwritingTween && (TweenLite.onOverwrite || this.vars.onOverwrite)) { + for (p in killProps) { + if (propLookup[p]) { + if (!killed) { + killed = []; + } + killed.push(p); + } + } + if ((killed || !vars) && !_onOverwrite(this, overwritingTween, target, killed)) { //if the onOverwrite returned false, that means the user wants to override the overwriting (cancel it). + return false; + } + } + + for (p in killProps) { + if ((pt = propLookup[p])) { + if (simultaneousOverwrite) { //if another tween overwrites this one and they both start at exactly the same time, yet this tween has already rendered once (for example, at 0.001) because it's first in the queue, we should revert the values to where they were at 0 so that the starting values aren't contaminated on the overwriting tween. + if (pt.f) { + pt.t[pt.p](pt.s); + } else { + pt.t[pt.p] = pt.s; + } + changed = true; + } + if (pt.pg && pt.t._kill(killProps)) { + changed = true; //some plugins need to be notified so they can perform cleanup tasks first + } + if (!pt.pg || pt.t._overwriteProps.length === 0) { + if (pt._prev) { + pt._prev._next = pt._next; + } else if (pt === this._firstPT) { + this._firstPT = pt._next; + } + if (pt._next) { + pt._next._prev = pt._prev; + } + pt._next = pt._prev = null; + } + delete propLookup[p]; + } + if (record) { + overwrittenProps[p] = 1; + } + } + if (!this._firstPT && this._initted) { //if all tweening properties are killed, kill the tween. Without this line, if there's a tween with multiple targets and then you killTweensOf() each target individually, the tween would technically still remain active and fire its onComplete even though there aren't any more properties tweening. + this._enabled(false, false); + } + } + } + return changed; + }; + + p.invalidate = function() { + if (this._notifyPluginsOfEnabled) { + TweenLite._onPluginEvent("_onDisable", this); + } + this._firstPT = this._overwrittenProps = this._startAt = this._onUpdate = null; + this._notifyPluginsOfEnabled = this._active = this._lazy = false; + this._propLookup = (this._targets) ? {} : []; + Animation.prototype.invalidate.call(this); + if (this.vars.immediateRender) { + this._time = -_tinyNum; //forces a render without having to set the render() "force" parameter to true because we want to allow lazying by default (using the "force" parameter always forces an immediate full render) + this.render(Math.min(0, -this._delay)); //in case delay is negative. + } + return this; + }; + + p._enabled = function(enabled, ignoreTimeline) { + if (!_tickerActive) { + _ticker.wake(); + } + if (enabled && this._gc) { + var targets = this._targets, + i; + if (targets) { + i = targets.length; + while (--i > -1) { + this._siblings[i] = _register(targets[i], this, true); + } + } else { + this._siblings = _register(this.target, this, true); + } + } + Animation.prototype._enabled.call(this, enabled, ignoreTimeline); + if (this._notifyPluginsOfEnabled) if (this._firstPT) { + return TweenLite._onPluginEvent((enabled ? "_onEnable" : "_onDisable"), this); + } + return false; + }; + + +//----TweenLite static methods ----------------------------------------------------- + + TweenLite.to = function(target, duration, vars) { + return new TweenLite(target, duration, vars); + }; + + TweenLite.from = function(target, duration, vars) { + vars.runBackwards = true; + vars.immediateRender = (vars.immediateRender != false); + return new TweenLite(target, duration, vars); + }; + + TweenLite.fromTo = function(target, duration, fromVars, toVars) { + toVars.startAt = fromVars; + toVars.immediateRender = (toVars.immediateRender != false && fromVars.immediateRender != false); + return new TweenLite(target, duration, toVars); + }; + + TweenLite.delayedCall = function(delay, callback, params, scope, useFrames) { + return new TweenLite(callback, 0, {delay:delay, onComplete:callback, onCompleteParams:params, callbackScope:scope, onReverseComplete:callback, onReverseCompleteParams:params, immediateRender:false, lazy:false, useFrames:useFrames, overwrite:0}); + }; + + TweenLite.set = function(target, vars) { + return new TweenLite(target, 0, vars); + }; + + TweenLite.getTweensOf = function(target, onlyActive) { + if (target == null) { return []; } + target = (typeof(target) !== "string") ? target : TweenLite.selector(target) || target; + var i, a, j, t; + if ((_isArray(target) || _isSelector(target)) && typeof(target[0]) !== "number") { + i = target.length; + a = []; + while (--i > -1) { + a = a.concat(TweenLite.getTweensOf(target[i], onlyActive)); + } + i = a.length; + //now get rid of any duplicates (tweens of arrays of objects could cause duplicates) + while (--i > -1) { + t = a[i]; + j = i; + while (--j > -1) { + if (t === a[j]) { + a.splice(i, 1); + } + } + } + } else { + a = _register(target).concat(); + i = a.length; + while (--i > -1) { + if (a[i]._gc || (onlyActive && !a[i].isActive())) { + a.splice(i, 1); + } + } + } + return a; + }; + + TweenLite.killTweensOf = TweenLite.killDelayedCallsTo = function(target, onlyActive, vars) { + if (typeof(onlyActive) === "object") { + vars = onlyActive; //for backwards compatibility (before "onlyActive" parameter was inserted) + onlyActive = false; + } + var a = TweenLite.getTweensOf(target, onlyActive), + i = a.length; + while (--i > -1) { + a[i]._kill(vars, target); + } + }; + + + +/* + * ---------------------------------------------------------------- + * TweenPlugin (could easily be split out as a separate file/class, but included for ease of use (so that people don't need to include another script call before loading plugins which is easy to forget) + * ---------------------------------------------------------------- + */ + var TweenPlugin = _class("plugins.TweenPlugin", function(props, priority) { + this._overwriteProps = (props || "").split(","); + this._propName = this._overwriteProps[0]; + this._priority = priority || 0; + this._super = TweenPlugin.prototype; + }, true); + + p = TweenPlugin.prototype; + TweenPlugin.version = "1.18.0"; + TweenPlugin.API = 2; + p._firstPT = null; + p._addTween = _addPropTween; + p.setRatio = _setRatio; + + p._kill = function(lookup) { + var a = this._overwriteProps, + pt = this._firstPT, + i; + if (lookup[this._propName] != null) { + this._overwriteProps = []; + } else { + i = a.length; + while (--i > -1) { + if (lookup[a[i]] != null) { + a.splice(i, 1); + } + } + } + while (pt) { + if (lookup[pt.n] != null) { + if (pt._next) { + pt._next._prev = pt._prev; + } + if (pt._prev) { + pt._prev._next = pt._next; + pt._prev = null; + } else if (this._firstPT === pt) { + this._firstPT = pt._next; + } + } + pt = pt._next; + } + return false; + }; + + p._roundProps = function(lookup, value) { + var pt = this._firstPT; + while (pt) { + if (lookup[this._propName] || (pt.n != null && lookup[ pt.n.split(this._propName + "_").join("") ])) { //some properties that are very plugin-specific add a prefix named after the _propName plus an underscore, so we need to ignore that extra stuff here. + pt.r = value; + } + pt = pt._next; + } + }; + + TweenLite._onPluginEvent = function(type, tween) { + var pt = tween._firstPT, + changed, pt2, first, last, next; + if (type === "_onInitAllProps") { + //sorts the PropTween linked list in order of priority because some plugins need to render earlier/later than others, like MotionBlurPlugin applies its effects after all x/y/alpha tweens have rendered on each frame. + while (pt) { + next = pt._next; + pt2 = first; + while (pt2 && pt2.pr > pt.pr) { + pt2 = pt2._next; + } + if ((pt._prev = pt2 ? pt2._prev : last)) { + pt._prev._next = pt; + } else { + first = pt; + } + if ((pt._next = pt2)) { + pt2._prev = pt; + } else { + last = pt; + } + pt = next; + } + pt = tween._firstPT = first; + } + while (pt) { + if (pt.pg) if (typeof(pt.t[type]) === "function") if (pt.t[type]()) { + changed = true; + } + pt = pt._next; + } + return changed; + }; + + TweenPlugin.activate = function(plugins) { + var i = plugins.length; + while (--i > -1) { + if (plugins[i].API === TweenPlugin.API) { + _plugins[(new plugins[i]())._propName] = plugins[i]; + } + } + return true; + }; + + //provides a more concise way to define plugins that have no dependencies besides TweenPlugin and TweenLite, wrapping common boilerplate stuff into one function (added in 1.9.0). You don't NEED to use this to define a plugin - the old way still works and can be useful in certain (rare) situations. + _gsDefine.plugin = function(config) { + if (!config || !config.propName || !config.init || !config.API) { throw "illegal plugin definition."; } + var propName = config.propName, + priority = config.priority || 0, + overwriteProps = config.overwriteProps, + map = {init:"_onInitTween", set:"setRatio", kill:"_kill", round:"_roundProps", initAll:"_onInitAllProps"}, + Plugin = _class("plugins." + propName.charAt(0).toUpperCase() + propName.substr(1) + "Plugin", + function() { + TweenPlugin.call(this, propName, priority); + this._overwriteProps = overwriteProps || []; + }, (config.global === true)), + p = Plugin.prototype = new TweenPlugin(propName), + prop; + p.constructor = Plugin; + Plugin.API = config.API; + for (prop in map) { + if (typeof(config[prop]) === "function") { + p[map[prop]] = config[prop]; + } + } + Plugin.version = config.version; + TweenPlugin.activate([Plugin]); + return Plugin; + }; + + + //now run through all the dependencies discovered and if any are missing, log that to the console as a warning. This is why it's best to have TweenLite load last - it can check all the dependencies for you. + a = window._gsQueue; + if (a) { + for (i = 0; i < a.length; i++) { + a[i](); + } + for (p in _defLookup) { + if (!_defLookup[p].func) { + window.console.log("GSAP encountered missing dependency: com.greensock." + p); + } + } + } + + _tickerActive = false; //ensures that the first official animation forces a ticker.tick() to update the time when it is instantiated + +})((typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window, "TweenMax"); \ No newline at end of file diff --git a/resources/html5app/js/gsap/TweenMax.min.js b/resources/html5app/js/gsap/TweenMax.min.js new file mode 100644 index 000000000..edc3665f6 --- /dev/null +++ b/resources/html5app/js/gsap/TweenMax.min.js @@ -0,0 +1,17 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * Includes all of the following: TweenLite, TweenMax, TimelineLite, TimelineMax, EasePack, CSSPlugin, RoundPropsPlugin, BezierPlugin, AttrPlugin, DirectionalRotationPlugin + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine("TweenMax",["core.Animation","core.SimpleTimeline","TweenLite"],function(a,b,c){var d=function(a){var b,c=[],d=a.length;for(b=0;b!==d;c.push(a[b++]));return c},e=function(a,b,c){var d,e,f=a.cycle;for(d in f)e=f[d],a[d]="function"==typeof e?e.call(b[c],c):e[c%e.length];delete a.cycle},f=function(a,b,d){c.call(this,a,b,d),this._cycle=0,this._yoyo=this.vars.yoyo===!0,this._repeat=this.vars.repeat||0,this._repeatDelay=this.vars.repeatDelay||0,this._dirty=!0,this.render=f.prototype.render},g=1e-10,h=c._internals,i=h.isSelector,j=h.isArray,k=f.prototype=c.to({},.1,{}),l=[];f.version="1.18.5",k.constructor=f,k.kill()._gc=!1,f.killTweensOf=f.killDelayedCallsTo=c.killTweensOf,f.getTweensOf=c.getTweensOf,f.lagSmoothing=c.lagSmoothing,f.ticker=c.ticker,f.render=c.render,k.invalidate=function(){return this._yoyo=this.vars.yoyo===!0,this._repeat=this.vars.repeat||0,this._repeatDelay=this.vars.repeatDelay||0,this._uncache(!0),c.prototype.invalidate.call(this)},k.updateTo=function(a,b){var d,e=this.ratio,f=this.vars.immediateRender||a.immediateRender;b&&this._startTime.998){var g=this._totalTime;this.render(0,!0,!1),this._initted=!1,this.render(g,!0,!1)}else if(this._initted=!1,this._init(),this._time>0||f)for(var h,i=1/(1-e),j=this._firstPT;j;)h=j.s+j.c,j.c*=i,j.s=h-j.c,j=j._next;return this},k.render=function(a,b,c){this._initted||0===this._duration&&this.vars.repeat&&this.invalidate();var d,e,f,i,j,k,l,m,n=this._dirty?this.totalDuration():this._totalDuration,o=this._time,p=this._totalTime,q=this._cycle,r=this._duration,s=this._rawPrevTime;if(a>=n-1e-7?(this._totalTime=n,this._cycle=this._repeat,this._yoyo&&0!==(1&this._cycle)?(this._time=0,this.ratio=this._ease._calcEnd?this._ease.getRatio(0):0):(this._time=r,this.ratio=this._ease._calcEnd?this._ease.getRatio(1):1),this._reversed||(d=!0,e="onComplete",c=c||this._timeline.autoRemoveChildren),0===r&&(this._initted||!this.vars.lazy||c)&&(this._startTime===this._timeline._duration&&(a=0),(0>s||0>=a&&a>=-1e-7||s===g&&"isPause"!==this.data)&&s!==a&&(c=!0,s>g&&(e="onReverseComplete")),this._rawPrevTime=m=!b||a||s===a?a:g)):1e-7>a?(this._totalTime=this._time=this._cycle=0,this.ratio=this._ease._calcEnd?this._ease.getRatio(0):0,(0!==p||0===r&&s>0)&&(e="onReverseComplete",d=this._reversed),0>a&&(this._active=!1,0===r&&(this._initted||!this.vars.lazy||c)&&(s>=0&&(c=!0),this._rawPrevTime=m=!b||a||s===a?a:g)),this._initted||(c=!0)):(this._totalTime=this._time=a,0!==this._repeat&&(i=r+this._repeatDelay,this._cycle=this._totalTime/i>>0,0!==this._cycle&&this._cycle===this._totalTime/i&&a>=p&&this._cycle--,this._time=this._totalTime-this._cycle*i,this._yoyo&&0!==(1&this._cycle)&&(this._time=r-this._time),this._time>r?this._time=r:this._time<0&&(this._time=0)),this._easeType?(j=this._time/r,k=this._easeType,l=this._easePower,(1===k||3===k&&j>=.5)&&(j=1-j),3===k&&(j*=2),1===l?j*=j:2===l?j*=j*j:3===l?j*=j*j*j:4===l&&(j*=j*j*j*j),1===k?this.ratio=1-j:2===k?this.ratio=j:this._time/r<.5?this.ratio=j/2:this.ratio=1-j/2):this.ratio=this._ease.getRatio(this._time/r)),o===this._time&&!c&&q===this._cycle)return void(p!==this._totalTime&&this._onUpdate&&(b||this._callback("onUpdate")));if(!this._initted){if(this._init(),!this._initted||this._gc)return;if(!c&&this._firstPT&&(this.vars.lazy!==!1&&this._duration||this.vars.lazy&&!this._duration))return this._time=o,this._totalTime=p,this._rawPrevTime=s,this._cycle=q,h.lazyTweens.push(this),void(this._lazy=[a,b]);this._time&&!d?this.ratio=this._ease.getRatio(this._time/r):d&&this._ease._calcEnd&&(this.ratio=this._ease.getRatio(0===this._time?0:1))}for(this._lazy!==!1&&(this._lazy=!1),this._active||!this._paused&&this._time!==o&&a>=0&&(this._active=!0),0===p&&(2===this._initted&&a>0&&this._init(),this._startAt&&(a>=0?this._startAt.render(a,b,c):e||(e="_dummyGS")),this.vars.onStart&&(0!==this._totalTime||0===r)&&(b||this._callback("onStart"))),f=this._firstPT;f;)f.f?f.t[f.p](f.c*this.ratio+f.s):f.t[f.p]=f.c*this.ratio+f.s,f=f._next;this._onUpdate&&(0>a&&this._startAt&&this._startTime&&this._startAt.render(a,b,c),b||(this._totalTime!==p||e)&&this._callback("onUpdate")),this._cycle!==q&&(b||this._gc||this.vars.onRepeat&&this._callback("onRepeat")),e&&(!this._gc||c)&&(0>a&&this._startAt&&!this._onUpdate&&this._startTime&&this._startAt.render(a,b,c),d&&(this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[e]&&this._callback(e),0===r&&this._rawPrevTime===g&&m!==g&&(this._rawPrevTime=0))},f.to=function(a,b,c){return new f(a,b,c)},f.from=function(a,b,c){return c.runBackwards=!0,c.immediateRender=0!=c.immediateRender,new f(a,b,c)},f.fromTo=function(a,b,c,d){return d.startAt=c,d.immediateRender=0!=d.immediateRender&&0!=c.immediateRender,new f(a,b,d)},f.staggerTo=f.allTo=function(a,b,g,h,k,m,n){h=h||0;var o,p,q,r,s=0,t=[],u=function(){g.onComplete&&g.onComplete.apply(g.onCompleteScope||this,arguments),k.apply(n||g.callbackScope||this,m||l)},v=g.cycle,w=g.startAt&&g.startAt.cycle;for(j(a)||("string"==typeof a&&(a=c.selector(a)||a),i(a)&&(a=d(a))),a=a||[],0>h&&(a=d(a),a.reverse(),h*=-1),o=a.length-1,q=0;o>=q;q++){p={};for(r in g)p[r]=g[r];if(v&&(e(p,a,q),null!=p.duration&&(b=p.duration,delete p.duration)),w){w=p.startAt={};for(r in g.startAt)w[r]=g.startAt[r];e(p.startAt,a,q)}p.delay=s+(p.delay||0),q===o&&k&&(p.onComplete=u),t[q]=new f(a[q],b,p),s+=h}return t},f.staggerFrom=f.allFrom=function(a,b,c,d,e,g,h){return c.runBackwards=!0,c.immediateRender=0!=c.immediateRender,f.staggerTo(a,b,c,d,e,g,h)},f.staggerFromTo=f.allFromTo=function(a,b,c,d,e,g,h,i){return d.startAt=c,d.immediateRender=0!=d.immediateRender&&0!=c.immediateRender,f.staggerTo(a,b,d,e,g,h,i)},f.delayedCall=function(a,b,c,d,e){return new f(b,0,{delay:a,onComplete:b,onCompleteParams:c,callbackScope:d,onReverseComplete:b,onReverseCompleteParams:c,immediateRender:!1,useFrames:e,overwrite:0})},f.set=function(a,b){return new f(a,0,b)},f.isTweening=function(a){return c.getTweensOf(a,!0).length>0};var m=function(a,b){for(var d=[],e=0,f=a._first;f;)f instanceof c?d[e++]=f:(b&&(d[e++]=f),d=d.concat(m(f,b)),e=d.length),f=f._next;return d},n=f.getAllTweens=function(b){return m(a._rootTimeline,b).concat(m(a._rootFramesTimeline,b))};f.killAll=function(a,c,d,e){null==c&&(c=!0),null==d&&(d=!0);var f,g,h,i=n(0!=e),j=i.length,k=c&&d&&e;for(h=0;j>h;h++)g=i[h],(k||g instanceof b||(f=g.target===g.vars.onComplete)&&d||c&&!f)&&(a?g.totalTime(g._reversed?0:g.totalDuration()):g._enabled(!1,!1))},f.killChildTweensOf=function(a,b){if(null!=a){var e,g,k,l,m,n=h.tweenLookup;if("string"==typeof a&&(a=c.selector(a)||a),i(a)&&(a=d(a)),j(a))for(l=a.length;--l>-1;)f.killChildTweensOf(a[l],b);else{e=[];for(k in n)for(g=n[k].target.parentNode;g;)g===a&&(e=e.concat(n[k].tweens)),g=g.parentNode;for(m=e.length,l=0;m>l;l++)b&&e[l].totalTime(e[l].totalDuration()),e[l]._enabled(!1,!1)}}};var o=function(a,c,d,e){c=c!==!1,d=d!==!1,e=e!==!1;for(var f,g,h=n(e),i=c&&d&&e,j=h.length;--j>-1;)g=h[j],(i||g instanceof b||(f=g.target===g.vars.onComplete)&&d||c&&!f)&&g.paused(a)};return f.pauseAll=function(a,b,c){o(!0,a,b,c)},f.resumeAll=function(a,b,c){o(!1,a,b,c)},f.globalTimeScale=function(b){var d=a._rootTimeline,e=c.ticker.time;return arguments.length?(b=b||g,d._startTime=e-(e-d._startTime)*d._timeScale/b,d=a._rootFramesTimeline,e=c.ticker.frame,d._startTime=e-(e-d._startTime)*d._timeScale/b,d._timeScale=a._rootTimeline._timeScale=b,b):d._timeScale},k.progress=function(a,b){return arguments.length?this.totalTime(this.duration()*(this._yoyo&&0!==(1&this._cycle)?1-a:a)+this._cycle*(this._duration+this._repeatDelay),b):this._time/this.duration()},k.totalProgress=function(a,b){return arguments.length?this.totalTime(this.totalDuration()*a,b):this._totalTime/this.totalDuration()},k.time=function(a,b){return arguments.length?(this._dirty&&this.totalDuration(),a>this._duration&&(a=this._duration),this._yoyo&&0!==(1&this._cycle)?a=this._duration-a+this._cycle*(this._duration+this._repeatDelay):0!==this._repeat&&(a+=this._cycle*(this._duration+this._repeatDelay)),this.totalTime(a,b)):this._time},k.duration=function(b){return arguments.length?a.prototype.duration.call(this,b):this._duration},k.totalDuration=function(a){return arguments.length?-1===this._repeat?this:this.duration((a-this._repeat*this._repeatDelay)/(this._repeat+1)):(this._dirty&&(this._totalDuration=-1===this._repeat?999999999999:this._duration*(this._repeat+1)+this._repeatDelay*this._repeat,this._dirty=!1),this._totalDuration)},k.repeat=function(a){return arguments.length?(this._repeat=a,this._uncache(!0)):this._repeat},k.repeatDelay=function(a){return arguments.length?(this._repeatDelay=a,this._uncache(!0)):this._repeatDelay},k.yoyo=function(a){return arguments.length?(this._yoyo=a,this):this._yoyo},f},!0),_gsScope._gsDefine("TimelineLite",["core.Animation","core.SimpleTimeline","TweenLite"],function(a,b,c){var d=function(a){b.call(this,a),this._labels={},this.autoRemoveChildren=this.vars.autoRemoveChildren===!0,this.smoothChildTiming=this.vars.smoothChildTiming===!0,this._sortChildren=!0,this._onUpdate=this.vars.onUpdate;var c,d,e=this.vars;for(d in e)c=e[d],i(c)&&-1!==c.join("").indexOf("{self}")&&(e[d]=this._swapSelfInParams(c));i(e.tweens)&&this.add(e.tweens,0,e.align,e.stagger)},e=1e-10,f=c._internals,g=d._internals={},h=f.isSelector,i=f.isArray,j=f.lazyTweens,k=f.lazyRender,l=_gsScope._gsDefine.globals,m=function(a){var b,c={};for(b in a)c[b]=a[b];return c},n=function(a,b,c){var d,e,f=a.cycle;for(d in f)e=f[d],a[d]="function"==typeof e?e.call(b[c],c):e[c%e.length];delete a.cycle},o=g.pauseCallback=function(){},p=function(a){var b,c=[],d=a.length;for(b=0;b!==d;c.push(a[b++]));return c},q=d.prototype=new b;return d.version="1.18.5",q.constructor=d,q.kill()._gc=q._forcingPlayhead=q._hasPause=!1,q.to=function(a,b,d,e){var f=d.repeat&&l.TweenMax||c;return b?this.add(new f(a,b,d),e):this.set(a,d,e)},q.from=function(a,b,d,e){return this.add((d.repeat&&l.TweenMax||c).from(a,b,d),e)},q.fromTo=function(a,b,d,e,f){var g=e.repeat&&l.TweenMax||c;return b?this.add(g.fromTo(a,b,d,e),f):this.set(a,e,f)},q.staggerTo=function(a,b,e,f,g,i,j,k){var l,o,q=new d({onComplete:i,onCompleteParams:j,callbackScope:k,smoothChildTiming:this.smoothChildTiming}),r=e.cycle;for("string"==typeof a&&(a=c.selector(a)||a),a=a||[],h(a)&&(a=p(a)),f=f||0,0>f&&(a=p(a),a.reverse(),f*=-1),o=0;ol;l++)i(m=e[l])&&(m=new d({tweens:m})),this.add(m,j),"string"!=typeof m&&"function"!=typeof m&&("sequence"===g?j=m._startTime+m.totalDuration()/m._timeScale:"start"===g&&(m._startTime-=m.delay())),j+=h;return this._uncache(!0)}if("string"==typeof e)return this.addLabel(e,f);if("function"!=typeof e)throw"Cannot add "+e+" into the timeline; it is not a tween, timeline, function, or string.";e=c.delayedCall(0,e)}if(b.prototype.add.call(this,e,f),(this._gc||this._time===this._duration)&&!this._paused&&this._duratione._startTime;n._timeline;)o&&n._timeline.smoothChildTiming?n.totalTime(n._totalTime,!0):n._gc&&n._enabled(!0,!1),n=n._timeline;return this},q.remove=function(b){if(b instanceof a){this._remove(b,!1);var c=b._timeline=b.vars.useFrames?a._rootFramesTimeline:a._rootTimeline;return b._startTime=(b._paused?b._pauseTime:c._time)-(b._reversed?b.totalDuration()-b._totalTime:b._totalTime)/b._timeScale,this}if(b instanceof Array||b&&b.push&&i(b)){for(var d=b.length;--d>-1;)this.remove(b[d]);return this}return"string"==typeof b?this.removeLabel(b):this.kill(null,b)},q._remove=function(a,c){b.prototype._remove.call(this,a,c);var d=this._last;return d?this._time>d._startTime+d._totalDuration/d._timeScale&&(this._time=this.duration(),this._totalTime=this._totalDuration):this._time=this._totalTime=this._duration=this._totalDuration=0,this},q.append=function(a,b){return this.add(a,this._parseTimeOrLabel(null,b,!0,a))},q.insert=q.insertMultiple=function(a,b,c,d){return this.add(a,b||0,c,d)},q.appendMultiple=function(a,b,c,d){return this.add(a,this._parseTimeOrLabel(null,b,!0,a),c,d)},q.addLabel=function(a,b){return this._labels[a]=this._parseTimeOrLabel(b),this},q.addPause=function(a,b,d,e){var f=c.delayedCall(0,o,d,e||this);return f.vars.onComplete=f.vars.onReverseComplete=b,f.data="isPause",this._hasPause=!0,this.add(f,a)},q.removeLabel=function(a){return delete this._labels[a],this},q.getLabelTime=function(a){return null!=this._labels[a]?this._labels[a]:-1},q._parseTimeOrLabel=function(b,c,d,e){var f;if(e instanceof a&&e.timeline===this)this.remove(e);else if(e&&(e instanceof Array||e.push&&i(e)))for(f=e.length;--f>-1;)e[f]instanceof a&&e[f].timeline===this&&this.remove(e[f]);if("string"==typeof c)return this._parseTimeOrLabel(c,d&&"number"==typeof b&&null==this._labels[c]?b-this.duration():0,d);if(c=c||0,"string"!=typeof b||!isNaN(b)&&null==this._labels[b])null==b&&(b=this.duration());else{if(f=b.indexOf("="),-1===f)return null==this._labels[b]?d?this._labels[b]=this.duration()+c:c:this._labels[b]+c;c=parseInt(b.charAt(f-1)+"1",10)*Number(b.substr(f+1)),b=f>1?this._parseTimeOrLabel(b.substr(0,f-1),0,d):this.duration()}return Number(b)+c},q.seek=function(a,b){return this.totalTime("number"==typeof a?a:this._parseTimeOrLabel(a),b!==!1)},q.stop=function(){return this.paused(!0)},q.gotoAndPlay=function(a,b){return this.play(a,b)},q.gotoAndStop=function(a,b){return this.pause(a,b)},q.render=function(a,b,c){this._gc&&this._enabled(!0,!1);var d,f,g,h,i,l,m,n=this._dirty?this.totalDuration():this._totalDuration,o=this._time,p=this._startTime,q=this._timeScale,r=this._paused;if(a>=n-1e-7)this._totalTime=this._time=n,this._reversed||this._hasPausedChild()||(f=!0,h="onComplete",i=!!this._timeline.autoRemoveChildren,0===this._duration&&(0>=a&&a>=-1e-7||this._rawPrevTime<0||this._rawPrevTime===e)&&this._rawPrevTime!==a&&this._first&&(i=!0,this._rawPrevTime>e&&(h="onReverseComplete"))),this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,a=n+1e-4;else if(1e-7>a)if(this._totalTime=this._time=0,(0!==o||0===this._duration&&this._rawPrevTime!==e&&(this._rawPrevTime>0||0>a&&this._rawPrevTime>=0))&&(h="onReverseComplete",f=this._reversed),0>a)this._active=!1,this._timeline.autoRemoveChildren&&this._reversed?(i=f=!0,h="onReverseComplete"):this._rawPrevTime>=0&&this._first&&(i=!0),this._rawPrevTime=a;else{if(this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,0===a&&f)for(d=this._first;d&&0===d._startTime;)d._duration||(f=!1),d=d._next;a=0,this._initted||(i=!0)}else{if(this._hasPause&&!this._forcingPlayhead&&!b){if(a>=o)for(d=this._first;d&&d._startTime<=a&&!l;)d._duration||"isPause"!==d.data||d.ratio||0===d._startTime&&0===this._rawPrevTime||(l=d),d=d._next;else for(d=this._last;d&&d._startTime>=a&&!l;)d._duration||"isPause"===d.data&&d._rawPrevTime>0&&(l=d),d=d._prev;l&&(this._time=a=l._startTime,this._totalTime=a+this._cycle*(this._totalDuration+this._repeatDelay))}this._totalTime=this._time=this._rawPrevTime=a}if(this._time!==o&&this._first||c||i||l){if(this._initted||(this._initted=!0),this._active||!this._paused&&this._time!==o&&a>0&&(this._active=!0),0===o&&this.vars.onStart&&(0===this._time&&this._duration||b||this._callback("onStart")),m=this._time,m>=o)for(d=this._first;d&&(g=d._next,m===this._time&&(!this._paused||r));)(d._active||d._startTime<=m&&!d._paused&&!d._gc)&&(l===d&&this.pause(),d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)),d=g;else for(d=this._last;d&&(g=d._prev,m===this._time&&(!this._paused||r));){if(d._active||d._startTime<=o&&!d._paused&&!d._gc){if(l===d){for(l=d._prev;l&&l.endTime()>this._time;)l.render(l._reversed?l.totalDuration()-(a-l._startTime)*l._timeScale:(a-l._startTime)*l._timeScale,b,c),l=l._prev;l=null,this.pause()}d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)}d=g}this._onUpdate&&(b||(j.length&&k(),this._callback("onUpdate"))),h&&(this._gc||(p===this._startTime||q!==this._timeScale)&&(0===this._time||n>=this.totalDuration())&&(f&&(j.length&&k(),this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[h]&&this._callback(h)))}},q._hasPausedChild=function(){for(var a=this._first;a;){if(a._paused||a instanceof d&&a._hasPausedChild())return!0;a=a._next}return!1},q.getChildren=function(a,b,d,e){e=e||-9999999999;for(var f=[],g=this._first,h=0;g;)g._startTime-1;)(d[e].timeline===this||b&&this._contains(d[e]))&&(g[h++]=d[e]);return f&&this._enabled(!1,!0),g},q.recent=function(){return this._recent},q._contains=function(a){for(var b=a.timeline;b;){if(b===this)return!0;b=b.timeline}return!1},q.shiftChildren=function(a,b,c){c=c||0;for(var d,e=this._first,f=this._labels;e;)e._startTime>=c&&(e._startTime+=a),e=e._next;if(b)for(d in f)f[d]>=c&&(f[d]+=a);return this._uncache(!0)},q._kill=function(a,b){if(!a&&!b)return this._enabled(!1,!1);for(var c=b?this.getTweensOf(b):this.getChildren(!0,!0,!1),d=c.length,e=!1;--d>-1;)c[d]._kill(a,b)&&(e=!0);return e},q.clear=function(a){var b=this.getChildren(!1,!0,!0),c=b.length;for(this._time=this._totalTime=0;--c>-1;)b[c]._enabled(!1,!1);return a!==!1&&(this._labels={}),this._uncache(!0)},q.invalidate=function(){for(var b=this._first;b;)b.invalidate(),b=b._next;return a.prototype.invalidate.call(this)},q._enabled=function(a,c){if(a===this._gc)for(var d=this._first;d;)d._enabled(a,!0),d=d._next;return b.prototype._enabled.call(this,a,c)},q.totalTime=function(b,c,d){this._forcingPlayhead=!0;var e=a.prototype.totalTime.apply(this,arguments);return this._forcingPlayhead=!1,e},q.duration=function(a){return arguments.length?(0!==this.duration()&&0!==a&&this.timeScale(this._duration/a),this):(this._dirty&&this.totalDuration(),this._duration)},q.totalDuration=function(a){if(!arguments.length){if(this._dirty){for(var b,c,d=0,e=this._last,f=999999999999;e;)b=e._prev,e._dirty&&e.totalDuration(),e._startTime>f&&this._sortChildren&&!e._paused?this.add(e,e._startTime-e._delay):f=e._startTime,e._startTime<0&&!e._paused&&(d-=e._startTime,this._timeline.smoothChildTiming&&(this._startTime+=e._startTime/this._timeScale),this.shiftChildren(-e._startTime,!1,-9999999999),f=0),c=e._startTime+e._totalDuration/e._timeScale,c>d&&(d=c),e=b;this._duration=this._totalDuration=d,this._dirty=!1}return this._totalDuration}return a&&this.totalDuration()?this.timeScale(this._totalDuration/a):this},q.paused=function(b){if(!b)for(var c=this._first,d=this._time;c;)c._startTime===d&&"isPause"===c.data&&(c._rawPrevTime=0),c=c._next;return a.prototype.paused.apply(this,arguments)},q.usesFrames=function(){for(var b=this._timeline;b._timeline;)b=b._timeline;return b===a._rootFramesTimeline},q.rawTime=function(){return this._paused?this._totalTime:(this._timeline.rawTime()-this._startTime)*this._timeScale},d},!0),_gsScope._gsDefine("TimelineMax",["TimelineLite","TweenLite","easing.Ease"],function(a,b,c){var d=function(b){a.call(this,b),this._repeat=this.vars.repeat||0,this._repeatDelay=this.vars.repeatDelay||0,this._cycle=0,this._yoyo=this.vars.yoyo===!0,this._dirty=!0},e=1e-10,f=b._internals,g=f.lazyTweens,h=f.lazyRender,i=new c(null,null,1,0),j=d.prototype=new a;return j.constructor=d,j.kill()._gc=!1,d.version="1.18.5",j.invalidate=function(){return this._yoyo=this.vars.yoyo===!0,this._repeat=this.vars.repeat||0,this._repeatDelay=this.vars.repeatDelay||0,this._uncache(!0),a.prototype.invalidate.call(this)},j.addCallback=function(a,c,d,e){return this.add(b.delayedCall(0,a,d,e),c)},j.removeCallback=function(a,b){if(a)if(null==b)this._kill(null,a);else for(var c=this.getTweensOf(a,!1),d=c.length,e=this._parseTimeOrLabel(b);--d>-1;)c[d]._startTime===e&&c[d]._enabled(!1,!1);return this},j.removePause=function(b){return this.removeCallback(a._internals.pauseCallback,b)},j.tweenTo=function(a,c){c=c||{};var d,e,f,g={ease:i,useFrames:this.usesFrames(),immediateRender:!1};for(e in c)g[e]=c[e];return g.time=this._parseTimeOrLabel(a),d=Math.abs(Number(g.time)-this._time)/this._timeScale||.001,f=new b(this,d,g),g.onStart=function(){f.target.paused(!0),f.vars.time!==f.target.time()&&d===f.duration()&&f.duration(Math.abs(f.vars.time-f.target.time())/f.target._timeScale),c.onStart&&f._callback("onStart")},f},j.tweenFromTo=function(a,b,c){c=c||{},a=this._parseTimeOrLabel(a),c.startAt={onComplete:this.seek,onCompleteParams:[a],callbackScope:this},c.immediateRender=c.immediateRender!==!1;var d=this.tweenTo(b,c);return d.duration(Math.abs(d.vars.time-a)/this._timeScale||.001)},j.render=function(a,b,c){this._gc&&this._enabled(!0,!1);var d,f,i,j,k,l,m,n,o=this._dirty?this.totalDuration():this._totalDuration,p=this._duration,q=this._time,r=this._totalTime,s=this._startTime,t=this._timeScale,u=this._rawPrevTime,v=this._paused,w=this._cycle;if(a>=o-1e-7)this._locked||(this._totalTime=o,this._cycle=this._repeat),this._reversed||this._hasPausedChild()||(f=!0,j="onComplete",k=!!this._timeline.autoRemoveChildren,0===this._duration&&(0>=a&&a>=-1e-7||0>u||u===e)&&u!==a&&this._first&&(k=!0,u>e&&(j="onReverseComplete"))),this._rawPrevTime=this._duration||!b||a||this._rawPrevTime===a?a:e,this._yoyo&&0!==(1&this._cycle)?this._time=a=0:(this._time=p,a=p+1e-4);else if(1e-7>a)if(this._locked||(this._totalTime=this._cycle=0),this._time=0,(0!==q||0===p&&u!==e&&(u>0||0>a&&u>=0)&&!this._locked)&&(j="onReverseComplete",f=this._reversed),0>a)this._active=!1,this._timeline.autoRemoveChildren&&this._reversed?(k=f=!0,j="onReverseComplete"):u>=0&&this._first&&(k=!0),this._rawPrevTime=a;else{if(this._rawPrevTime=p||!b||a||this._rawPrevTime===a?a:e,0===a&&f)for(d=this._first;d&&0===d._startTime;)d._duration||(f=!1),d=d._next;a=0,this._initted||(k=!0)}else if(0===p&&0>u&&(k=!0),this._time=this._rawPrevTime=a,this._locked||(this._totalTime=a,0!==this._repeat&&(l=p+this._repeatDelay,this._cycle=this._totalTime/l>>0,0!==this._cycle&&this._cycle===this._totalTime/l&&a>=r&&this._cycle--,this._time=this._totalTime-this._cycle*l,this._yoyo&&0!==(1&this._cycle)&&(this._time=p-this._time),this._time>p?(this._time=p,a=p+1e-4):this._time<0?this._time=a=0:a=this._time)),this._hasPause&&!this._forcingPlayhead&&!b){if(a=this._time,a>=q)for(d=this._first;d&&d._startTime<=a&&!m;)d._duration||"isPause"!==d.data||d.ratio||0===d._startTime&&0===this._rawPrevTime||(m=d),d=d._next;else for(d=this._last;d&&d._startTime>=a&&!m;)d._duration||"isPause"===d.data&&d._rawPrevTime>0&&(m=d),d=d._prev;m&&(this._time=a=m._startTime,this._totalTime=a+this._cycle*(this._totalDuration+this._repeatDelay))}if(this._cycle!==w&&!this._locked){var x=this._yoyo&&0!==(1&w),y=x===(this._yoyo&&0!==(1&this._cycle)),z=this._totalTime,A=this._cycle,B=this._rawPrevTime,C=this._time;if(this._totalTime=w*p,this._cycle0&&(this._active=!0),0===r&&this.vars.onStart&&(0===this._totalTime&&this._totalDuration||b||this._callback("onStart")),n=this._time,n>=q)for(d=this._first;d&&(i=d._next,n===this._time&&(!this._paused||v));)(d._active||d._startTime<=this._time&&!d._paused&&!d._gc)&&(m===d&&this.pause(),d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)),d=i;else for(d=this._last;d&&(i=d._prev,n===this._time&&(!this._paused||v));){if(d._active||d._startTime<=q&&!d._paused&&!d._gc){if(m===d){for(m=d._prev;m&&m.endTime()>this._time;)m.render(m._reversed?m.totalDuration()-(a-m._startTime)*m._timeScale:(a-m._startTime)*m._timeScale,b,c),m=m._prev;m=null,this.pause()}d._reversed?d.render((d._dirty?d.totalDuration():d._totalDuration)-(a-d._startTime)*d._timeScale,b,c):d.render((a-d._startTime)*d._timeScale,b,c)}d=i}this._onUpdate&&(b||(g.length&&h(),this._callback("onUpdate"))),j&&(this._locked||this._gc||(s===this._startTime||t!==this._timeScale)&&(0===this._time||o>=this.totalDuration())&&(f&&(g.length&&h(),this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[j]&&this._callback(j)))},j.getActive=function(a,b,c){null==a&&(a=!0),null==b&&(b=!0),null==c&&(c=!1);var d,e,f=[],g=this.getChildren(a,b,c),h=0,i=g.length;for(d=0;i>d;d++)e=g[d],e.isActive()&&(f[h++]=e);return f},j.getLabelAfter=function(a){a||0!==a&&(a=this._time);var b,c=this.getLabelsArray(),d=c.length;for(b=0;d>b;b++)if(c[b].time>a)return c[b].name;return null},j.getLabelBefore=function(a){null==a&&(a=this._time);for(var b=this.getLabelsArray(),c=b.length;--c>-1;)if(b[c].timethis._duration&&(a=this._duration),this._yoyo&&0!==(1&this._cycle)?a=this._duration-a+this._cycle*(this._duration+this._repeatDelay):0!==this._repeat&&(a+=this._cycle*(this._duration+this._repeatDelay)),this.totalTime(a,b)):this._time},j.repeat=function(a){return arguments.length?(this._repeat=a,this._uncache(!0)):this._repeat},j.repeatDelay=function(a){return arguments.length?(this._repeatDelay=a,this._uncache(!0)):this._repeatDelay},j.yoyo=function(a){return arguments.length?(this._yoyo=a,this):this._yoyo},j.currentLabel=function(a){return arguments.length?this.seek(a,!0):this.getLabelBefore(this._time+1e-8)},d},!0),function(){var a=180/Math.PI,b=[],c=[],d=[],e={},f=_gsScope._gsDefine.globals,g=function(a,b,c,d){c===d&&(c=d-(d-b)/1e6),a===b&&(b=a+(c-a)/1e6),this.a=a,this.b=b,this.c=c,this.d=d,this.da=d-a,this.ca=c-a,this.ba=b-a},h=",x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,",i=function(a,b,c,d){var e={a:a},f={},g={},h={c:d},i=(a+b)/2,j=(b+c)/2,k=(c+d)/2,l=(i+j)/2,m=(j+k)/2,n=(m-l)/8;return e.b=i+(a-i)/4,f.b=l+n,e.c=f.a=(e.b+f.b)/2,f.c=g.a=(l+m)/2,g.b=m-n,h.b=k+(d-k)/4,g.c=h.a=(g.b+h.b)/2,[e,f,g,h]},j=function(a,e,f,g,h){var j,k,l,m,n,o,p,q,r,s,t,u,v,w=a.length-1,x=0,y=a[0].a;for(j=0;w>j;j++)n=a[x],k=n.a,l=n.d,m=a[x+1].d,h?(t=b[j],u=c[j],v=(u+t)*e*.25/(g?.5:d[j]||.5),o=l-(l-k)*(g?.5*e:0!==t?v/t:0),p=l+(m-l)*(g?.5*e:0!==u?v/u:0),q=l-(o+((p-o)*(3*t/(t+u)+.5)/4||0))):(o=l-(l-k)*e*.5,p=l+(m-l)*e*.5,q=l-(o+p)/2),o+=q,p+=q,n.c=r=o,0!==j?n.b=y:n.b=y=n.a+.6*(n.c-n.a),n.da=l-k,n.ca=r-k,n.ba=y-k,f?(s=i(k,y,r,l),a.splice(x,1,s[0],s[1],s[2],s[3]),x+=4):x++,y=p;n=a[x],n.b=y,n.c=y+.4*(n.d-y),n.da=n.d-n.a,n.ca=n.c-n.a,n.ba=y-n.a,f&&(s=i(n.a,y,n.c,n.d),a.splice(x,1,s[0],s[1],s[2],s[3]))},k=function(a,d,e,f){var h,i,j,k,l,m,n=[];if(f)for(a=[f].concat(a),i=a.length;--i>-1;)"string"==typeof(m=a[i][d])&&"="===m.charAt(1)&&(a[i][d]=f[d]+Number(m.charAt(0)+m.substr(2)));if(h=a.length-2,0>h)return n[0]=new g(a[0][d],0,0,a[-1>h?0:1][d]),n;for(i=0;h>i;i++)j=a[i][d],k=a[i+1][d],n[i]=new g(j,0,0,k),e&&(l=a[i+2][d],b[i]=(b[i]||0)+(k-j)*(k-j),c[i]=(c[i]||0)+(l-k)*(l-k));return n[i]=new g(a[i][d],0,0,a[i+1][d]),n},l=function(a,f,g,i,l,m){var n,o,p,q,r,s,t,u,v={},w=[],x=m||a[0];l="string"==typeof l?","+l+",":h,null==f&&(f=1);for(o in a[0])w.push(o);if(a.length>1){for(u=a[a.length-1],t=!0,n=w.length;--n>-1;)if(o=w[n],Math.abs(x[o]-u[o])>.05){t=!1;break}t&&(a=a.concat(),m&&a.unshift(m),a.push(a[1]),m=a[a.length-3])}for(b.length=c.length=d.length=0,n=w.length;--n>-1;)o=w[n],e[o]=-1!==l.indexOf(","+o+","),v[o]=k(a,o,e[o],m);for(n=b.length;--n>-1;)b[n]=Math.sqrt(b[n]),c[n]=Math.sqrt(c[n]);if(!i){for(n=w.length;--n>-1;)if(e[o])for(p=v[w[n]],s=p.length-1,q=0;s>q;q++)r=p[q+1].da/c[q]+p[q].da/b[q]||0,d[q]=(d[q]||0)+r*r;for(n=d.length;--n>-1;)d[n]=Math.sqrt(d[n])}for(n=w.length,q=g?4:1;--n>-1;)o=w[n],p=v[o],j(p,f,g,i,e[o]),t&&(p.splice(0,q),p.splice(p.length-q,q));return v},m=function(a,b,c){b=b||"soft";var d,e,f,h,i,j,k,l,m,n,o,p={},q="cubic"===b?3:2,r="soft"===b,s=[];if(r&&c&&(a=[c].concat(a)),null==a||a.length-1;){for(m=s[j],p[m]=i=[],n=0,l=a.length,k=0;l>k;k++)d=null==c?a[k][m]:"string"==typeof(o=a[k][m])&&"="===o.charAt(1)?c[m]+Number(o.charAt(0)+o.substr(2)):Number(o),r&&k>1&&l-1>k&&(i[n++]=(d+i[n-2])/2),i[n++]=d;for(l=n-q+1,n=0,k=0;l>k;k+=q)d=i[k],e=i[k+1],f=i[k+2],h=2===q?0:i[k+3],i[n++]=o=3===q?new g(d,e,f,h):new g(d,(2*e+d)/3,(2*e+f)/3,f);i.length=n}return p},n=function(a,b,c){for(var d,e,f,g,h,i,j,k,l,m,n,o=1/c,p=a.length;--p>-1;)for(m=a[p],f=m.a,g=m.d-f,h=m.c-f,i=m.b-f,d=e=0,k=1;c>=k;k++)j=o*k,l=1-j,d=e-(e=(j*j*g+3*l*(j*h+l*i))*j),n=p*c+k-1,b[n]=(b[n]||0)+d*d},o=function(a,b){b=b>>0||6;var c,d,e,f,g=[],h=[],i=0,j=0,k=b-1,l=[],m=[];for(c in a)n(a[c],g,b);for(e=g.length,d=0;e>d;d++)i+=Math.sqrt(g[d]),f=d%b,m[f]=i,f===k&&(j+=i,f=d/b>>0,l[f]=m,h[f]=j,i=0,m=[]);return{length:j,lengths:h,segments:l}},p=_gsScope._gsDefine.plugin({propName:"bezier", +priority:-1,version:"1.3.6",API:2,global:!0,init:function(a,b,c){this._target=a,b instanceof Array&&(b={values:b}),this._func={},this._round={},this._props=[],this._timeRes=null==b.timeResolution?6:parseInt(b.timeResolution,10);var d,e,f,g,h,i=b.values||[],j={},k=i[0],n=b.autoRotate||c.vars.orientToBezier;this._autoRotate=n?n instanceof Array?n:[["x","y","rotation",n===!0?0:Number(n)||0]]:null;for(d in k)this._props.push(d);for(f=this._props.length;--f>-1;)d=this._props[f],this._overwriteProps.push(d),e=this._func[d]="function"==typeof a[d],j[d]=e?a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]():parseFloat(a[d]),h||j[d]!==i[0][d]&&(h=j);if(this._beziers="cubic"!==b.type&&"quadratic"!==b.type&&"soft"!==b.type?l(i,isNaN(b.curviness)?1:b.curviness,!1,"thruBasic"===b.type,b.correlate,h):m(i,b.type,j),this._segCount=this._beziers[d].length,this._timeRes){var p=o(this._beziers,this._timeRes);this._length=p.length,this._lengths=p.lengths,this._segments=p.segments,this._l1=this._li=this._s1=this._si=0,this._l2=this._lengths[0],this._curSeg=this._segments[0],this._s2=this._curSeg[0],this._prec=1/this._curSeg.length}if(n=this._autoRotate)for(this._initialRotations=[],n[0]instanceof Array||(this._autoRotate=n=[n]),f=n.length;--f>-1;){for(g=0;3>g;g++)d=n[f][g],this._func[d]="function"==typeof a[d]?a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]:!1;d=n[f][2],this._initialRotations[f]=(this._func[d]?this._func[d].call(this._target):this._target[d])||0}return this._startRatio=c.vars.runBackwards?1:0,!0},set:function(b){var c,d,e,f,g,h,i,j,k,l,m=this._segCount,n=this._func,o=this._target,p=b!==this._startRatio;if(this._timeRes){if(k=this._lengths,l=this._curSeg,b*=this._length,e=this._li,b>this._l2&&m-1>e){for(j=m-1;j>e&&(this._l2=k[++e])<=b;);this._l1=k[e-1],this._li=e,this._curSeg=l=this._segments[e],this._s2=l[this._s1=this._si=0]}else if(b0){for(;e>0&&(this._l1=k[--e])>=b;);0===e&&bthis._s2&&ee&&(this._s2=l[++e])<=b;);this._s1=l[e-1],this._si=e}else if(b0){for(;e>0&&(this._s1=l[--e])>=b;);0===e&&bb?0:b>=1?m-1:m*b>>0,h=(b-c*(1/m))*m;for(d=1-h,e=this._props.length;--e>-1;)f=this._props[e],g=this._beziers[f][c],i=(h*h*g.da+3*d*(h*g.ca+d*g.ba))*h+g.a,this._round[f]&&(i=Math.round(i)),n[f]?o[f](i):o[f]=i;if(this._autoRotate){var q,r,s,t,u,v,w,x=this._autoRotate;for(e=x.length;--e>-1;)f=x[e][2],v=x[e][3]||0,w=x[e][4]===!0?1:a,g=this._beziers[x[e][0]],q=this._beziers[x[e][1]],g&&q&&(g=g[c],q=q[c],r=g.a+(g.b-g.a)*h,t=g.b+(g.c-g.b)*h,r+=(t-r)*h,t+=(g.c+(g.d-g.c)*h-t)*h,s=q.a+(q.b-q.a)*h,u=q.b+(q.c-q.b)*h,s+=(u-s)*h,u+=(q.c+(q.d-q.c)*h-u)*h,i=p?Math.atan2(u-s,t-r)*w+v:this._initialRotations[e],n[f]?o[f](i):o[f]=i)}}}),q=p.prototype;p.bezierThrough=l,p.cubicToQuadratic=i,p._autoCSS=!0,p.quadraticToCubic=function(a,b,c){return new g(a,(2*b+a)/3,(2*b+c)/3,c)},p._cssRegister=function(){var a=f.CSSPlugin;if(a){var b=a._internals,c=b._parseToProxy,d=b._setPluginRatio,e=b.CSSPropTween;b._registerComplexSpecialProp("bezier",{parser:function(a,b,f,g,h,i){b instanceof Array&&(b={values:b}),i=new p;var j,k,l,m=b.values,n=m.length-1,o=[],q={};if(0>n)return h;for(j=0;n>=j;j++)l=c(a,m[j],g,h,i,n!==j),o[j]=l.end;for(k in b)q[k]=b[k];return q.values=o,h=new e(a,"bezier",0,0,l.pt,2),h.data=l,h.plugin=i,h.setRatio=d,0===q.autoRotate&&(q.autoRotate=!0),!q.autoRotate||q.autoRotate instanceof Array||(j=q.autoRotate===!0?0:Number(q.autoRotate),q.autoRotate=null!=l.end.left?[["left","top","rotation",j,!1]]:null!=l.end.x?[["x","y","rotation",j,!1]]:!1),q.autoRotate&&(g._transform||g._enableTransforms(!1),l.autoRotate=g._target._gsTransform,l.proxy.rotation=l.autoRotate.rotation||0),i._onInitTween(l.proxy,q,g._tween),h}})}},q._roundProps=function(a,b){for(var c=this._overwriteProps,d=c.length;--d>-1;)(a[c[d]]||a.bezier||a.bezierThrough)&&(this._round[c[d]]=b)},q._kill=function(a){var b,c,d=this._props;for(b in this._beziers)if(b in a)for(delete this._beziers[b],delete this._func[b],c=d.length;--c>-1;)d[c]===b&&d.splice(c,1);return this._super._kill.call(this,a)}}(),_gsScope._gsDefine("plugins.CSSPlugin",["plugins.TweenPlugin","TweenLite"],function(a,b){var c,d,e,f,g=function(){a.call(this,"css"),this._overwriteProps.length=0,this.setRatio=g.prototype.setRatio},h=_gsScope._gsDefine.globals,i={},j=g.prototype=new a("css");j.constructor=g,g.version="1.18.5",g.API=2,g.defaultTransformPerspective=0,g.defaultSkewType="compensated",g.defaultSmoothOrigin=!0,j="px",g.suffixMap={top:j,right:j,bottom:j,left:j,width:j,height:j,fontSize:j,padding:j,margin:j,perspective:j,lineHeight:""};var k,l,m,n,o,p,q=/(?:\-|\.|\b)(\d|\.|e\-)+/g,r=/(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g,s=/(?:\+=|\-=|\-|\b)[\d\-\.]+[a-zA-Z0-9]*(?:%|\b)/gi,t=/(?![+-]?\d*\.?\d+|[+-]|e[+-]\d+)[^0-9]/g,u=/(?:\d|\-|\+|=|#|\.)*/g,v=/opacity *= *([^)]*)/i,w=/opacity:([^;]*)/i,x=/alpha\(opacity *=.+?\)/i,y=/^(rgb|hsl)/,z=/([A-Z])/g,A=/-([a-z])/gi,B=/(^(?:url\(\"|url\())|(?:(\"\))$|\)$)/gi,C=function(a,b){return b.toUpperCase()},D=/(?:Left|Right|Width)/i,E=/(M11|M12|M21|M22)=[\d\-\.e]+/gi,F=/progid\:DXImageTransform\.Microsoft\.Matrix\(.+?\)/i,G=/,(?=[^\)]*(?:\(|$))/gi,H=/[\s,\(]/i,I=Math.PI/180,J=180/Math.PI,K={},L=document,M=function(a){return L.createElementNS?L.createElementNS("http://www.w3.org/1999/xhtml",a):L.createElement(a)},N=M("div"),O=M("img"),P=g._internals={_specialProps:i},Q=navigator.userAgent,R=function(){var a=Q.indexOf("Android"),b=M("a");return m=-1!==Q.indexOf("Safari")&&-1===Q.indexOf("Chrome")&&(-1===a||Number(Q.substr(a+8,1))>3),o=m&&Number(Q.substr(Q.indexOf("Version/")+8,1))<6,n=-1!==Q.indexOf("Firefox"),(/MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(Q)||/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(Q))&&(p=parseFloat(RegExp.$1)),b?(b.style.cssText="top:1px;opacity:.55;",/^0.55/.test(b.style.opacity)):!1}(),S=function(a){return v.test("string"==typeof a?a:(a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100:1},T=function(a){window.console&&console.log(a)},U="",V="",W=function(a,b){b=b||N;var c,d,e=b.style;if(void 0!==e[a])return a;for(a=a.charAt(0).toUpperCase()+a.substr(1),c=["O","Moz","ms","Ms","Webkit"],d=5;--d>-1&&void 0===e[c[d]+a];);return d>=0?(V=3===d?"ms":c[d],U="-"+V.toLowerCase()+"-",V+a):null},X=L.defaultView?L.defaultView.getComputedStyle:function(){},Y=g.getStyle=function(a,b,c,d,e){var f;return R||"opacity"!==b?(!d&&a.style[b]?f=a.style[b]:(c=c||X(a))?f=c[b]||c.getPropertyValue(b)||c.getPropertyValue(b.replace(z,"-$1").toLowerCase()):a.currentStyle&&(f=a.currentStyle[b]),null==e||f&&"none"!==f&&"auto"!==f&&"auto auto"!==f?f:e):S(a)},Z=P.convertToPixels=function(a,c,d,e,f){if("px"===e||!e)return d;if("auto"===e||!d)return 0;var h,i,j,k=D.test(c),l=a,m=N.style,n=0>d,o=1===d;if(n&&(d=-d),o&&(d*=100),"%"===e&&-1!==c.indexOf("border"))h=d/100*(k?a.clientWidth:a.clientHeight);else{if(m.cssText="border:0 solid red;position:"+Y(a,"position")+";line-height:0;","%"!==e&&l.appendChild&&"v"!==e.charAt(0)&&"rem"!==e)m[k?"borderLeftWidth":"borderTopWidth"]=d+e;else{if(l=a.parentNode||L.body,i=l._gsCache,j=b.ticker.frame,i&&k&&i.time===j)return i.width*d/100;m[k?"width":"height"]=d+e}l.appendChild(N),h=parseFloat(N[k?"offsetWidth":"offsetHeight"]),l.removeChild(N),k&&"%"===e&&g.cacheWidths!==!1&&(i=l._gsCache=l._gsCache||{},i.time=j,i.width=h/d*100),0!==h||f||(h=Z(a,c,d,e,!0))}return o&&(h/=100),n?-h:h},$=P.calculateOffset=function(a,b,c){if("absolute"!==Y(a,"position",c))return 0;var d="left"===b?"Left":"Top",e=Y(a,"margin"+d,c);return a["offset"+d]-(Z(a,b,parseFloat(e),e.replace(u,""))||0)},_=function(a,b){var c,d,e,f={};if(b=b||X(a,null))if(c=b.length)for(;--c>-1;)e=b[c],(-1===e.indexOf("-transform")||Aa===e)&&(f[e.replace(A,C)]=b.getPropertyValue(e));else for(c in b)(-1===c.indexOf("Transform")||za===c)&&(f[c]=b[c]);else if(b=a.currentStyle||a.style)for(c in b)"string"==typeof c&&void 0===f[c]&&(f[c.replace(A,C)]=b[c]);return R||(f.opacity=S(a)),d=Na(a,b,!1),f.rotation=d.rotation,f.skewX=d.skewX,f.scaleX=d.scaleX,f.scaleY=d.scaleY,f.x=d.x,f.y=d.y,Ca&&(f.z=d.z,f.rotationX=d.rotationX,f.rotationY=d.rotationY,f.scaleZ=d.scaleZ),f.filters&&delete f.filters,f},aa=function(a,b,c,d,e){var f,g,h,i={},j=a.style;for(g in c)"cssText"!==g&&"length"!==g&&isNaN(g)&&(b[g]!==(f=c[g])||e&&e[g])&&-1===g.indexOf("Origin")&&("number"==typeof f||"string"==typeof f)&&(i[g]="auto"!==f||"left"!==g&&"top"!==g?""!==f&&"auto"!==f&&"none"!==f||"string"!=typeof b[g]||""===b[g].replace(t,"")?f:0:$(a,g),void 0!==j[g]&&(h=new pa(j,g,j[g],h)));if(d)for(g in d)"className"!==g&&(i[g]=d[g]);return{difs:i,firstMPT:h}},ba={width:["Left","Right"],height:["Top","Bottom"]},ca=["marginLeft","marginRight","marginTop","marginBottom"],da=function(a,b,c){if("svg"===(a.nodeName+"").toLowerCase())return(c||X(a))[b]||0;if(a.getBBox&&Ka(a))return a.getBBox()[b]||0;var d=parseFloat("width"===b?a.offsetWidth:a.offsetHeight),e=ba[b],f=e.length;for(c=c||X(a,null);--f>-1;)d-=parseFloat(Y(a,"padding"+e[f],c,!0))||0,d-=parseFloat(Y(a,"border"+e[f]+"Width",c,!0))||0;return d},ea=function(a,b){if("contain"===a||"auto"===a||"auto auto"===a)return a+" ";(null==a||""===a)&&(a="0 0");var c,d=a.split(" "),e=-1!==a.indexOf("left")?"0%":-1!==a.indexOf("right")?"100%":d[0],f=-1!==a.indexOf("top")?"0%":-1!==a.indexOf("bottom")?"100%":d[1];if(d.length>3&&!b){for(d=a.split(", ").join(",").split(","),a=[],c=0;c2?" "+d[2]:""),b&&(b.oxp=-1!==e.indexOf("%"),b.oyp=-1!==f.indexOf("%"),b.oxr="="===e.charAt(1),b.oyr="="===f.charAt(1),b.ox=parseFloat(e.replace(t,"")),b.oy=parseFloat(f.replace(t,"")),b.v=a),b||a},fa=function(a,b){return"string"==typeof a&&"="===a.charAt(1)?parseInt(a.charAt(0)+"1",10)*parseFloat(a.substr(2)):parseFloat(a)-parseFloat(b)||0},ga=function(a,b){return null==a?b:"string"==typeof a&&"="===a.charAt(1)?parseInt(a.charAt(0)+"1",10)*parseFloat(a.substr(2))+b:parseFloat(a)||0},ha=function(a,b,c,d){var e,f,g,h,i,j=1e-6;return null==a?h=b:"number"==typeof a?h=a:(e=360,f=a.split("_"),i="="===a.charAt(1),g=(i?parseInt(a.charAt(0)+"1",10)*parseFloat(f[0].substr(2)):parseFloat(f[0]))*(-1===a.indexOf("rad")?1:J)-(i?0:b),f.length&&(d&&(d[c]=b+g),-1!==a.indexOf("short")&&(g%=e,g!==g%(e/2)&&(g=0>g?g+e:g-e)),-1!==a.indexOf("_cw")&&0>g?g=(g+9999999999*e)%e-(g/e|0)*e:-1!==a.indexOf("ccw")&&g>0&&(g=(g-9999999999*e)%e-(g/e|0)*e)),h=b+g),j>h&&h>-j&&(h=0),h},ia={aqua:[0,255,255],lime:[0,255,0],silver:[192,192,192],black:[0,0,0],maroon:[128,0,0],teal:[0,128,128],blue:[0,0,255],navy:[0,0,128],white:[255,255,255],fuchsia:[255,0,255],olive:[128,128,0],yellow:[255,255,0],orange:[255,165,0],gray:[128,128,128],purple:[128,0,128],green:[0,128,0],red:[255,0,0],pink:[255,192,203],cyan:[0,255,255],transparent:[255,255,255,0]},ja=function(a,b,c){return a=0>a?a+1:a>1?a-1:a,255*(1>6*a?b+(c-b)*a*6:.5>a?c:2>3*a?b+(c-b)*(2/3-a)*6:b)+.5|0},ka=g.parseColor=function(a,b){var c,d,e,f,g,h,i,j,k,l,m;if(a)if("number"==typeof a)c=[a>>16,a>>8&255,255&a];else{if(","===a.charAt(a.length-1)&&(a=a.substr(0,a.length-1)),ia[a])c=ia[a];else if("#"===a.charAt(0))4===a.length&&(d=a.charAt(1),e=a.charAt(2),f=a.charAt(3),a="#"+d+d+e+e+f+f),a=parseInt(a.substr(1),16),c=[a>>16,a>>8&255,255&a];else if("hsl"===a.substr(0,3))if(c=m=a.match(q),b){if(-1!==a.indexOf("="))return a.match(r)}else g=Number(c[0])%360/360,h=Number(c[1])/100,i=Number(c[2])/100,e=.5>=i?i*(h+1):i+h-i*h,d=2*i-e,c.length>3&&(c[3]=Number(a[3])),c[0]=ja(g+1/3,d,e),c[1]=ja(g,d,e),c[2]=ja(g-1/3,d,e);else c=a.match(q)||ia.transparent;c[0]=Number(c[0]),c[1]=Number(c[1]),c[2]=Number(c[2]),c.length>3&&(c[3]=Number(c[3]))}else c=ia.black;return b&&!m&&(d=c[0]/255,e=c[1]/255,f=c[2]/255,j=Math.max(d,e,f),k=Math.min(d,e,f),i=(j+k)/2,j===k?g=h=0:(l=j-k,h=i>.5?l/(2-j-k):l/(j+k),g=j===d?(e-f)/l+(f>e?6:0):j===e?(f-d)/l+2:(d-e)/l+4,g*=60),c[0]=g+.5|0,c[1]=100*h+.5|0,c[2]=100*i+.5|0),c},la=function(a,b){var c,d,e,f=a.match(ma)||[],g=0,h=f.length?"":a;for(c=0;c0?g[0].replace(q,""):"";return k?e=b?function(a){var b,m,n,o;if("number"==typeof a)a+=l;else if(d&&G.test(a)){for(o=a.replace(G,"|").split("|"),n=0;nn--)for(;++nm--)for(;++mi;i++)h[a[i]]=j[i]=j[i]||j[(i-1)/2>>0];return e.parse(b,h,f,g)}},pa=(P._setPluginRatio=function(a){this.plugin.setRatio(a);for(var b,c,d,e,f,g=this.data,h=g.proxy,i=g.firstMPT,j=1e-6;i;)b=h[i.v],i.r?b=Math.round(b):j>b&&b>-j&&(b=0),i.t[i.p]=b,i=i._next;if(g.autoRotate&&(g.autoRotate.rotation=h.rotation),1===a||0===a)for(i=g.firstMPT,f=1===a?"e":"b";i;){if(c=i.t,c.type){if(1===c.type){for(e=c.xs0+c.s+c.xs1,d=1;d0;)i="xn"+g,h=d.p+"_"+i,n[h]=d.data[i],m[h]=d[i],f||(j=new pa(d,i,h,j,d.rxp[i]));d=d._next}return{proxy:m,end:n,firstMPT:j,pt:k}},P.CSSPropTween=function(a,b,d,e,g,h,i,j,k,l,m){this.t=a,this.p=b,this.s=d,this.c=e,this.n=i||b,a instanceof qa||f.push(this.n),this.r=j,this.type=h||0,k&&(this.pr=k,c=!0),this.b=void 0===l?d:l,this.e=void 0===m?d+e:m,g&&(this._next=g,g._prev=this)}),ra=function(a,b,c,d,e,f){var g=new qa(a,b,c,d-c,e,-1,f);return g.b=c,g.e=g.xs0=d,g},sa=g.parseComplex=function(a,b,c,d,e,f,h,i,j,l){c=c||f||"",h=new qa(a,b,0,0,h,l?2:1,null,!1,i,c,d),d+="",e&&ma.test(d+c)&&(d=[c,d],g.colorStringFilter(d),c=d[0],d=d[1]);var m,n,o,p,s,t,u,v,w,x,y,z,A,B=c.split(", ").join(",").split(" "),C=d.split(", ").join(",").split(" "),D=B.length,E=k!==!1;for((-1!==d.indexOf(",")||-1!==c.indexOf(","))&&(B=B.join(" ").replace(G,", ").split(" "),C=C.join(" ").replace(G,", ").split(" "),D=B.length),D!==C.length&&(B=(f||"").split(" "),D=B.length),h.plugin=j,h.setRatio=l,ma.lastIndex=0,m=0;D>m;m++)if(p=B[m],s=C[m],v=parseFloat(p),v||0===v)h.appendXtra("",v,fa(s,v),s.replace(r,""),E&&-1!==s.indexOf("px"),!0);else if(e&&ma.test(p))z=s.indexOf(")")+1,z=")"+(z?s.substr(z):""),A=-1!==s.indexOf("hsl")&&R,p=ka(p,A),s=ka(s,A),w=p.length+s.length>6,w&&!R&&0===s[3]?(h["xs"+h.l]+=h.l?" transparent":"transparent",h.e=h.e.split(C[m]).join("transparent")):(R||(w=!1),A?h.appendXtra(w?"hsla(":"hsl(",p[0],fa(s[0],p[0]),",",!1,!0).appendXtra("",p[1],fa(s[1],p[1]),"%,",!1).appendXtra("",p[2],fa(s[2],p[2]),w?"%,":"%"+z,!1):h.appendXtra(w?"rgba(":"rgb(",p[0],s[0]-p[0],",",!0,!0).appendXtra("",p[1],s[1]-p[1],",",!0).appendXtra("",p[2],s[2]-p[2],w?",":z,!0),w&&(p=p.length<4?1:p[3],h.appendXtra("",p,(s.length<4?1:s[3])-p,z,!1))),ma.lastIndex=0;else if(t=p.match(q)){if(u=s.match(r),!u||u.length!==t.length)return h;for(o=0,n=0;n0;)j["xn"+ta]=0,j["xs"+ta]="";j.xs0="",j._next=j._prev=j.xfirst=j.data=j.plugin=j.setRatio=j.rxp=null,j.appendXtra=function(a,b,c,d,e,f){var g=this,h=g.l;return g["xs"+h]+=f&&(h||g["xs"+h])?" "+a:a||"",c||0===h||g.plugin?(g.l++,g.type=g.setRatio?2:1,g["xs"+g.l]=d||"",h>0?(g.data["xn"+h]=b+c,g.rxp["xn"+h]=e,g["xn"+h]=b,g.plugin||(g.xfirst=new qa(g,"xn"+h,b,c,g.xfirst||g,0,g.n,e,g.pr),g.xfirst.xs0=0),g):(g.data={s:b+c},g.rxp={},g.s=b,g.c=c,g.r=e,g)):(g["xs"+h]+=b+(d||""),g)};var ua=function(a,b){b=b||{},this.p=b.prefix?W(a)||a:a,i[a]=i[this.p]=this,this.format=b.formatter||na(b.defaultValue,b.color,b.collapsible,b.multi),b.parser&&(this.parse=b.parser),this.clrs=b.color,this.multi=b.multi,this.keyword=b.keyword,this.dflt=b.defaultValue,this.pr=b.priority||0},va=P._registerComplexSpecialProp=function(a,b,c){"object"!=typeof b&&(b={parser:c});var d,e,f=a.split(","),g=b.defaultValue;for(c=c||[g],d=0;dh.length?i.length:h.length,g=0;j>g;g++)b=h[g]=h[g]||this.dflt,c=i[g]=i[g]||this.dflt,m&&(k=b.indexOf(m),l=c.indexOf(m),k!==l&&(-1===l?h[g]=h[g].split(m).join(""):-1===k&&(h[g]+=" "+m)));b=h.join(", "),c=i.join(", ")}return sa(a,this.p,b,c,this.clrs,this.dflt,d,this.pr,e,f)},j.parse=function(a,b,c,d,f,g,h){return this.parseComplex(a.style,this.format(Y(a,this.p,e,!1,this.dflt)),this.format(b),f,g)},g.registerSpecialProp=function(a,b,c){va(a,{parser:function(a,d,e,f,g,h,i){var j=new qa(a,e,0,0,g,2,e,!1,c);return j.plugin=h,j.setRatio=b(a,d,f._tween,e),j},priority:c})},g.useSVGTransformAttr=m||n;var xa,ya="scaleX,scaleY,scaleZ,x,y,z,skewX,skewY,rotation,rotationX,rotationY,perspective,xPercent,yPercent".split(","),za=W("transform"),Aa=U+"transform",Ba=W("transformOrigin"),Ca=null!==W("perspective"),Da=P.Transform=function(){this.perspective=parseFloat(g.defaultTransformPerspective)||0,this.force3D=g.defaultForce3D!==!1&&Ca?g.defaultForce3D||"auto":!1},Ea=window.SVGElement,Fa=function(a,b,c){var d,e=L.createElementNS("http://www.w3.org/2000/svg",a),f=/([a-z])([A-Z])/g;for(d in c)e.setAttributeNS(null,d.replace(f,"$1-$2").toLowerCase(),c[d]);return b.appendChild(e),e},Ga=L.documentElement,Ha=function(){var a,b,c,d=p||/Android/i.test(Q)&&!window.chrome;return L.createElementNS&&!d&&(a=Fa("svg",Ga),b=Fa("rect",a,{width:100,height:50,x:100}),c=b.getBoundingClientRect().width,b.style[Ba]="50% 50%",b.style[za]="scaleX(0.5)",d=c===b.getBoundingClientRect().width&&!(n&&Ca),Ga.removeChild(a)),d}(),Ia=function(a,b,c,d,e,f){var h,i,j,k,l,m,n,o,p,q,r,s,t,u,v=a._gsTransform,w=Ma(a,!0);v&&(t=v.xOrigin,u=v.yOrigin),(!d||(h=d.split(" ")).length<2)&&(n=a.getBBox(),b=ea(b).split(" "),h=[(-1!==b[0].indexOf("%")?parseFloat(b[0])/100*n.width:parseFloat(b[0]))+n.x,(-1!==b[1].indexOf("%")?parseFloat(b[1])/100*n.height:parseFloat(b[1]))+n.y]),c.xOrigin=k=parseFloat(h[0]),c.yOrigin=l=parseFloat(h[1]),d&&w!==La&&(m=w[0],n=w[1],o=w[2],p=w[3],q=w[4],r=w[5],s=m*p-n*o,i=k*(p/s)+l*(-o/s)+(o*r-p*q)/s,j=k*(-n/s)+l*(m/s)-(m*r-n*q)/s,k=c.xOrigin=h[0]=i,l=c.yOrigin=h[1]=j),v&&(f&&(c.xOffset=v.xOffset,c.yOffset=v.yOffset,v=c),e||e!==!1&&g.defaultSmoothOrigin!==!1?(i=k-t,j=l-u,v.xOffset+=i*w[0]+j*w[2]-i,v.yOffset+=i*w[1]+j*w[3]-j):v.xOffset=v.yOffset=0),f||a.setAttribute("data-svg-origin",h.join(" "))},Ja=function(a){try{return a.getBBox()}catch(a){}},Ka=function(a){return!!(Ea&&a.getBBox&&a.getCTM&&Ja(a)&&(!a.parentNode||a.parentNode.getBBox&&a.parentNode.getCTM))},La=[1,0,0,1,0,0],Ma=function(a,b){var c,d,e,f,g,h,i=a._gsTransform||new Da,j=1e5,k=a.style;if(za?d=Y(a,Aa,null,!0):a.currentStyle&&(d=a.currentStyle.filter.match(E),d=d&&4===d.length?[d[0].substr(4),Number(d[2].substr(4)),Number(d[1].substr(4)),d[3].substr(4),i.x||0,i.y||0].join(","):""),c=!d||"none"===d||"matrix(1, 0, 0, 1, 0, 0)"===d,c&&za&&((h="none"===X(a).display)||!a.parentNode)&&(h&&(f=k.display,k.display="block"),a.parentNode||(g=1,Ga.appendChild(a)),d=Y(a,Aa,null,!0),c=!d||"none"===d||"matrix(1, 0, 0, 1, 0, 0)"===d,f?k.display=f:h&&Ra(k,"display"),g&&Ga.removeChild(a)),(i.svg||a.getBBox&&Ka(a))&&(c&&-1!==(k[za]+"").indexOf("matrix")&&(d=k[za],c=0),e=a.getAttribute("transform"),c&&e&&(-1!==e.indexOf("matrix")?(d=e,c=0):-1!==e.indexOf("translate")&&(d="matrix(1,0,0,1,"+e.match(/(?:\-|\b)[\d\-\.e]+\b/gi).join(",")+")",c=0))),c)return La;for(e=(d||"").match(q)||[],ta=e.length;--ta>-1;)f=Number(e[ta]),e[ta]=(g=f-(f|=0))?(g*j+(0>g?-.5:.5)|0)/j+f:f;return b&&e.length>6?[e[0],e[1],e[4],e[5],e[12],e[13]]:e},Na=P.getTransform=function(a,c,d,e){if(a._gsTransform&&d&&!e)return a._gsTransform;var f,h,i,j,k,l,m=d?a._gsTransform||new Da:new Da,n=m.scaleX<0,o=2e-5,p=1e5,q=Ca?parseFloat(Y(a,Ba,c,!1,"0 0 0").split(" ")[2])||m.zOrigin||0:0,r=parseFloat(g.defaultTransformPerspective)||0;if(m.svg=!(!a.getBBox||!Ka(a)),m.svg&&(Ia(a,Y(a,Ba,c,!1,"50% 50%")+"",m,a.getAttribute("data-svg-origin")),xa=g.useSVGTransformAttr||Ha),f=Ma(a),f!==La){if(16===f.length){var s,t,u,v,w,x=f[0],y=f[1],z=f[2],A=f[3],B=f[4],C=f[5],D=f[6],E=f[7],F=f[8],G=f[9],H=f[10],I=f[12],K=f[13],L=f[14],M=f[11],N=Math.atan2(D,H);m.zOrigin&&(L=-m.zOrigin,I=F*L-f[12],K=G*L-f[13],L=H*L+m.zOrigin-f[14]),m.rotationX=N*J,N&&(v=Math.cos(-N),w=Math.sin(-N),s=B*v+F*w,t=C*v+G*w,u=D*v+H*w,F=B*-w+F*v,G=C*-w+G*v,H=D*-w+H*v,M=E*-w+M*v,B=s,C=t,D=u),N=Math.atan2(-z,H),m.rotationY=N*J,N&&(v=Math.cos(-N),w=Math.sin(-N),s=x*v-F*w,t=y*v-G*w,u=z*v-H*w,G=y*w+G*v,H=z*w+H*v,M=A*w+M*v,x=s,y=t,z=u),N=Math.atan2(y,x),m.rotation=N*J,N&&(v=Math.cos(-N),w=Math.sin(-N),x=x*v+B*w,t=y*v+C*w,C=y*-w+C*v,D=z*-w+D*v,y=t),m.rotationX&&Math.abs(m.rotationX)+Math.abs(m.rotation)>359.9&&(m.rotationX=m.rotation=0,m.rotationY=180-m.rotationY),m.scaleX=(Math.sqrt(x*x+y*y)*p+.5|0)/p,m.scaleY=(Math.sqrt(C*C+G*G)*p+.5|0)/p,m.scaleZ=(Math.sqrt(D*D+H*H)*p+.5|0)/p,m.rotationX||m.rotationY?m.skewX=0:(m.skewX=B||C?Math.atan2(B,C)*J+m.rotation:m.skewX||0,Math.abs(m.skewX)>90&&Math.abs(m.skewX)<270&&(n?(m.scaleX*=-1,m.skewX+=m.rotation<=0?180:-180,m.rotation+=m.rotation<=0?180:-180):(m.scaleY*=-1,m.skewX+=m.skewX<=0?180:-180))),m.perspective=M?1/(0>M?-M:M):0,m.x=I,m.y=K,m.z=L,m.svg&&(m.x-=m.xOrigin-(m.xOrigin*x-m.yOrigin*B),m.y-=m.yOrigin-(m.yOrigin*y-m.xOrigin*C))}else if(!Ca||e||!f.length||m.x!==f[4]||m.y!==f[5]||!m.rotationX&&!m.rotationY){var O=f.length>=6,P=O?f[0]:1,Q=f[1]||0,R=f[2]||0,S=O?f[3]:1;m.x=f[4]||0,m.y=f[5]||0,i=Math.sqrt(P*P+Q*Q),j=Math.sqrt(S*S+R*R),k=P||Q?Math.atan2(Q,P)*J:m.rotation||0,l=R||S?Math.atan2(R,S)*J+k:m.skewX||0,Math.abs(l)>90&&Math.abs(l)<270&&(n?(i*=-1,l+=0>=k?180:-180,k+=0>=k?180:-180):(j*=-1,l+=0>=l?180:-180)),m.scaleX=i,m.scaleY=j,m.rotation=k,m.skewX=l,Ca&&(m.rotationX=m.rotationY=m.z=0,m.perspective=r,m.scaleZ=1),m.svg&&(m.x-=m.xOrigin-(m.xOrigin*P+m.yOrigin*R),m.y-=m.yOrigin-(m.xOrigin*Q+m.yOrigin*S))}m.zOrigin=q;for(h in m)m[h]-o&&(m[h]=0)}return d&&(a._gsTransform=m,m.svg&&(xa&&a.style[za]?b.delayedCall(.001,function(){Ra(a.style,za)}):!xa&&a.getAttribute("transform")&&b.delayedCall(.001,function(){a.removeAttribute("transform")}))),m},Oa=function(a){var b,c,d=this.data,e=-d.rotation*I,f=e+d.skewX*I,g=1e5,h=(Math.cos(e)*d.scaleX*g|0)/g,i=(Math.sin(e)*d.scaleX*g|0)/g,j=(Math.sin(f)*-d.scaleY*g|0)/g,k=(Math.cos(f)*d.scaleY*g|0)/g,l=this.t.style,m=this.t.currentStyle;if(m){c=i,i=-j,j=-c,b=m.filter,l.filter="";var n,o,q=this.t.offsetWidth,r=this.t.offsetHeight,s="absolute"!==m.position,t="progid:DXImageTransform.Microsoft.Matrix(M11="+h+", M12="+i+", M21="+j+", M22="+k,w=d.x+q*d.xPercent/100,x=d.y+r*d.yPercent/100;if(null!=d.ox&&(n=(d.oxp?q*d.ox*.01:d.ox)-q/2,o=(d.oyp?r*d.oy*.01:d.oy)-r/2,w+=n-(n*h+o*i),x+=o-(n*j+o*k)),s?(n=q/2,o=r/2,t+=", Dx="+(n-(n*h+o*i)+w)+", Dy="+(o-(n*j+o*k)+x)+")"):t+=", sizingMethod='auto expand')",-1!==b.indexOf("DXImageTransform.Microsoft.Matrix(")?l.filter=b.replace(F,t):l.filter=t+" "+b,(0===a||1===a)&&1===h&&0===i&&0===j&&1===k&&(s&&-1===t.indexOf("Dx=0, Dy=0")||v.test(b)&&100!==parseFloat(RegExp.$1)||-1===b.indexOf(b.indexOf("Alpha"))&&l.removeAttribute("filter")),!s){var y,z,A,B=8>p?1:-1;for(n=d.ieOffsetX||0,o=d.ieOffsetY||0,d.ieOffsetX=Math.round((q-((0>h?-h:h)*q+(0>i?-i:i)*r))/2+w),d.ieOffsetY=Math.round((r-((0>k?-k:k)*r+(0>j?-j:j)*q))/2+x),ta=0;4>ta;ta++)z=ca[ta],y=m[z],c=-1!==y.indexOf("px")?parseFloat(y):Z(this.t,z,parseFloat(y),y.replace(u,""))||0,A=c!==d[z]?2>ta?-d.ieOffsetX:-d.ieOffsetY:2>ta?n-d.ieOffsetX:o-d.ieOffsetY,l[z]=(d[z]=Math.round(c-A*(0===ta||2===ta?1:B)))+"px"}}},Pa=P.set3DTransformRatio=P.setTransformRatio=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,o,p,q,r,s,t,u,v,w,x,y,z=this.data,A=this.t.style,B=z.rotation,C=z.rotationX,D=z.rotationY,E=z.scaleX,F=z.scaleY,G=z.scaleZ,H=z.x,J=z.y,K=z.z,L=z.svg,M=z.perspective,N=z.force3D;if(((1===a||0===a)&&"auto"===N&&(this.tween._totalTime===this.tween._totalDuration||!this.tween._totalTime)||!N)&&!K&&!M&&!D&&!C&&1===G||xa&&L||!Ca)return void(B||z.skewX||L?(B*=I,x=z.skewX*I,y=1e5,b=Math.cos(B)*E,e=Math.sin(B)*E,c=Math.sin(B-x)*-F,f=Math.cos(B-x)*F,x&&"simple"===z.skewType&&(s=Math.tan(x),s=Math.sqrt(1+s*s),c*=s,f*=s,z.skewY&&(b*=s,e*=s)),L&&(H+=z.xOrigin-(z.xOrigin*b+z.yOrigin*c)+z.xOffset,J+=z.yOrigin-(z.xOrigin*e+z.yOrigin*f)+z.yOffset,xa&&(z.xPercent||z.yPercent)&&(p=this.t.getBBox(),H+=.01*z.xPercent*p.width,J+=.01*z.yPercent*p.height),p=1e-6,p>H&&H>-p&&(H=0),p>J&&J>-p&&(J=0)),u=(b*y|0)/y+","+(e*y|0)/y+","+(c*y|0)/y+","+(f*y|0)/y+","+H+","+J+")",L&&xa?this.t.setAttribute("transform","matrix("+u):A[za]=(z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) matrix(":"matrix(")+u):A[za]=(z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) matrix(":"matrix(")+E+",0,0,"+F+","+H+","+J+")");if(n&&(p=1e-4,p>E&&E>-p&&(E=G=2e-5),p>F&&F>-p&&(F=G=2e-5),!M||z.z||z.rotationX||z.rotationY||(M=0)),B||z.skewX)B*=I,q=b=Math.cos(B),r=e=Math.sin(B),z.skewX&&(B-=z.skewX*I,q=Math.cos(B),r=Math.sin(B),"simple"===z.skewType&&(s=Math.tan(z.skewX*I),s=Math.sqrt(1+s*s),q*=s,r*=s,z.skewY&&(b*=s,e*=s))),c=-r,f=q;else{if(!(D||C||1!==G||M||L))return void(A[za]=(z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) translate3d(":"translate3d(")+H+"px,"+J+"px,"+K+"px)"+(1!==E||1!==F?" scale("+E+","+F+")":""));b=f=1,c=e=0}j=1,d=g=h=i=k=l=0,m=M?-1/M:0,o=z.zOrigin,p=1e-6,v=",",w="0",B=D*I,B&&(q=Math.cos(B),r=Math.sin(B),h=-r,k=m*-r,d=b*r,g=e*r,j=q,m*=q,b*=q,e*=q),B=C*I,B&&(q=Math.cos(B),r=Math.sin(B),s=c*q+d*r,t=f*q+g*r,i=j*r,l=m*r,d=c*-r+d*q,g=f*-r+g*q,j*=q,m*=q,c=s,f=t),1!==G&&(d*=G,g*=G,j*=G,m*=G),1!==F&&(c*=F,f*=F,i*=F,l*=F),1!==E&&(b*=E,e*=E,h*=E,k*=E),(o||L)&&(o&&(H+=d*-o,J+=g*-o,K+=j*-o+o),L&&(H+=z.xOrigin-(z.xOrigin*b+z.yOrigin*c)+z.xOffset,J+=z.yOrigin-(z.xOrigin*e+z.yOrigin*f)+z.yOffset),p>H&&H>-p&&(H=w),p>J&&J>-p&&(J=w),p>K&&K>-p&&(K=0)),u=z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) matrix3d(":"matrix3d(",u+=(p>b&&b>-p?w:b)+v+(p>e&&e>-p?w:e)+v+(p>h&&h>-p?w:h),u+=v+(p>k&&k>-p?w:k)+v+(p>c&&c>-p?w:c)+v+(p>f&&f>-p?w:f),C||D||1!==G?(u+=v+(p>i&&i>-p?w:i)+v+(p>l&&l>-p?w:l)+v+(p>d&&d>-p?w:d),u+=v+(p>g&&g>-p?w:g)+v+(p>j&&j>-p?w:j)+v+(p>m&&m>-p?w:m)+v):u+=",0,0,0,0,1,0,",u+=H+v+J+v+K+v+(M?1+-K/M:1)+")",A[za]=u};j=Da.prototype,j.x=j.y=j.z=j.skewX=j.skewY=j.rotation=j.rotationX=j.rotationY=j.zOrigin=j.xPercent=j.yPercent=j.xOffset=j.yOffset=0,j.scaleX=j.scaleY=j.scaleZ=1,va("transform,scale,scaleX,scaleY,scaleZ,x,y,z,rotation,rotationX,rotationY,rotationZ,skewX,skewY,shortRotation,shortRotationX,shortRotationY,shortRotationZ,transformOrigin,svgOrigin,transformPerspective,directionalRotation,parseTransform,force3D,skewType,xPercent,yPercent,smoothOrigin",{parser:function(a,b,c,d,f,h,i){if(d._lastParsedTransform===i)return f;d._lastParsedTransform=i;var j,k,l,m,n,o,p,q,r,s=a._gsTransform,t=a.style,u=1e-6,v=ya.length,w=i,x={},y="transformOrigin",z=Na(a,e,!0,i.parseTransform);if(d._transform=z,"string"==typeof w.transform&&za)k=N.style,k[za]=w.transform,k.display="block",k.position="absolute",L.body.appendChild(N),j=Na(N,null,!1),z.svg&&(p=z.xOrigin,q=z.yOrigin,j.x-=z.xOffset,j.y-=z.yOffset,(w.transformOrigin||w.svgOrigin)&&(l={},Ia(a,ea(w.transformOrigin),l,w.svgOrigin,w.smoothOrigin,!0),p=l.xOrigin,q=l.yOrigin,j.x-=l.xOffset-z.xOffset,j.y-=l.yOffset-z.yOffset),(p||q)&&(r=Ma(N,!0),j.x-=p-(p*r[0]+q*r[2]),j.y-=q-(p*r[1]+q*r[3]))),L.body.removeChild(N),j.perspective||(j.perspective=z.perspective),null!=w.xPercent&&(j.xPercent=ga(w.xPercent,z.xPercent)),null!=w.yPercent&&(j.yPercent=ga(w.yPercent,z.yPercent));else if("object"==typeof w){if(j={scaleX:ga(null!=w.scaleX?w.scaleX:w.scale,z.scaleX),scaleY:ga(null!=w.scaleY?w.scaleY:w.scale,z.scaleY),scaleZ:ga(w.scaleZ,z.scaleZ),x:ga(w.x,z.x),y:ga(w.y,z.y),z:ga(w.z,z.z),xPercent:ga(w.xPercent,z.xPercent),yPercent:ga(w.yPercent,z.yPercent),perspective:ga(w.transformPerspective,z.perspective)},o=w.directionalRotation,null!=o)if("object"==typeof o)for(k in o)w[k]=o[k];else w.rotation=o;"string"==typeof w.x&&-1!==w.x.indexOf("%")&&(j.x=0,j.xPercent=ga(w.x,z.xPercent)),"string"==typeof w.y&&-1!==w.y.indexOf("%")&&(j.y=0,j.yPercent=ga(w.y,z.yPercent)),j.rotation=ha("rotation"in w?w.rotation:"shortRotation"in w?w.shortRotation+"_short":"rotationZ"in w?w.rotationZ:z.rotation-z.skewY,z.rotation-z.skewY,"rotation",x),Ca&&(j.rotationX=ha("rotationX"in w?w.rotationX:"shortRotationX"in w?w.shortRotationX+"_short":z.rotationX||0,z.rotationX,"rotationX",x),j.rotationY=ha("rotationY"in w?w.rotationY:"shortRotationY"in w?w.shortRotationY+"_short":z.rotationY||0,z.rotationY,"rotationY",x)),j.skewX=ha(w.skewX,z.skewX-z.skewY),(j.skewY=ha(w.skewY,z.skewY))&&(j.skewX+=j.skewY,j.rotation+=j.skewY)}for(Ca&&null!=w.force3D&&(z.force3D=w.force3D,n=!0),z.skewType=w.skewType||z.skewType||g.defaultSkewType,m=z.force3D||z.z||z.rotationX||z.rotationY||j.z||j.rotationX||j.rotationY||j.perspective,m||null==w.scale||(j.scaleZ=1);--v>-1;)c=ya[v],l=j[c]-z[c],(l>u||-u>l||null!=w[c]||null!=K[c])&&(n=!0,f=new qa(z,c,z[c],l,f),c in x&&(f.e=x[c]),f.xs0=0,f.plugin=h,d._overwriteProps.push(f.n));return l=w.transformOrigin,z.svg&&(l||w.svgOrigin)&&(p=z.xOffset,q=z.yOffset,Ia(a,ea(l),j,w.svgOrigin,w.smoothOrigin),f=ra(z,"xOrigin",(s?z:j).xOrigin,j.xOrigin,f,y),f=ra(z,"yOrigin",(s?z:j).yOrigin,j.yOrigin,f,y),(p!==z.xOffset||q!==z.yOffset)&&(f=ra(z,"xOffset",s?p:z.xOffset,z.xOffset,f,y),f=ra(z,"yOffset",s?q:z.yOffset,z.yOffset,f,y)),l=xa?null:"0px 0px"),(l||Ca&&m&&z.zOrigin)&&(za?(n=!0,c=Ba,l=(l||Y(a,c,e,!1,"50% 50%"))+"",f=new qa(t,c,0,0,f,-1,y),f.b=t[c],f.plugin=h,Ca?(k=z.zOrigin,l=l.split(" "),z.zOrigin=(l.length>2&&(0===k||"0px"!==l[2])?parseFloat(l[2]):k)||0, +f.xs0=f.e=l[0]+" "+(l[1]||"50%")+" 0px",f=new qa(z,"zOrigin",0,0,f,-1,f.n),f.b=k,f.xs0=f.e=z.zOrigin):f.xs0=f.e=l):ea(l+"",z)),n&&(d._transformType=z.svg&&xa||!m&&3!==this._transformType?2:3),f},prefix:!0}),va("boxShadow",{defaultValue:"0px 0px 0px 0px #999",prefix:!0,color:!0,multi:!0,keyword:"inset"}),va("borderRadius",{defaultValue:"0px",parser:function(a,b,c,f,g,h){b=this.format(b);var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y=["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],z=a.style;for(q=parseFloat(a.offsetWidth),r=parseFloat(a.offsetHeight),i=b.split(" "),j=0;jp?1:0))||""):(p=parseFloat(n),s=n.substr((p+"").length)),""===s&&(s=d[c]||t),s!==t&&(v=Z(a,"borderLeft",o,t),w=Z(a,"borderTop",o,t),"%"===s?(m=v/q*100+"%",l=w/r*100+"%"):"em"===s?(x=Z(a,"borderLeft",1,"em"),m=v/x+"em",l=w/x+"em"):(m=v+"px",l=w+"px"),u&&(n=parseFloat(m)+p+s,k=parseFloat(l)+p+s)),g=sa(z,y[j],m+" "+l,n+" "+k,!1,"0px",g);return g},prefix:!0,formatter:na("0px 0px 0px 0px",!1,!0)}),va("borderBottomLeftRadius,borderBottomRightRadius,borderTopLeftRadius,borderTopRightRadius",{defaultValue:"0px",parser:function(a,b,c,d,f,g){return sa(a.style,c,this.format(Y(a,c,e,!1,"0px 0px")),this.format(b),!1,"0px",f)},prefix:!0,formatter:na("0px 0px",!1,!0)}),va("backgroundPosition",{defaultValue:"0 0",parser:function(a,b,c,d,f,g){var h,i,j,k,l,m,n="background-position",o=e||X(a,null),q=this.format((o?p?o.getPropertyValue(n+"-x")+" "+o.getPropertyValue(n+"-y"):o.getPropertyValue(n):a.currentStyle.backgroundPositionX+" "+a.currentStyle.backgroundPositionY)||"0 0"),r=this.format(b);if(-1!==q.indexOf("%")!=(-1!==r.indexOf("%"))&&r.split(",").length<2&&(m=Y(a,"backgroundImage").replace(B,""),m&&"none"!==m)){for(h=q.split(" "),i=r.split(" "),O.setAttribute("src",m),j=2;--j>-1;)q=h[j],k=-1!==q.indexOf("%"),k!==(-1!==i[j].indexOf("%"))&&(l=0===j?a.offsetWidth-O.width:a.offsetHeight-O.height,h[j]=k?parseFloat(q)/100*l+"px":parseFloat(q)/l*100+"%");q=h.join(" ")}return this.parseComplex(a.style,q,r,f,g)},formatter:ea}),va("backgroundSize",{defaultValue:"0 0",formatter:ea}),va("perspective",{defaultValue:"0px",prefix:!0}),va("perspectiveOrigin",{defaultValue:"50% 50%",prefix:!0}),va("transformStyle",{prefix:!0}),va("backfaceVisibility",{prefix:!0}),va("userSelect",{prefix:!0}),va("margin",{parser:oa("marginTop,marginRight,marginBottom,marginLeft")}),va("padding",{parser:oa("paddingTop,paddingRight,paddingBottom,paddingLeft")}),va("clip",{defaultValue:"rect(0px,0px,0px,0px)",parser:function(a,b,c,d,f,g){var h,i,j;return 9>p?(i=a.currentStyle,j=8>p?" ":",",h="rect("+i.clipTop+j+i.clipRight+j+i.clipBottom+j+i.clipLeft+")",b=this.format(b).split(",").join(j)):(h=this.format(Y(a,this.p,e,!1,this.dflt)),b=this.format(b)),this.parseComplex(a.style,h,b,f,g)}}),va("textShadow",{defaultValue:"0px 0px 0px #999",color:!0,multi:!0}),va("autoRound,strictUnits",{parser:function(a,b,c,d,e){return e}}),va("border",{defaultValue:"0px solid #000",parser:function(a,b,c,d,f,g){var h=Y(a,"borderTopWidth",e,!1,"0px"),i=this.format(b).split(" "),j=i[0].replace(u,"");return"px"!==j&&(h=parseFloat(h)/Z(a,"borderTopWidth",1,j)+j),this.parseComplex(a.style,this.format(h+" "+Y(a,"borderTopStyle",e,!1,"solid")+" "+Y(a,"borderTopColor",e,!1,"#000")),i.join(" "),f,g)},color:!0,formatter:function(a){var b=a.split(" ");return b[0]+" "+(b[1]||"solid")+" "+(a.match(ma)||["#000"])[0]}}),va("borderWidth",{parser:oa("borderTopWidth,borderRightWidth,borderBottomWidth,borderLeftWidth")}),va("float,cssFloat,styleFloat",{parser:function(a,b,c,d,e,f){var g=a.style,h="cssFloat"in g?"cssFloat":"styleFloat";return new qa(g,h,0,0,e,-1,c,!1,0,g[h],b)}});var Qa=function(a){var b,c=this.t,d=c.filter||Y(this.data,"filter")||"",e=this.s+this.c*a|0;100===e&&(-1===d.indexOf("atrix(")&&-1===d.indexOf("radient(")&&-1===d.indexOf("oader(")?(c.removeAttribute("filter"),b=!Y(this.data,"filter")):(c.filter=d.replace(x,""),b=!0)),b||(this.xn1&&(c.filter=d=d||"alpha(opacity="+e+")"),-1===d.indexOf("pacity")?0===e&&this.xn1||(c.filter=d+" alpha(opacity="+e+")"):c.filter=d.replace(v,"opacity="+e))};va("opacity,alpha,autoAlpha",{defaultValue:"1",parser:function(a,b,c,d,f,g){var h=parseFloat(Y(a,"opacity",e,!1,"1")),i=a.style,j="autoAlpha"===c;return"string"==typeof b&&"="===b.charAt(1)&&(b=("-"===b.charAt(0)?-1:1)*parseFloat(b.substr(2))+h),j&&1===h&&"hidden"===Y(a,"visibility",e)&&0!==b&&(h=0),R?f=new qa(i,"opacity",h,b-h,f):(f=new qa(i,"opacity",100*h,100*(b-h),f),f.xn1=j?1:0,i.zoom=1,f.type=2,f.b="alpha(opacity="+f.s+")",f.e="alpha(opacity="+(f.s+f.c)+")",f.data=a,f.plugin=g,f.setRatio=Qa),j&&(f=new qa(i,"visibility",0,0,f,-1,null,!1,0,0!==h?"inherit":"hidden",0===b?"hidden":"inherit"),f.xs0="inherit",d._overwriteProps.push(f.n),d._overwriteProps.push(c)),f}});var Ra=function(a,b){b&&(a.removeProperty?(("ms"===b.substr(0,2)||"webkit"===b.substr(0,6))&&(b="-"+b),a.removeProperty(b.replace(z,"-$1").toLowerCase())):a.removeAttribute(b))},Sa=function(a){if(this.t._gsClassPT=this,1===a||0===a){this.t.setAttribute("class",0===a?this.b:this.e);for(var b=this.data,c=this.t.style;b;)b.v?c[b.p]=b.v:Ra(c,b.p),b=b._next;1===a&&this.t._gsClassPT===this&&(this.t._gsClassPT=null)}else this.t.getAttribute("class")!==this.e&&this.t.setAttribute("class",this.e)};va("className",{parser:function(a,b,d,f,g,h,i){var j,k,l,m,n,o=a.getAttribute("class")||"",p=a.style.cssText;if(g=f._classNamePT=new qa(a,d,0,0,g,2),g.setRatio=Sa,g.pr=-11,c=!0,g.b=o,k=_(a,e),l=a._gsClassPT){for(m={},n=l.data;n;)m[n.p]=1,n=n._next;l.setRatio(1)}return a._gsClassPT=g,g.e="="!==b.charAt(1)?b:o.replace(new RegExp("(?:\\s|^)"+b.substr(2)+"(?![\\w-])"),"")+("+"===b.charAt(0)?" "+b.substr(2):""),a.setAttribute("class",g.e),j=aa(a,k,_(a),i,m),a.setAttribute("class",o),g.data=j.firstMPT,a.style.cssText=p,g=g.xfirst=f.parse(a,j.difs,g,h)}});var Ta=function(a){if((1===a||0===a)&&this.data._totalTime===this.data._totalDuration&&"isFromStart"!==this.data.data){var b,c,d,e,f,g=this.t.style,h=i.transform.parse;if("all"===this.e)g.cssText="",e=!0;else for(b=this.e.split(" ").join("").split(","),d=b.length;--d>-1;)c=b[d],i[c]&&(i[c].parse===h?e=!0:c="transformOrigin"===c?Ba:i[c].p),Ra(g,c);e&&(Ra(g,za),f=this.t._gsTransform,f&&(f.svg&&(this.t.removeAttribute("data-svg-origin"),this.t.removeAttribute("transform")),delete this.t._gsTransform))}};for(va("clearProps",{parser:function(a,b,d,e,f){return f=new qa(a,d,0,0,f,2),f.setRatio=Ta,f.e=b,f.pr=-10,f.data=e._tween,c=!0,f}}),j="bezier,throwProps,physicsProps,physics2D".split(","),ta=j.length;ta--;)wa(j[ta]);j=g.prototype,j._firstPT=j._lastParsedTransform=j._transform=null,j._onInitTween=function(a,b,h){if(!a.nodeType)return!1;this._target=a,this._tween=h,this._vars=b,k=b.autoRound,c=!1,d=b.suffixMap||g.suffixMap,e=X(a,""),f=this._overwriteProps;var j,n,p,q,r,s,t,u,v,x=a.style;if(l&&""===x.zIndex&&(j=Y(a,"zIndex",e),("auto"===j||""===j)&&this._addLazySet(x,"zIndex",0)),"string"==typeof b&&(q=x.cssText,j=_(a,e),x.cssText=q+";"+b,j=aa(a,j,_(a)).difs,!R&&w.test(b)&&(j.opacity=parseFloat(RegExp.$1)),b=j,x.cssText=q),b.className?this._firstPT=n=i.className.parse(a,b.className,"className",this,null,null,b):this._firstPT=n=this.parse(a,b,null),this._transformType){for(v=3===this._transformType,za?m&&(l=!0,""===x.zIndex&&(t=Y(a,"zIndex",e),("auto"===t||""===t)&&this._addLazySet(x,"zIndex",0)),o&&this._addLazySet(x,"WebkitBackfaceVisibility",this._vars.WebkitBackfaceVisibility||(v?"visible":"hidden"))):x.zoom=1,p=n;p&&p._next;)p=p._next;u=new qa(a,"transform",0,0,null,2),this._linkCSSP(u,null,p),u.setRatio=za?Pa:Oa,u.data=this._transform||Na(a,e,!0),u.tween=h,u.pr=-1,f.pop()}if(c){for(;n;){for(s=n._next,p=q;p&&p.pr>n.pr;)p=p._next;(n._prev=p?p._prev:r)?n._prev._next=n:q=n,(n._next=p)?p._prev=n:r=n,n=s}this._firstPT=q}return!0},j.parse=function(a,b,c,f){var g,h,j,l,m,n,o,p,q,r,s=a.style;for(g in b)n=b[g],h=i[g],h?c=h.parse(a,n,g,this,c,f,b):(m=Y(a,g,e)+"",q="string"==typeof n,"color"===g||"fill"===g||"stroke"===g||-1!==g.indexOf("Color")||q&&y.test(n)?(q||(n=ka(n),n=(n.length>3?"rgba(":"rgb(")+n.join(",")+")"),c=sa(s,g,m,n,!0,"transparent",c,0,f)):q&&H.test(n)?c=sa(s,g,m,n,!0,null,c,0,f):(j=parseFloat(m),o=j||0===j?m.substr((j+"").length):"",(""===m||"auto"===m)&&("width"===g||"height"===g?(j=da(a,g,e),o="px"):"left"===g||"top"===g?(j=$(a,g,e),o="px"):(j="opacity"!==g?0:1,o="")),r=q&&"="===n.charAt(1),r?(l=parseInt(n.charAt(0)+"1",10),n=n.substr(2),l*=parseFloat(n),p=n.replace(u,"")):(l=parseFloat(n),p=q?n.replace(u,""):""),""===p&&(p=g in d?d[g]:o),n=l||0===l?(r?l+j:l)+p:b[g],o!==p&&""!==p&&(l||0===l)&&j&&(j=Z(a,g,j,o),"%"===p?(j/=Z(a,g,100,"%")/100,b.strictUnits!==!0&&(m=j+"%")):"em"===p||"rem"===p||"vw"===p||"vh"===p?j/=Z(a,g,1,p):"px"!==p&&(l=Z(a,g,l,p),p="px"),r&&(l||0===l)&&(n=l+j+p)),r&&(l+=j),!j&&0!==j||!l&&0!==l?void 0!==s[g]&&(n||n+""!="NaN"&&null!=n)?(c=new qa(s,g,l||j||0,0,c,-1,g,!1,0,m,n),c.xs0="none"!==n||"display"!==g&&-1===g.indexOf("Style")?n:m):T("invalid "+g+" tween value: "+b[g]):(c=new qa(s,g,j,l-j,c,0,g,k!==!1&&("px"===p||"zIndex"===g),0,m,n),c.xs0=p))),f&&c&&!c.plugin&&(c.plugin=f);return c},j.setRatio=function(a){var b,c,d,e=this._firstPT,f=1e-6;if(1!==a||this._tween._time!==this._tween._duration&&0!==this._tween._time)if(a||this._tween._time!==this._tween._duration&&0!==this._tween._time||this._tween._rawPrevTime===-1e-6)for(;e;){if(b=e.c*a+e.s,e.r?b=Math.round(b):f>b&&b>-f&&(b=0),e.type)if(1===e.type)if(d=e.l,2===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2;else if(3===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2+e.xn2+e.xs3;else if(4===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2+e.xn2+e.xs3+e.xn3+e.xs4;else if(5===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2+e.xn2+e.xs3+e.xn3+e.xs4+e.xn4+e.xs5;else{for(c=e.xs0+b+e.xs1,d=1;d-1;)Va(a[e],b,c);else for(d=a.childNodes,e=d.length;--e>-1;)f=d[e],g=f.type,f.style&&(b.push(_(f)),c&&c.push(f)),1!==g&&9!==g&&11!==g||!f.childNodes.length||Va(f,b,c)};return g.cascadeTo=function(a,c,d){var e,f,g,h,i=b.to(a,c,d),j=[i],k=[],l=[],m=[],n=b._internals.reservedProps;for(a=i._targets||i.target,Va(a,k,m),i.render(c,!0,!0),Va(a,l),i.render(0,!0,!0),i._enabled(!0),e=m.length;--e>-1;)if(f=aa(m[e],k[e],l[e]),f.firstMPT){f=f.difs;for(g in d)n[g]&&(f[g]=d[g]);h={};for(g in f)h[g]=k[e][g];j.push(b.fromTo(m[e],c,h,f))}return j},a.activate([g]),g},!0),function(){var a=_gsScope._gsDefine.plugin({propName:"roundProps",version:"1.5",priority:-1,API:2,init:function(a,b,c){return this._tween=c,!0}}),b=function(a){for(;a;)a.f||a.blob||(a.r=1),a=a._next},c=a.prototype;c._onInitAllProps=function(){for(var a,c,d,e=this._tween,f=e.vars.roundProps.join?e.vars.roundProps:e.vars.roundProps.split(","),g=f.length,h={},i=e._propLookup.roundProps;--g>-1;)h[f[g]]=1;for(g=f.length;--g>-1;)for(a=f[g],c=e._firstPT;c;)d=c._next,c.pg?c.t._roundProps(h,!0):c.n===a&&(2===c.f&&c.t?b(c.t._firstPT):(this._add(c.t,a,c.s,c.c),d&&(d._prev=c._prev),c._prev?c._prev._next=d:e._firstPT===c&&(e._firstPT=d),c._next=c._prev=null,e._propLookup[a]=i)),c=d;return!1},c._add=function(a,b,c,d){this._addTween(a,b,c,c+d,b,!0),this._overwriteProps.push(b)}}(),function(){_gsScope._gsDefine.plugin({propName:"attr",API:2,version:"0.5.0",init:function(a,b,c){var d;if("function"!=typeof a.setAttribute)return!1;for(d in b)this._addTween(a,"setAttribute",a.getAttribute(d)+"",b[d]+"",d,!1,d),this._overwriteProps.push(d);return!0}})}(),_gsScope._gsDefine.plugin({propName:"directionalRotation",version:"0.2.1",API:2,init:function(a,b,c){"object"!=typeof b&&(b={rotation:b}),this.finals={};var d,e,f,g,h,i,j=b.useRadians===!0?2*Math.PI:360,k=1e-6;for(d in b)"useRadians"!==d&&(i=(b[d]+"").split("_"),e=i[0],f=parseFloat("function"!=typeof a[d]?a[d]:a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]()),g=this.finals[d]="string"==typeof e&&"="===e.charAt(1)?f+parseInt(e.charAt(0)+"1",10)*Number(e.substr(2)):Number(e)||0,h=g-f,i.length&&(e=i.join("_"),-1!==e.indexOf("short")&&(h%=j,h!==h%(j/2)&&(h=0>h?h+j:h-j)),-1!==e.indexOf("_cw")&&0>h?h=(h+9999999999*j)%j-(h/j|0)*j:-1!==e.indexOf("ccw")&&h>0&&(h=(h-9999999999*j)%j-(h/j|0)*j)),(h>k||-k>h)&&(this._addTween(a,d,f,f+h,d),this._overwriteProps.push(d)));return!0},set:function(a){var b;if(1!==a)this._super.setRatio.call(this,a);else for(b=this._firstPT;b;)b.f?b.t[b.p](this.finals[b.p]):b.t[b.p]=this.finals[b.p],b=b._next}})._autoCSS=!0,_gsScope._gsDefine("easing.Back",["easing.Ease"],function(a){var b,c,d,e=_gsScope.GreenSockGlobals||_gsScope,f=e.com.greensock,g=2*Math.PI,h=Math.PI/2,i=f._class,j=function(b,c){var d=i("easing."+b,function(){},!0),e=d.prototype=new a;return e.constructor=d,e.getRatio=c,d},k=a.register||function(){},l=function(a,b,c,d,e){var f=i("easing."+a,{easeOut:new b,easeIn:new c,easeInOut:new d},!0);return k(f,a),f},m=function(a,b,c){this.t=a,this.v=b,c&&(this.next=c,c.prev=this,this.c=c.v-b,this.gap=c.t-a)},n=function(b,c){var d=i("easing."+b,function(a){this._p1=a||0===a?a:1.70158,this._p2=1.525*this._p1},!0),e=d.prototype=new a;return e.constructor=d,e.getRatio=c,e.config=function(a){return new d(a)},d},o=l("Back",n("BackOut",function(a){return(a-=1)*a*((this._p1+1)*a+this._p1)+1}),n("BackIn",function(a){return a*a*((this._p1+1)*a-this._p1)}),n("BackInOut",function(a){return(a*=2)<1?.5*a*a*((this._p2+1)*a-this._p2):.5*((a-=2)*a*((this._p2+1)*a+this._p2)+2)})),p=i("easing.SlowMo",function(a,b,c){b=b||0===b?b:.7,null==a?a=.7:a>1&&(a=1),this._p=1!==a?b:0,this._p1=(1-a)/2,this._p2=a,this._p3=this._p1+this._p2,this._calcEnd=c===!0},!0),q=p.prototype=new a;return q.constructor=p,q.getRatio=function(a){var b=a+(.5-a)*this._p;return athis._p3?this._calcEnd?1-(a=(a-this._p3)/this._p1)*a:b+(a-b)*(a=(a-this._p3)/this._p1)*a*a*a:this._calcEnd?1:b},p.ease=new p(.7,.7),q.config=p.config=function(a,b,c){return new p(a,b,c)},b=i("easing.SteppedEase",function(a){a=a||1,this._p1=1/a,this._p2=a+1},!0),q=b.prototype=new a,q.constructor=b,q.getRatio=function(a){return 0>a?a=0:a>=1&&(a=.999999999),(this._p2*a>>0)*this._p1},q.config=b.config=function(a){return new b(a)},c=i("easing.RoughEase",function(b){b=b||{};for(var c,d,e,f,g,h,i=b.taper||"none",j=[],k=0,l=0|(b.points||20),n=l,o=b.randomize!==!1,p=b.clamp===!0,q=b.template instanceof a?b.template:null,r="number"==typeof b.strength?.4*b.strength:.4;--n>-1;)c=o?Math.random():1/l*n,d=q?q.getRatio(c):c,"none"===i?e=r:"out"===i?(f=1-c,e=f*f*r):"in"===i?e=c*c*r:.5>c?(f=2*c,e=f*f*.5*r):(f=2*(1-c),e=f*f*.5*r),o?d+=Math.random()*e-.5*e:n%2?d+=.5*e:d-=.5*e,p&&(d>1?d=1:0>d&&(d=0)),j[k++]={x:c,y:d};for(j.sort(function(a,b){return a.x-b.x}),h=new m(1,1,null),n=l;--n>-1;)g=j[n],h=new m(g.x,g.y,h);this._prev=new m(0,0,0!==h.t?h:h.next)},!0),q=c.prototype=new a,q.constructor=c,q.getRatio=function(a){var b=this._prev;if(a>b.t){for(;b.next&&a>=b.t;)b=b.next;b=b.prev}else for(;b.prev&&a<=b.t;)b=b.prev;return this._prev=b,b.v+(a-b.t)/b.gap*b.c},q.config=function(a){return new c(a)},c.ease=new c,l("Bounce",j("BounceOut",function(a){return 1/2.75>a?7.5625*a*a:2/2.75>a?7.5625*(a-=1.5/2.75)*a+.75:2.5/2.75>a?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375}),j("BounceIn",function(a){return(a=1-a)<1/2.75?1-7.5625*a*a:2/2.75>a?1-(7.5625*(a-=1.5/2.75)*a+.75):2.5/2.75>a?1-(7.5625*(a-=2.25/2.75)*a+.9375):1-(7.5625*(a-=2.625/2.75)*a+.984375)}),j("BounceInOut",function(a){var b=.5>a;return a=b?1-2*a:2*a-1,a=1/2.75>a?7.5625*a*a:2/2.75>a?7.5625*(a-=1.5/2.75)*a+.75:2.5/2.75>a?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375,b?.5*(1-a):.5*a+.5})),l("Circ",j("CircOut",function(a){return Math.sqrt(1-(a-=1)*a)}),j("CircIn",function(a){return-(Math.sqrt(1-a*a)-1)}),j("CircInOut",function(a){return(a*=2)<1?-.5*(Math.sqrt(1-a*a)-1):.5*(Math.sqrt(1-(a-=2)*a)+1)})),d=function(b,c,d){var e=i("easing."+b,function(a,b){this._p1=a>=1?a:1,this._p2=(b||d)/(1>a?a:1),this._p3=this._p2/g*(Math.asin(1/this._p1)||0),this._p2=g/this._p2},!0),f=e.prototype=new a;return f.constructor=e,f.getRatio=c,f.config=function(a,b){return new e(a,b)},e},l("Elastic",d("ElasticOut",function(a){return this._p1*Math.pow(2,-10*a)*Math.sin((a-this._p3)*this._p2)+1},.3),d("ElasticIn",function(a){return-(this._p1*Math.pow(2,10*(a-=1))*Math.sin((a-this._p3)*this._p2))},.3),d("ElasticInOut",function(a){return(a*=2)<1?-.5*(this._p1*Math.pow(2,10*(a-=1))*Math.sin((a-this._p3)*this._p2)):this._p1*Math.pow(2,-10*(a-=1))*Math.sin((a-this._p3)*this._p2)*.5+1},.45)),l("Expo",j("ExpoOut",function(a){return 1-Math.pow(2,-10*a)}),j("ExpoIn",function(a){return Math.pow(2,10*(a-1))-.001}),j("ExpoInOut",function(a){return(a*=2)<1?.5*Math.pow(2,10*(a-1)):.5*(2-Math.pow(2,-10*(a-1)))})),l("Sine",j("SineOut",function(a){return Math.sin(a*h)}),j("SineIn",function(a){return-Math.cos(a*h)+1}),j("SineInOut",function(a){return-.5*(Math.cos(Math.PI*a)-1)})),i("easing.EaseLookup",{find:function(b){return a.map[b]}},!0),k(e.SlowMo,"SlowMo","ease,"),k(c,"RoughEase","ease,"),k(b,"SteppedEase","ease,"),o},!0)}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(),function(a,b){"use strict";var c={},d=a.GreenSockGlobals=a.GreenSockGlobals||a;if(!d.TweenLite){var e,f,g,h,i,j=function(a){var b,c=a.split("."),e=d;for(b=0;b-1;)(l=p[f[s]]||new q(f[s],[])).gsClass?(i[s]=l.gsClass,t--):k&&l.sc.push(this);if(0===t&&g){if(m=("com.greensock."+e).split("."),n=m.pop(),o=j(m.join("."))[n]=this.gsClass=g.apply(g,i),h)if(d[n]=o,r="undefined"!=typeof module&&module.exports,!r&&"function"==typeof define&&define.amd)define((a.GreenSockAMDPath?a.GreenSockAMDPath+"/":"")+e.split(".").pop(),[],function(){return o});else if(r)if(e===b){module.exports=c[b]=o;for(s in c)o[s]=c[s]}else c[b]&&(c[b][n]=o);for(s=0;s-1;)for(f=i[j],e=d?s("easing."+f,null,!0):k.easing[f]||{},g=l.length;--g>-1;)h=l[g],w[f+"."+h]=w[h+f]=e[h]=a.getRatio?a:a[h]||new a};for(g=v.prototype,g._calcEnd=!1,g.getRatio=function(a){if(this._func)return this._params[0]=a,this._func.apply(null,this._params);var b=this._type,c=this._power,d=1===b?1-a:2===b?a:.5>a?2*a:2*(1-a);return 1===c?d*=d:2===c?d*=d*d:3===c?d*=d*d*d:4===c&&(d*=d*d*d*d),1===b?1-d:2===b?d:.5>a?d/2:1-d/2},e=["Linear","Quad","Cubic","Quart","Quint,Strong"],f=e.length;--f>-1;)g=e[f]+",Power"+f,x(new v(null,null,1,f),g,"easeOut",!0),x(new v(null,null,2,f),g,"easeIn"+(0===f?",easeNone":"")),x(new v(null,null,3,f),g,"easeInOut");w.linear=k.easing.Linear.easeIn,w.swing=k.easing.Quad.easeInOut;var y=s("events.EventDispatcher",function(a){this._listeners={},this._eventTarget=a||this});g=y.prototype,g.addEventListener=function(a,b,c,d,e){e=e||0;var f,g,j=this._listeners[a],k=0;for(this!==h||i||h.wake(),null==j&&(this._listeners[a]=j=[]),g=j.length;--g>-1;)f=j[g],f.c===b&&f.s===c?j.splice(g,1):0===k&&f.pr-1;)if(d[c].c===b)return void d.splice(c,1)},g.dispatchEvent=function(a){var b,c,d,e=this._listeners[a];if(e)for(b=e.length,c=this._eventTarget;--b>-1;)d=e[b],d&&(d.up?d.c.call(d.s||c,{type:a,target:c}):d.c.call(d.s||c))};var z=a.requestAnimationFrame,A=a.cancelAnimationFrame,B=Date.now||function(){return(new Date).getTime()},C=B();for(e=["ms","moz","webkit","o"],f=e.length;--f>-1&&!z;)z=a[e[f]+"RequestAnimationFrame"],A=a[e[f]+"CancelAnimationFrame"]||a[e[f]+"CancelRequestAnimationFrame"];s("Ticker",function(a,b){var c,d,e,f,g,j=this,k=B(),m=b!==!1&&z?"auto":!1,o=500,p=33,q="tick",r=function(a){var b,h,i=B()-C;i>o&&(k+=i-p),C+=i,j.time=(C-k)/1e3,b=j.time-g,(!c||b>0||a===!0)&&(j.frame++,g+=b+(b>=f?.004:f-b),h=!0),a!==!0&&(e=d(r)),h&&j.dispatchEvent(q)};y.call(j),j.time=j.frame=0,j.tick=function(){r(!0)},j.lagSmoothing=function(a,b){o=a||1/l,p=Math.min(b,o,0)},j.sleep=function(){null!=e&&(m&&A?A(e):clearTimeout(e),d=n,e=null,j===h&&(i=!1))},j.wake=function(a){null!==e?j.sleep():a?k+=-C+(C=B()):j.frame>10&&(C=B()-o+5),d=0===c?n:m&&z?z:function(a){return setTimeout(a,1e3*(g-j.time)+1|0)},j===h&&(i=!0),r(2)},j.fps=function(a){return arguments.length?(c=a,f=1/(c||60),g=this.time+f,void j.wake()):c},j.useRAF=function(a){return arguments.length?(j.sleep(),m=a,void j.fps(c)):m},j.fps(a),setTimeout(function(){"auto"===m&&j.frame<5&&"hidden"!==document.visibilityState&&j.useRAF(!1)},1500)}),g=k.Ticker.prototype=new k.events.EventDispatcher,g.constructor=k.Ticker;var D=s("core.Animation",function(a,b){if(this.vars=b=b||{},this._duration=this._totalDuration=a||0,this._delay=Number(b.delay)||0,this._timeScale=1,this._active=b.immediateRender===!0,this.data=b.data,this._reversed=b.reversed===!0,W){i||h.wake();var c=this.vars.useFrames?V:W;c.add(this,c._time),this.vars.paused&&this.paused(!0)}});h=D.ticker=new k.Ticker,g=D.prototype,g._dirty=g._gc=g._initted=g._paused=!1,g._totalTime=g._time=0,g._rawPrevTime=-1,g._next=g._last=g._onUpdate=g._timeline=g.timeline=null,g._paused=!1;var E=function(){i&&B()-C>2e3&&h.wake(),setTimeout(E,2e3)};E(),g.play=function(a,b){return null!=a&&this.seek(a,b),this.reversed(!1).paused(!1)},g.pause=function(a,b){return null!=a&&this.seek(a,b),this.paused(!0)},g.resume=function(a,b){return null!=a&&this.seek(a,b),this.paused(!1)},g.seek=function(a,b){return this.totalTime(Number(a),b!==!1)},g.restart=function(a,b){return this.reversed(!1).paused(!1).totalTime(a?-this._delay:0,b!==!1,!0)},g.reverse=function(a,b){return null!=a&&this.seek(a||this.totalDuration(),b),this.reversed(!0).paused(!1)},g.render=function(a,b,c){},g.invalidate=function(){return this._time=this._totalTime=0,this._initted=this._gc=!1,this._rawPrevTime=-1,(this._gc||!this.timeline)&&this._enabled(!0),this},g.isActive=function(){var a,b=this._timeline,c=this._startTime;return!b||!this._gc&&!this._paused&&b.isActive()&&(a=b.rawTime())>=c&&a-1;)"{self}"===a[b]&&(c[b]=this);return c},g._callback=function(a){var b=this.vars;b[a].apply(b[a+"Scope"]||b.callbackScope||this,b[a+"Params"]||u)},g.eventCallback=function(a,b,c,d){if("on"===(a||"").substr(0,2)){var e=this.vars;if(1===arguments.length)return e[a];null==b?delete e[a]:(e[a]=b,e[a+"Params"]=o(c)&&-1!==c.join("").indexOf("{self}")?this._swapSelfInParams(c):c,e[a+"Scope"]=d),"onUpdate"===a&&(this._onUpdate=b)}return this},g.delay=function(a){return arguments.length?(this._timeline.smoothChildTiming&&this.startTime(this._startTime+a-this._delay),this._delay=a,this):this._delay},g.duration=function(a){return arguments.length?(this._duration=this._totalDuration=a,this._uncache(!0),this._timeline.smoothChildTiming&&this._time>0&&this._timethis._duration?this._duration:a,b)):this._time},g.totalTime=function(a,b,c){if(i||h.wake(),!arguments.length)return this._totalTime;if(this._timeline){if(0>a&&!c&&(a+=this.totalDuration()),this._timeline.smoothChildTiming){this._dirty&&this.totalDuration();var d=this._totalDuration,e=this._timeline;if(a>d&&!c&&(a=d),this._startTime=(this._paused?this._pauseTime:e._time)-(this._reversed?d-a:a)/this._timeScale,e._dirty||this._uncache(!1),e._timeline)for(;e._timeline;)e._timeline._time!==(e._startTime+e._totalTime)/e._timeScale&&e.totalTime(e._totalTime,!0),e=e._timeline}this._gc&&this._enabled(!0,!1),(this._totalTime!==a||0===this._duration)&&(J.length&&Y(),this.render(a,b,!1),J.length&&Y())}return this},g.progress=g.totalProgress=function(a,b){var c=this.duration();return arguments.length?this.totalTime(c*a,b):c?this._time/c:this.ratio},g.startTime=function(a){return arguments.length?(a!==this._startTime&&(this._startTime=a,this.timeline&&this.timeline._sortChildren&&this.timeline.add(this,a-this._delay)),this):this._startTime},g.endTime=function(a){return this._startTime+(0!=a?this.totalDuration():this.duration())/this._timeScale},g.timeScale=function(a){if(!arguments.length)return this._timeScale;if(a=a||l,this._timeline&&this._timeline.smoothChildTiming){var b=this._pauseTime,c=b||0===b?b:this._timeline.totalTime();this._startTime=c-(c-this._startTime)*this._timeScale/a}return this._timeScale=a,this._uncache(!1)},g.reversed=function(a){return arguments.length?(a!=this._reversed&&(this._reversed=a,this.totalTime(this._timeline&&!this._timeline.smoothChildTiming?this.totalDuration()-this._totalTime:this._totalTime,!0)),this):this._reversed},g.paused=function(a){if(!arguments.length)return this._paused;var b,c,d=this._timeline;return a!=this._paused&&d&&(i||a||h.wake(),b=d.rawTime(),c=b-this._pauseTime,!a&&d.smoothChildTiming&&(this._startTime+=c,this._uncache(!1)),this._pauseTime=a?b:null,this._paused=a,this._active=this.isActive(),!a&&0!==c&&this._initted&&this.duration()&&(b=d.smoothChildTiming?this._totalTime:(b-this._startTime)/this._timeScale,this.render(b,b===this._totalTime,!0))),this._gc&&!a&&this._enabled(!0,!1),this};var F=s("core.SimpleTimeline",function(a){D.call(this,0,a),this.autoRemoveChildren=this.smoothChildTiming=!0});g=F.prototype=new D,g.constructor=F,g.kill()._gc=!1,g._first=g._last=g._recent=null,g._sortChildren=!1,g.add=g.insert=function(a,b,c,d){var e,f;if(a._startTime=Number(b||0)+a._delay,a._paused&&this!==a._timeline&&(a._pauseTime=a._startTime+(this.rawTime()-a._startTime)/a._timeScale),a.timeline&&a.timeline._remove(a,!0),a.timeline=a._timeline=this,a._gc&&a._enabled(!0,!0),e=this._last,this._sortChildren)for(f=a._startTime;e&&e._startTime>f;)e=e._prev;return e?(a._next=e._next,e._next=a):(a._next=this._first,this._first=a),a._next?a._next._prev=a:this._last=a,a._prev=e,this._recent=a,this._timeline&&this._uncache(!0),this},g._remove=function(a,b){return a.timeline===this&&(b||a._enabled(!1,!0),a._prev?a._prev._next=a._next:this._first===a&&(this._first=a._next),a._next?a._next._prev=a._prev:this._last===a&&(this._last=a._prev),a._next=a._prev=a.timeline=null,a===this._recent&&(this._recent=this._last),this._timeline&&this._uncache(!0)),this},g.render=function(a,b,c){var d,e=this._first;for(this._totalTime=this._time=this._rawPrevTime=a;e;)d=e._next,(e._active||a>=e._startTime&&!e._paused)&&(e._reversed?e.render((e._dirty?e.totalDuration():e._totalDuration)-(a-e._startTime)*e._timeScale,b,c):e.render((a-e._startTime)*e._timeScale,b,c)),e=d},g.rawTime=function(){return i||h.wake(),this._totalTime};var G=s("TweenLite",function(b,c,d){if(D.call(this,c,d),this.render=G.prototype.render,null==b)throw"Cannot tween a null target.";this.target=b="string"!=typeof b?b:G.selector(b)||b;var e,f,g,h=b.jquery||b.length&&b!==a&&b[0]&&(b[0]===a||b[0].nodeType&&b[0].style&&!b.nodeType),i=this.vars.overwrite;if(this._overwrite=i=null==i?U[G.defaultOverwrite]:"number"==typeof i?i>>0:U[i],(h||b instanceof Array||b.push&&o(b))&&"number"!=typeof b[0])for(this._targets=g=m(b),this._propLookup=[],this._siblings=[],e=0;e1&&_(f,this,null,1,this._siblings[e])):(f=g[e--]=G.selector(f),"string"==typeof f&&g.splice(e+1,1)):g.splice(e--,1);else this._propLookup={},this._siblings=Z(b,this,!1),1===i&&this._siblings.length>1&&_(b,this,null,1,this._siblings);(this.vars.immediateRender||0===c&&0===this._delay&&this.vars.immediateRender!==!1)&&(this._time=-l,this.render(Math.min(0,-this._delay)))},!0),H=function(b){return b&&b.length&&b!==a&&b[0]&&(b[0]===a||b[0].nodeType&&b[0].style&&!b.nodeType)},I=function(a,b){var c,d={};for(c in a)T[c]||c in b&&"transform"!==c&&"x"!==c&&"y"!==c&&"width"!==c&&"height"!==c&&"className"!==c&&"border"!==c||!(!Q[c]||Q[c]&&Q[c]._autoCSS)||(d[c]=a[c],delete a[c]);a.css=d};g=G.prototype=new D,g.constructor=G,g.kill()._gc=!1,g.ratio=0,g._firstPT=g._targets=g._overwrittenProps=g._startAt=null,g._notifyPluginsOfEnabled=g._lazy=!1,G.version="1.18.5",G.defaultEase=g._ease=new v(null,null,1,1),G.defaultOverwrite="auto",G.ticker=h,G.autoSleep=120,G.lagSmoothing=function(a,b){h.lagSmoothing(a,b)},G.selector=a.$||a.jQuery||function(b){var c=a.$||a.jQuery;return c?(G.selector=c,c(b)):"undefined"==typeof document?b:document.querySelectorAll?document.querySelectorAll(b):document.getElementById("#"===b.charAt(0)?b.substr(1):b)};var J=[],K={},L=/(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi,M=function(a){for(var b,c=this._firstPT,d=1e-6;c;)b=c.blob?a?this.join(""):this.start:c.c*a+c.s,c.r?b=Math.round(b):d>b&&b>-d&&(b=0),c.f?c.fp?c.t[c.p](c.fp,b):c.t[c.p](b):c.t[c.p]=b,c=c._next},N=function(a,b,c,d){var e,f,g,h,i,j,k,l=[a,b],m=0,n="",o=0;for(l.start=a,c&&(c(l),a=l[0],b=l[1]),l.length=0,e=a.match(L)||[],f=b.match(L)||[],d&&(d._next=null, +d.blob=1,l._firstPT=d),i=f.length,h=0;i>h;h++)k=f[h],j=b.substr(m,b.indexOf(k,m)-m),n+=j||!h?j:",",m+=j.length,o?o=(o+1)%5:"rgba("===j.substr(-5)&&(o=1),k===e[h]||e.length<=h?n+=k:(n&&(l.push(n),n=""),g=parseFloat(e[h]),l.push(g),l._firstPT={_next:l._firstPT,t:l,p:l.length-1,s:g,c:("="===k.charAt(1)?parseInt(k.charAt(0)+"1",10)*parseFloat(k.substr(2)):parseFloat(k)-g)||0,f:0,r:o&&4>o}),m+=k.length;return n+=b.substr(m),n&&l.push(n),l.setRatio=M,l},O=function(a,b,c,d,e,f,g,h){var i,j,k="get"===c?a[b]:c,l=typeof a[b],m="string"==typeof d&&"="===d.charAt(1),n={t:a,p:b,s:k,f:"function"===l,pg:0,n:e||b,r:f,pr:0,c:m?parseInt(d.charAt(0)+"1",10)*parseFloat(d.substr(2)):parseFloat(d)-k||0};return"number"!==l&&("function"===l&&"get"===c&&(j=b.indexOf("set")||"function"!=typeof a["get"+b.substr(3)]?b:"get"+b.substr(3),n.s=k=g?a[j](g):a[j]()),"string"==typeof k&&(g||isNaN(k))?(n.fp=g,i=N(k,d,h||G.defaultStringFilter,n),n={t:i,p:"setRatio",s:0,c:1,f:2,pg:0,n:e||b,pr:0}):m||(n.s=parseFloat(k),n.c=parseFloat(d)-n.s||0)),n.c?((n._next=this._firstPT)&&(n._next._prev=n),this._firstPT=n,n):void 0},P=G._internals={isArray:o,isSelector:H,lazyTweens:J,blobDif:N},Q=G._plugins={},R=P.tweenLookup={},S=0,T=P.reservedProps={ease:1,delay:1,overwrite:1,onComplete:1,onCompleteParams:1,onCompleteScope:1,useFrames:1,runBackwards:1,startAt:1,onUpdate:1,onUpdateParams:1,onUpdateScope:1,onStart:1,onStartParams:1,onStartScope:1,onReverseComplete:1,onReverseCompleteParams:1,onReverseCompleteScope:1,onRepeat:1,onRepeatParams:1,onRepeatScope:1,easeParams:1,yoyo:1,immediateRender:1,repeat:1,repeatDelay:1,data:1,paused:1,reversed:1,autoCSS:1,lazy:1,onOverwrite:1,callbackScope:1,stringFilter:1,id:1},U={none:0,all:1,auto:2,concurrent:3,allOnStart:4,preexisting:5,"true":1,"false":0},V=D._rootFramesTimeline=new F,W=D._rootTimeline=new F,X=30,Y=P.lazyRender=function(){var a,b=J.length;for(K={};--b>-1;)a=J[b],a&&a._lazy!==!1&&(a.render(a._lazy[0],a._lazy[1],!0),a._lazy=!1);J.length=0};W._startTime=h.time,V._startTime=h.frame,W._active=V._active=!0,setTimeout(Y,1),D._updateRoot=G.render=function(){var a,b,c;if(J.length&&Y(),W.render((h.time-W._startTime)*W._timeScale,!1,!1),V.render((h.frame-V._startTime)*V._timeScale,!1,!1),J.length&&Y(),h.frame>=X){X=h.frame+(parseInt(G.autoSleep,10)||120);for(c in R){for(b=R[c].tweens,a=b.length;--a>-1;)b[a]._gc&&b.splice(a,1);0===b.length&&delete R[c]}if(c=W._first,(!c||c._paused)&&G.autoSleep&&!V._first&&1===h._listeners.tick.length){for(;c&&c._paused;)c=c._next;c||h.sleep()}}},h.addEventListener("tick",D._updateRoot);var Z=function(a,b,c){var d,e,f=a._gsTweenID;if(R[f||(a._gsTweenID=f="t"+S++)]||(R[f]={target:a,tweens:[]}),b&&(d=R[f].tweens,d[e=d.length]=b,c))for(;--e>-1;)d[e]===b&&d.splice(e,1);return R[f].tweens},$=function(a,b,c,d){var e,f,g=a.vars.onOverwrite;return g&&(e=g(a,b,c,d)),g=G.onOverwrite,g&&(f=g(a,b,c,d)),e!==!1&&f!==!1},_=function(a,b,c,d,e){var f,g,h,i;if(1===d||d>=4){for(i=e.length,f=0;i>f;f++)if((h=e[f])!==b)h._gc||h._kill(null,a,b)&&(g=!0);else if(5===d)break;return g}var j,k=b._startTime+l,m=[],n=0,o=0===b._duration;for(f=e.length;--f>-1;)(h=e[f])===b||h._gc||h._paused||(h._timeline!==b._timeline?(j=j||aa(b,0,o),0===aa(h,j,o)&&(m[n++]=h)):h._startTime<=k&&h._startTime+h.totalDuration()/h._timeScale>k&&((o||!h._initted)&&k-h._startTime<=2e-10||(m[n++]=h)));for(f=n;--f>-1;)if(h=m[f],2===d&&h._kill(c,a,b)&&(g=!0),2!==d||!h._firstPT&&h._initted){if(2!==d&&!$(h,b))continue;h._enabled(!1,!1)&&(g=!0)}return g},aa=function(a,b,c){for(var d=a._timeline,e=d._timeScale,f=a._startTime;d._timeline;){if(f+=d._startTime,e*=d._timeScale,d._paused)return-100;d=d._timeline}return f/=e,f>b?f-b:c&&f===b||!a._initted&&2*l>f-b?l:(f+=a.totalDuration()/a._timeScale/e)>b+l?0:f-b-l};g._init=function(){var a,b,c,d,e,f=this.vars,g=this._overwrittenProps,h=this._duration,i=!!f.immediateRender,j=f.ease;if(f.startAt){this._startAt&&(this._startAt.render(-1,!0),this._startAt.kill()),e={};for(d in f.startAt)e[d]=f.startAt[d];if(e.overwrite=!1,e.immediateRender=!0,e.lazy=i&&f.lazy!==!1,e.startAt=e.delay=null,this._startAt=G.to(this.target,0,e),i)if(this._time>0)this._startAt=null;else if(0!==h)return}else if(f.runBackwards&&0!==h)if(this._startAt)this._startAt.render(-1,!0),this._startAt.kill(),this._startAt=null;else{0!==this._time&&(i=!1),c={};for(d in f)T[d]&&"autoCSS"!==d||(c[d]=f[d]);if(c.overwrite=0,c.data="isFromStart",c.lazy=i&&f.lazy!==!1,c.immediateRender=i,this._startAt=G.to(this.target,0,c),i){if(0===this._time)return}else this._startAt._init(),this._startAt._enabled(!1),this.vars.immediateRender&&(this._startAt=null)}if(this._ease=j=j?j instanceof v?j:"function"==typeof j?new v(j,f.easeParams):w[j]||G.defaultEase:G.defaultEase,f.easeParams instanceof Array&&j.config&&(this._ease=j.config.apply(j,f.easeParams)),this._easeType=this._ease._type,this._easePower=this._ease._power,this._firstPT=null,this._targets)for(a=this._targets.length;--a>-1;)this._initProps(this._targets[a],this._propLookup[a]={},this._siblings[a],g?g[a]:null)&&(b=!0);else b=this._initProps(this.target,this._propLookup,this._siblings,g);if(b&&G._onPluginEvent("_onInitAllProps",this),g&&(this._firstPT||"function"!=typeof this.target&&this._enabled(!1,!1)),f.runBackwards)for(c=this._firstPT;c;)c.s+=c.c,c.c=-c.c,c=c._next;this._onUpdate=f.onUpdate,this._initted=!0},g._initProps=function(b,c,d,e){var f,g,h,i,j,k;if(null==b)return!1;K[b._gsTweenID]&&Y(),this.vars.css||b.style&&b!==a&&b.nodeType&&Q.css&&this.vars.autoCSS!==!1&&I(this.vars,b);for(f in this.vars)if(k=this.vars[f],T[f])k&&(k instanceof Array||k.push&&o(k))&&-1!==k.join("").indexOf("{self}")&&(this.vars[f]=k=this._swapSelfInParams(k,this));else if(Q[f]&&(i=new Q[f])._onInitTween(b,this.vars[f],this)){for(this._firstPT=j={_next:this._firstPT,t:i,p:"setRatio",s:0,c:1,f:1,n:f,pg:1,pr:i._priority},g=i._overwriteProps.length;--g>-1;)c[i._overwriteProps[g]]=this._firstPT;(i._priority||i._onInitAllProps)&&(h=!0),(i._onDisable||i._onEnable)&&(this._notifyPluginsOfEnabled=!0),j._next&&(j._next._prev=j)}else c[f]=O.call(this,b,f,"get",k,f,0,null,this.vars.stringFilter);return e&&this._kill(e,b)?this._initProps(b,c,d,e):this._overwrite>1&&this._firstPT&&d.length>1&&_(b,this,c,this._overwrite,d)?(this._kill(c,b),this._initProps(b,c,d,e)):(this._firstPT&&(this.vars.lazy!==!1&&this._duration||this.vars.lazy&&!this._duration)&&(K[b._gsTweenID]=!0),h)},g.render=function(a,b,c){var d,e,f,g,h=this._time,i=this._duration,j=this._rawPrevTime;if(a>=i-1e-7)this._totalTime=this._time=i,this.ratio=this._ease._calcEnd?this._ease.getRatio(1):1,this._reversed||(d=!0,e="onComplete",c=c||this._timeline.autoRemoveChildren),0===i&&(this._initted||!this.vars.lazy||c)&&(this._startTime===this._timeline._duration&&(a=0),(0>j||0>=a&&a>=-1e-7||j===l&&"isPause"!==this.data)&&j!==a&&(c=!0,j>l&&(e="onReverseComplete")),this._rawPrevTime=g=!b||a||j===a?a:l);else if(1e-7>a)this._totalTime=this._time=0,this.ratio=this._ease._calcEnd?this._ease.getRatio(0):0,(0!==h||0===i&&j>0)&&(e="onReverseComplete",d=this._reversed),0>a&&(this._active=!1,0===i&&(this._initted||!this.vars.lazy||c)&&(j>=0&&(j!==l||"isPause"!==this.data)&&(c=!0),this._rawPrevTime=g=!b||a||j===a?a:l)),this._initted||(c=!0);else if(this._totalTime=this._time=a,this._easeType){var k=a/i,m=this._easeType,n=this._easePower;(1===m||3===m&&k>=.5)&&(k=1-k),3===m&&(k*=2),1===n?k*=k:2===n?k*=k*k:3===n?k*=k*k*k:4===n&&(k*=k*k*k*k),1===m?this.ratio=1-k:2===m?this.ratio=k:.5>a/i?this.ratio=k/2:this.ratio=1-k/2}else this.ratio=this._ease.getRatio(a/i);if(this._time!==h||c){if(!this._initted){if(this._init(),!this._initted||this._gc)return;if(!c&&this._firstPT&&(this.vars.lazy!==!1&&this._duration||this.vars.lazy&&!this._duration))return this._time=this._totalTime=h,this._rawPrevTime=j,J.push(this),void(this._lazy=[a,b]);this._time&&!d?this.ratio=this._ease.getRatio(this._time/i):d&&this._ease._calcEnd&&(this.ratio=this._ease.getRatio(0===this._time?0:1))}for(this._lazy!==!1&&(this._lazy=!1),this._active||!this._paused&&this._time!==h&&a>=0&&(this._active=!0),0===h&&(this._startAt&&(a>=0?this._startAt.render(a,b,c):e||(e="_dummyGS")),this.vars.onStart&&(0!==this._time||0===i)&&(b||this._callback("onStart"))),f=this._firstPT;f;)f.f?f.t[f.p](f.c*this.ratio+f.s):f.t[f.p]=f.c*this.ratio+f.s,f=f._next;this._onUpdate&&(0>a&&this._startAt&&a!==-1e-4&&this._startAt.render(a,b,c),b||(this._time!==h||d||c)&&this._callback("onUpdate")),e&&(!this._gc||c)&&(0>a&&this._startAt&&!this._onUpdate&&a!==-1e-4&&this._startAt.render(a,b,c),d&&(this._timeline.autoRemoveChildren&&this._enabled(!1,!1),this._active=!1),!b&&this.vars[e]&&this._callback(e),0===i&&this._rawPrevTime===l&&g!==l&&(this._rawPrevTime=0))}},g._kill=function(a,b,c){if("all"===a&&(a=null),null==a&&(null==b||b===this.target))return this._lazy=!1,this._enabled(!1,!1);b="string"!=typeof b?b||this._targets||this.target:G.selector(b)||b;var d,e,f,g,h,i,j,k,l,m=c&&this._time&&c._startTime===this._startTime&&this._timeline===c._timeline;if((o(b)||H(b))&&"number"!=typeof b[0])for(d=b.length;--d>-1;)this._kill(a,b[d],c)&&(i=!0);else{if(this._targets){for(d=this._targets.length;--d>-1;)if(b===this._targets[d]){h=this._propLookup[d]||{},this._overwrittenProps=this._overwrittenProps||[],e=this._overwrittenProps[d]=a?this._overwrittenProps[d]||{}:"all";break}}else{if(b!==this.target)return!1;h=this._propLookup,e=this._overwrittenProps=a?this._overwrittenProps||{}:"all"}if(h){if(j=a||h,k=a!==e&&"all"!==e&&a!==h&&("object"!=typeof a||!a._tempKill),c&&(G.onOverwrite||this.vars.onOverwrite)){for(f in j)h[f]&&(l||(l=[]),l.push(f));if((l||!a)&&!$(this,c,b,l))return!1}for(f in j)(g=h[f])&&(m&&(g.f?g.t[g.p](g.s):g.t[g.p]=g.s,i=!0),g.pg&&g.t._kill(j)&&(i=!0),g.pg&&0!==g.t._overwriteProps.length||(g._prev?g._prev._next=g._next:g===this._firstPT&&(this._firstPT=g._next),g._next&&(g._next._prev=g._prev),g._next=g._prev=null),delete h[f]),k&&(e[f]=1);!this._firstPT&&this._initted&&this._enabled(!1,!1)}}return i},g.invalidate=function(){return this._notifyPluginsOfEnabled&&G._onPluginEvent("_onDisable",this),this._firstPT=this._overwrittenProps=this._startAt=this._onUpdate=null,this._notifyPluginsOfEnabled=this._active=this._lazy=!1,this._propLookup=this._targets?{}:[],D.prototype.invalidate.call(this),this.vars.immediateRender&&(this._time=-l,this.render(Math.min(0,-this._delay))),this},g._enabled=function(a,b){if(i||h.wake(),a&&this._gc){var c,d=this._targets;if(d)for(c=d.length;--c>-1;)this._siblings[c]=Z(d[c],this,!0);else this._siblings=Z(this.target,this,!0)}return D.prototype._enabled.call(this,a,b),this._notifyPluginsOfEnabled&&this._firstPT?G._onPluginEvent(a?"_onEnable":"_onDisable",this):!1},G.to=function(a,b,c){return new G(a,b,c)},G.from=function(a,b,c){return c.runBackwards=!0,c.immediateRender=0!=c.immediateRender,new G(a,b,c)},G.fromTo=function(a,b,c,d){return d.startAt=c,d.immediateRender=0!=d.immediateRender&&0!=c.immediateRender,new G(a,b,d)},G.delayedCall=function(a,b,c,d,e){return new G(b,0,{delay:a,onComplete:b,onCompleteParams:c,callbackScope:d,onReverseComplete:b,onReverseCompleteParams:c,immediateRender:!1,lazy:!1,useFrames:e,overwrite:0})},G.set=function(a,b){return new G(a,0,b)},G.getTweensOf=function(a,b){if(null==a)return[];a="string"!=typeof a?a:G.selector(a)||a;var c,d,e,f;if((o(a)||H(a))&&"number"!=typeof a[0]){for(c=a.length,d=[];--c>-1;)d=d.concat(G.getTweensOf(a[c],b));for(c=d.length;--c>-1;)for(f=d[c],e=c;--e>-1;)f===d[e]&&d.splice(c,1)}else for(d=Z(a).concat(),c=d.length;--c>-1;)(d[c]._gc||b&&!d[c].isActive())&&d.splice(c,1);return d},G.killTweensOf=G.killDelayedCallsTo=function(a,b,c){"object"==typeof b&&(c=b,b=!1);for(var d=G.getTweensOf(a,b),e=d.length;--e>-1;)d[e]._kill(c,a)};var ba=s("plugins.TweenPlugin",function(a,b){this._overwriteProps=(a||"").split(","),this._propName=this._overwriteProps[0],this._priority=b||0,this._super=ba.prototype},!0);if(g=ba.prototype,ba.version="1.18.0",ba.API=2,g._firstPT=null,g._addTween=O,g.setRatio=M,g._kill=function(a){var b,c=this._overwriteProps,d=this._firstPT;if(null!=a[this._propName])this._overwriteProps=[];else for(b=c.length;--b>-1;)null!=a[c[b]]&&c.splice(b,1);for(;d;)null!=a[d.n]&&(d._next&&(d._next._prev=d._prev),d._prev?(d._prev._next=d._next,d._prev=null):this._firstPT===d&&(this._firstPT=d._next)),d=d._next;return!1},g._roundProps=function(a,b){for(var c=this._firstPT;c;)(a[this._propName]||null!=c.n&&a[c.n.split(this._propName+"_").join("")])&&(c.r=b),c=c._next},G._onPluginEvent=function(a,b){var c,d,e,f,g,h=b._firstPT;if("_onInitAllProps"===a){for(;h;){for(g=h._next,d=e;d&&d.pr>h.pr;)d=d._next;(h._prev=d?d._prev:f)?h._prev._next=h:e=h,(h._next=d)?d._prev=h:f=h,h=g}h=b._firstPT=e}for(;h;)h.pg&&"function"==typeof h.t[a]&&h.t[a]()&&(c=!0),h=h._next;return c},ba.activate=function(a){for(var b=a.length;--b>-1;)a[b].API===ba.API&&(Q[(new a[b])._propName]=a[b]);return!0},r.plugin=function(a){if(!(a&&a.propName&&a.init&&a.API))throw"illegal plugin definition.";var b,c=a.propName,d=a.priority||0,e=a.overwriteProps,f={init:"_onInitTween",set:"setRatio",kill:"_kill",round:"_roundProps",initAll:"_onInitAllProps"},g=s("plugins."+c.charAt(0).toUpperCase()+c.substr(1)+"Plugin",function(){ba.call(this,c,d),this._overwriteProps=e||[]},a.global===!0),h=g.prototype=new ba(c);h.constructor=g,g.API=a.API;for(b in f)"function"==typeof a[b]&&(h[f[b]]=a[b]);return g.version=a.version,ba.activate([g]),g},e=a._gsQueue){for(f=0;f 1) { + linearRatio = 1; + } + this._p = (linearRatio !== 1) ? power : 0; + this._p1 = (1 - linearRatio) / 2; + this._p2 = linearRatio; + this._p3 = this._p1 + this._p2; + this._calcEnd = (yoyoMode === true); + }, true), + p = SlowMo.prototype = new Ease(), + SteppedEase, RoughEase, _createElastic; + + p.constructor = SlowMo; + p.getRatio = function(p) { + var r = p + (0.5 - p) * this._p; + if (p < this._p1) { + return this._calcEnd ? 1 - ((p = 1 - (p / this._p1)) * p) : r - ((p = 1 - (p / this._p1)) * p * p * p * r); + } else if (p > this._p3) { + return this._calcEnd ? 1 - (p = (p - this._p3) / this._p1) * p : r + ((p - r) * (p = (p - this._p3) / this._p1) * p * p * p); + } + return this._calcEnd ? 1 : r; + }; + SlowMo.ease = new SlowMo(0.7, 0.7); + + p.config = SlowMo.config = function(linearRatio, power, yoyoMode) { + return new SlowMo(linearRatio, power, yoyoMode); + }; + + + //SteppedEase + SteppedEase = _class("easing.SteppedEase", function(steps) { + steps = steps || 1; + this._p1 = 1 / steps; + this._p2 = steps + 1; + }, true); + p = SteppedEase.prototype = new Ease(); + p.constructor = SteppedEase; + p.getRatio = function(p) { + if (p < 0) { + p = 0; + } else if (p >= 1) { + p = 0.999999999; + } + return ((this._p2 * p) >> 0) * this._p1; + }; + p.config = SteppedEase.config = function(steps) { + return new SteppedEase(steps); + }; + + + //RoughEase + RoughEase = _class("easing.RoughEase", function(vars) { + vars = vars || {}; + var taper = vars.taper || "none", + a = [], + cnt = 0, + points = (vars.points || 20) | 0, + i = points, + randomize = (vars.randomize !== false), + clamp = (vars.clamp === true), + template = (vars.template instanceof Ease) ? vars.template : null, + strength = (typeof(vars.strength) === "number") ? vars.strength * 0.4 : 0.4, + x, y, bump, invX, obj, pnt; + while (--i > -1) { + x = randomize ? Math.random() : (1 / points) * i; + y = template ? template.getRatio(x) : x; + if (taper === "none") { + bump = strength; + } else if (taper === "out") { + invX = 1 - x; + bump = invX * invX * strength; + } else if (taper === "in") { + bump = x * x * strength; + } else if (x < 0.5) { //"both" (start) + invX = x * 2; + bump = invX * invX * 0.5 * strength; + } else { //"both" (end) + invX = (1 - x) * 2; + bump = invX * invX * 0.5 * strength; + } + if (randomize) { + y += (Math.random() * bump) - (bump * 0.5); + } else if (i % 2) { + y += bump * 0.5; + } else { + y -= bump * 0.5; + } + if (clamp) { + if (y > 1) { + y = 1; + } else if (y < 0) { + y = 0; + } + } + a[cnt++] = {x:x, y:y}; + } + a.sort(function(a, b) { + return a.x - b.x; + }); + + pnt = new EasePoint(1, 1, null); + i = points; + while (--i > -1) { + obj = a[i]; + pnt = new EasePoint(obj.x, obj.y, pnt); + } + + this._prev = new EasePoint(0, 0, (pnt.t !== 0) ? pnt : pnt.next); + }, true); + p = RoughEase.prototype = new Ease(); + p.constructor = RoughEase; + p.getRatio = function(p) { + var pnt = this._prev; + if (p > pnt.t) { + while (pnt.next && p >= pnt.t) { + pnt = pnt.next; + } + pnt = pnt.prev; + } else { + while (pnt.prev && p <= pnt.t) { + pnt = pnt.prev; + } + } + this._prev = pnt; + return (pnt.v + ((p - pnt.t) / pnt.gap) * pnt.c); + }; + p.config = function(vars) { + return new RoughEase(vars); + }; + RoughEase.ease = new RoughEase(); + + + //Bounce + _wrap("Bounce", + _create("BounceOut", function(p) { + if (p < 1 / 2.75) { + return 7.5625 * p * p; + } else if (p < 2 / 2.75) { + return 7.5625 * (p -= 1.5 / 2.75) * p + 0.75; + } else if (p < 2.5 / 2.75) { + return 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375; + } + return 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375; + }), + _create("BounceIn", function(p) { + if ((p = 1 - p) < 1 / 2.75) { + return 1 - (7.5625 * p * p); + } else if (p < 2 / 2.75) { + return 1 - (7.5625 * (p -= 1.5 / 2.75) * p + 0.75); + } else if (p < 2.5 / 2.75) { + return 1 - (7.5625 * (p -= 2.25 / 2.75) * p + 0.9375); + } + return 1 - (7.5625 * (p -= 2.625 / 2.75) * p + 0.984375); + }), + _create("BounceInOut", function(p) { + var invert = (p < 0.5); + if (invert) { + p = 1 - (p * 2); + } else { + p = (p * 2) - 1; + } + if (p < 1 / 2.75) { + p = 7.5625 * p * p; + } else if (p < 2 / 2.75) { + p = 7.5625 * (p -= 1.5 / 2.75) * p + 0.75; + } else if (p < 2.5 / 2.75) { + p = 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375; + } else { + p = 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375; + } + return invert ? (1 - p) * 0.5 : p * 0.5 + 0.5; + }) + ); + + + //CIRC + _wrap("Circ", + _create("CircOut", function(p) { + return Math.sqrt(1 - (p = p - 1) * p); + }), + _create("CircIn", function(p) { + return -(Math.sqrt(1 - (p * p)) - 1); + }), + _create("CircInOut", function(p) { + return ((p*=2) < 1) ? -0.5 * (Math.sqrt(1 - p * p) - 1) : 0.5 * (Math.sqrt(1 - (p -= 2) * p) + 1); + }) + ); + + + //Elastic + _createElastic = function(n, f, def) { + var C = _class("easing." + n, function(amplitude, period) { + this._p1 = (amplitude >= 1) ? amplitude : 1; //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1. + this._p2 = (period || def) / (amplitude < 1 ? amplitude : 1); + this._p3 = this._p2 / _2PI * (Math.asin(1 / this._p1) || 0); + this._p2 = _2PI / this._p2; //precalculate to optimize + }, true), + p = C.prototype = new Ease(); + p.constructor = C; + p.getRatio = f; + p.config = function(amplitude, period) { + return new C(amplitude, period); + }; + return C; + }; + _wrap("Elastic", + _createElastic("ElasticOut", function(p) { + return this._p1 * Math.pow(2, -10 * p) * Math.sin( (p - this._p3) * this._p2 ) + 1; + }, 0.3), + _createElastic("ElasticIn", function(p) { + return -(this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2 )); + }, 0.3), + _createElastic("ElasticInOut", function(p) { + return ((p *= 2) < 1) ? -0.5 * (this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin( (p - this._p3) * this._p2)) : this._p1 * Math.pow(2, -10 *(p -= 1)) * Math.sin( (p - this._p3) * this._p2 ) * 0.5 + 1; + }, 0.45) + ); + + + //Expo + _wrap("Expo", + _create("ExpoOut", function(p) { + return 1 - Math.pow(2, -10 * p); + }), + _create("ExpoIn", function(p) { + return Math.pow(2, 10 * (p - 1)) - 0.001; + }), + _create("ExpoInOut", function(p) { + return ((p *= 2) < 1) ? 0.5 * Math.pow(2, 10 * (p - 1)) : 0.5 * (2 - Math.pow(2, -10 * (p - 1))); + }) + ); + + + //Sine + _wrap("Sine", + _create("SineOut", function(p) { + return Math.sin(p * _HALF_PI); + }), + _create("SineIn", function(p) { + return -Math.cos(p * _HALF_PI) + 1; + }), + _create("SineInOut", function(p) { + return -0.5 * (Math.cos(Math.PI * p) - 1); + }) + ); + + _class("easing.EaseLookup", { + find:function(s) { + return Ease.map[s]; + } + }, true); + + //register the non-standard eases + _easeReg(w.SlowMo, "SlowMo", "ease,"); + _easeReg(RoughEase, "RoughEase", "ease,"); + _easeReg(SteppedEase, "SteppedEase", "ease,"); + + return Back; + + }, true); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } + +//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date) +(function() { + "use strict"; + var getGlobal = function() { + return (_gsScope.GreenSockGlobals || _gsScope); + }; + if (typeof(define) === "function" && define.amd) { //AMD + define(["../TweenLite"], getGlobal); + } else if (typeof(module) !== "undefined" && module.exports) { //node + require("../TweenLite.js"); + module.exports = getGlobal(); + } +}()); \ No newline at end of file diff --git a/resources/html5app/js/gsap/easing/EasePack.min.js b/resources/html5app/js/gsap/easing/EasePack.min.js new file mode 100644 index 000000000..7af6b958d --- /dev/null +++ b/resources/html5app/js/gsap/easing/EasePack.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 1.15.4 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine("easing.Back",["easing.Ease"],function(a){var b,c,d,e=_gsScope.GreenSockGlobals||_gsScope,f=e.com.greensock,g=2*Math.PI,h=Math.PI/2,i=f._class,j=function(b,c){var d=i("easing."+b,function(){},!0),e=d.prototype=new a;return e.constructor=d,e.getRatio=c,d},k=a.register||function(){},l=function(a,b,c,d,e){var f=i("easing."+a,{easeOut:new b,easeIn:new c,easeInOut:new d},!0);return k(f,a),f},m=function(a,b,c){this.t=a,this.v=b,c&&(this.next=c,c.prev=this,this.c=c.v-b,this.gap=c.t-a)},n=function(b,c){var d=i("easing."+b,function(a){this._p1=a||0===a?a:1.70158,this._p2=1.525*this._p1},!0),e=d.prototype=new a;return e.constructor=d,e.getRatio=c,e.config=function(a){return new d(a)},d},o=l("Back",n("BackOut",function(a){return(a-=1)*a*((this._p1+1)*a+this._p1)+1}),n("BackIn",function(a){return a*a*((this._p1+1)*a-this._p1)}),n("BackInOut",function(a){return(a*=2)<1?.5*a*a*((this._p2+1)*a-this._p2):.5*((a-=2)*a*((this._p2+1)*a+this._p2)+2)})),p=i("easing.SlowMo",function(a,b,c){b=b||0===b?b:.7,null==a?a=.7:a>1&&(a=1),this._p=1!==a?b:0,this._p1=(1-a)/2,this._p2=a,this._p3=this._p1+this._p2,this._calcEnd=c===!0},!0),q=p.prototype=new a;return q.constructor=p,q.getRatio=function(a){var b=a+(.5-a)*this._p;return athis._p3?this._calcEnd?1-(a=(a-this._p3)/this._p1)*a:b+(a-b)*(a=(a-this._p3)/this._p1)*a*a*a:this._calcEnd?1:b},p.ease=new p(.7,.7),q.config=p.config=function(a,b,c){return new p(a,b,c)},b=i("easing.SteppedEase",function(a){a=a||1,this._p1=1/a,this._p2=a+1},!0),q=b.prototype=new a,q.constructor=b,q.getRatio=function(a){return 0>a?a=0:a>=1&&(a=.999999999),(this._p2*a>>0)*this._p1},q.config=b.config=function(a){return new b(a)},c=i("easing.RoughEase",function(b){b=b||{};for(var c,d,e,f,g,h,i=b.taper||"none",j=[],k=0,l=0|(b.points||20),n=l,o=b.randomize!==!1,p=b.clamp===!0,q=b.template instanceof a?b.template:null,r="number"==typeof b.strength?.4*b.strength:.4;--n>-1;)c=o?Math.random():1/l*n,d=q?q.getRatio(c):c,"none"===i?e=r:"out"===i?(f=1-c,e=f*f*r):"in"===i?e=c*c*r:.5>c?(f=2*c,e=f*f*.5*r):(f=2*(1-c),e=f*f*.5*r),o?d+=Math.random()*e-.5*e:n%2?d+=.5*e:d-=.5*e,p&&(d>1?d=1:0>d&&(d=0)),j[k++]={x:c,y:d};for(j.sort(function(a,b){return a.x-b.x}),h=new m(1,1,null),n=l;--n>-1;)g=j[n],h=new m(g.x,g.y,h);this._prev=new m(0,0,0!==h.t?h:h.next)},!0),q=c.prototype=new a,q.constructor=c,q.getRatio=function(a){var b=this._prev;if(a>b.t){for(;b.next&&a>=b.t;)b=b.next;b=b.prev}else for(;b.prev&&a<=b.t;)b=b.prev;return this._prev=b,b.v+(a-b.t)/b.gap*b.c},q.config=function(a){return new c(a)},c.ease=new c,l("Bounce",j("BounceOut",function(a){return 1/2.75>a?7.5625*a*a:2/2.75>a?7.5625*(a-=1.5/2.75)*a+.75:2.5/2.75>a?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375}),j("BounceIn",function(a){return(a=1-a)<1/2.75?1-7.5625*a*a:2/2.75>a?1-(7.5625*(a-=1.5/2.75)*a+.75):2.5/2.75>a?1-(7.5625*(a-=2.25/2.75)*a+.9375):1-(7.5625*(a-=2.625/2.75)*a+.984375)}),j("BounceInOut",function(a){var b=.5>a;return a=b?1-2*a:2*a-1,a=1/2.75>a?7.5625*a*a:2/2.75>a?7.5625*(a-=1.5/2.75)*a+.75:2.5/2.75>a?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375,b?.5*(1-a):.5*a+.5})),l("Circ",j("CircOut",function(a){return Math.sqrt(1-(a-=1)*a)}),j("CircIn",function(a){return-(Math.sqrt(1-a*a)-1)}),j("CircInOut",function(a){return(a*=2)<1?-.5*(Math.sqrt(1-a*a)-1):.5*(Math.sqrt(1-(a-=2)*a)+1)})),d=function(b,c,d){var e=i("easing."+b,function(a,b){this._p1=a>=1?a:1,this._p2=(b||d)/(1>a?a:1),this._p3=this._p2/g*(Math.asin(1/this._p1)||0),this._p2=g/this._p2},!0),f=e.prototype=new a;return f.constructor=e,f.getRatio=c,f.config=function(a,b){return new e(a,b)},e},l("Elastic",d("ElasticOut",function(a){return this._p1*Math.pow(2,-10*a)*Math.sin((a-this._p3)*this._p2)+1},.3),d("ElasticIn",function(a){return-(this._p1*Math.pow(2,10*(a-=1))*Math.sin((a-this._p3)*this._p2))},.3),d("ElasticInOut",function(a){return(a*=2)<1?-.5*(this._p1*Math.pow(2,10*(a-=1))*Math.sin((a-this._p3)*this._p2)):this._p1*Math.pow(2,-10*(a-=1))*Math.sin((a-this._p3)*this._p2)*.5+1},.45)),l("Expo",j("ExpoOut",function(a){return 1-Math.pow(2,-10*a)}),j("ExpoIn",function(a){return Math.pow(2,10*(a-1))-.001}),j("ExpoInOut",function(a){return(a*=2)<1?.5*Math.pow(2,10*(a-1)):.5*(2-Math.pow(2,-10*(a-1)))})),l("Sine",j("SineOut",function(a){return Math.sin(a*h)}),j("SineIn",function(a){return-Math.cos(a*h)+1}),j("SineInOut",function(a){return-.5*(Math.cos(Math.PI*a)-1)})),i("easing.EaseLookup",{find:function(b){return a.map[b]}},!0),k(e.SlowMo,"SlowMo","ease,"),k(c,"RoughEase","ease,"),k(b,"SteppedEase","ease,"),o},!0)}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(),function(){"use strict";var a=function(){return _gsScope.GreenSockGlobals||_gsScope};"function"==typeof define&&define.amd?define(["../TweenLite"],a):"undefined"!=typeof module&&module.exports&&(require("../TweenLite.js"),module.exports=a())}(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/jquery.gsap.js b/resources/html5app/js/gsap/jquery.gsap.js new file mode 100644 index 000000000..b958396c3 --- /dev/null +++ b/resources/html5app/js/gsap/jquery.gsap.js @@ -0,0 +1,185 @@ +/*! + * VERSION: 0.1.12 + * DATE: 2015-08-11 + * UPDATES AND DOCS AT: http://greensock.com/jquery-gsap-plugin/ + * + * Requires TweenLite version 1.8.0 or higher and CSSPlugin. + * + * @license Copyright (c) 2013-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +(function($) { + "use strict"; + + var _animate = $.fn.animate, + _stop = $.fn.stop, + _enabled = true, + TweenLite, CSSPlugin, _warned, + _copy = function(o) { + var copy = {}, + p; + for (p in o) { + copy[p] = o[p]; + } + return copy; + }, + _reserved = {overwrite:1, delay:1, useFrames:1, runBackwards:1, easeParams:1, yoyo:1, immediateRender:1, repeat:1, repeatDelay:1, autoCSS:1}, + _defaultLegacyProps = ",scrollTop,scrollLeft,show,hide,toggle,", + _legacyProps = _defaultLegacyProps, + _copyCriticalReserved = function(main, sub) { + for (var p in _reserved) { + if (_reserved[p] && main[p] !== undefined) { + sub[p] = main[p]; + } + } + }, + _createEase = function(ease) { + return function(p) { + return ease.getRatio(p); + }; + }, + _easeMap = {}, + _init = function() { + var globals = window.GreenSockGlobals || window, + version, stale, p; + TweenLite = globals.TweenMax || globals.TweenLite; //we prioritize TweenMax if it's loaded so that we can accommodate special features like repeat, yoyo, repeatDelay, etc. + if (TweenLite) { + version = (TweenLite.version + ".0.0").split("."); //in case an old version of TweenLite is used that had a numeric version like 1.68 instead of a string like "1.6.8" + stale = !(Number(version[0]) > 0 && Number(version[1]) > 7); + globals = globals.com.greensock; + CSSPlugin = globals.plugins.CSSPlugin; + _easeMap = globals.easing.Ease.map || {}; //don't do just window.Ease or window.CSSPlugin because some other libraries like EaselJS/TweenJS use those same names and there could be a collision. + } + if (!TweenLite || !CSSPlugin || stale) { + TweenLite = null; + if (!_warned && window.console) { + window.console.log("The jquery.gsap.js plugin requires the TweenMax (or at least TweenLite and CSSPlugin) JavaScript file(s)." + (stale ? " Version " + version.join(".") + " is too old." : "")); + _warned = true; + } + return; + } + if ($.easing) { + for (p in _easeMap) { + $.easing[p] = _createEase(_easeMap[p]); + } + _init = false; + } + }; + + $.fn.animate = function(prop, speed, easing, callback) { + prop = prop || {}; + if (_init) { + _init(); + if (!TweenLite || !CSSPlugin) { + return _animate.call(this, prop, speed, easing, callback); + } + } + if (!_enabled || prop.skipGSAP === true || (typeof(speed) === "object" && typeof(speed.step) === "function")) { //we don't support the "step" feature because it's too costly performance-wise, so fall back to the native animate() call if we sense one. Same with scrollTop and scrollLeft which are handled in a special way in jQuery. + return _animate.call(this, prop, speed, easing, callback); + } + var config = $.speed(speed, easing, callback), + vars = {ease:(_easeMap[config.easing] || ((config.easing === false) ? _easeMap.linear : _easeMap.swing))}, + obj = this, + specEasing = (typeof(speed) === "object") ? speed.specialEasing : null, + val, p, doAnimation, specEasingVars; + + for (p in prop) { + val = prop[p]; + if (val instanceof Array && _easeMap[val[1]]) { + specEasing = specEasing || {}; + specEasing[p] = val[1]; + val = val[0]; + } + if (val === "show" || val === "hide" || val === "toggle" || (_legacyProps.indexOf(p) !== -1 && _legacyProps.indexOf("," + p + ",") !== -1)) { //note: slideUp() and slideDown() pass in opacity:"show" or opacity:"hide" + return _animate.call(this, prop, speed, easing, callback); + } else { + vars[(p.indexOf("-") === -1) ? p : $.camelCase(p)] = val; + } + } + + if (specEasing) { + vars = _copy(vars); + specEasingVars = []; + for (p in specEasing) { + val = specEasingVars[specEasingVars.length] = {}; + _copyCriticalReserved(vars, val); + val.ease = (_easeMap[specEasing[p]] || vars.ease); + if (p.indexOf("-") !== -1) { + p = $.camelCase(p); + } + val[p] = vars[p]; + delete vars[p]; + } + if (specEasingVars.length === 0) { + specEasingVars = null; + } + } + + doAnimation = function(next) { + var varsCopy = _copy(vars), + i; + if (specEasingVars) { + i = specEasingVars.length; + while (--i > -1) { + TweenLite.to(this, $.fx.off ? 0 : config.duration / 1000, specEasingVars[i]); + } + } + varsCopy.onComplete = function() { + if (next) { + next(); + } else if (config.old) { + $(this).each(config.old); + } + }; + TweenLite.to(this, $.fx.off ? 0 : config.duration / 1000, varsCopy); + }; + + if (config.queue !== false) { + obj.queue(config.queue, doAnimation); //note: the queued function will get called once for each element in the jQuery collection. + if (typeof(config.old) === "function") { + $(obj[obj.length-1]).queue(config.queue, function(next) { + config.old.call(obj); + next(); + }); + } + } else { + doAnimation.call(obj); + } + + return obj; + }; + + + $.fn.stop = function(clearQueue, gotoEnd) { + _stop.call(this, clearQueue, gotoEnd); + if (TweenLite) { + if (gotoEnd) { + var tweens = TweenLite.getTweensOf(this), + i = tweens.length, + progress; + while (--i > -1) { + progress = tweens[i].totalTime() / tweens[i].totalDuration(); + if (progress > 0 && progress < 1) { + tweens[i].seek(tweens[i].totalDuration()); + } + } + } + TweenLite.killTweensOf(this); + } + return this; + }; + + $.gsap = { + enabled:function(value) { + _enabled = value; + }, + version:"0.1.12", + legacyProps:function(value) { + _legacyProps = _defaultLegacyProps + value + ","; + } + }; + +}(jQuery)); \ No newline at end of file diff --git a/resources/html5app/js/gsap/jquery.gsap.min.js b/resources/html5app/js/gsap/jquery.gsap.min.js new file mode 100644 index 000000000..17ab850b3 --- /dev/null +++ b/resources/html5app/js/gsap/jquery.gsap.min.js @@ -0,0 +1,14 @@ +/*! + * VERSION: 0.1.12 + * DATE: 2015-08-11 + * UPDATES AND DOCS AT: http://greensock.com/jquery-gsap-plugin/ + * + * Requires TweenLite version 1.8.0 or higher and CSSPlugin. + * + * @license Copyright (c) 2013-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +!function(a){"use strict";var b,c,d,e=a.fn.animate,f=a.fn.stop,g=!0,h=function(a){var b,c={};for(b in a)c[b]=a[b];return c},i={overwrite:1,delay:1,useFrames:1,runBackwards:1,easeParams:1,yoyo:1,immediateRender:1,repeat:1,repeatDelay:1,autoCSS:1},j=",scrollTop,scrollLeft,show,hide,toggle,",k=j,l=function(a,b){for(var c in i)i[c]&&void 0!==a[c]&&(b[c]=a[c])},m=function(a){return function(b){return a.getRatio(b)}},n={},o=function(){var e,f,g,h=window.GreenSockGlobals||window;if(b=h.TweenMax||h.TweenLite,b&&(e=(b.version+".0.0").split("."),f=!(Number(e[0])>0&&Number(e[1])>7),h=h.com.greensock,c=h.plugins.CSSPlugin,n=h.easing.Ease.map||{}),!b||!c||f)return b=null,void(!d&&window.console&&(window.console.log("The jquery.gsap.js plugin requires the TweenMax (or at least TweenLite and CSSPlugin) JavaScript file(s)."+(f?" Version "+e.join(".")+" is too old.":"")),d=!0));if(a.easing){for(g in n)a.easing[g]=m(n[g]);o=!1}};a.fn.animate=function(d,f,i,j){if(d=d||{},o&&(o(),!b||!c))return e.call(this,d,f,i,j);if(!g||d.skipGSAP===!0||"object"==typeof f&&"function"==typeof f.step)return e.call(this,d,f,i,j);var m,p,q,r,s=a.speed(f,i,j),t={ease:n[s.easing]||(s.easing===!1?n.linear:n.swing)},u=this,v="object"==typeof f?f.specialEasing:null;for(p in d){if(m=d[p],m instanceof Array&&n[m[1]]&&(v=v||{},v[p]=m[1],m=m[0]),"show"===m||"hide"===m||"toggle"===m||-1!==k.indexOf(p)&&-1!==k.indexOf(","+p+","))return e.call(this,d,f,i,j);t[-1===p.indexOf("-")?p:a.camelCase(p)]=m}if(v){t=h(t),r=[];for(p in v)m=r[r.length]={},l(t,m),m.ease=n[v[p]]||t.ease,-1!==p.indexOf("-")&&(p=a.camelCase(p)),m[p]=t[p],delete t[p];0===r.length&&(r=null)}return q=function(c){var d,e=h(t);if(r)for(d=r.length;--d>-1;)b.to(this,a.fx.off?0:s.duration/1e3,r[d]);e.onComplete=function(){c?c():s.old&&a(this).each(s.old)},b.to(this,a.fx.off?0:s.duration/1e3,e)},s.queue!==!1?(u.queue(s.queue,q),"function"==typeof s.old&&a(u[u.length-1]).queue(s.queue,function(a){s.old.call(u),a()})):q.call(u),u},a.fn.stop=function(a,c){if(f.call(this,a,c),b){if(c)for(var d,e=b.getTweensOf(this),g=e.length;--g>-1;)d=e[g].totalTime()/e[g].totalDuration(),d>0&&1>d&&e[g].seek(e[g].totalDuration());b.killTweensOf(this)}return this},a.gsap={enabled:function(a){g=a},version:"0.1.12",legacyProps:function(a){k=j+a+","}}}(jQuery); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/AttrPlugin.js b/resources/html5app/js/gsap/plugins/AttrPlugin.js new file mode 100644 index 000000000..0754a2de7 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/AttrPlugin.js @@ -0,0 +1,37 @@ +/*! + * VERSION: 0.5.0 + * DATE: 2015-08-29 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine.plugin({ + propName: "attr", + API: 2, + version: "0.5.0", + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + var p; + if (typeof(target.setAttribute) !== "function") { + return false; + } + for (p in value) { + this._addTween(target, "setAttribute", target.getAttribute(p) + "", value[p] + "", p, false, p); + this._overwriteProps.push(p); + } + return true; + } + + }); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/AttrPlugin.min.js b/resources/html5app/js/gsap/plugins/AttrPlugin.min.js new file mode 100644 index 000000000..ba18edb25 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/AttrPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 0.5.0 + * DATE: 2015-08-29 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine.plugin({propName:"attr",API:2,version:"0.5.0",init:function(a,b,c){var d;if("function"!=typeof a.setAttribute)return!1;for(d in b)this._addTween(a,"setAttribute",a.getAttribute(d)+"",b[d]+"",d,!1,d),this._overwriteProps.push(d);return!0}})}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/BezierPlugin.js b/resources/html5app/js/gsap/plugins/BezierPlugin.js new file mode 100644 index 000000000..adb567e94 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/BezierPlugin.js @@ -0,0 +1,603 @@ +/*! + * VERSION: 1.3.6 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var _RAD2DEG = 180 / Math.PI, + _r1 = [], + _r2 = [], + _r3 = [], + _corProps = {}, + _globals = _gsScope._gsDefine.globals, + Segment = function(a, b, c, d) { + if (c === d) { //if c and d match, the final autoRotate value could lock at -90 degrees, so differentiate them slightly. + c = d - (d - b) / 1000000; + } + if (a === b) { //if a and b match, the starting autoRotate value could lock at -90 degrees, so differentiate them slightly. + b = a + (c - a) / 1000000; + } + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.da = d - a; + this.ca = c - a; + this.ba = b - a; + }, + _correlate = ",x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,", + cubicToQuadratic = function(a, b, c, d) { + var q1 = {a:a}, + q2 = {}, + q3 = {}, + q4 = {c:d}, + mab = (a + b) / 2, + mbc = (b + c) / 2, + mcd = (c + d) / 2, + mabc = (mab + mbc) / 2, + mbcd = (mbc + mcd) / 2, + m8 = (mbcd - mabc) / 8; + q1.b = mab + (a - mab) / 4; + q2.b = mabc + m8; + q1.c = q2.a = (q1.b + q2.b) / 2; + q2.c = q3.a = (mabc + mbcd) / 2; + q3.b = mbcd - m8; + q4.b = mcd + (d - mcd) / 4; + q3.c = q4.a = (q3.b + q4.b) / 2; + return [q1, q2, q3, q4]; + }, + _calculateControlPoints = function(a, curviness, quad, basic, correlate) { + var l = a.length - 1, + ii = 0, + cp1 = a[0].a, + i, p1, p2, p3, seg, m1, m2, mm, cp2, qb, r1, r2, tl; + for (i = 0; i < l; i++) { + seg = a[ii]; + p1 = seg.a; + p2 = seg.d; + p3 = a[ii+1].d; + + if (correlate) { + r1 = _r1[i]; + r2 = _r2[i]; + tl = ((r2 + r1) * curviness * 0.25) / (basic ? 0.5 : _r3[i] || 0.5); + m1 = p2 - (p2 - p1) * (basic ? curviness * 0.5 : (r1 !== 0 ? tl / r1 : 0)); + m2 = p2 + (p3 - p2) * (basic ? curviness * 0.5 : (r2 !== 0 ? tl / r2 : 0)); + mm = p2 - (m1 + (((m2 - m1) * ((r1 * 3 / (r1 + r2)) + 0.5) / 4) || 0)); + } else { + m1 = p2 - (p2 - p1) * curviness * 0.5; + m2 = p2 + (p3 - p2) * curviness * 0.5; + mm = p2 - (m1 + m2) / 2; + } + m1 += mm; + m2 += mm; + + seg.c = cp2 = m1; + if (i !== 0) { + seg.b = cp1; + } else { + seg.b = cp1 = seg.a + (seg.c - seg.a) * 0.6; //instead of placing b on a exactly, we move it inline with c so that if the user specifies an ease like Back.easeIn or Elastic.easeIn which goes BEYOND the beginning, it will do so smoothly. + } + + seg.da = p2 - p1; + seg.ca = cp2 - p1; + seg.ba = cp1 - p1; + + if (quad) { + qb = cubicToQuadratic(p1, cp1, cp2, p2); + a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]); + ii += 4; + } else { + ii++; + } + + cp1 = m2; + } + seg = a[ii]; + seg.b = cp1; + seg.c = cp1 + (seg.d - cp1) * 0.4; //instead of placing c on d exactly, we move it inline with b so that if the user specifies an ease like Back.easeOut or Elastic.easeOut which goes BEYOND the end, it will do so smoothly. + seg.da = seg.d - seg.a; + seg.ca = seg.c - seg.a; + seg.ba = cp1 - seg.a; + if (quad) { + qb = cubicToQuadratic(seg.a, cp1, seg.c, seg.d); + a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]); + } + }, + _parseAnchors = function(values, p, correlate, prepend) { + var a = [], + l, i, p1, p2, p3, tmp; + if (prepend) { + values = [prepend].concat(values); + i = values.length; + while (--i > -1) { + if (typeof( (tmp = values[i][p]) ) === "string") if (tmp.charAt(1) === "=") { + values[i][p] = prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)); //accommodate relative values. Do it inline instead of breaking it out into a function for speed reasons + } + } + } + l = values.length - 2; + if (l < 0) { + a[0] = new Segment(values[0][p], 0, 0, values[(l < -1) ? 0 : 1][p]); + return a; + } + for (i = 0; i < l; i++) { + p1 = values[i][p]; + p2 = values[i+1][p]; + a[i] = new Segment(p1, 0, 0, p2); + if (correlate) { + p3 = values[i+2][p]; + _r1[i] = (_r1[i] || 0) + (p2 - p1) * (p2 - p1); + _r2[i] = (_r2[i] || 0) + (p3 - p2) * (p3 - p2); + } + } + a[i] = new Segment(values[i][p], 0, 0, values[i+1][p]); + return a; + }, + bezierThrough = function(values, curviness, quadratic, basic, correlate, prepend) { + var obj = {}, + props = [], + first = prepend || values[0], + i, p, a, j, r, l, seamless, last; + correlate = (typeof(correlate) === "string") ? ","+correlate+"," : _correlate; + if (curviness == null) { + curviness = 1; + } + for (p in values[0]) { + props.push(p); + } + //check to see if the last and first values are identical (well, within 0.05). If so, make seamless by appending the second element to the very end of the values array and the 2nd-to-last element to the very beginning (we'll remove those segments later) + if (values.length > 1) { + last = values[values.length - 1]; + seamless = true; + i = props.length; + while (--i > -1) { + p = props[i]; + if (Math.abs(first[p] - last[p]) > 0.05) { //build in a tolerance of +/-0.05 to accommodate rounding errors. + seamless = false; + break; + } + } + if (seamless) { + values = values.concat(); //duplicate the array to avoid contaminating the original which the user may be reusing for other tweens + if (prepend) { + values.unshift(prepend); + } + values.push(values[1]); + prepend = values[values.length - 3]; + } + } + _r1.length = _r2.length = _r3.length = 0; + i = props.length; + while (--i > -1) { + p = props[i]; + _corProps[p] = (correlate.indexOf(","+p+",") !== -1); + obj[p] = _parseAnchors(values, p, _corProps[p], prepend); + } + i = _r1.length; + while (--i > -1) { + _r1[i] = Math.sqrt(_r1[i]); + _r2[i] = Math.sqrt(_r2[i]); + } + if (!basic) { + i = props.length; + while (--i > -1) { + if (_corProps[p]) { + a = obj[props[i]]; + l = a.length - 1; + for (j = 0; j < l; j++) { + r = (a[j+1].da / _r2[j] + a[j].da / _r1[j]) || 0; + _r3[j] = (_r3[j] || 0) + r * r; + } + } + } + i = _r3.length; + while (--i > -1) { + _r3[i] = Math.sqrt(_r3[i]); + } + } + i = props.length; + j = quadratic ? 4 : 1; + while (--i > -1) { + p = props[i]; + a = obj[p]; + _calculateControlPoints(a, curviness, quadratic, basic, _corProps[p]); //this method requires that _parseAnchors() and _setSegmentRatios() ran first so that _r1, _r2, and _r3 values are populated for all properties + if (seamless) { + a.splice(0, j); + a.splice(a.length - j, j); + } + } + return obj; + }, + _parseBezierData = function(values, type, prepend) { + type = type || "soft"; + var obj = {}, + inc = (type === "cubic") ? 3 : 2, + soft = (type === "soft"), + props = [], + a, b, c, d, cur, i, j, l, p, cnt, tmp; + if (soft && prepend) { + values = [prepend].concat(values); + } + if (values == null || values.length < inc + 1) { throw "invalid Bezier data"; } + for (p in values[0]) { + props.push(p); + } + i = props.length; + while (--i > -1) { + p = props[i]; + obj[p] = cur = []; + cnt = 0; + l = values.length; + for (j = 0; j < l; j++) { + a = (prepend == null) ? values[j][p] : (typeof( (tmp = values[j][p]) ) === "string" && tmp.charAt(1) === "=") ? prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)) : Number(tmp); + if (soft) if (j > 1) if (j < l - 1) { + cur[cnt++] = (a + cur[cnt-2]) / 2; + } + cur[cnt++] = a; + } + l = cnt - inc + 1; + cnt = 0; + for (j = 0; j < l; j += inc) { + a = cur[j]; + b = cur[j+1]; + c = cur[j+2]; + d = (inc === 2) ? 0 : cur[j+3]; + cur[cnt++] = tmp = (inc === 3) ? new Segment(a, b, c, d) : new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c); + } + cur.length = cnt; + } + return obj; + }, + _addCubicLengths = function(a, steps, resolution) { + var inc = 1 / resolution, + j = a.length, + d, d1, s, da, ca, ba, p, i, inv, bez, index; + while (--j > -1) { + bez = a[j]; + s = bez.a; + da = bez.d - s; + ca = bez.c - s; + ba = bez.b - s; + d = d1 = 0; + for (i = 1; i <= resolution; i++) { + p = inc * i; + inv = 1 - p; + d = d1 - (d1 = (p * p * da + 3 * inv * (p * ca + inv * ba)) * p); + index = j * resolution + i - 1; + steps[index] = (steps[index] || 0) + d * d; + } + } + }, + _parseLengthData = function(obj, resolution) { + resolution = resolution >> 0 || 6; + var a = [], + lengths = [], + d = 0, + total = 0, + threshold = resolution - 1, + segments = [], + curLS = [], //current length segments array + p, i, l, index; + for (p in obj) { + _addCubicLengths(obj[p], a, resolution); + } + l = a.length; + for (i = 0; i < l; i++) { + d += Math.sqrt(a[i]); + index = i % resolution; + curLS[index] = d; + if (index === threshold) { + total += d; + index = (i / resolution) >> 0; + segments[index] = curLS; + lengths[index] = total; + d = 0; + curLS = []; + } + } + return {length:total, lengths:lengths, segments:segments}; + }, + + + + BezierPlugin = _gsScope._gsDefine.plugin({ + propName: "bezier", + priority: -1, + version: "1.3.6", + API: 2, + global:true, + + //gets called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, vars, tween) { + this._target = target; + if (vars instanceof Array) { + vars = {values:vars}; + } + this._func = {}; + this._round = {}; + this._props = []; + this._timeRes = (vars.timeResolution == null) ? 6 : parseInt(vars.timeResolution, 10); + var values = vars.values || [], + first = {}, + second = values[0], + autoRotate = vars.autoRotate || tween.vars.orientToBezier, + p, isFunc, i, j, prepend; + + this._autoRotate = autoRotate ? (autoRotate instanceof Array) ? autoRotate : [["x","y","rotation",((autoRotate === true) ? 0 : Number(autoRotate) || 0)]] : null; + for (p in second) { + this._props.push(p); + } + + i = this._props.length; + while (--i > -1) { + p = this._props[i]; + + this._overwriteProps.push(p); + isFunc = this._func[p] = (typeof(target[p]) === "function"); + first[p] = (!isFunc) ? parseFloat(target[p]) : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ](); + if (!prepend) if (first[p] !== values[0][p]) { + prepend = first; + } + } + this._beziers = (vars.type !== "cubic" && vars.type !== "quadratic" && vars.type !== "soft") ? bezierThrough(values, isNaN(vars.curviness) ? 1 : vars.curviness, false, (vars.type === "thruBasic"), vars.correlate, prepend) : _parseBezierData(values, vars.type, first); + this._segCount = this._beziers[p].length; + + if (this._timeRes) { + var ld = _parseLengthData(this._beziers, this._timeRes); + this._length = ld.length; + this._lengths = ld.lengths; + this._segments = ld.segments; + this._l1 = this._li = this._s1 = this._si = 0; + this._l2 = this._lengths[0]; + this._curSeg = this._segments[0]; + this._s2 = this._curSeg[0]; + this._prec = 1 / this._curSeg.length; + } + + if ((autoRotate = this._autoRotate)) { + this._initialRotations = []; + if (!(autoRotate[0] instanceof Array)) { + this._autoRotate = autoRotate = [autoRotate]; + } + i = autoRotate.length; + while (--i > -1) { + for (j = 0; j < 3; j++) { + p = autoRotate[i][j]; + this._func[p] = (typeof(target[p]) === "function") ? target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ] : false; + } + p = autoRotate[i][2]; + this._initialRotations[i] = (this._func[p] ? this._func[p].call(this._target) : this._target[p]) || 0; + } + } + this._startRatio = tween.vars.runBackwards ? 1 : 0; //we determine the starting ratio when the tween inits which is always 0 unless the tween has runBackwards:true (indicating it's a from() tween) in which case it's 1. + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(v) { + var segments = this._segCount, + func = this._func, + target = this._target, + notStart = (v !== this._startRatio), + curIndex, inv, i, p, b, t, val, l, lengths, curSeg; + if (!this._timeRes) { + curIndex = (v < 0) ? 0 : (v >= 1) ? segments - 1 : (segments * v) >> 0; + t = (v - (curIndex * (1 / segments))) * segments; + } else { + lengths = this._lengths; + curSeg = this._curSeg; + v *= this._length; + i = this._li; + //find the appropriate segment (if the currently cached one isn't correct) + if (v > this._l2 && i < segments - 1) { + l = segments - 1; + while (i < l && (this._l2 = lengths[++i]) <= v) { } + this._l1 = lengths[i-1]; + this._li = i; + this._curSeg = curSeg = this._segments[i]; + this._s2 = curSeg[(this._s1 = this._si = 0)]; + } else if (v < this._l1 && i > 0) { + while (i > 0 && (this._l1 = lengths[--i]) >= v) { } + if (i === 0 && v < this._l1) { + this._l1 = 0; + } else { + i++; + } + this._l2 = lengths[i]; + this._li = i; + this._curSeg = curSeg = this._segments[i]; + this._s1 = curSeg[(this._si = curSeg.length - 1) - 1] || 0; + this._s2 = curSeg[this._si]; + } + curIndex = i; + //now find the appropriate sub-segment (we split it into the number of pieces that was defined by "precision" and measured each one) + v -= this._l1; + i = this._si; + if (v > this._s2 && i < curSeg.length - 1) { + l = curSeg.length - 1; + while (i < l && (this._s2 = curSeg[++i]) <= v) { } + this._s1 = curSeg[i-1]; + this._si = i; + } else if (v < this._s1 && i > 0) { + while (i > 0 && (this._s1 = curSeg[--i]) >= v) { } + if (i === 0 && v < this._s1) { + this._s1 = 0; + } else { + i++; + } + this._s2 = curSeg[i]; + this._si = i; + } + t = ((i + (v - this._s1) / (this._s2 - this._s1)) * this._prec) || 0; + } + inv = 1 - t; + + i = this._props.length; + while (--i > -1) { + p = this._props[i]; + b = this._beziers[p][curIndex]; + val = (t * t * b.da + 3 * inv * (t * b.ca + inv * b.ba)) * t + b.a; + if (this._round[p]) { + val = Math.round(val); + } + if (func[p]) { + target[p](val); + } else { + target[p] = val; + } + } + + if (this._autoRotate) { + var ar = this._autoRotate, + b2, x1, y1, x2, y2, add, conv; + i = ar.length; + while (--i > -1) { + p = ar[i][2]; + add = ar[i][3] || 0; + conv = (ar[i][4] === true) ? 1 : _RAD2DEG; + b = this._beziers[ar[i][0]]; + b2 = this._beziers[ar[i][1]]; + + if (b && b2) { //in case one of the properties got overwritten. + b = b[curIndex]; + b2 = b2[curIndex]; + + x1 = b.a + (b.b - b.a) * t; + x2 = b.b + (b.c - b.b) * t; + x1 += (x2 - x1) * t; + x2 += ((b.c + (b.d - b.c) * t) - x2) * t; + + y1 = b2.a + (b2.b - b2.a) * t; + y2 = b2.b + (b2.c - b2.b) * t; + y1 += (y2 - y1) * t; + y2 += ((b2.c + (b2.d - b2.c) * t) - y2) * t; + + val = notStart ? Math.atan2(y2 - y1, x2 - x1) * conv + add : this._initialRotations[i]; + + if (func[p]) { + target[p](val); + } else { + target[p] = val; + } + } + } + } + } + }), + p = BezierPlugin.prototype; + + + BezierPlugin.bezierThrough = bezierThrough; + BezierPlugin.cubicToQuadratic = cubicToQuadratic; + BezierPlugin._autoCSS = true; //indicates that this plugin can be inserted into the "css" object using the autoCSS feature of TweenLite + BezierPlugin.quadraticToCubic = function(a, b, c) { + return new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c); + }; + + BezierPlugin._cssRegister = function() { + var CSSPlugin = _globals.CSSPlugin; + if (!CSSPlugin) { + return; + } + var _internals = CSSPlugin._internals, + _parseToProxy = _internals._parseToProxy, + _setPluginRatio = _internals._setPluginRatio, + CSSPropTween = _internals.CSSPropTween; + _internals._registerComplexSpecialProp("bezier", {parser:function(t, e, prop, cssp, pt, plugin) { + if (e instanceof Array) { + e = {values:e}; + } + plugin = new BezierPlugin(); + var values = e.values, + l = values.length - 1, + pluginValues = [], + v = {}, + i, p, data; + if (l < 0) { + return pt; + } + for (i = 0; i <= l; i++) { + data = _parseToProxy(t, values[i], cssp, pt, plugin, (l !== i)); + pluginValues[i] = data.end; + } + for (p in e) { + v[p] = e[p]; //duplicate the vars object because we need to alter some things which would cause problems if the user plans to reuse the same vars object for another tween. + } + v.values = pluginValues; + pt = new CSSPropTween(t, "bezier", 0, 0, data.pt, 2); + pt.data = data; + pt.plugin = plugin; + pt.setRatio = _setPluginRatio; + if (v.autoRotate === 0) { + v.autoRotate = true; + } + if (v.autoRotate && !(v.autoRotate instanceof Array)) { + i = (v.autoRotate === true) ? 0 : Number(v.autoRotate); + v.autoRotate = (data.end.left != null) ? [["left","top","rotation",i,false]] : (data.end.x != null) ? [["x","y","rotation",i,false]] : false; + } + if (v.autoRotate) { + if (!cssp._transform) { + cssp._enableTransforms(false); + } + data.autoRotate = cssp._target._gsTransform; + data.proxy.rotation = data.autoRotate.rotation || 0; + } + plugin._onInitTween(data.proxy, v, cssp._tween); + return pt; + }}); + }; + + p._roundProps = function(lookup, value) { + var op = this._overwriteProps, + i = op.length; + while (--i > -1) { + if (lookup[op[i]] || lookup.bezier || lookup.bezierThrough) { + this._round[op[i]] = value; + } + } + }; + + p._kill = function(lookup) { + var a = this._props, + p, i; + for (p in this._beziers) { + if (p in lookup) { + delete this._beziers[p]; + delete this._func[p]; + i = a.length; + while (--i > -1) { + if (a[i] === p) { + a.splice(i, 1); + } + } + } + } + return this._super._kill.call(this, lookup); + }; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } + +//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date) +(function(name) { + "use strict"; + var getGlobal = function() { + return (_gsScope.GreenSockGlobals || _gsScope)[name]; + }; + if (typeof(define) === "function" && define.amd) { //AMD + define(["../TweenLite"], getGlobal); + } else if (typeof(module) !== "undefined" && module.exports) { //node + require("../TweenLite.js"); + module.exports = getGlobal(); + } +}("BezierPlugin")); diff --git a/resources/html5app/js/gsap/plugins/BezierPlugin.min.js b/resources/html5app/js/gsap/plugins/BezierPlugin.min.js new file mode 100644 index 000000000..a21be3e29 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/BezierPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 1.3.6 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a=180/Math.PI,b=[],c=[],d=[],e={},f=_gsScope._gsDefine.globals,g=function(a,b,c,d){c===d&&(c=d-(d-b)/1e6),a===b&&(b=a+(c-a)/1e6),this.a=a,this.b=b,this.c=c,this.d=d,this.da=d-a,this.ca=c-a,this.ba=b-a},h=",x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,",i=function(a,b,c,d){var e={a:a},f={},g={},h={c:d},i=(a+b)/2,j=(b+c)/2,k=(c+d)/2,l=(i+j)/2,m=(j+k)/2,n=(m-l)/8;return e.b=i+(a-i)/4,f.b=l+n,e.c=f.a=(e.b+f.b)/2,f.c=g.a=(l+m)/2,g.b=m-n,h.b=k+(d-k)/4,g.c=h.a=(g.b+h.b)/2,[e,f,g,h]},j=function(a,e,f,g,h){var j,k,l,m,n,o,p,q,r,s,t,u,v,w=a.length-1,x=0,y=a[0].a;for(j=0;w>j;j++)n=a[x],k=n.a,l=n.d,m=a[x+1].d,h?(t=b[j],u=c[j],v=(u+t)*e*.25/(g?.5:d[j]||.5),o=l-(l-k)*(g?.5*e:0!==t?v/t:0),p=l+(m-l)*(g?.5*e:0!==u?v/u:0),q=l-(o+((p-o)*(3*t/(t+u)+.5)/4||0))):(o=l-(l-k)*e*.5,p=l+(m-l)*e*.5,q=l-(o+p)/2),o+=q,p+=q,n.c=r=o,0!==j?n.b=y:n.b=y=n.a+.6*(n.c-n.a),n.da=l-k,n.ca=r-k,n.ba=y-k,f?(s=i(k,y,r,l),a.splice(x,1,s[0],s[1],s[2],s[3]),x+=4):x++,y=p;n=a[x],n.b=y,n.c=y+.4*(n.d-y),n.da=n.d-n.a,n.ca=n.c-n.a,n.ba=y-n.a,f&&(s=i(n.a,y,n.c,n.d),a.splice(x,1,s[0],s[1],s[2],s[3]))},k=function(a,d,e,f){var h,i,j,k,l,m,n=[];if(f)for(a=[f].concat(a),i=a.length;--i>-1;)"string"==typeof(m=a[i][d])&&"="===m.charAt(1)&&(a[i][d]=f[d]+Number(m.charAt(0)+m.substr(2)));if(h=a.length-2,0>h)return n[0]=new g(a[0][d],0,0,a[-1>h?0:1][d]),n;for(i=0;h>i;i++)j=a[i][d],k=a[i+1][d],n[i]=new g(j,0,0,k),e&&(l=a[i+2][d],b[i]=(b[i]||0)+(k-j)*(k-j),c[i]=(c[i]||0)+(l-k)*(l-k));return n[i]=new g(a[i][d],0,0,a[i+1][d]),n},l=function(a,f,g,i,l,m){var n,o,p,q,r,s,t,u,v={},w=[],x=m||a[0];l="string"==typeof l?","+l+",":h,null==f&&(f=1);for(o in a[0])w.push(o);if(a.length>1){for(u=a[a.length-1],t=!0,n=w.length;--n>-1;)if(o=w[n],Math.abs(x[o]-u[o])>.05){t=!1;break}t&&(a=a.concat(),m&&a.unshift(m),a.push(a[1]),m=a[a.length-3])}for(b.length=c.length=d.length=0,n=w.length;--n>-1;)o=w[n],e[o]=-1!==l.indexOf(","+o+","),v[o]=k(a,o,e[o],m);for(n=b.length;--n>-1;)b[n]=Math.sqrt(b[n]),c[n]=Math.sqrt(c[n]);if(!i){for(n=w.length;--n>-1;)if(e[o])for(p=v[w[n]],s=p.length-1,q=0;s>q;q++)r=p[q+1].da/c[q]+p[q].da/b[q]||0,d[q]=(d[q]||0)+r*r;for(n=d.length;--n>-1;)d[n]=Math.sqrt(d[n])}for(n=w.length,q=g?4:1;--n>-1;)o=w[n],p=v[o],j(p,f,g,i,e[o]),t&&(p.splice(0,q),p.splice(p.length-q,q));return v},m=function(a,b,c){b=b||"soft";var d,e,f,h,i,j,k,l,m,n,o,p={},q="cubic"===b?3:2,r="soft"===b,s=[];if(r&&c&&(a=[c].concat(a)),null==a||a.length-1;){for(m=s[j],p[m]=i=[],n=0,l=a.length,k=0;l>k;k++)d=null==c?a[k][m]:"string"==typeof(o=a[k][m])&&"="===o.charAt(1)?c[m]+Number(o.charAt(0)+o.substr(2)):Number(o),r&&k>1&&l-1>k&&(i[n++]=(d+i[n-2])/2),i[n++]=d;for(l=n-q+1,n=0,k=0;l>k;k+=q)d=i[k],e=i[k+1],f=i[k+2],h=2===q?0:i[k+3],i[n++]=o=3===q?new g(d,e,f,h):new g(d,(2*e+d)/3,(2*e+f)/3,f);i.length=n}return p},n=function(a,b,c){for(var d,e,f,g,h,i,j,k,l,m,n,o=1/c,p=a.length;--p>-1;)for(m=a[p],f=m.a,g=m.d-f,h=m.c-f,i=m.b-f,d=e=0,k=1;c>=k;k++)j=o*k,l=1-j,d=e-(e=(j*j*g+3*l*(j*h+l*i))*j),n=p*c+k-1,b[n]=(b[n]||0)+d*d},o=function(a,b){b=b>>0||6;var c,d,e,f,g=[],h=[],i=0,j=0,k=b-1,l=[],m=[];for(c in a)n(a[c],g,b);for(e=g.length,d=0;e>d;d++)i+=Math.sqrt(g[d]),f=d%b,m[f]=i,f===k&&(j+=i,f=d/b>>0,l[f]=m,h[f]=j,i=0,m=[]);return{length:j,lengths:h,segments:l}},p=_gsScope._gsDefine.plugin({propName:"bezier",priority:-1,version:"1.3.6",API:2,global:!0,init:function(a,b,c){this._target=a,b instanceof Array&&(b={values:b}),this._func={},this._round={},this._props=[],this._timeRes=null==b.timeResolution?6:parseInt(b.timeResolution,10);var d,e,f,g,h,i=b.values||[],j={},k=i[0],n=b.autoRotate||c.vars.orientToBezier;this._autoRotate=n?n instanceof Array?n:[["x","y","rotation",n===!0?0:Number(n)||0]]:null;for(d in k)this._props.push(d);for(f=this._props.length;--f>-1;)d=this._props[f],this._overwriteProps.push(d),e=this._func[d]="function"==typeof a[d],j[d]=e?a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]():parseFloat(a[d]),h||j[d]!==i[0][d]&&(h=j);if(this._beziers="cubic"!==b.type&&"quadratic"!==b.type&&"soft"!==b.type?l(i,isNaN(b.curviness)?1:b.curviness,!1,"thruBasic"===b.type,b.correlate,h):m(i,b.type,j),this._segCount=this._beziers[d].length,this._timeRes){var p=o(this._beziers,this._timeRes);this._length=p.length,this._lengths=p.lengths,this._segments=p.segments,this._l1=this._li=this._s1=this._si=0,this._l2=this._lengths[0],this._curSeg=this._segments[0],this._s2=this._curSeg[0],this._prec=1/this._curSeg.length}if(n=this._autoRotate)for(this._initialRotations=[],n[0]instanceof Array||(this._autoRotate=n=[n]),f=n.length;--f>-1;){for(g=0;3>g;g++)d=n[f][g],this._func[d]="function"==typeof a[d]?a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]:!1;d=n[f][2],this._initialRotations[f]=(this._func[d]?this._func[d].call(this._target):this._target[d])||0}return this._startRatio=c.vars.runBackwards?1:0,!0},set:function(b){var c,d,e,f,g,h,i,j,k,l,m=this._segCount,n=this._func,o=this._target,p=b!==this._startRatio;if(this._timeRes){if(k=this._lengths,l=this._curSeg,b*=this._length,e=this._li,b>this._l2&&m-1>e){for(j=m-1;j>e&&(this._l2=k[++e])<=b;);this._l1=k[e-1],this._li=e,this._curSeg=l=this._segments[e],this._s2=l[this._s1=this._si=0]}else if(b0){for(;e>0&&(this._l1=k[--e])>=b;);0===e&&bthis._s2&&ee&&(this._s2=l[++e])<=b;);this._s1=l[e-1],this._si=e}else if(b0){for(;e>0&&(this._s1=l[--e])>=b;);0===e&&bb?0:b>=1?m-1:m*b>>0,h=(b-c*(1/m))*m;for(d=1-h,e=this._props.length;--e>-1;)f=this._props[e],g=this._beziers[f][c],i=(h*h*g.da+3*d*(h*g.ca+d*g.ba))*h+g.a,this._round[f]&&(i=Math.round(i)),n[f]?o[f](i):o[f]=i;if(this._autoRotate){var q,r,s,t,u,v,w,x=this._autoRotate;for(e=x.length;--e>-1;)f=x[e][2],v=x[e][3]||0,w=x[e][4]===!0?1:a,g=this._beziers[x[e][0]],q=this._beziers[x[e][1]],g&&q&&(g=g[c],q=q[c],r=g.a+(g.b-g.a)*h,t=g.b+(g.c-g.b)*h,r+=(t-r)*h,t+=(g.c+(g.d-g.c)*h-t)*h,s=q.a+(q.b-q.a)*h,u=q.b+(q.c-q.b)*h,s+=(u-s)*h,u+=(q.c+(q.d-q.c)*h-u)*h,i=p?Math.atan2(u-s,t-r)*w+v:this._initialRotations[e],n[f]?o[f](i):o[f]=i)}}}),q=p.prototype;p.bezierThrough=l,p.cubicToQuadratic=i,p._autoCSS=!0,p.quadraticToCubic=function(a,b,c){return new g(a,(2*b+a)/3,(2*b+c)/3,c)},p._cssRegister=function(){var a=f.CSSPlugin;if(a){var b=a._internals,c=b._parseToProxy,d=b._setPluginRatio,e=b.CSSPropTween;b._registerComplexSpecialProp("bezier",{parser:function(a,b,f,g,h,i){b instanceof Array&&(b={values:b}),i=new p;var j,k,l,m=b.values,n=m.length-1,o=[],q={};if(0>n)return h;for(j=0;n>=j;j++)l=c(a,m[j],g,h,i,n!==j),o[j]=l.end;for(k in b)q[k]=b[k];return q.values=o,h=new e(a,"bezier",0,0,l.pt,2),h.data=l,h.plugin=i,h.setRatio=d,0===q.autoRotate&&(q.autoRotate=!0),!q.autoRotate||q.autoRotate instanceof Array||(j=q.autoRotate===!0?0:Number(q.autoRotate),q.autoRotate=null!=l.end.left?[["left","top","rotation",j,!1]]:null!=l.end.x?[["x","y","rotation",j,!1]]:!1),q.autoRotate&&(g._transform||g._enableTransforms(!1),l.autoRotate=g._target._gsTransform,l.proxy.rotation=l.autoRotate.rotation||0),i._onInitTween(l.proxy,q,g._tween),h}})}},q._roundProps=function(a,b){for(var c=this._overwriteProps,d=c.length;--d>-1;)(a[c[d]]||a.bezier||a.bezierThrough)&&(this._round[c[d]]=b)},q._kill=function(a){var b,c,d=this._props;for(b in this._beziers)if(b in a)for(delete this._beziers[b],delete this._func[b],c=d.length;--c>-1;)d[c]===b&&d.splice(c,1);return this._super._kill.call(this,a)}}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(),function(a){"use strict";var b=function(){return(_gsScope.GreenSockGlobals||_gsScope)[a]};"function"==typeof define&&define.amd?define(["../TweenLite"],b):"undefined"!=typeof module&&module.exports&&(require("../TweenLite.js"),module.exports=b())}("BezierPlugin"); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/CSSPlugin.js b/resources/html5app/js/gsap/plugins/CSSPlugin.js new file mode 100644 index 000000000..b734e3c3b --- /dev/null +++ b/resources/html5app/js/gsap/plugins/CSSPlugin.js @@ -0,0 +1,2774 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine("plugins.CSSPlugin", ["plugins.TweenPlugin","TweenLite"], function(TweenPlugin, TweenLite) { + + /** @constructor **/ + var CSSPlugin = function() { + TweenPlugin.call(this, "css"); + this._overwriteProps.length = 0; + this.setRatio = CSSPlugin.prototype.setRatio; //speed optimization (avoid prototype lookup on this "hot" method) + }, + _globals = _gsScope._gsDefine.globals, + _hasPriority, //turns true whenever a CSSPropTween instance is created that has a priority other than 0. This helps us discern whether or not we should spend the time organizing the linked list or not after a CSSPlugin's _onInitTween() method is called. + _suffixMap, //we set this in _onInitTween() each time as a way to have a persistent variable we can use in other methods like _parse() without having to pass it around as a parameter and we keep _parse() decoupled from a particular CSSPlugin instance + _cs, //computed style (we store this in a shared variable to conserve memory and make minification tighter + _overwriteProps, //alias to the currently instantiating CSSPlugin's _overwriteProps array. We use this closure in order to avoid having to pass a reference around from method to method and aid in minification. + _specialProps = {}, + p = CSSPlugin.prototype = new TweenPlugin("css"); + + p.constructor = CSSPlugin; + CSSPlugin.version = "1.18.5"; + CSSPlugin.API = 2; + CSSPlugin.defaultTransformPerspective = 0; + CSSPlugin.defaultSkewType = "compensated"; + CSSPlugin.defaultSmoothOrigin = true; + p = "px"; //we'll reuse the "p" variable to keep file size down + CSSPlugin.suffixMap = {top:p, right:p, bottom:p, left:p, width:p, height:p, fontSize:p, padding:p, margin:p, perspective:p, lineHeight:""}; + + + var _numExp = /(?:\-|\.|\b)(\d|\.|e\-)+/g, + _relNumExp = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g, + _valuesExp = /(?:\+=|\-=|\-|\b)[\d\-\.]+[a-zA-Z0-9]*(?:%|\b)/gi, //finds all the values that begin with numbers or += or -= and then a number. Includes suffixes. We use this to split complex values apart like "1px 5px 20px rgb(255,102,51)" + _NaNExp = /(?![+-]?\d*\.?\d+|[+-]|e[+-]\d+)[^0-9]/g, //also allows scientific notation and doesn't kill the leading -/+ in -= and += + _suffixExp = /(?:\d|\-|\+|=|#|\.)*/g, + _opacityExp = /opacity *= *([^)]*)/i, + _opacityValExp = /opacity:([^;]*)/i, + _alphaFilterExp = /alpha\(opacity *=.+?\)/i, + _rgbhslExp = /^(rgb|hsl)/, + _capsExp = /([A-Z])/g, + _camelExp = /-([a-z])/gi, + _urlExp = /(^(?:url\(\"|url\())|(?:(\"\))$|\)$)/gi, //for pulling out urls from url(...) or url("...") strings (some browsers wrap urls in quotes, some don't when reporting things like backgroundImage) + _camelFunc = function(s, g) { return g.toUpperCase(); }, + _horizExp = /(?:Left|Right|Width)/i, + _ieGetMatrixExp = /(M11|M12|M21|M22)=[\d\-\.e]+/gi, + _ieSetMatrixExp = /progid\:DXImageTransform\.Microsoft\.Matrix\(.+?\)/i, + _commasOutsideParenExp = /,(?=[^\)]*(?:\(|$))/gi, //finds any commas that are not within parenthesis + _complexExp = /[\s,\(]/i, //for testing a string to find if it has a space, comma, or open parenthesis (clues that it's a complex value) + _DEG2RAD = Math.PI / 180, + _RAD2DEG = 180 / Math.PI, + _forcePT = {}, + _doc = document, + _createElement = function(type) { + return _doc.createElementNS ? _doc.createElementNS("http://www.w3.org/1999/xhtml", type) : _doc.createElement(type); + }, + _tempDiv = _createElement("div"), + _tempImg = _createElement("img"), + _internals = CSSPlugin._internals = {_specialProps:_specialProps}, //provides a hook to a few internal methods that we need to access from inside other plugins + _agent = navigator.userAgent, + _autoRound, + _reqSafariFix, //we won't apply the Safari transform fix until we actually come across a tween that affects a transform property (to maintain best performance). + + _isSafari, + _isFirefox, //Firefox has a bug that causes 3D transformed elements to randomly disappear unless a repaint is forced after each update on each element. + _isSafariLT6, //Safari (and Android 4 which uses a flavor of Safari) has a bug that prevents changes to "top" and "left" properties from rendering properly if changed on the same frame as a transform UNLESS we set the element's WebkitBackfaceVisibility to hidden (weird, I know). Doing this for Android 3 and earlier seems to actually cause other problems, though (fun!) + _ieVers, + _supportsOpacity = (function() { //we set _isSafari, _ieVers, _isFirefox, and _supportsOpacity all in one function here to reduce file size slightly, especially in the minified version. + var i = _agent.indexOf("Android"), + a = _createElement("a"); + _isSafari = (_agent.indexOf("Safari") !== -1 && _agent.indexOf("Chrome") === -1 && (i === -1 || Number(_agent.substr(i+8, 1)) > 3)); + _isSafariLT6 = (_isSafari && (Number(_agent.substr(_agent.indexOf("Version/")+8, 1)) < 6)); + _isFirefox = (_agent.indexOf("Firefox") !== -1); + if ((/MSIE ([0-9]{1,}[\.0-9]{0,})/).exec(_agent) || (/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/).exec(_agent)) { + _ieVers = parseFloat( RegExp.$1 ); + } + if (!a) { + return false; + } + a.style.cssText = "top:1px;opacity:.55;"; + return /^0.55/.test(a.style.opacity); + }()), + _getIEOpacity = function(v) { + return (_opacityExp.test( ((typeof(v) === "string") ? v : (v.currentStyle ? v.currentStyle.filter : v.style.filter) || "") ) ? ( parseFloat( RegExp.$1 ) / 100 ) : 1); + }, + _log = function(s) {//for logging messages, but in a way that won't throw errors in old versions of IE. + if (window.console) { + console.log(s); + } + }, + + _prefixCSS = "", //the non-camelCase vendor prefix like "-o-", "-moz-", "-ms-", or "-webkit-" + _prefix = "", //camelCase vendor prefix like "O", "ms", "Webkit", or "Moz". + + // @private feed in a camelCase property name like "transform" and it will check to see if it is valid as-is or if it needs a vendor prefix. It returns the corrected camelCase property name (i.e. "WebkitTransform" or "MozTransform" or "transform" or null if no such property is found, like if the browser is IE8 or before, "transform" won't be found at all) + _checkPropPrefix = function(p, e) { + e = e || _tempDiv; + var s = e.style, + a, i; + if (s[p] !== undefined) { + return p; + } + p = p.charAt(0).toUpperCase() + p.substr(1); + a = ["O","Moz","ms","Ms","Webkit"]; + i = 5; + while (--i > -1 && s[a[i]+p] === undefined) { } + if (i >= 0) { + _prefix = (i === 3) ? "ms" : a[i]; + _prefixCSS = "-" + _prefix.toLowerCase() + "-"; + return _prefix + p; + } + return null; + }, + + _getComputedStyle = _doc.defaultView ? _doc.defaultView.getComputedStyle : function() {}, + + /** + * @private Returns the css style for a particular property of an element. For example, to get whatever the current "left" css value for an element with an ID of "myElement", you could do: + * var currentLeft = CSSPlugin.getStyle( document.getElementById("myElement"), "left"); + * + * @param {!Object} t Target element whose style property you want to query + * @param {!string} p Property name (like "left" or "top" or "marginTop", etc.) + * @param {Object=} cs Computed style object. This just provides a way to speed processing if you're going to get several properties on the same element in quick succession - you can reuse the result of the getComputedStyle() call. + * @param {boolean=} calc If true, the value will not be read directly from the element's "style" property (if it exists there), but instead the getComputedStyle() result will be used. This can be useful when you want to ensure that the browser itself is interpreting the value. + * @param {string=} dflt Default value that should be returned in the place of null, "none", "auto" or "auto auto". + * @return {?string} The current property value + */ + _getStyle = CSSPlugin.getStyle = function(t, p, cs, calc, dflt) { + var rv; + if (!_supportsOpacity) if (p === "opacity") { //several versions of IE don't use the standard "opacity" property - they use things like filter:alpha(opacity=50), so we parse that here. + return _getIEOpacity(t); + } + if (!calc && t.style[p]) { + rv = t.style[p]; + } else if ((cs = cs || _getComputedStyle(t))) { + rv = cs[p] || cs.getPropertyValue(p) || cs.getPropertyValue(p.replace(_capsExp, "-$1").toLowerCase()); + } else if (t.currentStyle) { + rv = t.currentStyle[p]; + } + return (dflt != null && (!rv || rv === "none" || rv === "auto" || rv === "auto auto")) ? dflt : rv; + }, + + /** + * @private Pass the target element, the property name, the numeric value, and the suffix (like "%", "em", "px", etc.) and it will spit back the equivalent pixel number. + * @param {!Object} t Target element + * @param {!string} p Property name (like "left", "top", "marginLeft", etc.) + * @param {!number} v Value + * @param {string=} sfx Suffix (like "px" or "%" or "em") + * @param {boolean=} recurse If true, the call is a recursive one. In some browsers (like IE7/8), occasionally the value isn't accurately reported initially, but if we run the function again it will take effect. + * @return {number} value in pixels + */ + _convertToPixels = _internals.convertToPixels = function(t, p, v, sfx, recurse) { + if (sfx === "px" || !sfx) { return v; } + if (sfx === "auto" || !v) { return 0; } + var horiz = _horizExp.test(p), + node = t, + style = _tempDiv.style, + neg = (v < 0), + precise = (v === 1), + pix, cache, time; + if (neg) { + v = -v; + } + if (precise) { + v *= 100; + } + if (sfx === "%" && p.indexOf("border") !== -1) { + pix = (v / 100) * (horiz ? t.clientWidth : t.clientHeight); + } else { + style.cssText = "border:0 solid red;position:" + _getStyle(t, "position") + ";line-height:0;"; + if (sfx === "%" || !node.appendChild || sfx.charAt(0) === "v" || sfx === "rem") { + node = t.parentNode || _doc.body; + cache = node._gsCache; + time = TweenLite.ticker.frame; + if (cache && horiz && cache.time === time) { //performance optimization: we record the width of elements along with the ticker frame so that we can quickly get it again on the same tick (seems relatively safe to assume it wouldn't change on the same tick) + return cache.width * v / 100; + } + style[(horiz ? "width" : "height")] = v + sfx; + } else { + style[(horiz ? "borderLeftWidth" : "borderTopWidth")] = v + sfx; + } + node.appendChild(_tempDiv); + pix = parseFloat(_tempDiv[(horiz ? "offsetWidth" : "offsetHeight")]); + node.removeChild(_tempDiv); + if (horiz && sfx === "%" && CSSPlugin.cacheWidths !== false) { + cache = node._gsCache = node._gsCache || {}; + cache.time = time; + cache.width = pix / v * 100; + } + if (pix === 0 && !recurse) { + pix = _convertToPixels(t, p, v, sfx, true); + } + } + if (precise) { + pix /= 100; + } + return neg ? -pix : pix; + }, + _calculateOffset = _internals.calculateOffset = function(t, p, cs) { //for figuring out "top" or "left" in px when it's "auto". We need to factor in margin with the offsetLeft/offsetTop + if (_getStyle(t, "position", cs) !== "absolute") { return 0; } + var dim = ((p === "left") ? "Left" : "Top"), + v = _getStyle(t, "margin" + dim, cs); + return t["offset" + dim] - (_convertToPixels(t, p, parseFloat(v), v.replace(_suffixExp, "")) || 0); + }, + + // @private returns at object containing ALL of the style properties in camelCase and their associated values. + _getAllStyles = function(t, cs) { + var s = {}, + i, tr, p; + if ((cs = cs || _getComputedStyle(t, null))) { + if ((i = cs.length)) { + while (--i > -1) { + p = cs[i]; + if (p.indexOf("-transform") === -1 || _transformPropCSS === p) { //Some webkit browsers duplicate transform values, one non-prefixed and one prefixed ("transform" and "WebkitTransform"), so we must weed out the extra one here. + s[p.replace(_camelExp, _camelFunc)] = cs.getPropertyValue(p); + } + } + } else { //some browsers behave differently - cs.length is always 0, so we must do a for...in loop. + for (i in cs) { + if (i.indexOf("Transform") === -1 || _transformProp === i) { //Some webkit browsers duplicate transform values, one non-prefixed and one prefixed ("transform" and "WebkitTransform"), so we must weed out the extra one here. + s[i] = cs[i]; + } + } + } + } else if ((cs = t.currentStyle || t.style)) { + for (i in cs) { + if (typeof(i) === "string" && s[i] === undefined) { + s[i.replace(_camelExp, _camelFunc)] = cs[i]; + } + } + } + if (!_supportsOpacity) { + s.opacity = _getIEOpacity(t); + } + tr = _getTransform(t, cs, false); + s.rotation = tr.rotation; + s.skewX = tr.skewX; + s.scaleX = tr.scaleX; + s.scaleY = tr.scaleY; + s.x = tr.x; + s.y = tr.y; + if (_supports3D) { + s.z = tr.z; + s.rotationX = tr.rotationX; + s.rotationY = tr.rotationY; + s.scaleZ = tr.scaleZ; + } + if (s.filters) { + delete s.filters; + } + return s; + }, + + // @private analyzes two style objects (as returned by _getAllStyles()) and only looks for differences between them that contain tweenable values (like a number or color). It returns an object with a "difs" property which refers to an object containing only those isolated properties and values for tweening, and a "firstMPT" property which refers to the first MiniPropTween instance in a linked list that recorded all the starting values of the different properties so that we can revert to them at the end or beginning of the tween - we don't want the cascading to get messed up. The forceLookup parameter is an optional generic object with properties that should be forced into the results - this is necessary for className tweens that are overwriting others because imagine a scenario where a rollover/rollout adds/removes a class and the user swipes the mouse over the target SUPER fast, thus nothing actually changed yet and the subsequent comparison of the properties would indicate they match (especially when px rounding is taken into consideration), thus no tweening is necessary even though it SHOULD tween and remove those properties after the tween (otherwise the inline styles will contaminate things). See the className SpecialProp code for details. + _cssDif = function(t, s1, s2, vars, forceLookup) { + var difs = {}, + style = t.style, + val, p, mpt; + for (p in s2) { + if (p !== "cssText") if (p !== "length") if (isNaN(p)) if (s1[p] !== (val = s2[p]) || (forceLookup && forceLookup[p])) if (p.indexOf("Origin") === -1) if (typeof(val) === "number" || typeof(val) === "string") { + difs[p] = (val === "auto" && (p === "left" || p === "top")) ? _calculateOffset(t, p) : ((val === "" || val === "auto" || val === "none") && typeof(s1[p]) === "string" && s1[p].replace(_NaNExp, "") !== "") ? 0 : val; //if the ending value is defaulting ("" or "auto"), we check the starting value and if it can be parsed into a number (a string which could have a suffix too, like 700px), then we swap in 0 for "" or "auto" so that things actually tween. + if (style[p] !== undefined) { //for className tweens, we must remember which properties already existed inline - the ones that didn't should be removed when the tween isn't in progress because they were only introduced to facilitate the transition between classes. + mpt = new MiniPropTween(style, p, style[p], mpt); + } + } + } + if (vars) { + for (p in vars) { //copy properties (except className) + if (p !== "className") { + difs[p] = vars[p]; + } + } + } + return {difs:difs, firstMPT:mpt}; + }, + _dimensions = {width:["Left","Right"], height:["Top","Bottom"]}, + _margins = ["marginLeft","marginRight","marginTop","marginBottom"], + + /** + * @private Gets the width or height of an element + * @param {!Object} t Target element + * @param {!string} p Property name ("width" or "height") + * @param {Object=} cs Computed style object (if one exists). Just a speed optimization. + * @return {number} Dimension (in pixels) + */ + _getDimension = function(t, p, cs) { + if ((t.nodeName + "").toLowerCase() === "svg") { //Chrome no longer supports offsetWidth/offsetHeight on SVG elements. + return (cs || _getComputedStyle(t))[p] || 0; + } else if (t.getBBox && _isSVG(t)) { + return t.getBBox()[p] || 0; + } + var v = parseFloat((p === "width") ? t.offsetWidth : t.offsetHeight), + a = _dimensions[p], + i = a.length; + cs = cs || _getComputedStyle(t, null); + while (--i > -1) { + v -= parseFloat( _getStyle(t, "padding" + a[i], cs, true) ) || 0; + v -= parseFloat( _getStyle(t, "border" + a[i] + "Width", cs, true) ) || 0; + } + return v; + }, + + // @private Parses position-related complex strings like "top left" or "50px 10px" or "70% 20%", etc. which are used for things like transformOrigin or backgroundPosition. Optionally decorates a supplied object (recObj) with the following properties: "ox" (offsetX), "oy" (offsetY), "oxp" (if true, "ox" is a percentage not a pixel value), and "oxy" (if true, "oy" is a percentage not a pixel value) + _parsePosition = function(v, recObj) { + if (v === "contain" || v === "auto" || v === "auto auto") { + return v + " "; + } + if (v == null || v === "") { //note: Firefox uses "auto auto" as default whereas Chrome uses "auto". + v = "0 0"; + } + var a = v.split(" "), + x = (v.indexOf("left") !== -1) ? "0%" : (v.indexOf("right") !== -1) ? "100%" : a[0], + y = (v.indexOf("top") !== -1) ? "0%" : (v.indexOf("bottom") !== -1) ? "100%" : a[1], + i; + if (a.length > 3 && !recObj) { //multiple positions + a = v.split(", ").join(",").split(","); + v = []; + for (i = 0; i < a.length; i++) { + v.push(_parsePosition(a[i])); + } + return v.join(","); + } + if (y == null) { + y = (x === "center") ? "50%" : "0"; + } else if (y === "center") { + y = "50%"; + } + if (x === "center" || (isNaN(parseFloat(x)) && (x + "").indexOf("=") === -1)) { //remember, the user could flip-flop the values and say "bottom center" or "center bottom", etc. "center" is ambiguous because it could be used to describe horizontal or vertical, hence the isNaN(). If there's an "=" sign in the value, it's relative. + x = "50%"; + } + v = x + " " + y + ((a.length > 2) ? " " + a[2] : ""); + if (recObj) { + recObj.oxp = (x.indexOf("%") !== -1); + recObj.oyp = (y.indexOf("%") !== -1); + recObj.oxr = (x.charAt(1) === "="); + recObj.oyr = (y.charAt(1) === "="); + recObj.ox = parseFloat(x.replace(_NaNExp, "")); + recObj.oy = parseFloat(y.replace(_NaNExp, "")); + recObj.v = v; + } + return recObj || v; + }, + + /** + * @private Takes an ending value (typically a string, but can be a number) and a starting value and returns the change between the two, looking for relative value indicators like += and -= and it also ignores suffixes (but make sure the ending value starts with a number or +=/-= and that the starting value is a NUMBER!) + * @param {(number|string)} e End value which is typically a string, but could be a number + * @param {(number|string)} b Beginning value which is typically a string but could be a number + * @return {number} Amount of change between the beginning and ending values (relative values that have a "+=" or "-=" are recognized) + */ + _parseChange = function(e, b) { + return (typeof(e) === "string" && e.charAt(1) === "=") ? parseInt(e.charAt(0) + "1", 10) * parseFloat(e.substr(2)) : (parseFloat(e) - parseFloat(b)) || 0; + }, + + /** + * @private Takes a value and a default number, checks if the value is relative, null, or numeric and spits back a normalized number accordingly. Primarily used in the _parseTransform() function. + * @param {Object} v Value to be parsed + * @param {!number} d Default value (which is also used for relative calculations if "+=" or "-=" is found in the first parameter) + * @return {number} Parsed value + */ + _parseVal = function(v, d) { + return (v == null) ? d : (typeof(v) === "string" && v.charAt(1) === "=") ? parseInt(v.charAt(0) + "1", 10) * parseFloat(v.substr(2)) + d : parseFloat(v) || 0; + }, + + /** + * @private Translates strings like "40deg" or "40" or 40rad" or "+=40deg" or "270_short" or "-90_cw" or "+=45_ccw" to a numeric radian angle. Of course a starting/default value must be fed in too so that relative values can be calculated properly. + * @param {Object} v Value to be parsed + * @param {!number} d Default value (which is also used for relative calculations if "+=" or "-=" is found in the first parameter) + * @param {string=} p property name for directionalEnd (optional - only used when the parsed value is directional ("_short", "_cw", or "_ccw" suffix). We need a way to store the uncompensated value so that at the end of the tween, we set it to exactly what was requested with no directional compensation). Property name would be "rotation", "rotationX", or "rotationY" + * @param {Object=} directionalEnd An object that will store the raw end values for directional angles ("_short", "_cw", or "_ccw" suffix). We need a way to store the uncompensated value so that at the end of the tween, we set it to exactly what was requested with no directional compensation. + * @return {number} parsed angle in radians + */ + _parseAngle = function(v, d, p, directionalEnd) { + var min = 0.000001, + cap, split, dif, result, isRelative; + if (v == null) { + result = d; + } else if (typeof(v) === "number") { + result = v; + } else { + cap = 360; + split = v.split("_"); + isRelative = (v.charAt(1) === "="); + dif = (isRelative ? parseInt(v.charAt(0) + "1", 10) * parseFloat(split[0].substr(2)) : parseFloat(split[0])) * ((v.indexOf("rad") === -1) ? 1 : _RAD2DEG) - (isRelative ? 0 : d); + if (split.length) { + if (directionalEnd) { + directionalEnd[p] = d + dif; + } + if (v.indexOf("short") !== -1) { + dif = dif % cap; + if (dif !== dif % (cap / 2)) { + dif = (dif < 0) ? dif + cap : dif - cap; + } + } + if (v.indexOf("_cw") !== -1 && dif < 0) { + dif = ((dif + cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; + } else if (v.indexOf("ccw") !== -1 && dif > 0) { + dif = ((dif - cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; + } + } + result = d + dif; + } + if (result < min && result > -min) { + result = 0; + } + return result; + }, + + _colorLookup = {aqua:[0,255,255], + lime:[0,255,0], + silver:[192,192,192], + black:[0,0,0], + maroon:[128,0,0], + teal:[0,128,128], + blue:[0,0,255], + navy:[0,0,128], + white:[255,255,255], + fuchsia:[255,0,255], + olive:[128,128,0], + yellow:[255,255,0], + orange:[255,165,0], + gray:[128,128,128], + purple:[128,0,128], + green:[0,128,0], + red:[255,0,0], + pink:[255,192,203], + cyan:[0,255,255], + transparent:[255,255,255,0]}, + + _hue = function(h, m1, m2) { + h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; + return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; + }, + + /** + * @private Parses a color (like #9F0, #FF9900, rgb(255,51,153) or hsl(108, 50%, 10%)) into an array with 3 elements for red, green, and blue or if toHSL parameter is true, it will populate the array with hue, saturation, and lightness values. If a relative value is found in an hsl() or hsla() string, it will preserve those relative prefixes and all the values in the array will be strings instead of numbers (in all other cases it will be populated with numbers). + * @param {(string|number)} v The value the should be parsed which could be a string like #9F0 or rgb(255,102,51) or rgba(255,0,0,0.5) or it could be a number like 0xFF00CC or even a named color like red, blue, purple, etc. + * @param {(boolean)} toHSL If true, an hsl() or hsla() value will be returned instead of rgb() or rgba() + * @return {Array.} An array containing red, green, and blue (and optionally alpha) in that order, or if the toHSL parameter was true, the array will contain hue, saturation and lightness (and optionally alpha) in that order. Always numbers unless there's a relative prefix found in an hsl() or hsla() string and toHSL is true. + */ + _parseColor = CSSPlugin.parseColor = function(v, toHSL) { + var a, r, g, b, h, s, l, max, min, d, wasHSL; + if (!v) { + a = _colorLookup.black; + } else if (typeof(v) === "number") { + a = [v >> 16, (v >> 8) & 255, v & 255]; + } else { + if (v.charAt(v.length - 1) === ",") { //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value. + v = v.substr(0, v.length - 1); + } + if (_colorLookup[v]) { + a = _colorLookup[v]; + } else if (v.charAt(0) === "#") { + if (v.length === 4) { //for shorthand like #9F0 + r = v.charAt(1); + g = v.charAt(2); + b = v.charAt(3); + v = "#" + r + r + g + g + b + b; + } + v = parseInt(v.substr(1), 16); + a = [v >> 16, (v >> 8) & 255, v & 255]; + } else if (v.substr(0, 3) === "hsl") { + a = wasHSL = v.match(_numExp); + if (!toHSL) { + h = (Number(a[0]) % 360) / 360; + s = Number(a[1]) / 100; + l = Number(a[2]) / 100; + g = (l <= 0.5) ? l * (s + 1) : l + s - l * s; + r = l * 2 - g; + if (a.length > 3) { + a[3] = Number(v[3]); + } + a[0] = _hue(h + 1 / 3, r, g); + a[1] = _hue(h, r, g); + a[2] = _hue(h - 1 / 3, r, g); + } else if (v.indexOf("=") !== -1) { //if relative values are found, just return the raw strings with the relative prefixes in place. + return v.match(_relNumExp); + } + } else { + a = v.match(_numExp) || _colorLookup.transparent; + } + a[0] = Number(a[0]); + a[1] = Number(a[1]); + a[2] = Number(a[2]); + if (a.length > 3) { + a[3] = Number(a[3]); + } + } + if (toHSL && !wasHSL) { + r = a[0] / 255; + g = a[1] / 255; + b = a[2] / 255; + max = Math.max(r, g, b); + min = Math.min(r, g, b); + l = (max + min) / 2; + if (max === min) { + h = s = 0; + } else { + d = max - min; + s = l > 0.5 ? d / (2 - max - min) : d / (max + min); + h = (max === r) ? (g - b) / d + (g < b ? 6 : 0) : (max === g) ? (b - r) / d + 2 : (r - g) / d + 4; + h *= 60; + } + a[0] = (h + 0.5) | 0; + a[1] = (s * 100 + 0.5) | 0; + a[2] = (l * 100 + 0.5) | 0; + } + return a; + }, + _formatColors = function(s, toHSL) { + var colors = s.match(_colorExp) || [], + charIndex = 0, + parsed = colors.length ? "" : s, + i, color, temp; + for (i = 0; i < colors.length; i++) { + color = colors[i]; + temp = s.substr(charIndex, s.indexOf(color, charIndex)-charIndex); + charIndex += temp.length + color.length; + color = _parseColor(color, toHSL); + if (color.length === 3) { + color.push(1); + } + parsed += temp + (toHSL ? "hsla(" + color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : "rgba(" + color.join(",")) + ")"; + } + return parsed + s.substr(charIndex); + }, + _colorExp = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b"; //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc. + + for (p in _colorLookup) { + _colorExp += "|" + p + "\\b"; + } + _colorExp = new RegExp(_colorExp+")", "gi"); + + CSSPlugin.colorStringFilter = function(a) { + var combined = a[0] + a[1], + toHSL; + if (_colorExp.test(combined)) { + toHSL = (combined.indexOf("hsl(") !== -1 || combined.indexOf("hsla(") !== -1); + a[0] = _formatColors(a[0], toHSL); + a[1] = _formatColors(a[1], toHSL); + } + _colorExp.lastIndex = 0; + }; + + if (!TweenLite.defaultStringFilter) { + TweenLite.defaultStringFilter = CSSPlugin.colorStringFilter; + } + + /** + * @private Returns a formatter function that handles taking a string (or number in some cases) and returning a consistently formatted one in terms of delimiters, quantity of values, etc. For example, we may get boxShadow values defined as "0px red" or "0px 0px 10px rgb(255,0,0)" or "0px 0px 20px 20px #F00" and we need to ensure that what we get back is described with 4 numbers and a color. This allows us to feed it into the _parseComplex() method and split the values up appropriately. The neat thing about this _getFormatter() function is that the dflt defines a pattern as well as a default, so for example, _getFormatter("0px 0px 0px 0px #777", true) not only sets the default as 0px for all distances and #777 for the color, but also sets the pattern such that 4 numbers and a color will always get returned. + * @param {!string} dflt The default value and pattern to follow. So "0px 0px 0px 0px #777" will ensure that 4 numbers and a color will always get returned. + * @param {boolean=} clr If true, the values should be searched for color-related data. For example, boxShadow values typically contain a color whereas borderRadius don't. + * @param {boolean=} collapsible If true, the value is a top/left/right/bottom style one that acts like margin or padding, where if only one value is received, it's used for all 4; if 2 are received, the first is duplicated for 3rd (bottom) and the 2nd is duplicated for the 4th spot (left), etc. + * @return {Function} formatter function + */ + var _getFormatter = function(dflt, clr, collapsible, multi) { + if (dflt == null) { + return function(v) {return v;}; + } + var dColor = clr ? (dflt.match(_colorExp) || [""])[0] : "", + dVals = dflt.split(dColor).join("").match(_valuesExp) || [], + pfx = dflt.substr(0, dflt.indexOf(dVals[0])), + sfx = (dflt.charAt(dflt.length - 1) === ")") ? ")" : "", + delim = (dflt.indexOf(" ") !== -1) ? " " : ",", + numVals = dVals.length, + dSfx = (numVals > 0) ? dVals[0].replace(_numExp, "") : "", + formatter; + if (!numVals) { + return function(v) {return v;}; + } + if (clr) { + formatter = function(v) { + var color, vals, i, a; + if (typeof(v) === "number") { + v += dSfx; + } else if (multi && _commasOutsideParenExp.test(v)) { + a = v.replace(_commasOutsideParenExp, "|").split("|"); + for (i = 0; i < a.length; i++) { + a[i] = formatter(a[i]); + } + return a.join(","); + } + color = (v.match(_colorExp) || [dColor])[0]; + vals = v.split(color).join("").match(_valuesExp) || []; + i = vals.length; + if (numVals > i--) { + while (++i < numVals) { + vals[i] = collapsible ? vals[(((i - 1) / 2) | 0)] : dVals[i]; + } + } + return pfx + vals.join(delim) + delim + color + sfx + (v.indexOf("inset") !== -1 ? " inset" : ""); + }; + return formatter; + + } + formatter = function(v) { + var vals, a, i; + if (typeof(v) === "number") { + v += dSfx; + } else if (multi && _commasOutsideParenExp.test(v)) { + a = v.replace(_commasOutsideParenExp, "|").split("|"); + for (i = 0; i < a.length; i++) { + a[i] = formatter(a[i]); + } + return a.join(","); + } + vals = v.match(_valuesExp) || []; + i = vals.length; + if (numVals > i--) { + while (++i < numVals) { + vals[i] = collapsible ? vals[(((i - 1) / 2) | 0)] : dVals[i]; + } + } + return pfx + vals.join(delim) + sfx; + }; + return formatter; + }, + + /** + * @private returns a formatter function that's used for edge-related values like marginTop, marginLeft, paddingBottom, paddingRight, etc. Just pass a comma-delimited list of property names related to the edges. + * @param {!string} props a comma-delimited list of property names in order from top to left, like "marginTop,marginRight,marginBottom,marginLeft" + * @return {Function} a formatter function + */ + _getEdgeParser = function(props) { + props = props.split(","); + return function(t, e, p, cssp, pt, plugin, vars) { + var a = (e + "").split(" "), + i; + vars = {}; + for (i = 0; i < 4; i++) { + vars[props[i]] = a[i] = a[i] || a[(((i - 1) / 2) >> 0)]; + } + return cssp.parse(t, vars, pt, plugin); + }; + }, + + // @private used when other plugins must tween values first, like BezierPlugin or ThrowPropsPlugin, etc. That plugin's setRatio() gets called first so that the values are updated, and then we loop through the MiniPropTweens which handle copying the values into their appropriate slots so that they can then be applied correctly in the main CSSPlugin setRatio() method. Remember, we typically create a proxy object that has a bunch of uniquely-named properties that we feed to the sub-plugin and it does its magic normally, and then we must interpret those values and apply them to the css because often numbers must get combined/concatenated, suffixes added, etc. to work with css, like boxShadow could have 4 values plus a color. + _setPluginRatio = _internals._setPluginRatio = function(v) { + this.plugin.setRatio(v); + var d = this.data, + proxy = d.proxy, + mpt = d.firstMPT, + min = 0.000001, + val, pt, i, str, p; + while (mpt) { + val = proxy[mpt.v]; + if (mpt.r) { + val = Math.round(val); + } else if (val < min && val > -min) { + val = 0; + } + mpt.t[mpt.p] = val; + mpt = mpt._next; + } + if (d.autoRotate) { + d.autoRotate.rotation = proxy.rotation; + } + //at the end, we must set the CSSPropTween's "e" (end) value dynamically here because that's what is used in the final setRatio() method. Same for "b" at the beginning. + if (v === 1 || v === 0) { + mpt = d.firstMPT; + p = (v === 1) ? "e" : "b"; + while (mpt) { + pt = mpt.t; + if (!pt.type) { + pt[p] = pt.s + pt.xs0; + } else if (pt.type === 1) { + str = pt.xs0 + pt.s + pt.xs1; + for (i = 1; i < pt.l; i++) { + str += pt["xn"+i] + pt["xs"+(i+1)]; + } + pt[p] = str; + } + mpt = mpt._next; + } + } + }, + + /** + * @private @constructor Used by a few SpecialProps to hold important values for proxies. For example, _parseToProxy() creates a MiniPropTween instance for each property that must get tweened on the proxy, and we record the original property name as well as the unique one we create for the proxy, plus whether or not the value needs to be rounded plus the original value. + * @param {!Object} t target object whose property we're tweening (often a CSSPropTween) + * @param {!string} p property name + * @param {(number|string|object)} v value + * @param {MiniPropTween=} next next MiniPropTween in the linked list + * @param {boolean=} r if true, the tweened value should be rounded to the nearest integer + */ + MiniPropTween = function(t, p, v, next, r) { + this.t = t; + this.p = p; + this.v = v; + this.r = r; + if (next) { + next._prev = this; + this._next = next; + } + }, + + /** + * @private Most other plugins (like BezierPlugin and ThrowPropsPlugin and others) can only tween numeric values, but CSSPlugin must accommodate special values that have a bunch of extra data (like a suffix or strings between numeric values, etc.). For example, boxShadow has values like "10px 10px 20px 30px rgb(255,0,0)" which would utterly confuse other plugins. This method allows us to split that data apart and grab only the numeric data and attach it to uniquely-named properties of a generic proxy object ({}) so that we can feed that to virtually any plugin to have the numbers tweened. However, we must also keep track of which properties from the proxy go with which CSSPropTween values and instances. So we create a linked list of MiniPropTweens. Each one records a target (the original CSSPropTween), property (like "s" or "xn1" or "xn2") that we're tweening and the unique property name that was used for the proxy (like "boxShadow_xn1" and "boxShadow_xn2") and whether or not they need to be rounded. That way, in the _setPluginRatio() method we can simply copy the values over from the proxy to the CSSPropTween instance(s). Then, when the main CSSPlugin setRatio() method runs and applies the CSSPropTween values accordingly, they're updated nicely. So the external plugin tweens the numbers, _setPluginRatio() copies them over, and setRatio() acts normally, applying css-specific values to the element. + * This method returns an object that has the following properties: + * - proxy: a generic object containing the starting values for all the properties that will be tweened by the external plugin. This is what we feed to the external _onInitTween() as the target + * - end: a generic object containing the ending values for all the properties that will be tweened by the external plugin. This is what we feed to the external plugin's _onInitTween() as the destination values + * - firstMPT: the first MiniPropTween in the linked list + * - pt: the first CSSPropTween in the linked list that was created when parsing. If shallow is true, this linked list will NOT attach to the one passed into the _parseToProxy() as the "pt" (4th) parameter. + * @param {!Object} t target object to be tweened + * @param {!(Object|string)} vars the object containing the information about the tweening values (typically the end/destination values) that should be parsed + * @param {!CSSPlugin} cssp The CSSPlugin instance + * @param {CSSPropTween=} pt the next CSSPropTween in the linked list + * @param {TweenPlugin=} plugin the external TweenPlugin instance that will be handling tweening the numeric values + * @param {boolean=} shallow if true, the resulting linked list from the parse will NOT be attached to the CSSPropTween that was passed in as the "pt" (4th) parameter. + * @return An object containing the following properties: proxy, end, firstMPT, and pt (see above for descriptions) + */ + _parseToProxy = _internals._parseToProxy = function(t, vars, cssp, pt, plugin, shallow) { + var bpt = pt, + start = {}, + end = {}, + transform = cssp._transform, + oldForce = _forcePT, + i, p, xp, mpt, firstPT; + cssp._transform = null; + _forcePT = vars; + pt = firstPT = cssp.parse(t, vars, pt, plugin); + _forcePT = oldForce; + //break off from the linked list so the new ones are isolated. + if (shallow) { + cssp._transform = transform; + if (bpt) { + bpt._prev = null; + if (bpt._prev) { + bpt._prev._next = null; + } + } + } + while (pt && pt !== bpt) { + if (pt.type <= 1) { + p = pt.p; + end[p] = pt.s + pt.c; + start[p] = pt.s; + if (!shallow) { + mpt = new MiniPropTween(pt, "s", p, mpt, pt.r); + pt.c = 0; + } + if (pt.type === 1) { + i = pt.l; + while (--i > 0) { + xp = "xn" + i; + p = pt.p + "_" + xp; + end[p] = pt.data[xp]; + start[p] = pt[xp]; + if (!shallow) { + mpt = new MiniPropTween(pt, xp, p, mpt, pt.rxp[xp]); + } + } + } + } + pt = pt._next; + } + return {proxy:start, end:end, firstMPT:mpt, pt:firstPT}; + }, + + + + /** + * @constructor Each property that is tweened has at least one CSSPropTween associated with it. These instances store important information like the target, property, starting value, amount of change, etc. They can also optionally have a number of "extra" strings and numeric values named xs1, xn1, xs2, xn2, xs3, xn3, etc. where "s" indicates string and "n" indicates number. These can be pieced together in a complex-value tween (type:1) that has alternating types of data like a string, number, string, number, etc. For example, boxShadow could be "5px 5px 8px rgb(102, 102, 51)". In that value, there are 6 numbers that may need to tween and then pieced back together into a string again with spaces, suffixes, etc. xs0 is special in that it stores the suffix for standard (type:0) tweens, -OR- the first string (prefix) in a complex-value (type:1) CSSPropTween -OR- it can be the non-tweening value in a type:-1 CSSPropTween. We do this to conserve memory. + * CSSPropTweens have the following optional properties as well (not defined through the constructor): + * - l: Length in terms of the number of extra properties that the CSSPropTween has (default: 0). For example, for a boxShadow we may need to tween 5 numbers in which case l would be 5; Keep in mind that the start/end values for the first number that's tweened are always stored in the s and c properties to conserve memory. All additional values thereafter are stored in xn1, xn2, etc. + * - xfirst: The first instance of any sub-CSSPropTweens that are tweening properties of this instance. For example, we may split up a boxShadow tween so that there's a main CSSPropTween of type:1 that has various xs* and xn* values associated with the h-shadow, v-shadow, blur, color, etc. Then we spawn a CSSPropTween for each of those that has a higher priority and runs BEFORE the main CSSPropTween so that the values are all set by the time it needs to re-assemble them. The xfirst gives us an easy way to identify the first one in that chain which typically ends at the main one (because they're all prepende to the linked list) + * - plugin: The TweenPlugin instance that will handle the tweening of any complex values. For example, sometimes we don't want to use normal subtweens (like xfirst refers to) to tween the values - we might want ThrowPropsPlugin or BezierPlugin some other plugin to do the actual tweening, so we create a plugin instance and store a reference here. We need this reference so that if we get a request to round values or disable a tween, we can pass along that request. + * - data: Arbitrary data that needs to be stored with the CSSPropTween. Typically if we're going to have a plugin handle the tweening of a complex-value tween, we create a generic object that stores the END values that we're tweening to and the CSSPropTween's xs1, xs2, etc. have the starting values. We store that object as data. That way, we can simply pass that object to the plugin and use the CSSPropTween as the target. + * - setRatio: Only used for type:2 tweens that require custom functionality. In this case, we call the CSSPropTween's setRatio() method and pass the ratio each time the tween updates. This isn't quite as efficient as doing things directly in the CSSPlugin's setRatio() method, but it's very convenient and flexible. + * @param {!Object} t Target object whose property will be tweened. Often a DOM element, but not always. It could be anything. + * @param {string} p Property to tween (name). For example, to tween element.width, p would be "width". + * @param {number} s Starting numeric value + * @param {number} c Change in numeric value over the course of the entire tween. For example, if element.width starts at 5 and should end at 100, c would be 95. + * @param {CSSPropTween=} next The next CSSPropTween in the linked list. If one is defined, we will define its _prev as the new instance, and the new instance's _next will be pointed at it. + * @param {number=} type The type of CSSPropTween where -1 = a non-tweening value, 0 = a standard simple tween, 1 = a complex value (like one that has multiple numbers in a comma- or space-delimited string like border:"1px solid red"), and 2 = one that uses a custom setRatio function that does all of the work of applying the values on each update. + * @param {string=} n Name of the property that should be used for overwriting purposes which is typically the same as p but not always. For example, we may need to create a subtween for the 2nd part of a "clip:rect(...)" tween in which case "p" might be xs1 but "n" is still "clip" + * @param {boolean=} r If true, the value(s) should be rounded + * @param {number=} pr Priority in the linked list order. Higher priority CSSPropTweens will be updated before lower priority ones. The default priority is 0. + * @param {string=} b Beginning value. We store this to ensure that it is EXACTLY what it was when the tween began without any risk of interpretation issues. + * @param {string=} e Ending value. We store this to ensure that it is EXACTLY what the user defined at the end of the tween without any risk of interpretation issues. + */ + CSSPropTween = _internals.CSSPropTween = function(t, p, s, c, next, type, n, r, pr, b, e) { + this.t = t; //target + this.p = p; //property + this.s = s; //starting value + this.c = c; //change value + this.n = n || p; //name that this CSSPropTween should be associated to (usually the same as p, but not always - n is what overwriting looks at) + if (!(t instanceof CSSPropTween)) { + _overwriteProps.push(this.n); + } + this.r = r; //round (boolean) + this.type = type || 0; //0 = normal tween, -1 = non-tweening (in which case xs0 will be applied to the target's property, like tp.t[tp.p] = tp.xs0), 1 = complex-value SpecialProp, 2 = custom setRatio() that does all the work + if (pr) { + this.pr = pr; + _hasPriority = true; + } + this.b = (b === undefined) ? s : b; + this.e = (e === undefined) ? s + c : e; + if (next) { + this._next = next; + next._prev = this; + } + }, + + _addNonTweeningNumericPT = function(target, prop, start, end, next, overwriteProp) { //cleans up some code redundancies and helps minification. Just a fast way to add a NUMERIC non-tweening CSSPropTween + var pt = new CSSPropTween(target, prop, start, end - start, next, -1, overwriteProp); + pt.b = start; + pt.e = pt.xs0 = end; + return pt; + }, + + /** + * Takes a target, the beginning value and ending value (as strings) and parses them into a CSSPropTween (possibly with child CSSPropTweens) that accommodates multiple numbers, colors, comma-delimited values, etc. For example: + * sp.parseComplex(element, "boxShadow", "5px 10px 20px rgb(255,102,51)", "0px 0px 0px red", true, "0px 0px 0px rgb(0,0,0,0)", pt); + * It will walk through the beginning and ending values (which should be in the same format with the same number and type of values) and figure out which parts are numbers, what strings separate the numeric/tweenable values, and then create the CSSPropTweens accordingly. If a plugin is defined, no child CSSPropTweens will be created. Instead, the ending values will be stored in the "data" property of the returned CSSPropTween like: {s:-5, xn1:-10, xn2:-20, xn3:255, xn4:0, xn5:0} so that it can be fed to any other plugin and it'll be plain numeric tweens but the recomposition of the complex value will be handled inside CSSPlugin's setRatio(). + * If a setRatio is defined, the type of the CSSPropTween will be set to 2 and recomposition of the values will be the responsibility of that method. + * + * @param {!Object} t Target whose property will be tweened + * @param {!string} p Property that will be tweened (its name, like "left" or "backgroundColor" or "boxShadow") + * @param {string} b Beginning value + * @param {string} e Ending value + * @param {boolean} clrs If true, the value could contain a color value like "rgb(255,0,0)" or "#F00" or "red". The default is false, so no colors will be recognized (a performance optimization) + * @param {(string|number|Object)} dflt The default beginning value that should be used if no valid beginning value is defined or if the number of values inside the complex beginning and ending values don't match + * @param {?CSSPropTween} pt CSSPropTween instance that is the current head of the linked list (we'll prepend to this). + * @param {number=} pr Priority in the linked list order. Higher priority properties will be updated before lower priority ones. The default priority is 0. + * @param {TweenPlugin=} plugin If a plugin should handle the tweening of extra properties, pass the plugin instance here. If one is defined, then NO subtweens will be created for any extra properties (the properties will be created - just not additional CSSPropTween instances to tween them) because the plugin is expected to do so. However, the end values WILL be populated in the "data" property, like {s:100, xn1:50, xn2:300} + * @param {function(number)=} setRatio If values should be set in a custom function instead of being pieced together in a type:1 (complex-value) CSSPropTween, define that custom function here. + * @return {CSSPropTween} The first CSSPropTween in the linked list which includes the new one(s) added by the parseComplex() call. + */ + _parseComplex = CSSPlugin.parseComplex = function(t, p, b, e, clrs, dflt, pt, pr, plugin, setRatio) { + //DEBUG: _log("parseComplex: "+p+", b: "+b+", e: "+e); + b = b || dflt || ""; + pt = new CSSPropTween(t, p, 0, 0, pt, (setRatio ? 2 : 1), null, false, pr, b, e); + e += ""; //ensures it's a string + if (clrs && _colorExp.test(e + b)) { //if colors are found, normalize the formatting to rgba() or hsla(). + e = [b, e]; + CSSPlugin.colorStringFilter(e); + b = e[0]; + e = e[1]; + } + var ba = b.split(", ").join(",").split(" "), //beginning array + ea = e.split(", ").join(",").split(" "), //ending array + l = ba.length, + autoRound = (_autoRound !== false), + i, xi, ni, bv, ev, bnums, enums, bn, hasAlpha, temp, cv, str, useHSL; + if (e.indexOf(",") !== -1 || b.indexOf(",") !== -1) { + ba = ba.join(" ").replace(_commasOutsideParenExp, ", ").split(" "); + ea = ea.join(" ").replace(_commasOutsideParenExp, ", ").split(" "); + l = ba.length; + } + if (l !== ea.length) { + //DEBUG: _log("mismatched formatting detected on " + p + " (" + b + " vs " + e + ")"); + ba = (dflt || "").split(" "); + l = ba.length; + } + pt.plugin = plugin; + pt.setRatio = setRatio; + _colorExp.lastIndex = 0; + for (i = 0; i < l; i++) { + bv = ba[i]; + ev = ea[i]; + bn = parseFloat(bv); + //if the value begins with a number (most common). It's fine if it has a suffix like px + if (bn || bn === 0) { + pt.appendXtra("", bn, _parseChange(ev, bn), ev.replace(_relNumExp, ""), (autoRound && ev.indexOf("px") !== -1), true); + + //if the value is a color + } else if (clrs && _colorExp.test(bv)) { + str = ev.indexOf(")") + 1; + str = ")" + (str ? ev.substr(str) : ""); //if there's a comma or ) at the end, retain it. + useHSL = (ev.indexOf("hsl") !== -1 && _supportsOpacity); + bv = _parseColor(bv, useHSL); + ev = _parseColor(ev, useHSL); + hasAlpha = (bv.length + ev.length > 6); + if (hasAlpha && !_supportsOpacity && ev[3] === 0) { //older versions of IE don't support rgba(), so if the destination alpha is 0, just use "transparent" for the end color + pt["xs" + pt.l] += pt.l ? " transparent" : "transparent"; + pt.e = pt.e.split(ea[i]).join("transparent"); + } else { + if (!_supportsOpacity) { //old versions of IE don't support rgba(). + hasAlpha = false; + } + if (useHSL) { + pt.appendXtra((hasAlpha ? "hsla(" : "hsl("), bv[0], _parseChange(ev[0], bv[0]), ",", false, true) + .appendXtra("", bv[1], _parseChange(ev[1], bv[1]), "%,", false) + .appendXtra("", bv[2], _parseChange(ev[2], bv[2]), (hasAlpha ? "%," : "%" + str), false); + } else { + pt.appendXtra((hasAlpha ? "rgba(" : "rgb("), bv[0], ev[0] - bv[0], ",", true, true) + .appendXtra("", bv[1], ev[1] - bv[1], ",", true) + .appendXtra("", bv[2], ev[2] - bv[2], (hasAlpha ? "," : str), true); + } + + if (hasAlpha) { + bv = (bv.length < 4) ? 1 : bv[3]; + pt.appendXtra("", bv, ((ev.length < 4) ? 1 : ev[3]) - bv, str, false); + } + } + _colorExp.lastIndex = 0; //otherwise the test() on the RegExp could move the lastIndex and taint future results. + + } else { + bnums = bv.match(_numExp); //gets each group of numbers in the beginning value string and drops them into an array + + //if no number is found, treat it as a non-tweening value and just append the string to the current xs. + if (!bnums) { + pt["xs" + pt.l] += (pt.l || pt["xs" + pt.l]) ? " " + ev : ev; + + //loop through all the numbers that are found and construct the extra values on the pt. + } else { + enums = ev.match(_relNumExp); //get each group of numbers in the end value string and drop them into an array. We allow relative values too, like +=50 or -=.5 + if (!enums || enums.length !== bnums.length) { + //DEBUG: _log("mismatched formatting detected on " + p + " (" + b + " vs " + e + ")"); + return pt; + } + ni = 0; + for (xi = 0; xi < bnums.length; xi++) { + cv = bnums[xi]; + temp = bv.indexOf(cv, ni); + pt.appendXtra(bv.substr(ni, temp - ni), Number(cv), _parseChange(enums[xi], cv), "", (autoRound && bv.substr(temp + cv.length, 2) === "px"), (xi === 0)); + ni = temp + cv.length; + } + pt["xs" + pt.l] += bv.substr(ni); + } + } + } + //if there are relative values ("+=" or "-=" prefix), we need to adjust the ending value to eliminate the prefixes and combine the values properly. + if (e.indexOf("=") !== -1) if (pt.data) { + str = pt.xs0 + pt.data.s; + for (i = 1; i < pt.l; i++) { + str += pt["xs" + i] + pt.data["xn" + i]; + } + pt.e = str + pt["xs" + i]; + } + if (!pt.l) { + pt.type = -1; + pt.xs0 = pt.e; + } + return pt.xfirst || pt; + }, + i = 9; + + + p = CSSPropTween.prototype; + p.l = p.pr = 0; //length (number of extra properties like xn1, xn2, xn3, etc. + while (--i > 0) { + p["xn" + i] = 0; + p["xs" + i] = ""; + } + p.xs0 = ""; + p._next = p._prev = p.xfirst = p.data = p.plugin = p.setRatio = p.rxp = null; + + + /** + * Appends and extra tweening value to a CSSPropTween and automatically manages any prefix and suffix strings. The first extra value is stored in the s and c of the main CSSPropTween instance, but thereafter any extras are stored in the xn1, xn2, xn3, etc. The prefixes and suffixes are stored in the xs0, xs1, xs2, etc. properties. For example, if I walk through a clip value like "rect(10px, 5px, 0px, 20px)", the values would be stored like this: + * xs0:"rect(", s:10, xs1:"px, ", xn1:5, xs2:"px, ", xn2:0, xs3:"px, ", xn3:20, xn4:"px)" + * And they'd all get joined together when the CSSPlugin renders (in the setRatio() method). + * @param {string=} pfx Prefix (if any) + * @param {!number} s Starting value + * @param {!number} c Change in numeric value over the course of the entire tween. For example, if the start is 5 and the end is 100, the change would be 95. + * @param {string=} sfx Suffix (if any) + * @param {boolean=} r Round (if true). + * @param {boolean=} pad If true, this extra value should be separated by the previous one by a space. If there is no previous extra and pad is true, it will automatically drop the space. + * @return {CSSPropTween} returns itself so that multiple methods can be chained together. + */ + p.appendXtra = function(pfx, s, c, sfx, r, pad) { + var pt = this, + l = pt.l; + pt["xs" + l] += (pad && (l || pt["xs" + l])) ? " " + pfx : pfx || ""; + if (!c) if (l !== 0 && !pt.plugin) { //typically we'll combine non-changing values right into the xs to optimize performance, but we don't combine them when there's a plugin that will be tweening the values because it may depend on the values being split apart, like for a bezier, if a value doesn't change between the first and second iteration but then it does on the 3rd, we'll run into trouble because there's no xn slot for that value! + pt["xs" + l] += s + (sfx || ""); + return pt; + } + pt.l++; + pt.type = pt.setRatio ? 2 : 1; + pt["xs" + pt.l] = sfx || ""; + if (l > 0) { + pt.data["xn" + l] = s + c; + pt.rxp["xn" + l] = r; //round extra property (we need to tap into this in the _parseToProxy() method) + pt["xn" + l] = s; + if (!pt.plugin) { + pt.xfirst = new CSSPropTween(pt, "xn" + l, s, c, pt.xfirst || pt, 0, pt.n, r, pt.pr); + pt.xfirst.xs0 = 0; //just to ensure that the property stays numeric which helps modern browsers speed up processing. Remember, in the setRatio() method, we do pt.t[pt.p] = val + pt.xs0 so if pt.xs0 is "" (the default), it'll cast the end value as a string. When a property is a number sometimes and a string sometimes, it prevents the compiler from locking in the data type, slowing things down slightly. + } + return pt; + } + pt.data = {s:s + c}; + pt.rxp = {}; + pt.s = s; + pt.c = c; + pt.r = r; + return pt; + }; + + /** + * @constructor A SpecialProp is basically a css property that needs to be treated in a non-standard way, like if it may contain a complex value like boxShadow:"5px 10px 15px rgb(255, 102, 51)" or if it is associated with another plugin like ThrowPropsPlugin or BezierPlugin. Every SpecialProp is associated with a particular property name like "boxShadow" or "throwProps" or "bezier" and it will intercept those values in the vars object that's passed to the CSSPlugin and handle them accordingly. + * @param {!string} p Property name (like "boxShadow" or "throwProps") + * @param {Object=} options An object containing any of the following configuration options: + * - defaultValue: the default value + * - parser: A function that should be called when the associated property name is found in the vars. This function should return a CSSPropTween instance and it should ensure that it is properly inserted into the linked list. It will receive 4 paramters: 1) The target, 2) The value defined in the vars, 3) The CSSPlugin instance (whose _firstPT should be used for the linked list), and 4) A computed style object if one was calculated (this is a speed optimization that allows retrieval of starting values quicker) + * - formatter: a function that formats any value received for this special property (for example, boxShadow could take "5px 5px red" and format it to "5px 5px 0px 0px red" so that both the beginning and ending values have a common order and quantity of values.) + * - prefix: if true, we'll determine whether or not this property requires a vendor prefix (like Webkit or Moz or ms or O) + * - color: set this to true if the value for this SpecialProp may contain color-related values like rgb(), rgba(), etc. + * - priority: priority in the linked list order. Higher priority SpecialProps will be updated before lower priority ones. The default priority is 0. + * - multi: if true, the formatter should accommodate a comma-delimited list of values, like boxShadow could have multiple boxShadows listed out. + * - collapsible: if true, the formatter should treat the value like it's a top/right/bottom/left value that could be collapsed, like "5px" would apply to all, "5px, 10px" would use 5px for top/bottom and 10px for right/left, etc. + * - keyword: a special keyword that can [optionally] be found inside the value (like "inset" for boxShadow). This allows us to validate beginning/ending values to make sure they match (if the keyword is found in one, it'll be added to the other for consistency by default). + */ + var SpecialProp = function(p, options) { + options = options || {}; + this.p = options.prefix ? _checkPropPrefix(p) || p : p; + _specialProps[p] = _specialProps[this.p] = this; + this.format = options.formatter || _getFormatter(options.defaultValue, options.color, options.collapsible, options.multi); + if (options.parser) { + this.parse = options.parser; + } + this.clrs = options.color; + this.multi = options.multi; + this.keyword = options.keyword; + this.dflt = options.defaultValue; + this.pr = options.priority || 0; + }, + + //shortcut for creating a new SpecialProp that can accept multiple properties as a comma-delimited list (helps minification). dflt can be an array for multiple values (we don't do a comma-delimited list because the default value may contain commas, like rect(0px,0px,0px,0px)). We attach this method to the SpecialProp class/object instead of using a private _createSpecialProp() method so that we can tap into it externally if necessary, like from another plugin. + _registerComplexSpecialProp = _internals._registerComplexSpecialProp = function(p, options, defaults) { + if (typeof(options) !== "object") { + options = {parser:defaults}; //to make backwards compatible with older versions of BezierPlugin and ThrowPropsPlugin + } + var a = p.split(","), + d = options.defaultValue, + i, temp; + defaults = defaults || [d]; + for (i = 0; i < a.length; i++) { + options.prefix = (i === 0 && options.prefix); + options.defaultValue = defaults[i] || d; + temp = new SpecialProp(a[i], options); + } + }, + + //creates a placeholder special prop for a plugin so that the property gets caught the first time a tween of it is attempted, and at that time it makes the plugin register itself, thus taking over for all future tweens of that property. This allows us to not mandate that things load in a particular order and it also allows us to log() an error that informs the user when they attempt to tween an external plugin-related property without loading its .js file. + _registerPluginProp = function(p) { + if (!_specialProps[p]) { + var pluginName = p.charAt(0).toUpperCase() + p.substr(1) + "Plugin"; + _registerComplexSpecialProp(p, {parser:function(t, e, p, cssp, pt, plugin, vars) { + var pluginClass = _globals.com.greensock.plugins[pluginName]; + if (!pluginClass) { + _log("Error: " + pluginName + " js file not loaded."); + return pt; + } + pluginClass._cssRegister(); + return _specialProps[p].parse(t, e, p, cssp, pt, plugin, vars); + }}); + } + }; + + + p = SpecialProp.prototype; + + /** + * Alias for _parseComplex() that automatically plugs in certain values for this SpecialProp, like its property name, whether or not colors should be sensed, the default value, and priority. It also looks for any keyword that the SpecialProp defines (like "inset" for boxShadow) and ensures that the beginning and ending values have the same number of values for SpecialProps where multi is true (like boxShadow and textShadow can have a comma-delimited list) + * @param {!Object} t target element + * @param {(string|number|object)} b beginning value + * @param {(string|number|object)} e ending (destination) value + * @param {CSSPropTween=} pt next CSSPropTween in the linked list + * @param {TweenPlugin=} plugin If another plugin will be tweening the complex value, that TweenPlugin instance goes here. + * @param {function=} setRatio If a custom setRatio() method should be used to handle this complex value, that goes here. + * @return {CSSPropTween=} First CSSPropTween in the linked list + */ + p.parseComplex = function(t, b, e, pt, plugin, setRatio) { + var kwd = this.keyword, + i, ba, ea, l, bi, ei; + //if this SpecialProp's value can contain a comma-delimited list of values (like boxShadow or textShadow), we must parse them in a special way, and look for a keyword (like "inset" for boxShadow) and ensure that the beginning and ending BOTH have it if the end defines it as such. We also must ensure that there are an equal number of values specified (we can't tween 1 boxShadow to 3 for example) + if (this.multi) if (_commasOutsideParenExp.test(e) || _commasOutsideParenExp.test(b)) { + ba = b.replace(_commasOutsideParenExp, "|").split("|"); + ea = e.replace(_commasOutsideParenExp, "|").split("|"); + } else if (kwd) { + ba = [b]; + ea = [e]; + } + if (ea) { + l = (ea.length > ba.length) ? ea.length : ba.length; + for (i = 0; i < l; i++) { + b = ba[i] = ba[i] || this.dflt; + e = ea[i] = ea[i] || this.dflt; + if (kwd) { + bi = b.indexOf(kwd); + ei = e.indexOf(kwd); + if (bi !== ei) { + if (ei === -1) { //if the keyword isn't in the end value, remove it from the beginning one. + ba[i] = ba[i].split(kwd).join(""); + } else if (bi === -1) { //if the keyword isn't in the beginning, add it. + ba[i] += " " + kwd; + } + } + } + } + b = ba.join(", "); + e = ea.join(", "); + } + return _parseComplex(t, this.p, b, e, this.clrs, this.dflt, pt, this.pr, plugin, setRatio); + }; + + /** + * Accepts a target and end value and spits back a CSSPropTween that has been inserted into the CSSPlugin's linked list and conforms with all the conventions we use internally, like type:-1, 0, 1, or 2, setting up any extra property tweens, priority, etc. For example, if we have a boxShadow SpecialProp and call: + * this._firstPT = sp.parse(element, "5px 10px 20px rgb(2550,102,51)", "boxShadow", this); + * It should figure out the starting value of the element's boxShadow, compare it to the provided end value and create all the necessary CSSPropTweens of the appropriate types to tween the boxShadow. The CSSPropTween that gets spit back should already be inserted into the linked list (the 4th parameter is the current head, so prepend to that). + * @param {!Object} t Target object whose property is being tweened + * @param {Object} e End value as provided in the vars object (typically a string, but not always - like a throwProps would be an object). + * @param {!string} p Property name + * @param {!CSSPlugin} cssp The CSSPlugin instance that should be associated with this tween. + * @param {?CSSPropTween} pt The CSSPropTween that is the current head of the linked list (we'll prepend to it) + * @param {TweenPlugin=} plugin If a plugin will be used to tween the parsed value, this is the plugin instance. + * @param {Object=} vars Original vars object that contains the data for parsing. + * @return {CSSPropTween} The first CSSPropTween in the linked list which includes the new one(s) added by the parse() call. + */ + p.parse = function(t, e, p, cssp, pt, plugin, vars) { + return this.parseComplex(t.style, this.format(_getStyle(t, this.p, _cs, false, this.dflt)), this.format(e), pt, plugin); + }; + + /** + * Registers a special property that should be intercepted from any "css" objects defined in tweens. This allows you to handle them however you want without CSSPlugin doing it for you. The 2nd parameter should be a function that accepts 3 parameters: + * 1) Target object whose property should be tweened (typically a DOM element) + * 2) The end/destination value (could be a string, number, object, or whatever you want) + * 3) The tween instance (you probably don't need to worry about this, but it can be useful for looking up information like the duration) + * + * Then, your function should return a function which will be called each time the tween gets rendered, passing a numeric "ratio" parameter to your function that indicates the change factor (usually between 0 and 1). For example: + * + * CSSPlugin.registerSpecialProp("myCustomProp", function(target, value, tween) { + * var start = target.style.width; + * return function(ratio) { + * target.style.width = (start + value * ratio) + "px"; + * console.log("set width to " + target.style.width); + * } + * }, 0); + * + * Then, when I do this tween, it will trigger my special property: + * + * TweenLite.to(element, 1, {css:{myCustomProp:100}}); + * + * In the example, of course, we're just changing the width, but you can do anything you want. + * + * @param {!string} name Property name (or comma-delimited list of property names) that should be intercepted and handled by your function. For example, if I define "myCustomProp", then it would handle that portion of the following tween: TweenLite.to(element, 1, {css:{myCustomProp:100}}) + * @param {!function(Object, Object, Object, string):function(number)} onInitTween The function that will be called when a tween of this special property is performed. The function will receive 4 parameters: 1) Target object that should be tweened, 2) Value that was passed to the tween, 3) The tween instance itself (rarely used), and 4) The property name that's being tweened. Your function should return a function that should be called on every update of the tween. That function will receive a single parameter that is a "change factor" value (typically between 0 and 1) indicating the amount of change as a ratio. You can use this to determine how to set the values appropriately in your function. + * @param {number=} priority Priority that helps the engine determine the order in which to set the properties (default: 0). Higher priority properties will be updated before lower priority ones. + */ + CSSPlugin.registerSpecialProp = function(name, onInitTween, priority) { + _registerComplexSpecialProp(name, {parser:function(t, e, p, cssp, pt, plugin, vars) { + var rv = new CSSPropTween(t, p, 0, 0, pt, 2, p, false, priority); + rv.plugin = plugin; + rv.setRatio = onInitTween(t, e, cssp._tween, p); + return rv; + }, priority:priority}); + }; + + + + + + + //transform-related methods and properties + CSSPlugin.useSVGTransformAttr = _isSafari || _isFirefox; //Safari and Firefox both have some rendering bugs when applying CSS transforms to SVG elements, so default to using the "transform" attribute instead (users can override this). + var _transformProps = ("scaleX,scaleY,scaleZ,x,y,z,skewX,skewY,rotation,rotationX,rotationY,perspective,xPercent,yPercent").split(","), + _transformProp = _checkPropPrefix("transform"), //the Javascript (camelCase) transform property, like msTransform, WebkitTransform, MozTransform, or OTransform. + _transformPropCSS = _prefixCSS + "transform", + _transformOriginProp = _checkPropPrefix("transformOrigin"), + _supports3D = (_checkPropPrefix("perspective") !== null), + Transform = _internals.Transform = function() { + this.perspective = parseFloat(CSSPlugin.defaultTransformPerspective) || 0; + this.force3D = (CSSPlugin.defaultForce3D === false || !_supports3D) ? false : CSSPlugin.defaultForce3D || "auto"; + }, + _SVGElement = window.SVGElement, + _useSVGTransformAttr, + //Some browsers (like Firefox and IE) don't honor transform-origin properly in SVG elements, so we need to manually adjust the matrix accordingly. We feature detect here rather than always doing the conversion for certain browsers because they may fix the problem at some point in the future. + + _createSVG = function(type, container, attributes) { + var element = _doc.createElementNS("http://www.w3.org/2000/svg", type), + reg = /([a-z])([A-Z])/g, + p; + for (p in attributes) { + element.setAttributeNS(null, p.replace(reg, "$1-$2").toLowerCase(), attributes[p]); + } + container.appendChild(element); + return element; + }, + _docElement = _doc.documentElement, + _forceSVGTransformAttr = (function() { + //IE and Android stock don't support CSS transforms on SVG elements, so we must write them to the "transform" attribute. We populate this variable in the _parseTransform() method, and only if/when we come across an SVG element + var force = _ieVers || (/Android/i.test(_agent) && !window.chrome), + svg, rect, width; + if (_doc.createElementNS && !force) { //IE8 and earlier doesn't support SVG anyway + svg = _createSVG("svg", _docElement); + rect = _createSVG("rect", svg, {width:100, height:50, x:100}); + width = rect.getBoundingClientRect().width; + rect.style[_transformOriginProp] = "50% 50%"; + rect.style[_transformProp] = "scaleX(0.5)"; + force = (width === rect.getBoundingClientRect().width && !(_isFirefox && _supports3D)); //note: Firefox fails the test even though it does support CSS transforms in 3D. Since we can't push 3D stuff into the transform attribute, we force Firefox to pass the test here (as long as it does truly support 3D). + _docElement.removeChild(svg); + } + return force; + })(), + _parseSVGOrigin = function(e, local, decoratee, absolute, smoothOrigin, skipRecord) { + var tm = e._gsTransform, + m = _getMatrix(e, true), + v, x, y, xOrigin, yOrigin, a, b, c, d, tx, ty, determinant, xOriginOld, yOriginOld; + if (tm) { + xOriginOld = tm.xOrigin; //record the original values before we alter them. + yOriginOld = tm.yOrigin; + } + if (!absolute || (v = absolute.split(" ")).length < 2) { + b = e.getBBox(); + local = _parsePosition(local).split(" "); + v = [(local[0].indexOf("%") !== -1 ? parseFloat(local[0]) / 100 * b.width : parseFloat(local[0])) + b.x, + (local[1].indexOf("%") !== -1 ? parseFloat(local[1]) / 100 * b.height : parseFloat(local[1])) + b.y]; + } + decoratee.xOrigin = xOrigin = parseFloat(v[0]); + decoratee.yOrigin = yOrigin = parseFloat(v[1]); + if (absolute && m !== _identity2DMatrix) { //if svgOrigin is being set, we must invert the matrix and determine where the absolute point is, factoring in the current transforms. Otherwise, the svgOrigin would be based on the element's non-transformed position on the canvas. + a = m[0]; + b = m[1]; + c = m[2]; + d = m[3]; + tx = m[4]; + ty = m[5]; + determinant = (a * d - b * c); + x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + ((c * ty - d * tx) / determinant); + y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - ((a * ty - b * tx) / determinant); + xOrigin = decoratee.xOrigin = v[0] = x; + yOrigin = decoratee.yOrigin = v[1] = y; + } + if (tm) { //avoid jump when transformOrigin is changed - adjust the x/y values accordingly + if (skipRecord) { + decoratee.xOffset = tm.xOffset; + decoratee.yOffset = tm.yOffset; + tm = decoratee; + } + if (smoothOrigin || (smoothOrigin !== false && CSSPlugin.defaultSmoothOrigin !== false)) { + x = xOrigin - xOriginOld; + y = yOrigin - yOriginOld; + //originally, we simply adjusted the x and y values, but that would cause problems if, for example, you created a rotational tween part-way through an x/y tween. Managing the offset in a separate variable gives us ultimate flexibility. + //tm.x -= x - (x * m[0] + y * m[2]); + //tm.y -= y - (x * m[1] + y * m[3]); + tm.xOffset += (x * m[0] + y * m[2]) - x; + tm.yOffset += (x * m[1] + y * m[3]) - y; + } else { + tm.xOffset = tm.yOffset = 0; + } + } + if (!skipRecord) { + e.setAttribute("data-svg-origin", v.join(" ")); + } + }, + _canGetBBox = function(e) { + try { + return e.getBBox(); //Firefox throws errors if you try calling getBBox() on an SVG element that's not rendered (like in a or ). https://bugzilla.mozilla.org/show_bug.cgi?id=612118 + } catch (e) {} + }, + _isSVG = function(e) { //reports if the element is an SVG on which getBBox() actually works + return !!(_SVGElement && e.getBBox && e.getCTM && _canGetBBox(e) && (!e.parentNode || (e.parentNode.getBBox && e.parentNode.getCTM))); + }, + _identity2DMatrix = [1,0,0,1,0,0], + _getMatrix = function(e, force2D) { + var tm = e._gsTransform || new Transform(), + rnd = 100000, + style = e.style, + isDefault, s, m, n, dec, none; + if (_transformProp) { + s = _getStyle(e, _transformPropCSS, null, true); + } else if (e.currentStyle) { + //for older versions of IE, we need to interpret the filter portion that is in the format: progid:DXImageTransform.Microsoft.Matrix(M11=6.123233995736766e-17, M12=-1, M21=1, M22=6.123233995736766e-17, sizingMethod='auto expand') Notice that we need to swap b and c compared to a normal matrix. + s = e.currentStyle.filter.match(_ieGetMatrixExp); + s = (s && s.length === 4) ? [s[0].substr(4), Number(s[2].substr(4)), Number(s[1].substr(4)), s[3].substr(4), (tm.x || 0), (tm.y || 0)].join(",") : ""; + } + isDefault = (!s || s === "none" || s === "matrix(1, 0, 0, 1, 0, 0)"); + if (isDefault && _transformProp && ((none = (_getComputedStyle(e).display === "none")) || !e.parentNode)) { + if (none) { //browsers don't report transforms accurately unless the element is in the DOM and has a display value that's not "none". + n = style.display; + style.display = "block"; + } + if (!e.parentNode) { + dec = 1; //flag + _docElement.appendChild(e); + } + s = _getStyle(e, _transformPropCSS, null, true); + isDefault = (!s || s === "none" || s === "matrix(1, 0, 0, 1, 0, 0)"); + if (n) { + style.display = n; + } else if (none) { + _removeProp(style, "display"); + } + if (dec) { + _docElement.removeChild(e); + } + } + if (tm.svg || (e.getBBox && _isSVG(e))) { + if (isDefault && (style[_transformProp] + "").indexOf("matrix") !== -1) { //some browsers (like Chrome 40) don't correctly report transforms that are applied inline on an SVG element (they don't get included in the computed style), so we double-check here and accept matrix values + s = style[_transformProp]; + isDefault = 0; + } + m = e.getAttribute("transform"); + if (isDefault && m) { + if (m.indexOf("matrix") !== -1) { //just in case there's a "transform" value specified as an attribute instead of CSS style. Accept either a matrix() or simple translate() value though. + s = m; + isDefault = 0; + } else if (m.indexOf("translate") !== -1) { + s = "matrix(1,0,0,1," + m.match(/(?:\-|\b)[\d\-\.e]+\b/gi).join(",") + ")"; + isDefault = 0; + } + } + } + if (isDefault) { + return _identity2DMatrix; + } + //split the matrix values out into an array (m for matrix) + m = (s || "").match(_numExp) || []; + i = m.length; + while (--i > -1) { + n = Number(m[i]); + m[i] = (dec = n - (n |= 0)) ? ((dec * rnd + (dec < 0 ? -0.5 : 0.5)) | 0) / rnd + n : n; //convert strings to Numbers and round to 5 decimal places to avoid issues with tiny numbers. Roughly 20x faster than Number.toFixed(). We also must make sure to round before dividing so that values like 0.9999999999 become 1 to avoid glitches in browser rendering and interpretation of flipped/rotated 3D matrices. And don't just multiply the number by rnd, floor it, and then divide by rnd because the bitwise operations max out at a 32-bit signed integer, thus it could get clipped at a relatively low value (like 22,000.00000 for example). + } + return (force2D && m.length > 6) ? [m[0], m[1], m[4], m[5], m[12], m[13]] : m; + }, + + /** + * Parses the transform values for an element, returning an object with x, y, z, scaleX, scaleY, scaleZ, rotation, rotationX, rotationY, skewX, and skewY properties. Note: by default (for performance reasons), all skewing is combined into skewX and rotation but skewY still has a place in the transform object so that we can record how much of the skew is attributed to skewX vs skewY. Remember, a skewY of 10 looks the same as a rotation of 10 and skewX of -10. + * @param {!Object} t target element + * @param {Object=} cs computed style object (optional) + * @param {boolean=} rec if true, the transform values will be recorded to the target element's _gsTransform object, like target._gsTransform = {x:0, y:0, z:0, scaleX:1...} + * @param {boolean=} parse if true, we'll ignore any _gsTransform values that already exist on the element, and force a reparsing of the css (calculated style) + * @return {object} object containing all of the transform properties/values like {x:0, y:0, z:0, scaleX:1...} + */ + _getTransform = _internals.getTransform = function(t, cs, rec, parse) { + if (t._gsTransform && rec && !parse) { + return t._gsTransform; //if the element already has a _gsTransform, use that. Note: some browsers don't accurately return the calculated style for the transform (particularly for SVG), so it's almost always safest to just use the values we've already applied rather than re-parsing things. + } + var tm = rec ? t._gsTransform || new Transform() : new Transform(), + invX = (tm.scaleX < 0), //in order to interpret things properly, we need to know if the user applied a negative scaleX previously so that we can adjust the rotation and skewX accordingly. Otherwise, if we always interpret a flipped matrix as affecting scaleY and the user only wants to tween the scaleX on multiple sequential tweens, it would keep the negative scaleY without that being the user's intent. + min = 0.00002, + rnd = 100000, + zOrigin = _supports3D ? parseFloat(_getStyle(t, _transformOriginProp, cs, false, "0 0 0").split(" ")[2]) || tm.zOrigin || 0 : 0, + defaultTransformPerspective = parseFloat(CSSPlugin.defaultTransformPerspective) || 0, + m, i, scaleX, scaleY, rotation, skewX; + + tm.svg = !!(t.getBBox && _isSVG(t)); + if (tm.svg) { + _parseSVGOrigin(t, _getStyle(t, _transformOriginProp, cs, false, "50% 50%") + "", tm, t.getAttribute("data-svg-origin")); + _useSVGTransformAttr = CSSPlugin.useSVGTransformAttr || _forceSVGTransformAttr; + } + m = _getMatrix(t); + if (m !== _identity2DMatrix) { + + if (m.length === 16) { + //we'll only look at these position-related 6 variables first because if x/y/z all match, it's relatively safe to assume we don't need to re-parse everything which risks losing important rotational information (like rotationX:180 plus rotationY:180 would look the same as rotation:180 - there's no way to know for sure which direction was taken based solely on the matrix3d() values) + var a11 = m[0], a21 = m[1], a31 = m[2], a41 = m[3], + a12 = m[4], a22 = m[5], a32 = m[6], a42 = m[7], + a13 = m[8], a23 = m[9], a33 = m[10], + a14 = m[12], a24 = m[13], a34 = m[14], + a43 = m[11], + angle = Math.atan2(a32, a33), + t1, t2, t3, t4, cos, sin; + + //we manually compensate for non-zero z component of transformOrigin to work around bugs in Safari + if (tm.zOrigin) { + a34 = -tm.zOrigin; + a14 = a13*a34-m[12]; + a24 = a23*a34-m[13]; + a34 = a33*a34+tm.zOrigin-m[14]; + } + tm.rotationX = angle * _RAD2DEG; + //rotationX + if (angle) { + cos = Math.cos(-angle); + sin = Math.sin(-angle); + t1 = a12*cos+a13*sin; + t2 = a22*cos+a23*sin; + t3 = a32*cos+a33*sin; + a13 = a12*-sin+a13*cos; + a23 = a22*-sin+a23*cos; + a33 = a32*-sin+a33*cos; + a43 = a42*-sin+a43*cos; + a12 = t1; + a22 = t2; + a32 = t3; + } + //rotationY + angle = Math.atan2(-a31, a33); + tm.rotationY = angle * _RAD2DEG; + if (angle) { + cos = Math.cos(-angle); + sin = Math.sin(-angle); + t1 = a11*cos-a13*sin; + t2 = a21*cos-a23*sin; + t3 = a31*cos-a33*sin; + a23 = a21*sin+a23*cos; + a33 = a31*sin+a33*cos; + a43 = a41*sin+a43*cos; + a11 = t1; + a21 = t2; + a31 = t3; + } + //rotationZ + angle = Math.atan2(a21, a11); + tm.rotation = angle * _RAD2DEG; + if (angle) { + cos = Math.cos(-angle); + sin = Math.sin(-angle); + a11 = a11*cos+a12*sin; + t2 = a21*cos+a22*sin; + a22 = a21*-sin+a22*cos; + a32 = a31*-sin+a32*cos; + a21 = t2; + } + + if (tm.rotationX && Math.abs(tm.rotationX) + Math.abs(tm.rotation) > 359.9) { //when rotationY is set, it will often be parsed as 180 degrees different than it should be, and rotationX and rotation both being 180 (it looks the same), so we adjust for that here. + tm.rotationX = tm.rotation = 0; + tm.rotationY = 180 - tm.rotationY; + } + + tm.scaleX = ((Math.sqrt(a11 * a11 + a21 * a21) * rnd + 0.5) | 0) / rnd; + tm.scaleY = ((Math.sqrt(a22 * a22 + a23 * a23) * rnd + 0.5) | 0) / rnd; + tm.scaleZ = ((Math.sqrt(a32 * a32 + a33 * a33) * rnd + 0.5) | 0) / rnd; + if (tm.rotationX || tm.rotationY) { + tm.skewX = 0; + } else { + tm.skewX = (a12 || a22) ? Math.atan2(a12, a22) * _RAD2DEG + tm.rotation : tm.skewX || 0; + if (Math.abs(tm.skewX) > 90 && Math.abs(tm.skewX) < 270) { + if (invX) { + tm.scaleX *= -1; + tm.skewX += (tm.rotation <= 0) ? 180 : -180; + tm.rotation += (tm.rotation <= 0) ? 180 : -180; + } else { + tm.scaleY *= -1; + tm.skewX += (tm.skewX <= 0) ? 180 : -180; + } + } + } + tm.perspective = a43 ? 1 / ((a43 < 0) ? -a43 : a43) : 0; + tm.x = a14; + tm.y = a24; + tm.z = a34; + if (tm.svg) { + tm.x -= tm.xOrigin - (tm.xOrigin * a11 - tm.yOrigin * a12); + tm.y -= tm.yOrigin - (tm.yOrigin * a21 - tm.xOrigin * a22); + } + + } else if ((!_supports3D || parse || !m.length || tm.x !== m[4] || tm.y !== m[5] || (!tm.rotationX && !tm.rotationY))) { //sometimes a 6-element matrix is returned even when we performed 3D transforms, like if rotationX and rotationY are 180. In cases like this, we still need to honor the 3D transforms. If we just rely on the 2D info, it could affect how the data is interpreted, like scaleY might get set to -1 or rotation could get offset by 180 degrees. For example, do a TweenLite.to(element, 1, {css:{rotationX:180, rotationY:180}}) and then later, TweenLite.to(element, 1, {css:{rotationX:0}}) and without this conditional logic in place, it'd jump to a state of being unrotated when the 2nd tween starts. Then again, we need to honor the fact that the user COULD alter the transforms outside of CSSPlugin, like by manually applying new css, so we try to sense that by looking at x and y because if those changed, we know the changes were made outside CSSPlugin and we force a reinterpretation of the matrix values. Also, in Webkit browsers, if the element's "display" is "none", its calculated style value will always return empty, so if we've already recorded the values in the _gsTransform object, we'll just rely on those. + var k = (m.length >= 6), + a = k ? m[0] : 1, + b = m[1] || 0, + c = m[2] || 0, + d = k ? m[3] : 1; + tm.x = m[4] || 0; + tm.y = m[5] || 0; + scaleX = Math.sqrt(a * a + b * b); + scaleY = Math.sqrt(d * d + c * c); + rotation = (a || b) ? Math.atan2(b, a) * _RAD2DEG : tm.rotation || 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist). + skewX = (c || d) ? Math.atan2(c, d) * _RAD2DEG + rotation : tm.skewX || 0; + if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) { + if (invX) { + scaleX *= -1; + skewX += (rotation <= 0) ? 180 : -180; + rotation += (rotation <= 0) ? 180 : -180; + } else { + scaleY *= -1; + skewX += (skewX <= 0) ? 180 : -180; + } + } + tm.scaleX = scaleX; + tm.scaleY = scaleY; + tm.rotation = rotation; + tm.skewX = skewX; + if (_supports3D) { + tm.rotationX = tm.rotationY = tm.z = 0; + tm.perspective = defaultTransformPerspective; + tm.scaleZ = 1; + } + if (tm.svg) { + tm.x -= tm.xOrigin - (tm.xOrigin * a + tm.yOrigin * c); + tm.y -= tm.yOrigin - (tm.xOrigin * b + tm.yOrigin * d); + } + } + tm.zOrigin = zOrigin; + //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 0 in these cases. The conditional logic here is faster than calling Math.abs(). Also, browsers tend to render a SLIGHTLY rotated object in a fuzzy way, so we need to snap to exactly 0 when appropriate. + for (i in tm) { + if (tm[i] < min) if (tm[i] > -min) { + tm[i] = 0; + } + } + } + //DEBUG: _log("parsed rotation of " + t.getAttribute("id")+": "+(tm.rotationX)+", "+(tm.rotationY)+", "+(tm.rotation)+", scale: "+tm.scaleX+", "+tm.scaleY+", "+tm.scaleZ+", position: "+tm.x+", "+tm.y+", "+tm.z+", perspective: "+tm.perspective+ ", origin: "+ tm.xOrigin+ ","+ tm.yOrigin); + if (rec) { + t._gsTransform = tm; //record to the object's _gsTransform which we use so that tweens can control individual properties independently (we need all the properties to accurately recompose the matrix in the setRatio() method) + if (tm.svg) { //if we're supposed to apply transforms to the SVG element's "transform" attribute, make sure there aren't any CSS transforms applied or they'll override the attribute ones. Also clear the transform attribute if we're using CSS, just to be clean. + if (_useSVGTransformAttr && t.style[_transformProp]) { + TweenLite.delayedCall(0.001, function(){ //if we apply this right away (before anything has rendered), we risk there being no transforms for a brief moment and it also interferes with adjusting the transformOrigin in a tween with immediateRender:true (it'd try reading the matrix and it wouldn't have the appropriate data in place because we just removed it). + _removeProp(t.style, _transformProp); + }); + } else if (!_useSVGTransformAttr && t.getAttribute("transform")) { + TweenLite.delayedCall(0.001, function(){ + t.removeAttribute("transform"); + }); + } + } + } + return tm; + }, + + //for setting 2D transforms in IE6, IE7, and IE8 (must use a "filter" to emulate the behavior of modern day browser transforms) + _setIETransformRatio = function(v) { + var t = this.data, //refers to the element's _gsTransform object + ang = -t.rotation * _DEG2RAD, + skew = ang + t.skewX * _DEG2RAD, + rnd = 100000, + a = ((Math.cos(ang) * t.scaleX * rnd) | 0) / rnd, + b = ((Math.sin(ang) * t.scaleX * rnd) | 0) / rnd, + c = ((Math.sin(skew) * -t.scaleY * rnd) | 0) / rnd, + d = ((Math.cos(skew) * t.scaleY * rnd) | 0) / rnd, + style = this.t.style, + cs = this.t.currentStyle, + filters, val; + if (!cs) { + return; + } + val = b; //just for swapping the variables an inverting them (reused "val" to avoid creating another variable in memory). IE's filter matrix uses a non-standard matrix configuration (angle goes the opposite way, and b and c are reversed and inverted) + b = -c; + c = -val; + filters = cs.filter; + style.filter = ""; //remove filters so that we can accurately measure offsetWidth/offsetHeight + var w = this.t.offsetWidth, + h = this.t.offsetHeight, + clip = (cs.position !== "absolute"), + m = "progid:DXImageTransform.Microsoft.Matrix(M11=" + a + ", M12=" + b + ", M21=" + c + ", M22=" + d, + ox = t.x + (w * t.xPercent / 100), + oy = t.y + (h * t.yPercent / 100), + dx, dy; + + //if transformOrigin is being used, adjust the offset x and y + if (t.ox != null) { + dx = ((t.oxp) ? w * t.ox * 0.01 : t.ox) - w / 2; + dy = ((t.oyp) ? h * t.oy * 0.01 : t.oy) - h / 2; + ox += dx - (dx * a + dy * b); + oy += dy - (dx * c + dy * d); + } + + if (!clip) { + m += ", sizingMethod='auto expand')"; + } else { + dx = (w / 2); + dy = (h / 2); + //translate to ensure that transformations occur around the correct origin (default is center). + m += ", Dx=" + (dx - (dx * a + dy * b) + ox) + ", Dy=" + (dy - (dx * c + dy * d) + oy) + ")"; + } + if (filters.indexOf("DXImageTransform.Microsoft.Matrix(") !== -1) { + style.filter = filters.replace(_ieSetMatrixExp, m); + } else { + style.filter = m + " " + filters; //we must always put the transform/matrix FIRST (before alpha(opacity=xx)) to avoid an IE bug that slices part of the object when rotation is applied with alpha. + } + + //at the end or beginning of the tween, if the matrix is normal (1, 0, 0, 1) and opacity is 100 (or doesn't exist), remove the filter to improve browser performance. + if (v === 0 || v === 1) if (a === 1) if (b === 0) if (c === 0) if (d === 1) if (!clip || m.indexOf("Dx=0, Dy=0") !== -1) if (!_opacityExp.test(filters) || parseFloat(RegExp.$1) === 100) if (filters.indexOf("gradient(" && filters.indexOf("Alpha")) === -1) { + style.removeAttribute("filter"); + } + + //we must set the margins AFTER applying the filter in order to avoid some bugs in IE8 that could (in rare scenarios) cause them to be ignored intermittently (vibration). + if (!clip) { + var mult = (_ieVers < 8) ? 1 : -1, //in Internet Explorer 7 and before, the box model is broken, causing the browser to treat the width/height of the actual rotated filtered image as the width/height of the box itself, but Microsoft corrected that in IE8. We must use a negative offset in IE8 on the right/bottom + marg, prop, dif; + dx = t.ieOffsetX || 0; + dy = t.ieOffsetY || 0; + t.ieOffsetX = Math.round((w - ((a < 0 ? -a : a) * w + (b < 0 ? -b : b) * h)) / 2 + ox); + t.ieOffsetY = Math.round((h - ((d < 0 ? -d : d) * h + (c < 0 ? -c : c) * w)) / 2 + oy); + for (i = 0; i < 4; i++) { + prop = _margins[i]; + marg = cs[prop]; + //we need to get the current margin in case it is being tweened separately (we want to respect that tween's changes) + val = (marg.indexOf("px") !== -1) ? parseFloat(marg) : _convertToPixels(this.t, prop, parseFloat(marg), marg.replace(_suffixExp, "")) || 0; + if (val !== t[prop]) { + dif = (i < 2) ? -t.ieOffsetX : -t.ieOffsetY; //if another tween is controlling a margin, we cannot only apply the difference in the ieOffsets, so we essentially zero-out the dx and dy here in that case. We record the margin(s) later so that we can keep comparing them, making this code very flexible. + } else { + dif = (i < 2) ? dx - t.ieOffsetX : dy - t.ieOffsetY; + } + style[prop] = (t[prop] = Math.round( val - dif * ((i === 0 || i === 2) ? 1 : mult) )) + "px"; + } + } + }, + + /* translates a super small decimal to a string WITHOUT scientific notation + _safeDecimal = function(n) { + var s = (n < 0 ? -n : n) + "", + a = s.split("e-"); + return (n < 0 ? "-0." : "0.") + new Array(parseInt(a[1], 10) || 0).join("0") + a[0].split(".").join(""); + }, + */ + + _setTransformRatio = _internals.set3DTransformRatio = _internals.setTransformRatio = function(v) { + var t = this.data, //refers to the element's _gsTransform object + style = this.t.style, + angle = t.rotation, + rotationX = t.rotationX, + rotationY = t.rotationY, + sx = t.scaleX, + sy = t.scaleY, + sz = t.scaleZ, + x = t.x, + y = t.y, + z = t.z, + isSVG = t.svg, + perspective = t.perspective, + force3D = t.force3D, + a11, a12, a13, a21, a22, a23, a31, a32, a33, a41, a42, a43, + zOrigin, min, cos, sin, t1, t2, transform, comma, zero, skew, rnd; + //check to see if we should render as 2D (and SVGs must use 2D when _useSVGTransformAttr is true) + if (((((v === 1 || v === 0) && force3D === "auto" && (this.tween._totalTime === this.tween._totalDuration || !this.tween._totalTime)) || !force3D) && !z && !perspective && !rotationY && !rotationX && sz === 1) || (_useSVGTransformAttr && isSVG) || !_supports3D) { //on the final render (which could be 0 for a from tween), if there are no 3D aspects, render in 2D to free up memory and improve performance especially on mobile devices. Check the tween's totalTime/totalDuration too in order to make sure it doesn't happen between repeats if it's a repeating tween. + + //2D + if (angle || t.skewX || isSVG) { + angle *= _DEG2RAD; + skew = t.skewX * _DEG2RAD; + rnd = 100000; + a11 = Math.cos(angle) * sx; + a21 = Math.sin(angle) * sx; + a12 = Math.sin(angle - skew) * -sy; + a22 = Math.cos(angle - skew) * sy; + if (skew && t.skewType === "simple") { //by default, we compensate skewing on the other axis to make it look more natural, but you can set the skewType to "simple" to use the uncompensated skewing that CSS does + t1 = Math.tan(skew); + t1 = Math.sqrt(1 + t1 * t1); + a12 *= t1; + a22 *= t1; + if (t.skewY) { + a11 *= t1; + a21 *= t1; + } + } + if (isSVG) { + x += t.xOrigin - (t.xOrigin * a11 + t.yOrigin * a12) + t.xOffset; + y += t.yOrigin - (t.xOrigin * a21 + t.yOrigin * a22) + t.yOffset; + if (_useSVGTransformAttr && (t.xPercent || t.yPercent)) { //The SVG spec doesn't support percentage-based translation in the "transform" attribute, so we merge it into the matrix to simulate it. + min = this.t.getBBox(); + x += t.xPercent * 0.01 * min.width; + y += t.yPercent * 0.01 * min.height; + } + min = 0.000001; + if (x < min) if (x > -min) { + x = 0; + } + if (y < min) if (y > -min) { + y = 0; + } + } + transform = (((a11 * rnd) | 0) / rnd) + "," + (((a21 * rnd) | 0) / rnd) + "," + (((a12 * rnd) | 0) / rnd) + "," + (((a22 * rnd) | 0) / rnd) + "," + x + "," + y + ")"; + if (isSVG && _useSVGTransformAttr) { + this.t.setAttribute("transform", "matrix(" + transform); + } else { + //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 5 decimal places. + style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix(" : "matrix(") + transform; + } + } else { + style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix(" : "matrix(") + sx + ",0,0," + sy + "," + x + "," + y + ")"; + } + return; + + } + if (_isFirefox) { //Firefox has a bug (at least in v25) that causes it to render the transparent part of 32-bit PNG images as black when displayed inside an iframe and the 3D scale is very small and doesn't change sufficiently enough between renders (like if you use a Power4.easeInOut to scale from 0 to 1 where the beginning values only change a tiny amount to begin the tween before accelerating). In this case, we force the scale to be 0.00002 instead which is visually the same but works around the Firefox issue. + min = 0.0001; + if (sx < min && sx > -min) { + sx = sz = 0.00002; + } + if (sy < min && sy > -min) { + sy = sz = 0.00002; + } + if (perspective && !t.z && !t.rotationX && !t.rotationY) { //Firefox has a bug that causes elements to have an odd super-thin, broken/dotted black border on elements that have a perspective set but aren't utilizing 3D space (no rotationX, rotationY, or z). + perspective = 0; + } + } + if (angle || t.skewX) { + angle *= _DEG2RAD; + cos = a11 = Math.cos(angle); + sin = a21 = Math.sin(angle); + if (t.skewX) { + angle -= t.skewX * _DEG2RAD; + cos = Math.cos(angle); + sin = Math.sin(angle); + if (t.skewType === "simple") { //by default, we compensate skewing on the other axis to make it look more natural, but you can set the skewType to "simple" to use the uncompensated skewing that CSS does + t1 = Math.tan(t.skewX * _DEG2RAD); + t1 = Math.sqrt(1 + t1 * t1); + cos *= t1; + sin *= t1; + if (t.skewY) { + a11 *= t1; + a21 *= t1; + } + } + } + a12 = -sin; + a22 = cos; + + } else if (!rotationY && !rotationX && sz === 1 && !perspective && !isSVG) { //if we're only translating and/or 2D scaling, this is faster... + style[_transformProp] = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) translate3d(" : "translate3d(") + x + "px," + y + "px," + z +"px)" + ((sx !== 1 || sy !== 1) ? " scale(" + sx + "," + sy + ")" : ""); + return; + } else { + a11 = a22 = 1; + a12 = a21 = 0; + } + // KEY INDEX AFFECTS + // a11 0 rotation, rotationY, scaleX + // a21 1 rotation, rotationY, scaleX + // a31 2 rotationY, scaleX + // a41 3 rotationY, scaleX + // a12 4 rotation, skewX, rotationX, scaleY + // a22 5 rotation, skewX, rotationX, scaleY + // a32 6 rotationX, scaleY + // a42 7 rotationX, scaleY + // a13 8 rotationY, rotationX, scaleZ + // a23 9 rotationY, rotationX, scaleZ + // a33 10 rotationY, rotationX, scaleZ + // a43 11 rotationY, rotationX, perspective, scaleZ + // a14 12 x, zOrigin, svgOrigin + // a24 13 y, zOrigin, svgOrigin + // a34 14 z, zOrigin + // a44 15 + // rotation: Math.atan2(a21, a11) + // rotationY: Math.atan2(a13, a33) (or Math.atan2(a13, a11)) + // rotationX: Math.atan2(a32, a33) + a33 = 1; + a13 = a23 = a31 = a32 = a41 = a42 = 0; + a43 = (perspective) ? -1 / perspective : 0; + zOrigin = t.zOrigin; + min = 0.000001; //threshold below which browsers use scientific notation which won't work. + comma = ","; + zero = "0"; + angle = rotationY * _DEG2RAD; + if (angle) { + cos = Math.cos(angle); + sin = Math.sin(angle); + a31 = -sin; + a41 = a43*-sin; + a13 = a11*sin; + a23 = a21*sin; + a33 = cos; + a43 *= cos; + a11 *= cos; + a21 *= cos; + } + angle = rotationX * _DEG2RAD; + if (angle) { + cos = Math.cos(angle); + sin = Math.sin(angle); + t1 = a12*cos+a13*sin; + t2 = a22*cos+a23*sin; + a32 = a33*sin; + a42 = a43*sin; + a13 = a12*-sin+a13*cos; + a23 = a22*-sin+a23*cos; + a33 = a33*cos; + a43 = a43*cos; + a12 = t1; + a22 = t2; + } + if (sz !== 1) { + a13*=sz; + a23*=sz; + a33*=sz; + a43*=sz; + } + if (sy !== 1) { + a12*=sy; + a22*=sy; + a32*=sy; + a42*=sy; + } + if (sx !== 1) { + a11*=sx; + a21*=sx; + a31*=sx; + a41*=sx; + } + + if (zOrigin || isSVG) { + if (zOrigin) { + x += a13*-zOrigin; + y += a23*-zOrigin; + z += a33*-zOrigin+zOrigin; + } + if (isSVG) { //due to bugs in some browsers, we need to manage the transform-origin of SVG manually + x += t.xOrigin - (t.xOrigin * a11 + t.yOrigin * a12) + t.xOffset; + y += t.yOrigin - (t.xOrigin * a21 + t.yOrigin * a22) + t.yOffset; + } + if (x < min && x > -min) { + x = zero; + } + if (y < min && y > -min) { + y = zero; + } + if (z < min && z > -min) { + z = 0; //don't use string because we calculate perspective later and need the number. + } + } + + //optimized way of concatenating all the values into a string. If we do it all in one shot, it's slower because of the way browsers have to create temp strings and the way it affects memory. If we do it piece-by-piece with +=, it's a bit slower too. We found that doing it in these sized chunks works best overall: + transform = ((t.xPercent || t.yPercent) ? "translate(" + t.xPercent + "%," + t.yPercent + "%) matrix3d(" : "matrix3d("); + transform += ((a11 < min && a11 > -min) ? zero : a11) + comma + ((a21 < min && a21 > -min) ? zero : a21) + comma + ((a31 < min && a31 > -min) ? zero : a31); + transform += comma + ((a41 < min && a41 > -min) ? zero : a41) + comma + ((a12 < min && a12 > -min) ? zero : a12) + comma + ((a22 < min && a22 > -min) ? zero : a22); + if (rotationX || rotationY || sz !== 1) { //performance optimization (often there's no rotationX or rotationY, so we can skip these calculations) + transform += comma + ((a32 < min && a32 > -min) ? zero : a32) + comma + ((a42 < min && a42 > -min) ? zero : a42) + comma + ((a13 < min && a13 > -min) ? zero : a13); + transform += comma + ((a23 < min && a23 > -min) ? zero : a23) + comma + ((a33 < min && a33 > -min) ? zero : a33) + comma + ((a43 < min && a43 > -min) ? zero : a43) + comma; + } else { + transform += ",0,0,0,0,1,0,"; + } + transform += x + comma + y + comma + z + comma + (perspective ? (1 + (-z / perspective)) : 1) + ")"; + + style[_transformProp] = transform; + }; + + p = Transform.prototype; + p.x = p.y = p.z = p.skewX = p.skewY = p.rotation = p.rotationX = p.rotationY = p.zOrigin = p.xPercent = p.yPercent = p.xOffset = p.yOffset = 0; + p.scaleX = p.scaleY = p.scaleZ = 1; + + _registerComplexSpecialProp("transform,scale,scaleX,scaleY,scaleZ,x,y,z,rotation,rotationX,rotationY,rotationZ,skewX,skewY,shortRotation,shortRotationX,shortRotationY,shortRotationZ,transformOrigin,svgOrigin,transformPerspective,directionalRotation,parseTransform,force3D,skewType,xPercent,yPercent,smoothOrigin", {parser:function(t, e, p, cssp, pt, plugin, vars) { + if (cssp._lastParsedTransform === vars) { return pt; } //only need to parse the transform once, and only if the browser supports it. + cssp._lastParsedTransform = vars; + var originalGSTransform = t._gsTransform, + style = t.style, + min = 0.000001, + i = _transformProps.length, + v = vars, + endRotations = {}, + transformOriginString = "transformOrigin", + m1 = _getTransform(t, _cs, true, vars.parseTransform), + m2, copy, orig, has3D, hasChange, dr, x, y, matrix; + cssp._transform = m1; + if (typeof(v.transform) === "string" && _transformProp) { //for values like transform:"rotate(60deg) scale(0.5, 0.8)" + copy = _tempDiv.style; //don't use the original target because it might be SVG in which case some browsers don't report computed style correctly. + copy[_transformProp] = v.transform; + copy.display = "block"; //if display is "none", the browser often refuses to report the transform properties correctly. + copy.position = "absolute"; + _doc.body.appendChild(_tempDiv); + m2 = _getTransform(_tempDiv, null, false); + if (m1.svg) { //if it's an SVG element, x/y part of the matrix will be affected by whatever we use as the origin and the offsets, so compensate here... + x = m1.xOrigin; + y = m1.yOrigin; + m2.x -= m1.xOffset; + m2.y -= m1.yOffset; + if (v.transformOrigin || v.svgOrigin) { //if this tween is altering the origin, we must factor that in here. The actual work of recording the transformOrigin values and setting up the PropTween is done later (still inside this function) so we cannot leave the changes intact here - we only want to update the x/y accordingly. + orig = {}; + _parseSVGOrigin(t, _parsePosition(v.transformOrigin), orig, v.svgOrigin, v.smoothOrigin, true); + x = orig.xOrigin; + y = orig.yOrigin; + m2.x -= orig.xOffset - m1.xOffset; + m2.y -= orig.yOffset - m1.yOffset; + } + if (x || y) { + matrix = _getMatrix(_tempDiv, true); + m2.x -= x - (x * matrix[0] + y * matrix[2]); + m2.y -= y - (x * matrix[1] + y * matrix[3]); + } + } + _doc.body.removeChild(_tempDiv); + if (!m2.perspective) { + m2.perspective = m1.perspective; //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case. + } + if (v.xPercent != null) { + m2.xPercent = _parseVal(v.xPercent, m1.xPercent); + } + if (v.yPercent != null) { + m2.yPercent = _parseVal(v.yPercent, m1.yPercent); + } + } else if (typeof(v) === "object") { //for values like scaleX, scaleY, rotation, x, y, skewX, and skewY or transform:{...} (object) + m2 = {scaleX:_parseVal((v.scaleX != null) ? v.scaleX : v.scale, m1.scaleX), + scaleY:_parseVal((v.scaleY != null) ? v.scaleY : v.scale, m1.scaleY), + scaleZ:_parseVal(v.scaleZ, m1.scaleZ), + x:_parseVal(v.x, m1.x), + y:_parseVal(v.y, m1.y), + z:_parseVal(v.z, m1.z), + xPercent:_parseVal(v.xPercent, m1.xPercent), + yPercent:_parseVal(v.yPercent, m1.yPercent), + perspective:_parseVal(v.transformPerspective, m1.perspective)}; + dr = v.directionalRotation; + if (dr != null) { + if (typeof(dr) === "object") { + for (copy in dr) { + v[copy] = dr[copy]; + } + } else { + v.rotation = dr; + } + } + if (typeof(v.x) === "string" && v.x.indexOf("%") !== -1) { + m2.x = 0; + m2.xPercent = _parseVal(v.x, m1.xPercent); + } + if (typeof(v.y) === "string" && v.y.indexOf("%") !== -1) { + m2.y = 0; + m2.yPercent = _parseVal(v.y, m1.yPercent); + } + + m2.rotation = _parseAngle(("rotation" in v) ? v.rotation : ("shortRotation" in v) ? v.shortRotation + "_short" : ("rotationZ" in v) ? v.rotationZ : m1.rotation - m1.skewY, m1.rotation - m1.skewY, "rotation", endRotations); //see notes below about skewY for why we subtract it from rotation here + if (_supports3D) { + m2.rotationX = _parseAngle(("rotationX" in v) ? v.rotationX : ("shortRotationX" in v) ? v.shortRotationX + "_short" : m1.rotationX || 0, m1.rotationX, "rotationX", endRotations); + m2.rotationY = _parseAngle(("rotationY" in v) ? v.rotationY : ("shortRotationY" in v) ? v.shortRotationY + "_short" : m1.rotationY || 0, m1.rotationY, "rotationY", endRotations); + } + m2.skewX = _parseAngle(v.skewX, m1.skewX - m1.skewY); //see notes below about skewY and why we subtract it from skewX here + + //note: for performance reasons, we combine all skewing into the skewX and rotation values, ignoring skewY but we must still record it so that we can discern how much of the overall skew is attributed to skewX vs. skewY. Otherwise, if the skewY would always act relative (tween skewY to 10deg, for example, multiple times and if we always combine things into skewX, we can't remember that skewY was 10 from last time). Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of -10 degrees. + if ((m2.skewY = _parseAngle(v.skewY, m1.skewY))) { + m2.skewX += m2.skewY; + m2.rotation += m2.skewY; + } + } + if (_supports3D && v.force3D != null) { + m1.force3D = v.force3D; + hasChange = true; + } + + m1.skewType = v.skewType || m1.skewType || CSSPlugin.defaultSkewType; + + has3D = (m1.force3D || m1.z || m1.rotationX || m1.rotationY || m2.z || m2.rotationX || m2.rotationY || m2.perspective); + if (!has3D && v.scale != null) { + m2.scaleZ = 1; //no need to tween scaleZ. + } + + while (--i > -1) { + p = _transformProps[i]; + orig = m2[p] - m1[p]; + if (orig > min || orig < -min || v[p] != null || _forcePT[p] != null) { + hasChange = true; + pt = new CSSPropTween(m1, p, m1[p], orig, pt); + if (p in endRotations) { + pt.e = endRotations[p]; //directional rotations typically have compensated values during the tween, but we need to make sure they end at exactly what the user requested + } + pt.xs0 = 0; //ensures the value stays numeric in setRatio() + pt.plugin = plugin; + cssp._overwriteProps.push(pt.n); + } + } + + orig = v.transformOrigin; + if (m1.svg && (orig || v.svgOrigin)) { + x = m1.xOffset; //when we change the origin, in order to prevent things from jumping we adjust the x/y so we must record those here so that we can create PropTweens for them and flip them at the same time as the origin + y = m1.yOffset; + _parseSVGOrigin(t, _parsePosition(orig), m2, v.svgOrigin, v.smoothOrigin); + pt = _addNonTweeningNumericPT(m1, "xOrigin", (originalGSTransform ? m1 : m2).xOrigin, m2.xOrigin, pt, transformOriginString); //note: if there wasn't a transformOrigin defined yet, just start with the destination one; it's wasteful otherwise, and it causes problems with fromTo() tweens. For example, TweenLite.to("#wheel", 3, {rotation:180, transformOrigin:"50% 50%", delay:1}); TweenLite.fromTo("#wheel", 3, {scale:0.5, transformOrigin:"50% 50%"}, {scale:1, delay:2}); would cause a jump when the from values revert at the beginning of the 2nd tween. + pt = _addNonTweeningNumericPT(m1, "yOrigin", (originalGSTransform ? m1 : m2).yOrigin, m2.yOrigin, pt, transformOriginString); + if (x !== m1.xOffset || y !== m1.yOffset) { + pt = _addNonTweeningNumericPT(m1, "xOffset", (originalGSTransform ? x : m1.xOffset), m1.xOffset, pt, transformOriginString); + pt = _addNonTweeningNumericPT(m1, "yOffset", (originalGSTransform ? y : m1.yOffset), m1.yOffset, pt, transformOriginString); + } + orig = _useSVGTransformAttr ? null : "0px 0px"; //certain browsers (like firefox) completely botch transform-origin, so we must remove it to prevent it from contaminating transforms. We manage it ourselves with xOrigin and yOrigin + } + if (orig || (_supports3D && has3D && m1.zOrigin)) { //if anything 3D is happening and there's a transformOrigin with a z component that's non-zero, we must ensure that the transformOrigin's z-component is set to 0 so that we can manually do those calculations to get around Safari bugs. Even if the user didn't specifically define a "transformOrigin" in this particular tween (maybe they did it via css directly). + if (_transformProp) { + hasChange = true; + p = _transformOriginProp; + orig = (orig || _getStyle(t, p, _cs, false, "50% 50%")) + ""; //cast as string to avoid errors + pt = new CSSPropTween(style, p, 0, 0, pt, -1, transformOriginString); + pt.b = style[p]; + pt.plugin = plugin; + if (_supports3D) { + copy = m1.zOrigin; + orig = orig.split(" "); + m1.zOrigin = ((orig.length > 2 && !(copy !== 0 && orig[2] === "0px")) ? parseFloat(orig[2]) : copy) || 0; //Safari doesn't handle the z part of transformOrigin correctly, so we'll manually handle it in the _set3DTransformRatio() method. + pt.xs0 = pt.e = orig[0] + " " + (orig[1] || "50%") + " 0px"; //we must define a z value of 0px specifically otherwise iOS 5 Safari will stick with the old one (if one was defined)! + pt = new CSSPropTween(m1, "zOrigin", 0, 0, pt, -1, pt.n); //we must create a CSSPropTween for the _gsTransform.zOrigin so that it gets reset properly at the beginning if the tween runs backward (as opposed to just setting m1.zOrigin here) + pt.b = copy; + pt.xs0 = pt.e = m1.zOrigin; + } else { + pt.xs0 = pt.e = orig; + } + + //for older versions of IE (6-8), we need to manually calculate things inside the setRatio() function. We record origin x and y (ox and oy) and whether or not the values are percentages (oxp and oyp). + } else { + _parsePosition(orig + "", m1); + } + } + if (hasChange) { + cssp._transformType = (!(m1.svg && _useSVGTransformAttr) && (has3D || this._transformType === 3)) ? 3 : 2; //quicker than calling cssp._enableTransforms(); + } + return pt; + }, prefix:true}); + + _registerComplexSpecialProp("boxShadow", {defaultValue:"0px 0px 0px 0px #999", prefix:true, color:true, multi:true, keyword:"inset"}); + + _registerComplexSpecialProp("borderRadius", {defaultValue:"0px", parser:function(t, e, p, cssp, pt, plugin) { + e = this.format(e); + var props = ["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"], + style = t.style, + ea1, i, es2, bs2, bs, es, bn, en, w, h, esfx, bsfx, rel, hn, vn, em; + w = parseFloat(t.offsetWidth); + h = parseFloat(t.offsetHeight); + ea1 = e.split(" "); + for (i = 0; i < props.length; i++) { //if we're dealing with percentages, we must convert things separately for the horizontal and vertical axis! + if (this.p.indexOf("border")) { //older browsers used a prefix + props[i] = _checkPropPrefix(props[i]); + } + bs = bs2 = _getStyle(t, props[i], _cs, false, "0px"); + if (bs.indexOf(" ") !== -1) { + bs2 = bs.split(" "); + bs = bs2[0]; + bs2 = bs2[1]; + } + es = es2 = ea1[i]; + bn = parseFloat(bs); + bsfx = bs.substr((bn + "").length); + rel = (es.charAt(1) === "="); + if (rel) { + en = parseInt(es.charAt(0)+"1", 10); + es = es.substr(2); + en *= parseFloat(es); + esfx = es.substr((en + "").length - (en < 0 ? 1 : 0)) || ""; + } else { + en = parseFloat(es); + esfx = es.substr((en + "").length); + } + if (esfx === "") { + esfx = _suffixMap[p] || bsfx; + } + if (esfx !== bsfx) { + hn = _convertToPixels(t, "borderLeft", bn, bsfx); //horizontal number (we use a bogus "borderLeft" property just because the _convertToPixels() method searches for the keywords "Left", "Right", "Top", and "Bottom" to determine of it's a horizontal or vertical property, and we need "border" in the name so that it knows it should measure relative to the element itself, not its parent. + vn = _convertToPixels(t, "borderTop", bn, bsfx); //vertical number + if (esfx === "%") { + bs = (hn / w * 100) + "%"; + bs2 = (vn / h * 100) + "%"; + } else if (esfx === "em") { + em = _convertToPixels(t, "borderLeft", 1, "em"); + bs = (hn / em) + "em"; + bs2 = (vn / em) + "em"; + } else { + bs = hn + "px"; + bs2 = vn + "px"; + } + if (rel) { + es = (parseFloat(bs) + en) + esfx; + es2 = (parseFloat(bs2) + en) + esfx; + } + } + pt = _parseComplex(style, props[i], bs + " " + bs2, es + " " + es2, false, "0px", pt); + } + return pt; + }, prefix:true, formatter:_getFormatter("0px 0px 0px 0px", false, true)}); + _registerComplexSpecialProp("borderBottomLeftRadius,borderBottomRightRadius,borderTopLeftRadius,borderTopRightRadius", {defaultValue:"0px", parser:function(t, e, p, cssp, pt, plugin) { + return _parseComplex(t.style, p, this.format(_getStyle(t, p, _cs, false, "0px 0px")), this.format(e), false, "0px", pt); + }, prefix:true, formatter:_getFormatter("0px 0px", false, true)}); + _registerComplexSpecialProp("backgroundPosition", {defaultValue:"0 0", parser:function(t, e, p, cssp, pt, plugin) { + var bp = "background-position", + cs = (_cs || _getComputedStyle(t, null)), + bs = this.format( ((cs) ? _ieVers ? cs.getPropertyValue(bp + "-x") + " " + cs.getPropertyValue(bp + "-y") : cs.getPropertyValue(bp) : t.currentStyle.backgroundPositionX + " " + t.currentStyle.backgroundPositionY) || "0 0"), //Internet Explorer doesn't report background-position correctly - we must query background-position-x and background-position-y and combine them (even in IE10). Before IE9, we must do the same with the currentStyle object and use camelCase + es = this.format(e), + ba, ea, i, pct, overlap, src; + if ((bs.indexOf("%") !== -1) !== (es.indexOf("%") !== -1) && es.split(",").length < 2) { + src = _getStyle(t, "backgroundImage").replace(_urlExp, ""); + if (src && src !== "none") { + ba = bs.split(" "); + ea = es.split(" "); + _tempImg.setAttribute("src", src); //set the temp IMG's src to the background-image so that we can measure its width/height + i = 2; + while (--i > -1) { + bs = ba[i]; + pct = (bs.indexOf("%") !== -1); + if (pct !== (ea[i].indexOf("%") !== -1)) { + overlap = (i === 0) ? t.offsetWidth - _tempImg.width : t.offsetHeight - _tempImg.height; + ba[i] = pct ? (parseFloat(bs) / 100 * overlap) + "px" : (parseFloat(bs) / overlap * 100) + "%"; + } + } + bs = ba.join(" "); + } + } + return this.parseComplex(t.style, bs, es, pt, plugin); + }, formatter:_parsePosition}); + _registerComplexSpecialProp("backgroundSize", {defaultValue:"0 0", formatter:_parsePosition}); + _registerComplexSpecialProp("perspective", {defaultValue:"0px", prefix:true}); + _registerComplexSpecialProp("perspectiveOrigin", {defaultValue:"50% 50%", prefix:true}); + _registerComplexSpecialProp("transformStyle", {prefix:true}); + _registerComplexSpecialProp("backfaceVisibility", {prefix:true}); + _registerComplexSpecialProp("userSelect", {prefix:true}); + _registerComplexSpecialProp("margin", {parser:_getEdgeParser("marginTop,marginRight,marginBottom,marginLeft")}); + _registerComplexSpecialProp("padding", {parser:_getEdgeParser("paddingTop,paddingRight,paddingBottom,paddingLeft")}); + _registerComplexSpecialProp("clip", {defaultValue:"rect(0px,0px,0px,0px)", parser:function(t, e, p, cssp, pt, plugin){ + var b, cs, delim; + if (_ieVers < 9) { //IE8 and earlier don't report a "clip" value in the currentStyle - instead, the values are split apart into clipTop, clipRight, clipBottom, and clipLeft. Also, in IE7 and earlier, the values inside rect() are space-delimited, not comma-delimited. + cs = t.currentStyle; + delim = _ieVers < 8 ? " " : ","; + b = "rect(" + cs.clipTop + delim + cs.clipRight + delim + cs.clipBottom + delim + cs.clipLeft + ")"; + e = this.format(e).split(",").join(delim); + } else { + b = this.format(_getStyle(t, this.p, _cs, false, this.dflt)); + e = this.format(e); + } + return this.parseComplex(t.style, b, e, pt, plugin); + }}); + _registerComplexSpecialProp("textShadow", {defaultValue:"0px 0px 0px #999", color:true, multi:true}); + _registerComplexSpecialProp("autoRound,strictUnits", {parser:function(t, e, p, cssp, pt) {return pt;}}); //just so that we can ignore these properties (not tween them) + _registerComplexSpecialProp("border", {defaultValue:"0px solid #000", parser:function(t, e, p, cssp, pt, plugin) { + var bw = _getStyle(t, "borderTopWidth", _cs, false, "0px"), + end = this.format(e).split(" "), + esfx = end[0].replace(_suffixExp, ""); + if (esfx !== "px") { //if we're animating to a non-px value, we need to convert the beginning width to that unit. + bw = (parseFloat(bw) / _convertToPixels(t, "borderTopWidth", 1, esfx)) + esfx; + } + return this.parseComplex(t.style, this.format(bw + " " + _getStyle(t, "borderTopStyle", _cs, false, "solid") + " " + _getStyle(t, "borderTopColor", _cs, false, "#000")), end.join(" "), pt, plugin); + }, color:true, formatter:function(v) { + var a = v.split(" "); + return a[0] + " " + (a[1] || "solid") + " " + (v.match(_colorExp) || ["#000"])[0]; + }}); + _registerComplexSpecialProp("borderWidth", {parser:_getEdgeParser("borderTopWidth,borderRightWidth,borderBottomWidth,borderLeftWidth")}); //Firefox doesn't pick up on borderWidth set in style sheets (only inline). + _registerComplexSpecialProp("float,cssFloat,styleFloat", {parser:function(t, e, p, cssp, pt, plugin) { + var s = t.style, + prop = ("cssFloat" in s) ? "cssFloat" : "styleFloat"; + return new CSSPropTween(s, prop, 0, 0, pt, -1, p, false, 0, s[prop], e); + }}); + + //opacity-related + var _setIEOpacityRatio = function(v) { + var t = this.t, //refers to the element's style property + filters = t.filter || _getStyle(this.data, "filter") || "", + val = (this.s + this.c * v) | 0, + skip; + if (val === 100) { //for older versions of IE that need to use a filter to apply opacity, we should remove the filter if opacity hits 1 in order to improve performance, but make sure there isn't a transform (matrix) or gradient in the filters. + if (filters.indexOf("atrix(") === -1 && filters.indexOf("radient(") === -1 && filters.indexOf("oader(") === -1) { + t.removeAttribute("filter"); + skip = (!_getStyle(this.data, "filter")); //if a class is applied that has an alpha filter, it will take effect (we don't want that), so re-apply our alpha filter in that case. We must first remove it and then check. + } else { + t.filter = filters.replace(_alphaFilterExp, ""); + skip = true; + } + } + if (!skip) { + if (this.xn1) { + t.filter = filters = filters || ("alpha(opacity=" + val + ")"); //works around bug in IE7/8 that prevents changes to "visibility" from being applied properly if the filter is changed to a different alpha on the same frame. + } + if (filters.indexOf("pacity") === -1) { //only used if browser doesn't support the standard opacity style property (IE 7 and 8). We omit the "O" to avoid case-sensitivity issues + if (val !== 0 || !this.xn1) { //bugs in IE7/8 won't render the filter properly if opacity is ADDED on the same frame/render as "visibility" changes (this.xn1 is 1 if this tween is an "autoAlpha" tween) + t.filter = filters + " alpha(opacity=" + val + ")"; //we round the value because otherwise, bugs in IE7/8 can prevent "visibility" changes from being applied properly. + } + } else { + t.filter = filters.replace(_opacityExp, "opacity=" + val); + } + } + }; + _registerComplexSpecialProp("opacity,alpha,autoAlpha", {defaultValue:"1", parser:function(t, e, p, cssp, pt, plugin) { + var b = parseFloat(_getStyle(t, "opacity", _cs, false, "1")), + style = t.style, + isAutoAlpha = (p === "autoAlpha"); + if (typeof(e) === "string" && e.charAt(1) === "=") { + e = ((e.charAt(0) === "-") ? -1 : 1) * parseFloat(e.substr(2)) + b; + } + if (isAutoAlpha && b === 1 && _getStyle(t, "visibility", _cs) === "hidden" && e !== 0) { //if visibility is initially set to "hidden", we should interpret that as intent to make opacity 0 (a convenience) + b = 0; + } + if (_supportsOpacity) { + pt = new CSSPropTween(style, "opacity", b, e - b, pt); + } else { + pt = new CSSPropTween(style, "opacity", b * 100, (e - b) * 100, pt); + pt.xn1 = isAutoAlpha ? 1 : 0; //we need to record whether or not this is an autoAlpha so that in the setRatio(), we know to duplicate the setting of the alpha in order to work around a bug in IE7 and IE8 that prevents changes to "visibility" from taking effect if the filter is changed to a different alpha(opacity) at the same time. Setting it to the SAME value first, then the new value works around the IE7/8 bug. + style.zoom = 1; //helps correct an IE issue. + pt.type = 2; + pt.b = "alpha(opacity=" + pt.s + ")"; + pt.e = "alpha(opacity=" + (pt.s + pt.c) + ")"; + pt.data = t; + pt.plugin = plugin; + pt.setRatio = _setIEOpacityRatio; + } + if (isAutoAlpha) { //we have to create the "visibility" PropTween after the opacity one in the linked list so that they run in the order that works properly in IE8 and earlier + pt = new CSSPropTween(style, "visibility", 0, 0, pt, -1, null, false, 0, ((b !== 0) ? "inherit" : "hidden"), ((e === 0) ? "hidden" : "inherit")); + pt.xs0 = "inherit"; + cssp._overwriteProps.push(pt.n); + cssp._overwriteProps.push(p); + } + return pt; + }}); + + + var _removeProp = function(s, p) { + if (p) { + if (s.removeProperty) { + if (p.substr(0,2) === "ms" || p.substr(0,6) === "webkit") { //Microsoft and some Webkit browsers don't conform to the standard of capitalizing the first prefix character, so we adjust so that when we prefix the caps with a dash, it's correct (otherwise it'd be "ms-transform" instead of "-ms-transform" for IE9, for example) + p = "-" + p; + } + s.removeProperty(p.replace(_capsExp, "-$1").toLowerCase()); + } else { //note: old versions of IE use "removeAttribute()" instead of "removeProperty()" + s.removeAttribute(p); + } + } + }, + _setClassNameRatio = function(v) { + this.t._gsClassPT = this; + if (v === 1 || v === 0) { + this.t.setAttribute("class", (v === 0) ? this.b : this.e); + var mpt = this.data, //first MiniPropTween + s = this.t.style; + while (mpt) { + if (!mpt.v) { + _removeProp(s, mpt.p); + } else { + s[mpt.p] = mpt.v; + } + mpt = mpt._next; + } + if (v === 1 && this.t._gsClassPT === this) { + this.t._gsClassPT = null; + } + } else if (this.t.getAttribute("class") !== this.e) { + this.t.setAttribute("class", this.e); + } + }; + _registerComplexSpecialProp("className", {parser:function(t, e, p, cssp, pt, plugin, vars) { + var b = t.getAttribute("class") || "", //don't use t.className because it doesn't work consistently on SVG elements; getAttribute("class") and setAttribute("class", value") is more reliable. + cssText = t.style.cssText, + difData, bs, cnpt, cnptLookup, mpt; + pt = cssp._classNamePT = new CSSPropTween(t, p, 0, 0, pt, 2); + pt.setRatio = _setClassNameRatio; + pt.pr = -11; + _hasPriority = true; + pt.b = b; + bs = _getAllStyles(t, _cs); + //if there's a className tween already operating on the target, force it to its end so that the necessary inline styles are removed and the class name is applied before we determine the end state (we don't want inline styles interfering that were there just for class-specific values) + cnpt = t._gsClassPT; + if (cnpt) { + cnptLookup = {}; + mpt = cnpt.data; //first MiniPropTween which stores the inline styles - we need to force these so that the inline styles don't contaminate things. Otherwise, there's a small chance that a tween could start and the inline values match the destination values and they never get cleaned. + while (mpt) { + cnptLookup[mpt.p] = 1; + mpt = mpt._next; + } + cnpt.setRatio(1); + } + t._gsClassPT = pt; + pt.e = (e.charAt(1) !== "=") ? e : b.replace(new RegExp("(?:\\s|^)" + e.substr(2) + "(?![\\w-])"), "") + ((e.charAt(0) === "+") ? " " + e.substr(2) : ""); + t.setAttribute("class", pt.e); + difData = _cssDif(t, bs, _getAllStyles(t), vars, cnptLookup); + t.setAttribute("class", b); + pt.data = difData.firstMPT; + t.style.cssText = cssText; //we recorded cssText before we swapped classes and ran _getAllStyles() because in cases when a className tween is overwritten, we remove all the related tweening properties from that class change (otherwise class-specific stuff can't override properties we've directly set on the target's style object due to specificity). + pt = pt.xfirst = cssp.parse(t, difData.difs, pt, plugin); //we record the CSSPropTween as the xfirst so that we can handle overwriting propertly (if "className" gets overwritten, we must kill all the properties associated with the className part of the tween, so we can loop through from xfirst to the pt itself) + return pt; + }}); + + + var _setClearPropsRatio = function(v) { + if (v === 1 || v === 0) if (this.data._totalTime === this.data._totalDuration && this.data.data !== "isFromStart") { //this.data refers to the tween. Only clear at the END of the tween (remember, from() tweens make the ratio go from 1 to 0, so we can't just check that and if the tween is the zero-duration one that's created internally to render the starting values in a from() tween, ignore that because otherwise, for example, from(...{height:100, clearProps:"height", delay:1}) would wipe the height at the beginning of the tween and after 1 second, it'd kick back in). + var s = this.t.style, + transformParse = _specialProps.transform.parse, + a, p, i, clearTransform, transform; + if (this.e === "all") { + s.cssText = ""; + clearTransform = true; + } else { + a = this.e.split(" ").join("").split(","); + i = a.length; + while (--i > -1) { + p = a[i]; + if (_specialProps[p]) { + if (_specialProps[p].parse === transformParse) { + clearTransform = true; + } else { + p = (p === "transformOrigin") ? _transformOriginProp : _specialProps[p].p; //ensures that special properties use the proper browser-specific property name, like "scaleX" might be "-webkit-transform" or "boxShadow" might be "-moz-box-shadow" + } + } + _removeProp(s, p); + } + } + if (clearTransform) { + _removeProp(s, _transformProp); + transform = this.t._gsTransform; + if (transform) { + if (transform.svg) { + this.t.removeAttribute("data-svg-origin"); + this.t.removeAttribute("transform"); + } + delete this.t._gsTransform; + } + } + + } + }; + _registerComplexSpecialProp("clearProps", {parser:function(t, e, p, cssp, pt) { + pt = new CSSPropTween(t, p, 0, 0, pt, 2); + pt.setRatio = _setClearPropsRatio; + pt.e = e; + pt.pr = -10; + pt.data = cssp._tween; + _hasPriority = true; + return pt; + }}); + + p = "bezier,throwProps,physicsProps,physics2D".split(","); + i = p.length; + while (i--) { + _registerPluginProp(p[i]); + } + + + + + + + + + p = CSSPlugin.prototype; + p._firstPT = p._lastParsedTransform = p._transform = null; + + //gets called when the tween renders for the first time. This kicks everything off, recording start/end values, etc. + p._onInitTween = function(target, vars, tween) { + if (!target.nodeType) { //css is only for dom elements + return false; + } + this._target = target; + this._tween = tween; + this._vars = vars; + _autoRound = vars.autoRound; + _hasPriority = false; + _suffixMap = vars.suffixMap || CSSPlugin.suffixMap; + _cs = _getComputedStyle(target, ""); + _overwriteProps = this._overwriteProps; + var style = target.style, + v, pt, pt2, first, last, next, zIndex, tpt, threeD; + if (_reqSafariFix) if (style.zIndex === "") { + v = _getStyle(target, "zIndex", _cs); + if (v === "auto" || v === "") { + //corrects a bug in [non-Android] Safari that prevents it from repainting elements in their new positions if they don't have a zIndex set. We also can't just apply this inside _parseTransform() because anything that's moved in any way (like using "left" or "top" instead of transforms like "x" and "y") can be affected, so it is best to ensure that anything that's tweening has a z-index. Setting "WebkitPerspective" to a non-zero value worked too except that on iOS Safari things would flicker randomly. Plus zIndex is less memory-intensive. + this._addLazySet(style, "zIndex", 0); + } + } + + if (typeof(vars) === "string") { + first = style.cssText; + v = _getAllStyles(target, _cs); + style.cssText = first + ";" + vars; + v = _cssDif(target, v, _getAllStyles(target)).difs; + if (!_supportsOpacity && _opacityValExp.test(vars)) { + v.opacity = parseFloat( RegExp.$1 ); + } + vars = v; + style.cssText = first; + } + + if (vars.className) { //className tweens will combine any differences they find in the css with the vars that are passed in, so {className:"myClass", scale:0.5, left:20} would work. + this._firstPT = pt = _specialProps.className.parse(target, vars.className, "className", this, null, null, vars); + } else { + this._firstPT = pt = this.parse(target, vars, null); + } + + if (this._transformType) { + threeD = (this._transformType === 3); + if (!_transformProp) { + style.zoom = 1; //helps correct an IE issue. + } else if (_isSafari) { + _reqSafariFix = true; + //if zIndex isn't set, iOS Safari doesn't repaint things correctly sometimes (seemingly at random). + if (style.zIndex === "") { + zIndex = _getStyle(target, "zIndex", _cs); + if (zIndex === "auto" || zIndex === "") { + this._addLazySet(style, "zIndex", 0); + } + } + //Setting WebkitBackfaceVisibility corrects 3 bugs: + // 1) [non-Android] Safari skips rendering changes to "top" and "left" that are made on the same frame/render as a transform update. + // 2) iOS Safari sometimes neglects to repaint elements in their new positions. Setting "WebkitPerspective" to a non-zero value worked too except that on iOS Safari things would flicker randomly. + // 3) Safari sometimes displayed odd artifacts when tweening the transform (or WebkitTransform) property, like ghosts of the edges of the element remained. Definitely a browser bug. + //Note: we allow the user to override the auto-setting by defining WebkitBackfaceVisibility in the vars of the tween. + if (_isSafariLT6) { + this._addLazySet(style, "WebkitBackfaceVisibility", this._vars.WebkitBackfaceVisibility || (threeD ? "visible" : "hidden")); + } + } + pt2 = pt; + while (pt2 && pt2._next) { + pt2 = pt2._next; + } + tpt = new CSSPropTween(target, "transform", 0, 0, null, 2); + this._linkCSSP(tpt, null, pt2); + tpt.setRatio = _transformProp ? _setTransformRatio : _setIETransformRatio; + tpt.data = this._transform || _getTransform(target, _cs, true); + tpt.tween = tween; + tpt.pr = -1; //ensures that the transforms get applied after the components are updated. + _overwriteProps.pop(); //we don't want to force the overwrite of all "transform" tweens of the target - we only care about individual transform properties like scaleX, rotation, etc. The CSSPropTween constructor automatically adds the property to _overwriteProps which is why we need to pop() here. + } + + if (_hasPriority) { + //reorders the linked list in order of pr (priority) + while (pt) { + next = pt._next; + pt2 = first; + while (pt2 && pt2.pr > pt.pr) { + pt2 = pt2._next; + } + if ((pt._prev = pt2 ? pt2._prev : last)) { + pt._prev._next = pt; + } else { + first = pt; + } + if ((pt._next = pt2)) { + pt2._prev = pt; + } else { + last = pt; + } + pt = next; + } + this._firstPT = first; + } + return true; + }; + + + p.parse = function(target, vars, pt, plugin) { + var style = target.style, + p, sp, bn, en, bs, es, bsfx, esfx, isStr, rel; + for (p in vars) { + es = vars[p]; //ending value string + sp = _specialProps[p]; //SpecialProp lookup. + if (sp) { + pt = sp.parse(target, es, p, this, pt, plugin, vars); + + } else { + bs = _getStyle(target, p, _cs) + ""; + isStr = (typeof(es) === "string"); + if (p === "color" || p === "fill" || p === "stroke" || p.indexOf("Color") !== -1 || (isStr && _rgbhslExp.test(es))) { //Opera uses background: to define color sometimes in addition to backgroundColor: + if (!isStr) { + es = _parseColor(es); + es = ((es.length > 3) ? "rgba(" : "rgb(") + es.join(",") + ")"; + } + pt = _parseComplex(style, p, bs, es, true, "transparent", pt, 0, plugin); + + } else if (isStr && _complexExp.test(es)) { + pt = _parseComplex(style, p, bs, es, true, null, pt, 0, plugin); + + } else { + bn = parseFloat(bs); + bsfx = (bn || bn === 0) ? bs.substr((bn + "").length) : ""; //remember, bs could be non-numeric like "normal" for fontWeight, so we should default to a blank suffix in that case. + + if (bs === "" || bs === "auto") { + if (p === "width" || p === "height") { + bn = _getDimension(target, p, _cs); + bsfx = "px"; + } else if (p === "left" || p === "top") { + bn = _calculateOffset(target, p, _cs); + bsfx = "px"; + } else { + bn = (p !== "opacity") ? 0 : 1; + bsfx = ""; + } + } + + rel = (isStr && es.charAt(1) === "="); + if (rel) { + en = parseInt(es.charAt(0) + "1", 10); + es = es.substr(2); + en *= parseFloat(es); + esfx = es.replace(_suffixExp, ""); + } else { + en = parseFloat(es); + esfx = isStr ? es.replace(_suffixExp, "") : ""; + } + + if (esfx === "") { + esfx = (p in _suffixMap) ? _suffixMap[p] : bsfx; //populate the end suffix, prioritizing the map, then if none is found, use the beginning suffix. + } + + es = (en || en === 0) ? (rel ? en + bn : en) + esfx : vars[p]; //ensures that any += or -= prefixes are taken care of. Record the end value before normalizing the suffix because we always want to end the tween on exactly what they intended even if it doesn't match the beginning value's suffix. + + //if the beginning/ending suffixes don't match, normalize them... + if (bsfx !== esfx) if (esfx !== "") if (en || en === 0) if (bn) { //note: if the beginning value (bn) is 0, we don't need to convert units! + bn = _convertToPixels(target, p, bn, bsfx); + if (esfx === "%") { + bn /= _convertToPixels(target, p, 100, "%") / 100; + if (vars.strictUnits !== true) { //some browsers report only "px" values instead of allowing "%" with getComputedStyle(), so we assume that if we're tweening to a %, we should start there too unless strictUnits:true is defined. This approach is particularly useful for responsive designs that use from() tweens. + bs = bn + "%"; + } + + } else if (esfx === "em" || esfx === "rem" || esfx === "vw" || esfx === "vh") { + bn /= _convertToPixels(target, p, 1, esfx); + + //otherwise convert to pixels. + } else if (esfx !== "px") { + en = _convertToPixels(target, p, en, esfx); + esfx = "px"; //we don't use bsfx after this, so we don't need to set it to px too. + } + if (rel) if (en || en === 0) { + es = (en + bn) + esfx; //the changes we made affect relative calculations, so adjust the end value here. + } + } + + if (rel) { + en += bn; + } + + if ((bn || bn === 0) && (en || en === 0)) { //faster than isNaN(). Also, previously we required en !== bn but that doesn't really gain much performance and it prevents _parseToProxy() from working properly if beginning and ending values match but need to get tweened by an external plugin anyway. For example, a bezier tween where the target starts at left:0 and has these points: [{left:50},{left:0}] wouldn't work properly because when parsing the last point, it'd match the first (current) one and a non-tweening CSSPropTween would be recorded when we actually need a normal tween (type:0) so that things get updated during the tween properly. + pt = new CSSPropTween(style, p, bn, en - bn, pt, 0, p, (_autoRound !== false && (esfx === "px" || p === "zIndex")), 0, bs, es); + pt.xs0 = esfx; + //DEBUG: _log("tween "+p+" from "+pt.b+" ("+bn+esfx+") to "+pt.e+" with suffix: "+pt.xs0); + } else if (style[p] === undefined || !es && (es + "" === "NaN" || es == null)) { + _log("invalid " + p + " tween value: " + vars[p]); + } else { + pt = new CSSPropTween(style, p, en || bn || 0, 0, pt, -1, p, false, 0, bs, es); + pt.xs0 = (es === "none" && (p === "display" || p.indexOf("Style") !== -1)) ? bs : es; //intermediate value should typically be set immediately (end value) except for "display" or things like borderTopStyle, borderBottomStyle, etc. which should use the beginning value during the tween. + //DEBUG: _log("non-tweening value "+p+": "+pt.xs0); + } + } + } + if (plugin) if (pt && !pt.plugin) { + pt.plugin = plugin; + } + } + return pt; + }; + + + //gets called every time the tween updates, passing the new ratio (typically a value between 0 and 1, but not always (for example, if an Elastic.easeOut is used, the value can jump above 1 mid-tween). It will always start and 0 and end at 1. + p.setRatio = function(v) { + var pt = this._firstPT, + min = 0.000001, + val, str, i; + //at the end of the tween, we set the values to exactly what we received in order to make sure non-tweening values (like "position" or "float" or whatever) are set and so that if the beginning/ending suffixes (units) didn't match and we normalized to px, the value that the user passed in is used here. We check to see if the tween is at its beginning in case it's a from() tween in which case the ratio will actually go from 1 to 0 over the course of the tween (backwards). + if (v === 1 && (this._tween._time === this._tween._duration || this._tween._time === 0)) { + while (pt) { + if (pt.type !== 2) { + if (pt.r && pt.type !== -1) { + val = Math.round(pt.s + pt.c); + if (!pt.type) { + pt.t[pt.p] = val + pt.xs0; + } else if (pt.type === 1) { //complex value (one that typically has multiple numbers inside a string, like "rect(5px,10px,20px,25px)" + i = pt.l; + str = pt.xs0 + val + pt.xs1; + for (i = 1; i < pt.l; i++) { + str += pt["xn"+i] + pt["xs"+(i+1)]; + } + pt.t[pt.p] = str; + } + } else { + pt.t[pt.p] = pt.e; + } + } else { + pt.setRatio(v); + } + pt = pt._next; + } + + } else if (v || !(this._tween._time === this._tween._duration || this._tween._time === 0) || this._tween._rawPrevTime === -0.000001) { + while (pt) { + val = pt.c * v + pt.s; + if (pt.r) { + val = Math.round(val); + } else if (val < min) if (val > -min) { + val = 0; + } + if (!pt.type) { + pt.t[pt.p] = val + pt.xs0; + } else if (pt.type === 1) { //complex value (one that typically has multiple numbers inside a string, like "rect(5px,10px,20px,25px)" + i = pt.l; + if (i === 2) { + pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2; + } else if (i === 3) { + pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3; + } else if (i === 4) { + pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3 + pt.xn3 + pt.xs4; + } else if (i === 5) { + pt.t[pt.p] = pt.xs0 + val + pt.xs1 + pt.xn1 + pt.xs2 + pt.xn2 + pt.xs3 + pt.xn3 + pt.xs4 + pt.xn4 + pt.xs5; + } else { + str = pt.xs0 + val + pt.xs1; + for (i = 1; i < pt.l; i++) { + str += pt["xn"+i] + pt["xs"+(i+1)]; + } + pt.t[pt.p] = str; + } + + } else if (pt.type === -1) { //non-tweening value + pt.t[pt.p] = pt.xs0; + + } else if (pt.setRatio) { //custom setRatio() for things like SpecialProps, external plugins, etc. + pt.setRatio(v); + } + pt = pt._next; + } + + //if the tween is reversed all the way back to the beginning, we need to restore the original values which may have different units (like % instead of px or em or whatever). + } else { + while (pt) { + if (pt.type !== 2) { + pt.t[pt.p] = pt.b; + } else { + pt.setRatio(v); + } + pt = pt._next; + } + } + }; + + /** + * @private + * Forces rendering of the target's transforms (rotation, scale, etc.) whenever the CSSPlugin's setRatio() is called. + * Basically, this tells the CSSPlugin to create a CSSPropTween (type 2) after instantiation that runs last in the linked + * list and calls the appropriate (3D or 2D) rendering function. We separate this into its own method so that we can call + * it from other plugins like BezierPlugin if, for example, it needs to apply an autoRotation and this CSSPlugin + * doesn't have any transform-related properties of its own. You can call this method as many times as you + * want and it won't create duplicate CSSPropTweens. + * + * @param {boolean} threeD if true, it should apply 3D tweens (otherwise, just 2D ones are fine and typically faster) + */ + p._enableTransforms = function(threeD) { + this._transform = this._transform || _getTransform(this._target, _cs, true); //ensures that the element has a _gsTransform property with the appropriate values. + this._transformType = (!(this._transform.svg && _useSVGTransformAttr) && (threeD || this._transformType === 3)) ? 3 : 2; + }; + + var lazySet = function(v) { + this.t[this.p] = this.e; + this.data._linkCSSP(this, this._next, null, true); //we purposefully keep this._next even though it'd make sense to null it, but this is a performance optimization, as this happens during the while (pt) {} loop in setRatio() at the bottom of which it sets pt = pt._next, so if we null it, the linked list will be broken in that loop. + }; + /** @private Gives us a way to set a value on the first render (and only the first render). **/ + p._addLazySet = function(t, p, v) { + var pt = this._firstPT = new CSSPropTween(t, p, 0, 0, this._firstPT, 2); + pt.e = v; + pt.setRatio = lazySet; + pt.data = this; + }; + + /** @private **/ + p._linkCSSP = function(pt, next, prev, remove) { + if (pt) { + if (next) { + next._prev = pt; + } + if (pt._next) { + pt._next._prev = pt._prev; + } + if (pt._prev) { + pt._prev._next = pt._next; + } else if (this._firstPT === pt) { + this._firstPT = pt._next; + remove = true; //just to prevent resetting this._firstPT 5 lines down in case pt._next is null. (optimized for speed) + } + if (prev) { + prev._next = pt; + } else if (!remove && this._firstPT === null) { + this._firstPT = pt; + } + pt._next = next; + pt._prev = prev; + } + return pt; + }; + + //we need to make sure that if alpha or autoAlpha is killed, opacity is too. And autoAlpha affects the "visibility" property. + p._kill = function(lookup) { + var copy = lookup, + pt, p, xfirst; + if (lookup.autoAlpha || lookup.alpha) { + copy = {}; + for (p in lookup) { //copy the lookup so that we're not changing the original which may be passed elsewhere. + copy[p] = lookup[p]; + } + copy.opacity = 1; + if (copy.autoAlpha) { + copy.visibility = 1; + } + } + if (lookup.className && (pt = this._classNamePT)) { //for className tweens, we need to kill any associated CSSPropTweens too; a linked list starts at the className's "xfirst". + xfirst = pt.xfirst; + if (xfirst && xfirst._prev) { + this._linkCSSP(xfirst._prev, pt._next, xfirst._prev._prev); //break off the prev + } else if (xfirst === this._firstPT) { + this._firstPT = pt._next; + } + if (pt._next) { + this._linkCSSP(pt._next, pt._next._next, xfirst._prev); + } + this._classNamePT = null; + } + return TweenPlugin.prototype._kill.call(this, copy); + }; + + + + //used by cascadeTo() for gathering all the style properties of each child element into an array for comparison. + var _getChildStyles = function(e, props, targets) { + var children, i, child, type; + if (e.slice) { + i = e.length; + while (--i > -1) { + _getChildStyles(e[i], props, targets); + } + return; + } + children = e.childNodes; + i = children.length; + while (--i > -1) { + child = children[i]; + type = child.type; + if (child.style) { + props.push(_getAllStyles(child)); + if (targets) { + targets.push(child); + } + } + if ((type === 1 || type === 9 || type === 11) && child.childNodes.length) { + _getChildStyles(child, props, targets); + } + } + }; + + /** + * Typically only useful for className tweens that may affect child elements, this method creates a TweenLite + * and then compares the style properties of all the target's child elements at the tween's start and end, and + * if any are different, it also creates tweens for those and returns an array containing ALL of the resulting + * tweens (so that you can easily add() them to a TimelineLite, for example). The reason this functionality is + * wrapped into a separate static method of CSSPlugin instead of being integrated into all regular className tweens + * is because it creates entirely new tweens that may have completely different targets than the original tween, + * so if they were all lumped into the original tween instance, it would be inconsistent with the rest of the API + * and it would create other problems. For example: + * - If I create a tween of elementA, that tween instance may suddenly change its target to include 50 other elements (unintuitive if I specifically defined the target I wanted) + * - We can't just create new independent tweens because otherwise, what happens if the original/parent tween is reversed or pause or dropped into a TimelineLite for tight control? You'd expect that tween's behavior to affect all the others. + * - Analyzing every style property of every child before and after the tween is an expensive operation when there are many children, so this behavior shouldn't be imposed on all className tweens by default, especially since it's probably rare that this extra functionality is needed. + * + * @param {Object} target object to be tweened + * @param {number} Duration in seconds (or frames for frames-based tweens) + * @param {Object} Object containing the end values, like {className:"newClass", ease:Linear.easeNone} + * @return {Array} An array of TweenLite instances + */ + CSSPlugin.cascadeTo = function(target, duration, vars) { + var tween = TweenLite.to(target, duration, vars), + results = [tween], + b = [], + e = [], + targets = [], + _reservedProps = TweenLite._internals.reservedProps, + i, difs, p, from; + target = tween._targets || tween.target; + _getChildStyles(target, b, targets); + tween.render(duration, true, true); + _getChildStyles(target, e); + tween.render(0, true, true); + tween._enabled(true); + i = targets.length; + while (--i > -1) { + difs = _cssDif(targets[i], b[i], e[i]); + if (difs.firstMPT) { + difs = difs.difs; + for (p in vars) { + if (_reservedProps[p]) { + difs[p] = vars[p]; + } + } + from = {}; + for (p in difs) { + from[p] = b[i][p]; + } + results.push(TweenLite.fromTo(targets[i], duration, from, difs)); + } + } + return results; + }; + + TweenPlugin.activate([CSSPlugin]); + return CSSPlugin; + + }, true); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } + +//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date) +(function(name) { + "use strict"; + var getGlobal = function() { + return (_gsScope.GreenSockGlobals || _gsScope)[name]; + }; + if (typeof(define) === "function" && define.amd) { //AMD + define(["../TweenLite"], getGlobal); + } else if (typeof(module) !== "undefined" && module.exports) { //node + require("../TweenLite.js"); + module.exports = getGlobal(); + } +}("CSSPlugin")); diff --git a/resources/html5app/js/gsap/plugins/CSSPlugin.min.js b/resources/html5app/js/gsap/plugins/CSSPlugin.min.js new file mode 100644 index 000000000..c639e0ea1 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/CSSPlugin.min.js @@ -0,0 +1,13 @@ +/*! + * VERSION: 1.18.5 + * DATE: 2016-05-24 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine("plugins.CSSPlugin",["plugins.TweenPlugin","TweenLite"],function(a,b){var c,d,e,f,g=function(){a.call(this,"css"),this._overwriteProps.length=0,this.setRatio=g.prototype.setRatio},h=_gsScope._gsDefine.globals,i={},j=g.prototype=new a("css");j.constructor=g,g.version="1.18.5",g.API=2,g.defaultTransformPerspective=0,g.defaultSkewType="compensated",g.defaultSmoothOrigin=!0,j="px",g.suffixMap={top:j,right:j,bottom:j,left:j,width:j,height:j,fontSize:j,padding:j,margin:j,perspective:j,lineHeight:""};var k,l,m,n,o,p,q=/(?:\-|\.|\b)(\d|\.|e\-)+/g,r=/(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g,s=/(?:\+=|\-=|\-|\b)[\d\-\.]+[a-zA-Z0-9]*(?:%|\b)/gi,t=/(?![+-]?\d*\.?\d+|[+-]|e[+-]\d+)[^0-9]/g,u=/(?:\d|\-|\+|=|#|\.)*/g,v=/opacity *= *([^)]*)/i,w=/opacity:([^;]*)/i,x=/alpha\(opacity *=.+?\)/i,y=/^(rgb|hsl)/,z=/([A-Z])/g,A=/-([a-z])/gi,B=/(^(?:url\(\"|url\())|(?:(\"\))$|\)$)/gi,C=function(a,b){return b.toUpperCase()},D=/(?:Left|Right|Width)/i,E=/(M11|M12|M21|M22)=[\d\-\.e]+/gi,F=/progid\:DXImageTransform\.Microsoft\.Matrix\(.+?\)/i,G=/,(?=[^\)]*(?:\(|$))/gi,H=/[\s,\(]/i,I=Math.PI/180,J=180/Math.PI,K={},L=document,M=function(a){return L.createElementNS?L.createElementNS("http://www.w3.org/1999/xhtml",a):L.createElement(a)},N=M("div"),O=M("img"),P=g._internals={_specialProps:i},Q=navigator.userAgent,R=function(){var a=Q.indexOf("Android"),b=M("a");return m=-1!==Q.indexOf("Safari")&&-1===Q.indexOf("Chrome")&&(-1===a||Number(Q.substr(a+8,1))>3),o=m&&Number(Q.substr(Q.indexOf("Version/")+8,1))<6,n=-1!==Q.indexOf("Firefox"),(/MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(Q)||/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(Q))&&(p=parseFloat(RegExp.$1)),b?(b.style.cssText="top:1px;opacity:.55;",/^0.55/.test(b.style.opacity)):!1}(),S=function(a){return v.test("string"==typeof a?a:(a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?parseFloat(RegExp.$1)/100:1},T=function(a){window.console&&console.log(a)},U="",V="",W=function(a,b){b=b||N;var c,d,e=b.style;if(void 0!==e[a])return a;for(a=a.charAt(0).toUpperCase()+a.substr(1),c=["O","Moz","ms","Ms","Webkit"],d=5;--d>-1&&void 0===e[c[d]+a];);return d>=0?(V=3===d?"ms":c[d],U="-"+V.toLowerCase()+"-",V+a):null},X=L.defaultView?L.defaultView.getComputedStyle:function(){},Y=g.getStyle=function(a,b,c,d,e){var f;return R||"opacity"!==b?(!d&&a.style[b]?f=a.style[b]:(c=c||X(a))?f=c[b]||c.getPropertyValue(b)||c.getPropertyValue(b.replace(z,"-$1").toLowerCase()):a.currentStyle&&(f=a.currentStyle[b]),null==e||f&&"none"!==f&&"auto"!==f&&"auto auto"!==f?f:e):S(a)},Z=P.convertToPixels=function(a,c,d,e,f){if("px"===e||!e)return d;if("auto"===e||!d)return 0;var h,i,j,k=D.test(c),l=a,m=N.style,n=0>d,o=1===d;if(n&&(d=-d),o&&(d*=100),"%"===e&&-1!==c.indexOf("border"))h=d/100*(k?a.clientWidth:a.clientHeight);else{if(m.cssText="border:0 solid red;position:"+Y(a,"position")+";line-height:0;","%"!==e&&l.appendChild&&"v"!==e.charAt(0)&&"rem"!==e)m[k?"borderLeftWidth":"borderTopWidth"]=d+e;else{if(l=a.parentNode||L.body,i=l._gsCache,j=b.ticker.frame,i&&k&&i.time===j)return i.width*d/100;m[k?"width":"height"]=d+e}l.appendChild(N),h=parseFloat(N[k?"offsetWidth":"offsetHeight"]),l.removeChild(N),k&&"%"===e&&g.cacheWidths!==!1&&(i=l._gsCache=l._gsCache||{},i.time=j,i.width=h/d*100),0!==h||f||(h=Z(a,c,d,e,!0))}return o&&(h/=100),n?-h:h},$=P.calculateOffset=function(a,b,c){if("absolute"!==Y(a,"position",c))return 0;var d="left"===b?"Left":"Top",e=Y(a,"margin"+d,c);return a["offset"+d]-(Z(a,b,parseFloat(e),e.replace(u,""))||0)},_=function(a,b){var c,d,e,f={};if(b=b||X(a,null))if(c=b.length)for(;--c>-1;)e=b[c],(-1===e.indexOf("-transform")||Aa===e)&&(f[e.replace(A,C)]=b.getPropertyValue(e));else for(c in b)(-1===c.indexOf("Transform")||za===c)&&(f[c]=b[c]);else if(b=a.currentStyle||a.style)for(c in b)"string"==typeof c&&void 0===f[c]&&(f[c.replace(A,C)]=b[c]);return R||(f.opacity=S(a)),d=Na(a,b,!1),f.rotation=d.rotation,f.skewX=d.skewX,f.scaleX=d.scaleX,f.scaleY=d.scaleY,f.x=d.x,f.y=d.y,Ca&&(f.z=d.z,f.rotationX=d.rotationX,f.rotationY=d.rotationY,f.scaleZ=d.scaleZ),f.filters&&delete f.filters,f},aa=function(a,b,c,d,e){var f,g,h,i={},j=a.style;for(g in c)"cssText"!==g&&"length"!==g&&isNaN(g)&&(b[g]!==(f=c[g])||e&&e[g])&&-1===g.indexOf("Origin")&&("number"==typeof f||"string"==typeof f)&&(i[g]="auto"!==f||"left"!==g&&"top"!==g?""!==f&&"auto"!==f&&"none"!==f||"string"!=typeof b[g]||""===b[g].replace(t,"")?f:0:$(a,g),void 0!==j[g]&&(h=new pa(j,g,j[g],h)));if(d)for(g in d)"className"!==g&&(i[g]=d[g]);return{difs:i,firstMPT:h}},ba={width:["Left","Right"],height:["Top","Bottom"]},ca=["marginLeft","marginRight","marginTop","marginBottom"],da=function(a,b,c){if("svg"===(a.nodeName+"").toLowerCase())return(c||X(a))[b]||0;if(a.getBBox&&Ka(a))return a.getBBox()[b]||0;var d=parseFloat("width"===b?a.offsetWidth:a.offsetHeight),e=ba[b],f=e.length;for(c=c||X(a,null);--f>-1;)d-=parseFloat(Y(a,"padding"+e[f],c,!0))||0,d-=parseFloat(Y(a,"border"+e[f]+"Width",c,!0))||0;return d},ea=function(a,b){if("contain"===a||"auto"===a||"auto auto"===a)return a+" ";(null==a||""===a)&&(a="0 0");var c,d=a.split(" "),e=-1!==a.indexOf("left")?"0%":-1!==a.indexOf("right")?"100%":d[0],f=-1!==a.indexOf("top")?"0%":-1!==a.indexOf("bottom")?"100%":d[1];if(d.length>3&&!b){for(d=a.split(", ").join(",").split(","),a=[],c=0;c2?" "+d[2]:""),b&&(b.oxp=-1!==e.indexOf("%"),b.oyp=-1!==f.indexOf("%"),b.oxr="="===e.charAt(1),b.oyr="="===f.charAt(1),b.ox=parseFloat(e.replace(t,"")),b.oy=parseFloat(f.replace(t,"")),b.v=a),b||a},fa=function(a,b){return"string"==typeof a&&"="===a.charAt(1)?parseInt(a.charAt(0)+"1",10)*parseFloat(a.substr(2)):parseFloat(a)-parseFloat(b)||0},ga=function(a,b){return null==a?b:"string"==typeof a&&"="===a.charAt(1)?parseInt(a.charAt(0)+"1",10)*parseFloat(a.substr(2))+b:parseFloat(a)||0},ha=function(a,b,c,d){var e,f,g,h,i,j=1e-6;return null==a?h=b:"number"==typeof a?h=a:(e=360,f=a.split("_"),i="="===a.charAt(1),g=(i?parseInt(a.charAt(0)+"1",10)*parseFloat(f[0].substr(2)):parseFloat(f[0]))*(-1===a.indexOf("rad")?1:J)-(i?0:b),f.length&&(d&&(d[c]=b+g),-1!==a.indexOf("short")&&(g%=e,g!==g%(e/2)&&(g=0>g?g+e:g-e)),-1!==a.indexOf("_cw")&&0>g?g=(g+9999999999*e)%e-(g/e|0)*e:-1!==a.indexOf("ccw")&&g>0&&(g=(g-9999999999*e)%e-(g/e|0)*e)),h=b+g),j>h&&h>-j&&(h=0),h},ia={aqua:[0,255,255],lime:[0,255,0],silver:[192,192,192],black:[0,0,0],maroon:[128,0,0],teal:[0,128,128],blue:[0,0,255],navy:[0,0,128],white:[255,255,255],fuchsia:[255,0,255],olive:[128,128,0],yellow:[255,255,0],orange:[255,165,0],gray:[128,128,128],purple:[128,0,128],green:[0,128,0],red:[255,0,0],pink:[255,192,203],cyan:[0,255,255],transparent:[255,255,255,0]},ja=function(a,b,c){return a=0>a?a+1:a>1?a-1:a,255*(1>6*a?b+(c-b)*a*6:.5>a?c:2>3*a?b+(c-b)*(2/3-a)*6:b)+.5|0},ka=g.parseColor=function(a,b){var c,d,e,f,g,h,i,j,k,l,m;if(a)if("number"==typeof a)c=[a>>16,a>>8&255,255&a];else{if(","===a.charAt(a.length-1)&&(a=a.substr(0,a.length-1)),ia[a])c=ia[a];else if("#"===a.charAt(0))4===a.length&&(d=a.charAt(1),e=a.charAt(2),f=a.charAt(3),a="#"+d+d+e+e+f+f),a=parseInt(a.substr(1),16),c=[a>>16,a>>8&255,255&a];else if("hsl"===a.substr(0,3))if(c=m=a.match(q),b){if(-1!==a.indexOf("="))return a.match(r)}else g=Number(c[0])%360/360,h=Number(c[1])/100,i=Number(c[2])/100,e=.5>=i?i*(h+1):i+h-i*h,d=2*i-e,c.length>3&&(c[3]=Number(a[3])),c[0]=ja(g+1/3,d,e),c[1]=ja(g,d,e),c[2]=ja(g-1/3,d,e);else c=a.match(q)||ia.transparent;c[0]=Number(c[0]),c[1]=Number(c[1]),c[2]=Number(c[2]),c.length>3&&(c[3]=Number(c[3]))}else c=ia.black;return b&&!m&&(d=c[0]/255,e=c[1]/255,f=c[2]/255,j=Math.max(d,e,f),k=Math.min(d,e,f),i=(j+k)/2,j===k?g=h=0:(l=j-k,h=i>.5?l/(2-j-k):l/(j+k),g=j===d?(e-f)/l+(f>e?6:0):j===e?(f-d)/l+2:(d-e)/l+4,g*=60),c[0]=g+.5|0,c[1]=100*h+.5|0,c[2]=100*i+.5|0),c},la=function(a,b){var c,d,e,f=a.match(ma)||[],g=0,h=f.length?"":a;for(c=0;c0?g[0].replace(q,""):"";return k?e=b?function(a){var b,m,n,o;if("number"==typeof a)a+=l;else if(d&&G.test(a)){for(o=a.replace(G,"|").split("|"),n=0;nn--)for(;++nm--)for(;++mi;i++)h[a[i]]=j[i]=j[i]||j[(i-1)/2>>0];return e.parse(b,h,f,g)}},pa=(P._setPluginRatio=function(a){this.plugin.setRatio(a);for(var b,c,d,e,f,g=this.data,h=g.proxy,i=g.firstMPT,j=1e-6;i;)b=h[i.v],i.r?b=Math.round(b):j>b&&b>-j&&(b=0),i.t[i.p]=b,i=i._next;if(g.autoRotate&&(g.autoRotate.rotation=h.rotation),1===a||0===a)for(i=g.firstMPT,f=1===a?"e":"b";i;){if(c=i.t,c.type){if(1===c.type){for(e=c.xs0+c.s+c.xs1,d=1;d0;)i="xn"+g,h=d.p+"_"+i,n[h]=d.data[i],m[h]=d[i],f||(j=new pa(d,i,h,j,d.rxp[i]));d=d._next}return{proxy:m,end:n,firstMPT:j,pt:k}},P.CSSPropTween=function(a,b,d,e,g,h,i,j,k,l,m){this.t=a,this.p=b,this.s=d,this.c=e,this.n=i||b,a instanceof qa||f.push(this.n),this.r=j,this.type=h||0,k&&(this.pr=k,c=!0),this.b=void 0===l?d:l,this.e=void 0===m?d+e:m,g&&(this._next=g,g._prev=this)}),ra=function(a,b,c,d,e,f){var g=new qa(a,b,c,d-c,e,-1,f);return g.b=c,g.e=g.xs0=d,g},sa=g.parseComplex=function(a,b,c,d,e,f,h,i,j,l){c=c||f||"",h=new qa(a,b,0,0,h,l?2:1,null,!1,i,c,d),d+="",e&&ma.test(d+c)&&(d=[c,d],g.colorStringFilter(d),c=d[0],d=d[1]);var m,n,o,p,s,t,u,v,w,x,y,z,A,B=c.split(", ").join(",").split(" "),C=d.split(", ").join(",").split(" "),D=B.length,E=k!==!1;for((-1!==d.indexOf(",")||-1!==c.indexOf(","))&&(B=B.join(" ").replace(G,", ").split(" "),C=C.join(" ").replace(G,", ").split(" "),D=B.length),D!==C.length&&(B=(f||"").split(" "),D=B.length),h.plugin=j,h.setRatio=l,ma.lastIndex=0,m=0;D>m;m++)if(p=B[m],s=C[m],v=parseFloat(p),v||0===v)h.appendXtra("",v,fa(s,v),s.replace(r,""),E&&-1!==s.indexOf("px"),!0);else if(e&&ma.test(p))z=s.indexOf(")")+1,z=")"+(z?s.substr(z):""),A=-1!==s.indexOf("hsl")&&R,p=ka(p,A),s=ka(s,A),w=p.length+s.length>6,w&&!R&&0===s[3]?(h["xs"+h.l]+=h.l?" transparent":"transparent",h.e=h.e.split(C[m]).join("transparent")):(R||(w=!1),A?h.appendXtra(w?"hsla(":"hsl(",p[0],fa(s[0],p[0]),",",!1,!0).appendXtra("",p[1],fa(s[1],p[1]),"%,",!1).appendXtra("",p[2],fa(s[2],p[2]),w?"%,":"%"+z,!1):h.appendXtra(w?"rgba(":"rgb(",p[0],s[0]-p[0],",",!0,!0).appendXtra("",p[1],s[1]-p[1],",",!0).appendXtra("",p[2],s[2]-p[2],w?",":z,!0),w&&(p=p.length<4?1:p[3],h.appendXtra("",p,(s.length<4?1:s[3])-p,z,!1))),ma.lastIndex=0;else if(t=p.match(q)){if(u=s.match(r),!u||u.length!==t.length)return h;for(o=0,n=0;n0;)j["xn"+ta]=0,j["xs"+ta]="";j.xs0="",j._next=j._prev=j.xfirst=j.data=j.plugin=j.setRatio=j.rxp=null,j.appendXtra=function(a,b,c,d,e,f){var g=this,h=g.l;return g["xs"+h]+=f&&(h||g["xs"+h])?" "+a:a||"",c||0===h||g.plugin?(g.l++,g.type=g.setRatio?2:1,g["xs"+g.l]=d||"",h>0?(g.data["xn"+h]=b+c,g.rxp["xn"+h]=e,g["xn"+h]=b,g.plugin||(g.xfirst=new qa(g,"xn"+h,b,c,g.xfirst||g,0,g.n,e,g.pr),g.xfirst.xs0=0),g):(g.data={s:b+c},g.rxp={},g.s=b,g.c=c,g.r=e,g)):(g["xs"+h]+=b+(d||""),g)};var ua=function(a,b){b=b||{},this.p=b.prefix?W(a)||a:a,i[a]=i[this.p]=this,this.format=b.formatter||na(b.defaultValue,b.color,b.collapsible,b.multi),b.parser&&(this.parse=b.parser),this.clrs=b.color,this.multi=b.multi,this.keyword=b.keyword,this.dflt=b.defaultValue,this.pr=b.priority||0},va=P._registerComplexSpecialProp=function(a,b,c){"object"!=typeof b&&(b={parser:c});var d,e,f=a.split(","),g=b.defaultValue;for(c=c||[g],d=0;dh.length?i.length:h.length,g=0;j>g;g++)b=h[g]=h[g]||this.dflt,c=i[g]=i[g]||this.dflt,m&&(k=b.indexOf(m),l=c.indexOf(m),k!==l&&(-1===l?h[g]=h[g].split(m).join(""):-1===k&&(h[g]+=" "+m)));b=h.join(", "),c=i.join(", ")}return sa(a,this.p,b,c,this.clrs,this.dflt,d,this.pr,e,f)},j.parse=function(a,b,c,d,f,g,h){return this.parseComplex(a.style,this.format(Y(a,this.p,e,!1,this.dflt)),this.format(b),f,g)},g.registerSpecialProp=function(a,b,c){va(a,{parser:function(a,d,e,f,g,h,i){var j=new qa(a,e,0,0,g,2,e,!1,c);return j.plugin=h,j.setRatio=b(a,d,f._tween,e),j},priority:c})},g.useSVGTransformAttr=m||n;var xa,ya="scaleX,scaleY,scaleZ,x,y,z,skewX,skewY,rotation,rotationX,rotationY,perspective,xPercent,yPercent".split(","),za=W("transform"),Aa=U+"transform",Ba=W("transformOrigin"),Ca=null!==W("perspective"),Da=P.Transform=function(){this.perspective=parseFloat(g.defaultTransformPerspective)||0,this.force3D=g.defaultForce3D!==!1&&Ca?g.defaultForce3D||"auto":!1},Ea=window.SVGElement,Fa=function(a,b,c){var d,e=L.createElementNS("http://www.w3.org/2000/svg",a),f=/([a-z])([A-Z])/g;for(d in c)e.setAttributeNS(null,d.replace(f,"$1-$2").toLowerCase(),c[d]);return b.appendChild(e),e},Ga=L.documentElement,Ha=function(){var a,b,c,d=p||/Android/i.test(Q)&&!window.chrome;return L.createElementNS&&!d&&(a=Fa("svg",Ga),b=Fa("rect",a,{width:100,height:50,x:100}),c=b.getBoundingClientRect().width,b.style[Ba]="50% 50%",b.style[za]="scaleX(0.5)",d=c===b.getBoundingClientRect().width&&!(n&&Ca),Ga.removeChild(a)),d}(),Ia=function(a,b,c,d,e,f){var h,i,j,k,l,m,n,o,p,q,r,s,t,u,v=a._gsTransform,w=Ma(a,!0);v&&(t=v.xOrigin,u=v.yOrigin),(!d||(h=d.split(" ")).length<2)&&(n=a.getBBox(),b=ea(b).split(" "),h=[(-1!==b[0].indexOf("%")?parseFloat(b[0])/100*n.width:parseFloat(b[0]))+n.x,(-1!==b[1].indexOf("%")?parseFloat(b[1])/100*n.height:parseFloat(b[1]))+n.y]),c.xOrigin=k=parseFloat(h[0]),c.yOrigin=l=parseFloat(h[1]),d&&w!==La&&(m=w[0],n=w[1],o=w[2],p=w[3],q=w[4],r=w[5],s=m*p-n*o,i=k*(p/s)+l*(-o/s)+(o*r-p*q)/s,j=k*(-n/s)+l*(m/s)-(m*r-n*q)/s,k=c.xOrigin=h[0]=i,l=c.yOrigin=h[1]=j),v&&(f&&(c.xOffset=v.xOffset,c.yOffset=v.yOffset,v=c),e||e!==!1&&g.defaultSmoothOrigin!==!1?(i=k-t,j=l-u,v.xOffset+=i*w[0]+j*w[2]-i,v.yOffset+=i*w[1]+j*w[3]-j):v.xOffset=v.yOffset=0),f||a.setAttribute("data-svg-origin",h.join(" "))},Ja=function(a){try{return a.getBBox()}catch(a){}},Ka=function(a){return!!(Ea&&a.getBBox&&a.getCTM&&Ja(a)&&(!a.parentNode||a.parentNode.getBBox&&a.parentNode.getCTM))},La=[1,0,0,1,0,0],Ma=function(a,b){var c,d,e,f,g,h,i=a._gsTransform||new Da,j=1e5,k=a.style;if(za?d=Y(a,Aa,null,!0):a.currentStyle&&(d=a.currentStyle.filter.match(E),d=d&&4===d.length?[d[0].substr(4),Number(d[2].substr(4)),Number(d[1].substr(4)),d[3].substr(4),i.x||0,i.y||0].join(","):""),c=!d||"none"===d||"matrix(1, 0, 0, 1, 0, 0)"===d,c&&za&&((h="none"===X(a).display)||!a.parentNode)&&(h&&(f=k.display,k.display="block"),a.parentNode||(g=1,Ga.appendChild(a)),d=Y(a,Aa,null,!0),c=!d||"none"===d||"matrix(1, 0, 0, 1, 0, 0)"===d,f?k.display=f:h&&Ra(k,"display"),g&&Ga.removeChild(a)),(i.svg||a.getBBox&&Ka(a))&&(c&&-1!==(k[za]+"").indexOf("matrix")&&(d=k[za],c=0),e=a.getAttribute("transform"),c&&e&&(-1!==e.indexOf("matrix")?(d=e,c=0):-1!==e.indexOf("translate")&&(d="matrix(1,0,0,1,"+e.match(/(?:\-|\b)[\d\-\.e]+\b/gi).join(",")+")",c=0))),c)return La;for(e=(d||"").match(q)||[],ta=e.length;--ta>-1;)f=Number(e[ta]),e[ta]=(g=f-(f|=0))?(g*j+(0>g?-.5:.5)|0)/j+f:f;return b&&e.length>6?[e[0],e[1],e[4],e[5],e[12],e[13]]:e},Na=P.getTransform=function(a,c,d,e){if(a._gsTransform&&d&&!e)return a._gsTransform;var f,h,i,j,k,l,m=d?a._gsTransform||new Da:new Da,n=m.scaleX<0,o=2e-5,p=1e5,q=Ca?parseFloat(Y(a,Ba,c,!1,"0 0 0").split(" ")[2])||m.zOrigin||0:0,r=parseFloat(g.defaultTransformPerspective)||0;if(m.svg=!(!a.getBBox||!Ka(a)),m.svg&&(Ia(a,Y(a,Ba,c,!1,"50% 50%")+"",m,a.getAttribute("data-svg-origin")),xa=g.useSVGTransformAttr||Ha),f=Ma(a),f!==La){if(16===f.length){var s,t,u,v,w,x=f[0],y=f[1],z=f[2],A=f[3],B=f[4],C=f[5],D=f[6],E=f[7],F=f[8],G=f[9],H=f[10],I=f[12],K=f[13],L=f[14],M=f[11],N=Math.atan2(D,H);m.zOrigin&&(L=-m.zOrigin,I=F*L-f[12],K=G*L-f[13],L=H*L+m.zOrigin-f[14]),m.rotationX=N*J,N&&(v=Math.cos(-N),w=Math.sin(-N),s=B*v+F*w,t=C*v+G*w,u=D*v+H*w,F=B*-w+F*v,G=C*-w+G*v,H=D*-w+H*v,M=E*-w+M*v,B=s,C=t,D=u),N=Math.atan2(-z,H),m.rotationY=N*J,N&&(v=Math.cos(-N),w=Math.sin(-N),s=x*v-F*w,t=y*v-G*w,u=z*v-H*w,G=y*w+G*v,H=z*w+H*v,M=A*w+M*v,x=s,y=t,z=u),N=Math.atan2(y,x),m.rotation=N*J,N&&(v=Math.cos(-N),w=Math.sin(-N),x=x*v+B*w,t=y*v+C*w,C=y*-w+C*v,D=z*-w+D*v,y=t),m.rotationX&&Math.abs(m.rotationX)+Math.abs(m.rotation)>359.9&&(m.rotationX=m.rotation=0,m.rotationY=180-m.rotationY),m.scaleX=(Math.sqrt(x*x+y*y)*p+.5|0)/p,m.scaleY=(Math.sqrt(C*C+G*G)*p+.5|0)/p,m.scaleZ=(Math.sqrt(D*D+H*H)*p+.5|0)/p,m.rotationX||m.rotationY?m.skewX=0:(m.skewX=B||C?Math.atan2(B,C)*J+m.rotation:m.skewX||0,Math.abs(m.skewX)>90&&Math.abs(m.skewX)<270&&(n?(m.scaleX*=-1,m.skewX+=m.rotation<=0?180:-180,m.rotation+=m.rotation<=0?180:-180):(m.scaleY*=-1,m.skewX+=m.skewX<=0?180:-180))),m.perspective=M?1/(0>M?-M:M):0,m.x=I,m.y=K,m.z=L,m.svg&&(m.x-=m.xOrigin-(m.xOrigin*x-m.yOrigin*B),m.y-=m.yOrigin-(m.yOrigin*y-m.xOrigin*C))}else if(!Ca||e||!f.length||m.x!==f[4]||m.y!==f[5]||!m.rotationX&&!m.rotationY){var O=f.length>=6,P=O?f[0]:1,Q=f[1]||0,R=f[2]||0,S=O?f[3]:1;m.x=f[4]||0,m.y=f[5]||0,i=Math.sqrt(P*P+Q*Q),j=Math.sqrt(S*S+R*R),k=P||Q?Math.atan2(Q,P)*J:m.rotation||0,l=R||S?Math.atan2(R,S)*J+k:m.skewX||0,Math.abs(l)>90&&Math.abs(l)<270&&(n?(i*=-1,l+=0>=k?180:-180,k+=0>=k?180:-180):(j*=-1,l+=0>=l?180:-180)),m.scaleX=i,m.scaleY=j,m.rotation=k,m.skewX=l,Ca&&(m.rotationX=m.rotationY=m.z=0,m.perspective=r,m.scaleZ=1),m.svg&&(m.x-=m.xOrigin-(m.xOrigin*P+m.yOrigin*R),m.y-=m.yOrigin-(m.xOrigin*Q+m.yOrigin*S))}m.zOrigin=q;for(h in m)m[h]-o&&(m[h]=0)}return d&&(a._gsTransform=m,m.svg&&(xa&&a.style[za]?b.delayedCall(.001,function(){Ra(a.style,za)}):!xa&&a.getAttribute("transform")&&b.delayedCall(.001,function(){a.removeAttribute("transform")}))),m},Oa=function(a){var b,c,d=this.data,e=-d.rotation*I,f=e+d.skewX*I,g=1e5,h=(Math.cos(e)*d.scaleX*g|0)/g,i=(Math.sin(e)*d.scaleX*g|0)/g,j=(Math.sin(f)*-d.scaleY*g|0)/g,k=(Math.cos(f)*d.scaleY*g|0)/g,l=this.t.style,m=this.t.currentStyle;if(m){c=i,i=-j,j=-c,b=m.filter,l.filter="";var n,o,q=this.t.offsetWidth,r=this.t.offsetHeight,s="absolute"!==m.position,t="progid:DXImageTransform.Microsoft.Matrix(M11="+h+", M12="+i+", M21="+j+", M22="+k,w=d.x+q*d.xPercent/100,x=d.y+r*d.yPercent/100;if(null!=d.ox&&(n=(d.oxp?q*d.ox*.01:d.ox)-q/2,o=(d.oyp?r*d.oy*.01:d.oy)-r/2,w+=n-(n*h+o*i),x+=o-(n*j+o*k)),s?(n=q/2,o=r/2,t+=", Dx="+(n-(n*h+o*i)+w)+", Dy="+(o-(n*j+o*k)+x)+")"):t+=", sizingMethod='auto expand')",-1!==b.indexOf("DXImageTransform.Microsoft.Matrix(")?l.filter=b.replace(F,t):l.filter=t+" "+b,(0===a||1===a)&&1===h&&0===i&&0===j&&1===k&&(s&&-1===t.indexOf("Dx=0, Dy=0")||v.test(b)&&100!==parseFloat(RegExp.$1)||-1===b.indexOf(b.indexOf("Alpha"))&&l.removeAttribute("filter")),!s){var y,z,A,B=8>p?1:-1;for(n=d.ieOffsetX||0,o=d.ieOffsetY||0,d.ieOffsetX=Math.round((q-((0>h?-h:h)*q+(0>i?-i:i)*r))/2+w),d.ieOffsetY=Math.round((r-((0>k?-k:k)*r+(0>j?-j:j)*q))/2+x),ta=0;4>ta;ta++)z=ca[ta],y=m[z],c=-1!==y.indexOf("px")?parseFloat(y):Z(this.t,z,parseFloat(y),y.replace(u,""))||0,A=c!==d[z]?2>ta?-d.ieOffsetX:-d.ieOffsetY:2>ta?n-d.ieOffsetX:o-d.ieOffsetY,l[z]=(d[z]=Math.round(c-A*(0===ta||2===ta?1:B)))+"px"}}},Pa=P.set3DTransformRatio=P.setTransformRatio=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,o,p,q,r,s,t,u,v,w,x,y,z=this.data,A=this.t.style,B=z.rotation,C=z.rotationX,D=z.rotationY,E=z.scaleX,F=z.scaleY,G=z.scaleZ,H=z.x,J=z.y,K=z.z,L=z.svg,M=z.perspective,N=z.force3D;if(((1===a||0===a)&&"auto"===N&&(this.tween._totalTime===this.tween._totalDuration||!this.tween._totalTime)||!N)&&!K&&!M&&!D&&!C&&1===G||xa&&L||!Ca)return void(B||z.skewX||L?(B*=I,x=z.skewX*I,y=1e5,b=Math.cos(B)*E,e=Math.sin(B)*E,c=Math.sin(B-x)*-F,f=Math.cos(B-x)*F,x&&"simple"===z.skewType&&(s=Math.tan(x),s=Math.sqrt(1+s*s),c*=s,f*=s,z.skewY&&(b*=s,e*=s)),L&&(H+=z.xOrigin-(z.xOrigin*b+z.yOrigin*c)+z.xOffset,J+=z.yOrigin-(z.xOrigin*e+z.yOrigin*f)+z.yOffset,xa&&(z.xPercent||z.yPercent)&&(p=this.t.getBBox(),H+=.01*z.xPercent*p.width,J+=.01*z.yPercent*p.height),p=1e-6,p>H&&H>-p&&(H=0),p>J&&J>-p&&(J=0)),u=(b*y|0)/y+","+(e*y|0)/y+","+(c*y|0)/y+","+(f*y|0)/y+","+H+","+J+")",L&&xa?this.t.setAttribute("transform","matrix("+u):A[za]=(z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) matrix(":"matrix(")+u):A[za]=(z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) matrix(":"matrix(")+E+",0,0,"+F+","+H+","+J+")");if(n&&(p=1e-4,p>E&&E>-p&&(E=G=2e-5),p>F&&F>-p&&(F=G=2e-5),!M||z.z||z.rotationX||z.rotationY||(M=0)),B||z.skewX)B*=I,q=b=Math.cos(B),r=e=Math.sin(B),z.skewX&&(B-=z.skewX*I,q=Math.cos(B),r=Math.sin(B),"simple"===z.skewType&&(s=Math.tan(z.skewX*I),s=Math.sqrt(1+s*s),q*=s,r*=s,z.skewY&&(b*=s,e*=s))),c=-r,f=q;else{if(!(D||C||1!==G||M||L))return void(A[za]=(z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) translate3d(":"translate3d(")+H+"px,"+J+"px,"+K+"px)"+(1!==E||1!==F?" scale("+E+","+F+")":""));b=f=1,c=e=0}j=1,d=g=h=i=k=l=0,m=M?-1/M:0,o=z.zOrigin,p=1e-6,v=",",w="0",B=D*I,B&&(q=Math.cos(B),r=Math.sin(B),h=-r,k=m*-r,d=b*r,g=e*r,j=q,m*=q,b*=q,e*=q),B=C*I,B&&(q=Math.cos(B),r=Math.sin(B),s=c*q+d*r,t=f*q+g*r,i=j*r,l=m*r,d=c*-r+d*q,g=f*-r+g*q,j*=q,m*=q,c=s,f=t),1!==G&&(d*=G,g*=G,j*=G,m*=G),1!==F&&(c*=F,f*=F,i*=F,l*=F),1!==E&&(b*=E,e*=E,h*=E,k*=E),(o||L)&&(o&&(H+=d*-o,J+=g*-o,K+=j*-o+o),L&&(H+=z.xOrigin-(z.xOrigin*b+z.yOrigin*c)+z.xOffset,J+=z.yOrigin-(z.xOrigin*e+z.yOrigin*f)+z.yOffset),p>H&&H>-p&&(H=w),p>J&&J>-p&&(J=w),p>K&&K>-p&&(K=0)),u=z.xPercent||z.yPercent?"translate("+z.xPercent+"%,"+z.yPercent+"%) matrix3d(":"matrix3d(",u+=(p>b&&b>-p?w:b)+v+(p>e&&e>-p?w:e)+v+(p>h&&h>-p?w:h),u+=v+(p>k&&k>-p?w:k)+v+(p>c&&c>-p?w:c)+v+(p>f&&f>-p?w:f),C||D||1!==G?(u+=v+(p>i&&i>-p?w:i)+v+(p>l&&l>-p?w:l)+v+(p>d&&d>-p?w:d),u+=v+(p>g&&g>-p?w:g)+v+(p>j&&j>-p?w:j)+v+(p>m&&m>-p?w:m)+v):u+=",0,0,0,0,1,0,",u+=H+v+J+v+K+v+(M?1+-K/M:1)+")",A[za]=u};j=Da.prototype,j.x=j.y=j.z=j.skewX=j.skewY=j.rotation=j.rotationX=j.rotationY=j.zOrigin=j.xPercent=j.yPercent=j.xOffset=j.yOffset=0,j.scaleX=j.scaleY=j.scaleZ=1,va("transform,scale,scaleX,scaleY,scaleZ,x,y,z,rotation,rotationX,rotationY,rotationZ,skewX,skewY,shortRotation,shortRotationX,shortRotationY,shortRotationZ,transformOrigin,svgOrigin,transformPerspective,directionalRotation,parseTransform,force3D,skewType,xPercent,yPercent,smoothOrigin",{parser:function(a,b,c,d,f,h,i){if(d._lastParsedTransform===i)return f;d._lastParsedTransform=i;var j,k,l,m,n,o,p,q,r,s=a._gsTransform,t=a.style,u=1e-6,v=ya.length,w=i,x={},y="transformOrigin",z=Na(a,e,!0,i.parseTransform);if(d._transform=z,"string"==typeof w.transform&&za)k=N.style,k[za]=w.transform,k.display="block",k.position="absolute",L.body.appendChild(N),j=Na(N,null,!1),z.svg&&(p=z.xOrigin,q=z.yOrigin,j.x-=z.xOffset,j.y-=z.yOffset,(w.transformOrigin||w.svgOrigin)&&(l={},Ia(a,ea(w.transformOrigin),l,w.svgOrigin,w.smoothOrigin,!0),p=l.xOrigin,q=l.yOrigin,j.x-=l.xOffset-z.xOffset,j.y-=l.yOffset-z.yOffset),(p||q)&&(r=Ma(N,!0),j.x-=p-(p*r[0]+q*r[2]),j.y-=q-(p*r[1]+q*r[3]))),L.body.removeChild(N),j.perspective||(j.perspective=z.perspective),null!=w.xPercent&&(j.xPercent=ga(w.xPercent,z.xPercent)),null!=w.yPercent&&(j.yPercent=ga(w.yPercent,z.yPercent));else if("object"==typeof w){if(j={scaleX:ga(null!=w.scaleX?w.scaleX:w.scale,z.scaleX),scaleY:ga(null!=w.scaleY?w.scaleY:w.scale,z.scaleY),scaleZ:ga(w.scaleZ,z.scaleZ),x:ga(w.x,z.x),y:ga(w.y,z.y),z:ga(w.z,z.z),xPercent:ga(w.xPercent,z.xPercent),yPercent:ga(w.yPercent,z.yPercent),perspective:ga(w.transformPerspective,z.perspective)},o=w.directionalRotation,null!=o)if("object"==typeof o)for(k in o)w[k]=o[k];else w.rotation=o;"string"==typeof w.x&&-1!==w.x.indexOf("%")&&(j.x=0,j.xPercent=ga(w.x,z.xPercent)),"string"==typeof w.y&&-1!==w.y.indexOf("%")&&(j.y=0,j.yPercent=ga(w.y,z.yPercent)),j.rotation=ha("rotation"in w?w.rotation:"shortRotation"in w?w.shortRotation+"_short":"rotationZ"in w?w.rotationZ:z.rotation-z.skewY,z.rotation-z.skewY,"rotation",x),Ca&&(j.rotationX=ha("rotationX"in w?w.rotationX:"shortRotationX"in w?w.shortRotationX+"_short":z.rotationX||0,z.rotationX,"rotationX",x),j.rotationY=ha("rotationY"in w?w.rotationY:"shortRotationY"in w?w.shortRotationY+"_short":z.rotationY||0,z.rotationY,"rotationY",x)),j.skewX=ha(w.skewX,z.skewX-z.skewY),(j.skewY=ha(w.skewY,z.skewY))&&(j.skewX+=j.skewY,j.rotation+=j.skewY)}for(Ca&&null!=w.force3D&&(z.force3D=w.force3D,n=!0),z.skewType=w.skewType||z.skewType||g.defaultSkewType,m=z.force3D||z.z||z.rotationX||z.rotationY||j.z||j.rotationX||j.rotationY||j.perspective,m||null==w.scale||(j.scaleZ=1);--v>-1;)c=ya[v],l=j[c]-z[c],(l>u||-u>l||null!=w[c]||null!=K[c])&&(n=!0,f=new qa(z,c,z[c],l,f),c in x&&(f.e=x[c]),f.xs0=0,f.plugin=h,d._overwriteProps.push(f.n));return l=w.transformOrigin,z.svg&&(l||w.svgOrigin)&&(p=z.xOffset,q=z.yOffset,Ia(a,ea(l),j,w.svgOrigin,w.smoothOrigin),f=ra(z,"xOrigin",(s?z:j).xOrigin,j.xOrigin,f,y),f=ra(z,"yOrigin",(s?z:j).yOrigin,j.yOrigin,f,y),(p!==z.xOffset||q!==z.yOffset)&&(f=ra(z,"xOffset",s?p:z.xOffset,z.xOffset,f,y),f=ra(z,"yOffset",s?q:z.yOffset,z.yOffset,f,y)),l=xa?null:"0px 0px"),(l||Ca&&m&&z.zOrigin)&&(za?(n=!0,c=Ba,l=(l||Y(a,c,e,!1,"50% 50%"))+"",f=new qa(t,c,0,0,f,-1,y),f.b=t[c],f.plugin=h,Ca?(k=z.zOrigin,l=l.split(" "),z.zOrigin=(l.length>2&&(0===k||"0px"!==l[2])?parseFloat(l[2]):k)||0,f.xs0=f.e=l[0]+" "+(l[1]||"50%")+" 0px",f=new qa(z,"zOrigin",0,0,f,-1,f.n),f.b=k,f.xs0=f.e=z.zOrigin):f.xs0=f.e=l):ea(l+"",z)),n&&(d._transformType=z.svg&&xa||!m&&3!==this._transformType?2:3),f},prefix:!0}),va("boxShadow",{defaultValue:"0px 0px 0px 0px #999",prefix:!0,color:!0,multi:!0,keyword:"inset"}),va("borderRadius",{defaultValue:"0px",parser:function(a,b,c,f,g,h){b=this.format(b);var i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y=["borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius"],z=a.style;for(q=parseFloat(a.offsetWidth),r=parseFloat(a.offsetHeight),i=b.split(" "),j=0;jp?1:0))||""):(p=parseFloat(n),s=n.substr((p+"").length)),""===s&&(s=d[c]||t),s!==t&&(v=Z(a,"borderLeft",o,t),w=Z(a,"borderTop",o,t),"%"===s?(m=v/q*100+"%",l=w/r*100+"%"):"em"===s?(x=Z(a,"borderLeft",1,"em"),m=v/x+"em",l=w/x+"em"):(m=v+"px",l=w+"px"),u&&(n=parseFloat(m)+p+s,k=parseFloat(l)+p+s)),g=sa(z,y[j],m+" "+l,n+" "+k,!1,"0px",g);return g},prefix:!0,formatter:na("0px 0px 0px 0px",!1,!0)}),va("borderBottomLeftRadius,borderBottomRightRadius,borderTopLeftRadius,borderTopRightRadius",{defaultValue:"0px",parser:function(a,b,c,d,f,g){return sa(a.style,c,this.format(Y(a,c,e,!1,"0px 0px")),this.format(b),!1,"0px",f)},prefix:!0,formatter:na("0px 0px",!1,!0)}),va("backgroundPosition",{defaultValue:"0 0",parser:function(a,b,c,d,f,g){var h,i,j,k,l,m,n="background-position",o=e||X(a,null),q=this.format((o?p?o.getPropertyValue(n+"-x")+" "+o.getPropertyValue(n+"-y"):o.getPropertyValue(n):a.currentStyle.backgroundPositionX+" "+a.currentStyle.backgroundPositionY)||"0 0"),r=this.format(b);if(-1!==q.indexOf("%")!=(-1!==r.indexOf("%"))&&r.split(",").length<2&&(m=Y(a,"backgroundImage").replace(B,""),m&&"none"!==m)){for(h=q.split(" "),i=r.split(" "),O.setAttribute("src",m),j=2;--j>-1;)q=h[j],k=-1!==q.indexOf("%"),k!==(-1!==i[j].indexOf("%"))&&(l=0===j?a.offsetWidth-O.width:a.offsetHeight-O.height,h[j]=k?parseFloat(q)/100*l+"px":parseFloat(q)/l*100+"%");q=h.join(" ")}return this.parseComplex(a.style,q,r,f,g)},formatter:ea}),va("backgroundSize",{defaultValue:"0 0",formatter:ea}),va("perspective",{defaultValue:"0px",prefix:!0}),va("perspectiveOrigin",{defaultValue:"50% 50%",prefix:!0}),va("transformStyle",{prefix:!0}),va("backfaceVisibility",{prefix:!0}),va("userSelect",{prefix:!0}),va("margin",{parser:oa("marginTop,marginRight,marginBottom,marginLeft")}),va("padding",{parser:oa("paddingTop,paddingRight,paddingBottom,paddingLeft")}),va("clip",{defaultValue:"rect(0px,0px,0px,0px)",parser:function(a,b,c,d,f,g){var h,i,j;return 9>p?(i=a.currentStyle,j=8>p?" ":",",h="rect("+i.clipTop+j+i.clipRight+j+i.clipBottom+j+i.clipLeft+")",b=this.format(b).split(",").join(j)):(h=this.format(Y(a,this.p,e,!1,this.dflt)),b=this.format(b)),this.parseComplex(a.style,h,b,f,g)}}),va("textShadow",{defaultValue:"0px 0px 0px #999",color:!0,multi:!0}),va("autoRound,strictUnits",{parser:function(a,b,c,d,e){return e}}),va("border",{defaultValue:"0px solid #000",parser:function(a,b,c,d,f,g){var h=Y(a,"borderTopWidth",e,!1,"0px"),i=this.format(b).split(" "),j=i[0].replace(u,"");return"px"!==j&&(h=parseFloat(h)/Z(a,"borderTopWidth",1,j)+j),this.parseComplex(a.style,this.format(h+" "+Y(a,"borderTopStyle",e,!1,"solid")+" "+Y(a,"borderTopColor",e,!1,"#000")),i.join(" "),f,g)},color:!0,formatter:function(a){var b=a.split(" ");return b[0]+" "+(b[1]||"solid")+" "+(a.match(ma)||["#000"])[0]}}),va("borderWidth",{parser:oa("borderTopWidth,borderRightWidth,borderBottomWidth,borderLeftWidth")}),va("float,cssFloat,styleFloat",{parser:function(a,b,c,d,e,f){var g=a.style,h="cssFloat"in g?"cssFloat":"styleFloat";return new qa(g,h,0,0,e,-1,c,!1,0,g[h],b)}});var Qa=function(a){var b,c=this.t,d=c.filter||Y(this.data,"filter")||"",e=this.s+this.c*a|0;100===e&&(-1===d.indexOf("atrix(")&&-1===d.indexOf("radient(")&&-1===d.indexOf("oader(")?(c.removeAttribute("filter"),b=!Y(this.data,"filter")):(c.filter=d.replace(x,""), +b=!0)),b||(this.xn1&&(c.filter=d=d||"alpha(opacity="+e+")"),-1===d.indexOf("pacity")?0===e&&this.xn1||(c.filter=d+" alpha(opacity="+e+")"):c.filter=d.replace(v,"opacity="+e))};va("opacity,alpha,autoAlpha",{defaultValue:"1",parser:function(a,b,c,d,f,g){var h=parseFloat(Y(a,"opacity",e,!1,"1")),i=a.style,j="autoAlpha"===c;return"string"==typeof b&&"="===b.charAt(1)&&(b=("-"===b.charAt(0)?-1:1)*parseFloat(b.substr(2))+h),j&&1===h&&"hidden"===Y(a,"visibility",e)&&0!==b&&(h=0),R?f=new qa(i,"opacity",h,b-h,f):(f=new qa(i,"opacity",100*h,100*(b-h),f),f.xn1=j?1:0,i.zoom=1,f.type=2,f.b="alpha(opacity="+f.s+")",f.e="alpha(opacity="+(f.s+f.c)+")",f.data=a,f.plugin=g,f.setRatio=Qa),j&&(f=new qa(i,"visibility",0,0,f,-1,null,!1,0,0!==h?"inherit":"hidden",0===b?"hidden":"inherit"),f.xs0="inherit",d._overwriteProps.push(f.n),d._overwriteProps.push(c)),f}});var Ra=function(a,b){b&&(a.removeProperty?(("ms"===b.substr(0,2)||"webkit"===b.substr(0,6))&&(b="-"+b),a.removeProperty(b.replace(z,"-$1").toLowerCase())):a.removeAttribute(b))},Sa=function(a){if(this.t._gsClassPT=this,1===a||0===a){this.t.setAttribute("class",0===a?this.b:this.e);for(var b=this.data,c=this.t.style;b;)b.v?c[b.p]=b.v:Ra(c,b.p),b=b._next;1===a&&this.t._gsClassPT===this&&(this.t._gsClassPT=null)}else this.t.getAttribute("class")!==this.e&&this.t.setAttribute("class",this.e)};va("className",{parser:function(a,b,d,f,g,h,i){var j,k,l,m,n,o=a.getAttribute("class")||"",p=a.style.cssText;if(g=f._classNamePT=new qa(a,d,0,0,g,2),g.setRatio=Sa,g.pr=-11,c=!0,g.b=o,k=_(a,e),l=a._gsClassPT){for(m={},n=l.data;n;)m[n.p]=1,n=n._next;l.setRatio(1)}return a._gsClassPT=g,g.e="="!==b.charAt(1)?b:o.replace(new RegExp("(?:\\s|^)"+b.substr(2)+"(?![\\w-])"),"")+("+"===b.charAt(0)?" "+b.substr(2):""),a.setAttribute("class",g.e),j=aa(a,k,_(a),i,m),a.setAttribute("class",o),g.data=j.firstMPT,a.style.cssText=p,g=g.xfirst=f.parse(a,j.difs,g,h)}});var Ta=function(a){if((1===a||0===a)&&this.data._totalTime===this.data._totalDuration&&"isFromStart"!==this.data.data){var b,c,d,e,f,g=this.t.style,h=i.transform.parse;if("all"===this.e)g.cssText="",e=!0;else for(b=this.e.split(" ").join("").split(","),d=b.length;--d>-1;)c=b[d],i[c]&&(i[c].parse===h?e=!0:c="transformOrigin"===c?Ba:i[c].p),Ra(g,c);e&&(Ra(g,za),f=this.t._gsTransform,f&&(f.svg&&(this.t.removeAttribute("data-svg-origin"),this.t.removeAttribute("transform")),delete this.t._gsTransform))}};for(va("clearProps",{parser:function(a,b,d,e,f){return f=new qa(a,d,0,0,f,2),f.setRatio=Ta,f.e=b,f.pr=-10,f.data=e._tween,c=!0,f}}),j="bezier,throwProps,physicsProps,physics2D".split(","),ta=j.length;ta--;)wa(j[ta]);j=g.prototype,j._firstPT=j._lastParsedTransform=j._transform=null,j._onInitTween=function(a,b,h){if(!a.nodeType)return!1;this._target=a,this._tween=h,this._vars=b,k=b.autoRound,c=!1,d=b.suffixMap||g.suffixMap,e=X(a,""),f=this._overwriteProps;var j,n,p,q,r,s,t,u,v,x=a.style;if(l&&""===x.zIndex&&(j=Y(a,"zIndex",e),("auto"===j||""===j)&&this._addLazySet(x,"zIndex",0)),"string"==typeof b&&(q=x.cssText,j=_(a,e),x.cssText=q+";"+b,j=aa(a,j,_(a)).difs,!R&&w.test(b)&&(j.opacity=parseFloat(RegExp.$1)),b=j,x.cssText=q),b.className?this._firstPT=n=i.className.parse(a,b.className,"className",this,null,null,b):this._firstPT=n=this.parse(a,b,null),this._transformType){for(v=3===this._transformType,za?m&&(l=!0,""===x.zIndex&&(t=Y(a,"zIndex",e),("auto"===t||""===t)&&this._addLazySet(x,"zIndex",0)),o&&this._addLazySet(x,"WebkitBackfaceVisibility",this._vars.WebkitBackfaceVisibility||(v?"visible":"hidden"))):x.zoom=1,p=n;p&&p._next;)p=p._next;u=new qa(a,"transform",0,0,null,2),this._linkCSSP(u,null,p),u.setRatio=za?Pa:Oa,u.data=this._transform||Na(a,e,!0),u.tween=h,u.pr=-1,f.pop()}if(c){for(;n;){for(s=n._next,p=q;p&&p.pr>n.pr;)p=p._next;(n._prev=p?p._prev:r)?n._prev._next=n:q=n,(n._next=p)?p._prev=n:r=n,n=s}this._firstPT=q}return!0},j.parse=function(a,b,c,f){var g,h,j,l,m,n,o,p,q,r,s=a.style;for(g in b)n=b[g],h=i[g],h?c=h.parse(a,n,g,this,c,f,b):(m=Y(a,g,e)+"",q="string"==typeof n,"color"===g||"fill"===g||"stroke"===g||-1!==g.indexOf("Color")||q&&y.test(n)?(q||(n=ka(n),n=(n.length>3?"rgba(":"rgb(")+n.join(",")+")"),c=sa(s,g,m,n,!0,"transparent",c,0,f)):q&&H.test(n)?c=sa(s,g,m,n,!0,null,c,0,f):(j=parseFloat(m),o=j||0===j?m.substr((j+"").length):"",(""===m||"auto"===m)&&("width"===g||"height"===g?(j=da(a,g,e),o="px"):"left"===g||"top"===g?(j=$(a,g,e),o="px"):(j="opacity"!==g?0:1,o="")),r=q&&"="===n.charAt(1),r?(l=parseInt(n.charAt(0)+"1",10),n=n.substr(2),l*=parseFloat(n),p=n.replace(u,"")):(l=parseFloat(n),p=q?n.replace(u,""):""),""===p&&(p=g in d?d[g]:o),n=l||0===l?(r?l+j:l)+p:b[g],o!==p&&""!==p&&(l||0===l)&&j&&(j=Z(a,g,j,o),"%"===p?(j/=Z(a,g,100,"%")/100,b.strictUnits!==!0&&(m=j+"%")):"em"===p||"rem"===p||"vw"===p||"vh"===p?j/=Z(a,g,1,p):"px"!==p&&(l=Z(a,g,l,p),p="px"),r&&(l||0===l)&&(n=l+j+p)),r&&(l+=j),!j&&0!==j||!l&&0!==l?void 0!==s[g]&&(n||n+""!="NaN"&&null!=n)?(c=new qa(s,g,l||j||0,0,c,-1,g,!1,0,m,n),c.xs0="none"!==n||"display"!==g&&-1===g.indexOf("Style")?n:m):T("invalid "+g+" tween value: "+b[g]):(c=new qa(s,g,j,l-j,c,0,g,k!==!1&&("px"===p||"zIndex"===g),0,m,n),c.xs0=p))),f&&c&&!c.plugin&&(c.plugin=f);return c},j.setRatio=function(a){var b,c,d,e=this._firstPT,f=1e-6;if(1!==a||this._tween._time!==this._tween._duration&&0!==this._tween._time)if(a||this._tween._time!==this._tween._duration&&0!==this._tween._time||this._tween._rawPrevTime===-1e-6)for(;e;){if(b=e.c*a+e.s,e.r?b=Math.round(b):f>b&&b>-f&&(b=0),e.type)if(1===e.type)if(d=e.l,2===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2;else if(3===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2+e.xn2+e.xs3;else if(4===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2+e.xn2+e.xs3+e.xn3+e.xs4;else if(5===d)e.t[e.p]=e.xs0+b+e.xs1+e.xn1+e.xs2+e.xn2+e.xs3+e.xn3+e.xs4+e.xn4+e.xs5;else{for(c=e.xs0+b+e.xs1,d=1;d-1;)Va(a[e],b,c);else for(d=a.childNodes,e=d.length;--e>-1;)f=d[e],g=f.type,f.style&&(b.push(_(f)),c&&c.push(f)),1!==g&&9!==g&&11!==g||!f.childNodes.length||Va(f,b,c)};return g.cascadeTo=function(a,c,d){var e,f,g,h,i=b.to(a,c,d),j=[i],k=[],l=[],m=[],n=b._internals.reservedProps;for(a=i._targets||i.target,Va(a,k,m),i.render(c,!0,!0),Va(a,l),i.render(0,!0,!0),i._enabled(!0),e=m.length;--e>-1;)if(f=aa(m[e],k[e],l[e]),f.firstMPT){f=f.difs;for(g in d)n[g]&&(f[g]=d[g]);h={};for(g in f)h[g]=k[e][g];j.push(b.fromTo(m[e],c,h,f))}return j},a.activate([g]),g},!0)}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(),function(a){"use strict";var b=function(){return(_gsScope.GreenSockGlobals||_gsScope)[a]};"function"==typeof define&&define.amd?define(["../TweenLite"],b):"undefined"!=typeof module&&module.exports&&(require("../TweenLite.js"),module.exports=b())}("CSSPlugin"); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/CSSRulePlugin.js b/resources/html5app/js/gsap/plugins/CSSRulePlugin.js new file mode 100644 index 000000000..9d7858dde --- /dev/null +++ b/resources/html5app/js/gsap/plugins/CSSRulePlugin.js @@ -0,0 +1,105 @@ +/*! + * VERSION: beta 0.6.3 + * DATE: 2014-12-31 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine("plugins.CSSRulePlugin", ["plugins.TweenPlugin","TweenLite","plugins.CSSPlugin"], function(TweenPlugin, TweenLite, CSSPlugin) { + + /** @constructor **/ + var CSSRulePlugin = function() { + TweenPlugin.call(this, "cssRule"); + this._overwriteProps.length = 0; + }, + _doc = window.document, + _superSetRatio = CSSPlugin.prototype.setRatio, + p = CSSRulePlugin.prototype = new CSSPlugin(); + + p._propName = "cssRule"; + p.constructor = CSSRulePlugin; + CSSRulePlugin.version = "0.6.3"; + CSSRulePlugin.API = 2; + + /** + * Searches the style sheets in the document for a particular selector like ".myClass" or "a" or "a:hover" or ":after" and + * returns a reference to that style sheet (or an array of them in the case of a pseudo selector like ":after"). Then you + * can animate the individual properties of the style sheet. + * + * @param {!string} selector a string describing the selector, like ".myClass" or "a" or "a:hover" or ":after" + * @return a reference to the style sheet (or an array of them in the case of a pseudo selector). If none was found, null is returned (or an empty array for a pseudo selector) + */ + CSSRulePlugin.getRule = function(selector) { + var ruleProp = _doc.all ? 'rules' : 'cssRules', + ss = _doc.styleSheets, + i = ss.length, + pseudo = (selector.charAt(0) === ":"), + j, curSS, cs, a; + selector = (pseudo ? "" : ",") + selector.toLowerCase() + ","; //note: old versions of IE report tag name selectors as upper case, so we just change everything to lowercase. + if (pseudo) { + a = []; + } + while (--i > -1) { + //Firefox may throw insecure operation errors when css is loaded from other domains, so try/catch. + try { + curSS = ss[i][ruleProp]; + if (!curSS) { + continue; + } + j = curSS.length; + } catch (e) { + console.log(e); + continue; + } + while (--j > -1) { + cs = curSS[j]; + if (cs.selectorText && ("," + cs.selectorText.split("::").join(":").toLowerCase() + ",").indexOf(selector) !== -1) { //note: IE adds an extra ":" to pseudo selectors, so .myClass:after becomes .myClass::after, so we need to strip the extra one out. + if (pseudo) { + a.push(cs.style); + } else { + return cs.style; + } + } + } + } + return a; + }; + + + // @private gets called when the tween renders for the first time. This kicks everything off, recording start/end values, etc. + p._onInitTween = function(target, value, tween) { + if (target.cssText === undefined) { + return false; + } + var div = target._gsProxy = target._gsProxy || _doc.createElement("div"); + this._ss = target; + this._proxy = div.style; + div.style.cssText = target.cssText; + CSSPlugin.prototype._onInitTween.call(this, div, value, tween); //we just offload all the work to the regular CSSPlugin and then copy the cssText back over to the rule in the setRatio() method. This allows us to have all of the updates to CSSPlugin automatically flow through to CSSRulePlugin instead of having to maintain both + return true; + }; + + + + // @private gets called every time the tween updates, passing the new ratio (typically a value between 0 and 1, but not always (for example, if an Elastic.easeOut is used, the value can jump above 1 mid-tween). It will always start and 0 and end at 1. + p.setRatio = function(v) { + _superSetRatio.call(this, v); + this._ss.cssText = this._proxy.cssText; + }; + + + TweenPlugin.activate([CSSRulePlugin]); + return CSSRulePlugin; + + }, true); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/CSSRulePlugin.min.js b/resources/html5app/js/gsap/plugins/CSSRulePlugin.min.js new file mode 100644 index 000000000..c3e4d4846 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/CSSRulePlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: beta 0.6.3 + * DATE: 2014-12-31 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine("plugins.CSSRulePlugin",["plugins.TweenPlugin","TweenLite","plugins.CSSPlugin"],function(a,b,c){var d=function(){a.call(this,"cssRule"),this._overwriteProps.length=0},e=window.document,f=c.prototype.setRatio,g=d.prototype=new c;return g._propName="cssRule",g.constructor=d,d.version="0.6.3",d.API=2,d.getRule=function(a){var b,c,d,f,g=e.all?"rules":"cssRules",h=e.styleSheets,i=h.length,j=":"===a.charAt(0);for(a=(j?"":",")+a.toLowerCase()+",",j&&(f=[]);--i>-1;){try{if(c=h[i][g],!c)continue;b=c.length}catch(k){console.log(k);continue}for(;--b>-1;)if(d=c[b],d.selectorText&&-1!==(","+d.selectorText.split("::").join(":").toLowerCase()+",").indexOf(a)){if(!j)return d.style;f.push(d.style)}}return f},g._onInitTween=function(a,b,d){if(void 0===a.cssText)return!1;var f=a._gsProxy=a._gsProxy||e.createElement("div");return this._ss=a,this._proxy=f.style,f.style.cssText=a.cssText,c.prototype._onInitTween.call(this,f,b,d),!0},g.setRatio=function(a){f.call(this,a),this._ss.cssText=this._proxy.cssText},a.activate([d]),d},!0)}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/ColorPropsPlugin.js b/resources/html5app/js/gsap/plugins/ColorPropsPlugin.js new file mode 100644 index 000000000..705b59de5 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/ColorPropsPlugin.js @@ -0,0 +1,225 @@ +/*! + * VERSION: beta 1.4.2 + * DATE: 2016-04-19 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var _numExp = /(\d|\.)+/g, + _relNumExp = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g, + _colorLookup = {aqua:[0,255,255], + lime:[0,255,0], + silver:[192,192,192], + black:[0,0,0], + maroon:[128,0,0], + teal:[0,128,128], + blue:[0,0,255], + navy:[0,0,128], + white:[255,255,255], + fuchsia:[255,0,255], + olive:[128,128,0], + yellow:[255,255,0], + orange:[255,165,0], + gray:[128,128,128], + purple:[128,0,128], + green:[0,128,0], + red:[255,0,0], + pink:[255,192,203], + cyan:[0,255,255], + transparent:[255,255,255,0]}, + _hue = function(h, m1, m2) { + h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; + return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; + }, + /** + * @private Parses a color (like #9F0, #FF9900, rgb(255,51,153) or hsl(108, 50%, 10%)) into an array with 3 elements for red, green, and blue or if toHSL parameter is true, it will populate the array with hue, saturation, and lightness values. If a relative value is found in an hsl() or hsla() string, it will preserve those relative prefixes and all the values in the array will be strings instead of numbers (in all other cases it will be populated with numbers). + * @param {(string|number)} v The value the should be parsed which could be a string like #9F0 or rgb(255,102,51) or rgba(255,0,0,0.5) or it could be a number like 0xFF00CC or even a named color like red, blue, purple, etc. + * @param {(boolean)} toHSL If true, an hsl() or hsla() value will be returned instead of rgb() or rgba() + * @return {Array.} An array containing red, green, and blue (and optionally alpha) in that order, or if the toHSL parameter was true, the array will contain hue, saturation and lightness (and optionally alpha) in that order. Always numbers unless there's a relative prefix found in an hsl() or hsla() string and toHSL is true. + */ + _parseColor = function(v, toHSL) { + var a, r, g, b, h, s, l, max, min, d, wasHSL; + if (!v) { + a = _colorLookup.black; + } else if (typeof(v) === "number") { + a = [v >> 16, (v >> 8) & 255, v & 255]; + } else { + if (v.charAt(v.length - 1) === ",") { //sometimes a trailing comma is included and we should chop it off (typically from a comma-delimited list of values like a textShadow:"2px 2px 2px blue, 5px 5px 5px rgb(255,0,0)" - in this example "blue," has a trailing comma. We could strip it out inside parseComplex() but we'd need to do it to the beginning and ending values plus it wouldn't provide protection from other potential scenarios like if the user passes in a similar value. + v = v.substr(0, v.length - 1); + } + if (_colorLookup[v]) { + a = _colorLookup[v]; + } else if (v.charAt(0) === "#") { + if (v.length === 4) { //for shorthand like #9F0 + r = v.charAt(1); + g = v.charAt(2); + b = v.charAt(3); + v = "#" + r + r + g + g + b + b; + } + v = parseInt(v.substr(1), 16); + a = [v >> 16, (v >> 8) & 255, v & 255]; + } else if (v.substr(0, 3) === "hsl") { + a = wasHSL = v.match(_numExp); + if (!toHSL) { + h = (Number(a[0]) % 360) / 360; + s = Number(a[1]) / 100; + l = Number(a[2]) / 100; + g = (l <= 0.5) ? l * (s + 1) : l + s - l * s; + r = l * 2 - g; + if (a.length > 3) { + a[3] = Number(v[3]); + } + a[0] = _hue(h + 1 / 3, r, g); + a[1] = _hue(h, r, g); + a[2] = _hue(h - 1 / 3, r, g); + } else if (v.indexOf("=") !== -1) { //if relative values are found, just return the raw strings with the relative prefixes in place. + return v.match(_relNumExp); + } + } else { + a = v.match(_numExp) || _colorLookup.transparent; + } + a[0] = Number(a[0]); + a[1] = Number(a[1]); + a[2] = Number(a[2]); + if (a.length > 3) { + a[3] = Number(a[3]); + } + } + if (toHSL && !wasHSL) { + r = a[0] / 255; + g = a[1] / 255; + b = a[2] / 255; + max = Math.max(r, g, b); + min = Math.min(r, g, b); + l = (max + min) / 2; + if (max === min) { + h = s = 0; + } else { + d = max - min; + s = l > 0.5 ? d / (2 - max - min) : d / (max + min); + h = (max === r) ? (g - b) / d + (g < b ? 6 : 0) : (max === g) ? (b - r) / d + 2 : (r - g) / d + 4; + h *= 60; + } + a[0] = (h + 0.5) | 0; + a[1] = (s * 100 + 0.5) | 0; + a[2] = (l * 100 + 0.5) | 0; + } + return a; + }, + _formatColors = function(s, toHSL) { + var colors = (s + "").match(_colorExp) || [], + charIndex = 0, + parsed = colors.length ? "" : s, + i, color, temp; + for (i = 0; i < colors.length; i++) { + color = colors[i]; + temp = s.substr(charIndex, s.indexOf(color, charIndex)-charIndex); + charIndex += temp.length + color.length; + color = _parseColor(color, toHSL); + if (color.length === 3) { + color.push(1); + } + parsed += temp + (toHSL ? "hsla(" + color[0] + "," + color[1] + "%," + color[2] + "%," + color[3] : "rgba(" + color.join(",")) + ")"; + } + return parsed + s.substr(charIndex); + }, p, _colorStringFilter, + TweenLite = _gsScope.TweenLite, + _colorExp = "(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b", //we'll dynamically build this Regular Expression to conserve file size. After building it, it will be able to find rgb(), rgba(), # (hexadecimal), and named color values like red, blue, purple, etc. + + ColorPropsPlugin = _gsScope._gsDefine.plugin({ + propName: "colorProps", + version: "1.4.2", + priority: -1, + API: 2, + global: true, + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + var p, proxy, pt, val; + this._target = target; + this._proxy = proxy = ((value.format + "").toUpperCase() === "NUMBER") ? {} : 0; + for (p in value) { + if (p !== "format") { + if (proxy) { + this._firstNumPT = pt = {_next:this._firstNumPT, t:target, p:p, f:(typeof(target[p]) === "function")}; + proxy[p] = "rgb(" + _parseColor(!pt.f ? target[p] : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ]()).join(",") + ")"; + val = value[p]; + this._addTween(proxy, p, "get", ((typeof(val) === "number") ? "rgb(" + _parseColor(val, false).join(",") + ")" : val), p, null, null, _colorStringFilter); + } else { + this._addTween(target, p, "get", value[p], p, null, null, _colorStringFilter); + } + + } + } + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(v) { + var pt = this._firstNumPT, + val; + this._super.setRatio.call(this, v); + while (pt) { + val = _parseColor(this._proxy[pt.p], false); + val = val[0] << 16 | val[1] << 8 | val[2]; + if (pt.f) { + this._target[pt.p](val); + } else { + this._target[pt.p] = val; + } + pt = pt._next; + } + } + }); + + for (p in _colorLookup) { + _colorExp += "|" + p + "\\b"; + } + _colorExp = new RegExp(_colorExp+")", "gi"); + ColorPropsPlugin.colorStringFilter = _colorStringFilter = function(a) { + var combined = a[0] + a[1], + toHSL; + _colorExp.lastIndex = 0; + if (_colorExp.test(combined)) { + toHSL = (combined.indexOf("hsl(") !== -1 || combined.indexOf("hsla(") !== -1); + a[0] = _formatColors(a[0], toHSL); + a[1] = _formatColors(a[1], toHSL); + } + }; + + if (!TweenLite.defaultStringFilter) { + TweenLite.defaultStringFilter = ColorPropsPlugin.colorStringFilter; + } + + ColorPropsPlugin.parseColor = _parseColor; + p = ColorPropsPlugin.prototype; + p._firstNumPT = null; + p._kill = function(lookup) { + var pt = this._firstNumPT, + prev; + while (pt) { + if (pt.p in lookup) { + if (pt === p._firstNumPT) { + this._firstNumPT = pt._next; + } + if (prev) { + prev._next = pt._next; + } + } else { + prev = pt; + } + pt = pt._next; + } + return this._super._kill(lookup); + }; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } diff --git a/resources/html5app/js/gsap/plugins/ColorPropsPlugin.min.js b/resources/html5app/js/gsap/plugins/ColorPropsPlugin.min.js new file mode 100644 index 000000000..5ac8ed172 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/ColorPropsPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: beta 1.4.2 + * DATE: 2016-04-19 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a,b,c=/(\d|\.)+/g,d=/(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g,e={aqua:[0,255,255],lime:[0,255,0],silver:[192,192,192],black:[0,0,0],maroon:[128,0,0],teal:[0,128,128],blue:[0,0,255],navy:[0,0,128],white:[255,255,255],fuchsia:[255,0,255],olive:[128,128,0],yellow:[255,255,0],orange:[255,165,0],gray:[128,128,128],purple:[128,0,128],green:[0,128,0],red:[255,0,0],pink:[255,192,203],cyan:[0,255,255],transparent:[255,255,255,0]},f=function(a,b,c){return a=0>a?a+1:a>1?a-1:a,255*(1>6*a?b+(c-b)*a*6:.5>a?c:2>3*a?b+(c-b)*(2/3-a)*6:b)+.5|0},g=function(a,b){var g,h,i,j,k,l,m,n,o,p,q;if(a)if("number"==typeof a)g=[a>>16,a>>8&255,255&a];else{if(","===a.charAt(a.length-1)&&(a=a.substr(0,a.length-1)),e[a])g=e[a];else if("#"===a.charAt(0))4===a.length&&(h=a.charAt(1),i=a.charAt(2),j=a.charAt(3),a="#"+h+h+i+i+j+j),a=parseInt(a.substr(1),16),g=[a>>16,a>>8&255,255&a];else if("hsl"===a.substr(0,3))if(g=q=a.match(c),b){if(-1!==a.indexOf("="))return a.match(d)}else k=Number(g[0])%360/360,l=Number(g[1])/100,m=Number(g[2])/100,i=.5>=m?m*(l+1):m+l-m*l,h=2*m-i,g.length>3&&(g[3]=Number(a[3])),g[0]=f(k+1/3,h,i),g[1]=f(k,h,i),g[2]=f(k-1/3,h,i);else g=a.match(c)||e.transparent;g[0]=Number(g[0]),g[1]=Number(g[1]),g[2]=Number(g[2]),g.length>3&&(g[3]=Number(g[3]))}else g=e.black;return b&&!q&&(h=g[0]/255,i=g[1]/255,j=g[2]/255,n=Math.max(h,i,j),o=Math.min(h,i,j),m=(n+o)/2,n===o?k=l=0:(p=n-o,l=m>.5?p/(2-n-o):p/(n+o),k=n===h?(i-j)/p+(j>i?6:0):n===i?(j-h)/p+2:(h-i)/p+4,k*=60),g[0]=k+.5|0,g[1]=100*l+.5|0,g[2]=100*m+.5|0),g},h=function(a,b){var c,d,e,f=(a+"").match(j)||[],h=0,i=f.length?"":a;for(c=0;c 0) { + dif = ((dif - cap * 9999999999) % cap) - ((dif / cap) | 0) * cap; + } + } + if (dif > min || dif < -min) { + this._addTween(target, p, start, start + dif, p); + this._overwriteProps.push(p); + } + } + } + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(ratio) { + var pt; + if (ratio !== 1) { + this._super.setRatio.call(this, ratio); + } else { + pt = this._firstPT; + while (pt) { + if (pt.f) { + pt.t[pt.p](this.finals[pt.p]); + } else { + pt.t[pt.p] = this.finals[pt.p]; + } + pt = pt._next; + } + } + } + + })._autoCSS = true; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/DirectionalRotationPlugin.min.js b/resources/html5app/js/gsap/plugins/DirectionalRotationPlugin.min.js new file mode 100644 index 000000000..5f9a98805 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/DirectionalRotationPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: beta 0.2.1 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine.plugin({propName:"directionalRotation",version:"0.2.1",API:2,init:function(a,b,c){"object"!=typeof b&&(b={rotation:b}),this.finals={};var d,e,f,g,h,i,j=b.useRadians===!0?2*Math.PI:360,k=1e-6;for(d in b)"useRadians"!==d&&(i=(b[d]+"").split("_"),e=i[0],f=parseFloat("function"!=typeof a[d]?a[d]:a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]()),g=this.finals[d]="string"==typeof e&&"="===e.charAt(1)?f+parseInt(e.charAt(0)+"1",10)*Number(e.substr(2)):Number(e)||0,h=g-f,i.length&&(e=i.join("_"),-1!==e.indexOf("short")&&(h%=j,h!==h%(j/2)&&(h=0>h?h+j:h-j)),-1!==e.indexOf("_cw")&&0>h?h=(h+9999999999*j)%j-(h/j|0)*j:-1!==e.indexOf("ccw")&&h>0&&(h=(h-9999999999*j)%j-(h/j|0)*j)),(h>k||-k>h)&&(this._addTween(a,d,f,f+h,d),this._overwriteProps.push(d)));return!0},set:function(a){var b;if(1!==a)this._super.setRatio.call(this,a);else for(b=this._firstPT;b;)b.f?b.t[b.p](this.finals[b.p]):b.t[b.p]=this.finals[b.p],b=b._next}})._autoCSS=!0}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/EaselPlugin.js b/resources/html5app/js/gsap/plugins/EaselPlugin.js new file mode 100644 index 000000000..fdd8b40ed --- /dev/null +++ b/resources/html5app/js/gsap/plugins/EaselPlugin.js @@ -0,0 +1,300 @@ +/*! + * VERSION: 0.1.6 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var _numExp = /(\d|\.)+/g, + _ColorFilter, _ColorMatrixFilter, + _colorProps = ["redMultiplier","greenMultiplier","blueMultiplier","alphaMultiplier","redOffset","greenOffset","blueOffset","alphaOffset"], + _colorLookup = {aqua:[0,255,255], + lime:[0,255,0], + silver:[192,192,192], + black:[0,0,0], + maroon:[128,0,0], + teal:[0,128,128], + blue:[0,0,255], + navy:[0,0,128], + white:[255,255,255], + fuchsia:[255,0,255], + olive:[128,128,0], + yellow:[255,255,0], + orange:[255,165,0], + gray:[128,128,128], + purple:[128,0,128], + green:[0,128,0], + red:[255,0,0], + pink:[255,192,203], + cyan:[0,255,255], + transparent:[255,255,255,0]}, + _parseColor = function(color) { + if (color === "" || color == null || color === "none") { + return _colorLookup.transparent; + } else if (_colorLookup[color]) { + return _colorLookup[color]; + } else if (typeof(color) === "number") { + return [color >> 16, (color >> 8) & 255, color & 255]; + } else if (color.charAt(0) === "#") { + if (color.length === 4) { //for shorthand like #9F0 + color = "#" + color.charAt(1) + color.charAt(1) + color.charAt(2) + color.charAt(2) + color.charAt(3) + color.charAt(3); + } + color = parseInt(color.substr(1), 16); + return [color >> 16, (color >> 8) & 255, color & 255]; + } + return color.match(_numExp) || _colorLookup.transparent; + }, + _parseColorFilter = function(t, v, pg) { + if (!_ColorFilter) { + _ColorFilter = (_gsScope.ColorFilter || _gsScope.createjs.ColorFilter); + if (!_ColorFilter) { + throw("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded."); + } + } + var filters = t.filters || [], + i = filters.length, + c, s, e, a, p; + while (--i > -1) { + if (filters[i] instanceof _ColorFilter) { + s = filters[i]; + break; + } + } + if (!s) { + s = new _ColorFilter(); + filters.push(s); + t.filters = filters; + } + e = s.clone(); + if (v.tint != null) { + c = _parseColor(v.tint); + a = (v.tintAmount != null) ? Number(v.tintAmount) : 1; + e.redOffset = Number(c[0]) * a; + e.greenOffset = Number(c[1]) * a; + e.blueOffset = Number(c[2]) * a; + e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - a; + } else { + for (p in v) { + if (p !== "exposure") if (p !== "brightness") { + e[p] = Number(v[p]); + } + } + } + if (v.exposure != null) { + e.redOffset = e.greenOffset = e.blueOffset = 255 * (Number(v.exposure) - 1); + e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1; + } else if (v.brightness != null) { + a = Number(v.brightness) - 1; + e.redOffset = e.greenOffset = e.blueOffset = (a > 0) ? a * 255 : 0; + e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - Math.abs(a); + } + i = 8; + while (--i > -1) { + p = _colorProps[i]; + if (s[p] !== e[p]) { + pg._addTween(s, p, s[p], e[p], "easel_colorFilter"); + } + } + pg._overwriteProps.push("easel_colorFilter"); + if (!t.cacheID) { + throw("EaselPlugin warning: for filters to display in EaselJS, you must call the object's cache() method first. " + t); + } + }, + + _idMatrix = [1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0], + _lumR = 0.212671, + _lumG = 0.715160, + _lumB = 0.072169, + + _applyMatrix = function(m, m2) { + if (!(m instanceof Array) || !(m2 instanceof Array)) { + return m2; + } + var temp = [], + i = 0, + z = 0, + y, x; + for (y = 0; y < 4; y++) { + for (x = 0; x < 5; x++) { + z = (x === 4) ? m[i + 4] : 0; + temp[i + x] = m[i] * m2[x] + m[i+1] * m2[x + 5] + m[i+2] * m2[x + 10] + m[i+3] * m2[x + 15] + z; + } + i += 5; + } + return temp; + }, + + _setSaturation = function(m, n) { + if (isNaN(n)) { + return m; + } + var inv = 1 - n, + r = inv * _lumR, + g = inv * _lumG, + b = inv * _lumB; + return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m); + }, + + _colorize = function(m, color, amount) { + if (isNaN(amount)) { + amount = 1; + } + var c = _parseColor(color), + r = c[0] / 255, + g = c[1] / 255, + b = c[2] / 255, + inv = 1 - amount; + return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m); + }, + + _setHue = function(m, n) { + if (isNaN(n)) { + return m; + } + n *= Math.PI / 180; + var c = Math.cos(n), + s = Math.sin(n); + return _applyMatrix([(_lumR + (c * (1 - _lumR))) + (s * (-_lumR)), (_lumG + (c * (-_lumG))) + (s * (-_lumG)), (_lumB + (c * (-_lumB))) + (s * (1 - _lumB)), 0, 0, (_lumR + (c * (-_lumR))) + (s * 0.143), (_lumG + (c * (1 - _lumG))) + (s * 0.14), (_lumB + (c * (-_lumB))) + (s * -0.283), 0, 0, (_lumR + (c * (-_lumR))) + (s * (-(1 - _lumR))), (_lumG + (c * (-_lumG))) + (s * _lumG), (_lumB + (c * (1 - _lumB))) + (s * _lumB), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m); + }, + + _setContrast = function(m, n) { + if (isNaN(n)) { + return m; + } + n += 0.01; + return _applyMatrix([n,0,0,0,128 * (1 - n), 0,n,0,0,128 * (1 - n), 0,0,n,0,128 * (1 - n), 0,0,0,1,0], m); + }, + + _parseColorMatrixFilter = function(t, v, pg) { + if (!_ColorMatrixFilter) { + _ColorMatrixFilter = (_gsScope.ColorMatrixFilter || _gsScope.createjs.ColorMatrixFilter); + if (!_ColorMatrixFilter) { + throw("EaselPlugin error: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded."); + } + } + var filters = t.filters || [], + i = filters.length, + matrix, startMatrix, s; + while (--i > -1) { + if (filters[i] instanceof _ColorMatrixFilter) { + s = filters[i]; + break; + } + } + if (!s) { + s = new _ColorMatrixFilter(_idMatrix.slice()); + filters.push(s); + t.filters = filters; + } + startMatrix = s.matrix; + matrix = _idMatrix.slice(); + if (v.colorize != null) { + matrix = _colorize(matrix, v.colorize, Number(v.colorizeAmount)); + } + if (v.contrast != null) { + matrix = _setContrast(matrix, Number(v.contrast)); + } + if (v.hue != null) { + matrix = _setHue(matrix, Number(v.hue)); + } + if (v.saturation != null) { + matrix = _setSaturation(matrix, Number(v.saturation)); + } + + i = matrix.length; + while (--i > -1) { + if (matrix[i] !== startMatrix[i]) { + pg._addTween(startMatrix, i, startMatrix[i], matrix[i], "easel_colorMatrixFilter"); + } + } + + pg._overwriteProps.push("easel_colorMatrixFilter"); + if (!t.cacheID) { + throw("EaselPlugin warning: for filters to display in EaselJS, you must call the object's cache() method first. " + t); + } + + pg._matrix = startMatrix; + }; + + + _gsScope._gsDefine.plugin({ + propName: "easel", + priority: -1, + version: "0.1.6", + API: 2, + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + this._target = target; + var p, pt, tint, colorMatrix; + for (p in value) { + + if (p === "colorFilter" || p === "tint" || p === "tintAmount" || p === "exposure" || p === "brightness") { + if (!tint) { + _parseColorFilter(target, value.colorFilter || value, this); + tint = true; + } + + } else if (p === "saturation" || p === "contrast" || p === "hue" || p === "colorize" || p === "colorizeAmount") { + if (!colorMatrix) { + _parseColorMatrixFilter(target, value.colorMatrixFilter || value, this); + colorMatrix = true; + } + + } else if (p === "frame") { + this._firstPT = pt = {_next:this._firstPT, t:target, p:"gotoAndStop", s:target.currentFrame, f:true, n:"frame", pr:0, type:0, r:true}; + pt.c = (typeof(value[p]) === "number") ? value[p] - pt.s : (typeof(value[p]) === "string") ? parseFloat(value[p].split("=").join("")) : 0; + if (pt._next) { + pt._next._prev = pt; + } + + } else if (target[p] != null) { + this._firstPT = pt = {_next:this._firstPT, t:target, p:p, f:(typeof(target[p]) === "function"), n:p, pr:0, type:0}; + pt.s = (!pt.f) ? parseFloat(target[p]) : target[ ((p.indexOf("set") || typeof(target["get" + p.substr(3)]) !== "function") ? p : "get" + p.substr(3)) ](); + pt.c = (typeof(value[p]) === "number") ? value[p] - pt.s : (typeof(value[p]) === "string") ? parseFloat(value[p].split("=").join("")) : 0; + + if (pt._next) { + pt._next._prev = pt; + } + } + + } + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(v) { + var pt = this._firstPT, + min = 0.000001, + val; + while (pt) { + val = pt.c * v + pt.s; + if (pt.r) { + val = Math.round(val); + } else if (val < min && val > -min) { + val = 0; + } + if (pt.f) { + pt.t[pt.p](val); + } else { + pt.t[pt.p] = val; + } + pt = pt._next; + } + if (this._target.cacheID) { + this._target.updateCache(); + } + } + + }); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/EaselPlugin.min.js b/resources/html5app/js/gsap/plugins/EaselPlugin.min.js new file mode 100644 index 000000000..517194d9f --- /dev/null +++ b/resources/html5app/js/gsap/plugins/EaselPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 0.1.6 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a,b,c=/(\d|\.)+/g,d=["redMultiplier","greenMultiplier","blueMultiplier","alphaMultiplier","redOffset","greenOffset","blueOffset","alphaOffset"],e={aqua:[0,255,255],lime:[0,255,0],silver:[192,192,192],black:[0,0,0],maroon:[128,0,0],teal:[0,128,128],blue:[0,0,255],navy:[0,0,128],white:[255,255,255],fuchsia:[255,0,255],olive:[128,128,0],yellow:[255,255,0],orange:[255,165,0],gray:[128,128,128],purple:[128,0,128],green:[0,128,0],red:[255,0,0],pink:[255,192,203],cyan:[0,255,255],transparent:[255,255,255,0]},f=function(a){return""===a||null==a||"none"===a?e.transparent:e[a]?e[a]:"number"==typeof a?[a>>16,a>>8&255,255&a]:"#"===a.charAt(0)?(4===a.length&&(a="#"+a.charAt(1)+a.charAt(1)+a.charAt(2)+a.charAt(2)+a.charAt(3)+a.charAt(3)),a=parseInt(a.substr(1),16),[a>>16,a>>8&255,255&a]):a.match(c)||e.transparent},g=function(b,c,e){if(!a&&(a=_gsScope.ColorFilter||_gsScope.createjs.ColorFilter,!a))throw"EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded.";for(var g,h,i,j,k,l=b.filters||[],m=l.length;--m>-1;)if(l[m]instanceof a){h=l[m];break}if(h||(h=new a,l.push(h),b.filters=l),i=h.clone(),null!=c.tint)g=f(c.tint),j=null!=c.tintAmount?Number(c.tintAmount):1,i.redOffset=Number(g[0])*j,i.greenOffset=Number(g[1])*j,i.blueOffset=Number(g[2])*j,i.redMultiplier=i.greenMultiplier=i.blueMultiplier=1-j;else for(k in c)"exposure"!==k&&"brightness"!==k&&(i[k]=Number(c[k]));for(null!=c.exposure?(i.redOffset=i.greenOffset=i.blueOffset=255*(Number(c.exposure)-1),i.redMultiplier=i.greenMultiplier=i.blueMultiplier=1):null!=c.brightness&&(j=Number(c.brightness)-1,i.redOffset=i.greenOffset=i.blueOffset=j>0?255*j:0,i.redMultiplier=i.greenMultiplier=i.blueMultiplier=1-Math.abs(j)),m=8;--m>-1;)k=d[m],h[k]!==i[k]&&e._addTween(h,k,h[k],i[k],"easel_colorFilter");if(e._overwriteProps.push("easel_colorFilter"),!b.cacheID)throw"EaselPlugin warning: for filters to display in EaselJS, you must call the object's cache() method first. "+b},h=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0],i=.212671,j=.71516,k=.072169,l=function(a,b){if(!(a instanceof Array&&b instanceof Array))return b;var c,d,e=[],f=0,g=0;for(c=0;4>c;c++){for(d=0;5>d;d++)g=4===d?a[f+4]:0,e[f+d]=a[f]*b[d]+a[f+1]*b[d+5]+a[f+2]*b[d+10]+a[f+3]*b[d+15]+g;f+=5}return e},m=function(a,b){if(isNaN(b))return a;var c=1-b,d=c*i,e=c*j,f=c*k;return l([d+b,e,f,0,0,d,e+b,f,0,0,d,e,f+b,0,0,0,0,0,1,0],a)},n=function(a,b,c){isNaN(c)&&(c=1);var d=f(b),e=d[0]/255,g=d[1]/255,h=d[2]/255,m=1-c;return l([m+c*e*i,c*e*j,c*e*k,0,0,c*g*i,m+c*g*j,c*g*k,0,0,c*h*i,c*h*j,m+c*h*k,0,0,0,0,0,1,0],a)},o=function(a,b){if(isNaN(b))return a;b*=Math.PI/180;var c=Math.cos(b),d=Math.sin(b);return l([i+c*(1-i)+d*-i,j+c*-j+d*-j,k+c*-k+d*(1-k),0,0,i+c*-i+.143*d,j+c*(1-j)+.14*d,k+c*-k+d*-.283,0,0,i+c*-i+d*-(1-i),j+c*-j+d*j,k+c*(1-k)+d*k,0,0,0,0,0,1,0,0,0,0,0,1],a)},p=function(a,b){return isNaN(b)?a:(b+=.01,l([b,0,0,0,128*(1-b),0,b,0,0,128*(1-b),0,0,b,0,128*(1-b),0,0,0,1,0],a))},q=function(a,c,d){if(!b&&(b=_gsScope.ColorMatrixFilter||_gsScope.createjs.ColorMatrixFilter,!b))throw"EaselPlugin error: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded.";for(var e,f,g,i=a.filters||[],j=i.length;--j>-1;)if(i[j]instanceof b){g=i[j];break}for(g||(g=new b(h.slice()),i.push(g),a.filters=i),f=g.matrix,e=h.slice(),null!=c.colorize&&(e=n(e,c.colorize,Number(c.colorizeAmount))),null!=c.contrast&&(e=p(e,Number(c.contrast))),null!=c.hue&&(e=o(e,Number(c.hue))),null!=c.saturation&&(e=m(e,Number(c.saturation))),j=e.length;--j>-1;)e[j]!==f[j]&&d._addTween(f,j,f[j],e[j],"easel_colorMatrixFilter");if(d._overwriteProps.push("easel_colorMatrixFilter"),!a.cacheID)throw"EaselPlugin warning: for filters to display in EaselJS, you must call the object's cache() method first. "+a;d._matrix=f};_gsScope._gsDefine.plugin({propName:"easel",priority:-1,version:"0.1.6",API:2,init:function(a,b,c){this._target=a;var d,e,f,h;for(d in b)"colorFilter"===d||"tint"===d||"tintAmount"===d||"exposure"===d||"brightness"===d?f||(g(a,b.colorFilter||b,this),f=!0):"saturation"===d||"contrast"===d||"hue"===d||"colorize"===d||"colorizeAmount"===d?h||(q(a,b.colorMatrixFilter||b,this),h=!0):"frame"===d?(this._firstPT=e={_next:this._firstPT,t:a,p:"gotoAndStop",s:a.currentFrame,f:!0,n:"frame",pr:0,type:0,r:!0},e.c="number"==typeof b[d]?b[d]-e.s:"string"==typeof b[d]?parseFloat(b[d].split("=").join("")):0,e._next&&(e._next._prev=e)):null!=a[d]&&(this._firstPT=e={_next:this._firstPT,t:a,p:d,f:"function"==typeof a[d],n:d,pr:0,type:0},e.s=e.f?a[d.indexOf("set")||"function"!=typeof a["get"+d.substr(3)]?d:"get"+d.substr(3)]():parseFloat(a[d]),e.c="number"==typeof b[d]?b[d]-e.s:"string"==typeof b[d]?parseFloat(b[d].split("=").join("")):0,e._next&&(e._next._prev=e));return!0},set:function(a){for(var b,c=this._firstPT,d=1e-6;c;)b=c.c*a+c.s,c.r?b=Math.round(b):d>b&&b>-d&&(b=0),c.f?c.t[c.p](b):c.t[c.p]=b,c=c._next;this._target.cacheID&&this._target.updateCache()}})}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/EndArrayPlugin.js b/resources/html5app/js/gsap/plugins/EndArrayPlugin.js new file mode 100644 index 000000000..597963755 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/EndArrayPlugin.js @@ -0,0 +1,70 @@ +/*! + * VERSION: 0.1.2 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine.plugin({ + propName: "endArray", + API: 2, + version: "0.1.2", + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + var i = value.length, + a = this.a = [], + start, end; + this.target = target; + this._round = false; + if (!i) { + return false; + } + while (--i > -1) { + start = target[i]; + end = value[i]; + if (start !== end) { + a.push({i:i, s:start, c:end - start}); + } + } + return true; + }, + + round: function(lookup) { + if ("endArray" in lookup) { + this._round = true; + } + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(ratio) { + var target = this.target, + a = this.a, + i = a.length, + e, val; + if (this._round) { + while (--i > -1) { + e = a[i]; + target[e.i] = Math.round(e.s + e.c * ratio); + } + } else { + while (--i > -1) { + e = a[i]; + val = e.s + e.c * ratio; + target[e.i] = (val < 0.000001 && val > -0.000001) ? 0 : val; + } + } + } + + }); + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/EndArrayPlugin.min.js b/resources/html5app/js/gsap/plugins/EndArrayPlugin.min.js new file mode 100644 index 000000000..c522a8f44 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/EndArrayPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 0.1.2 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";_gsScope._gsDefine.plugin({propName:"endArray",API:2,version:"0.1.2",init:function(a,b,c){var d,e,f=b.length,g=this.a=[];if(this.target=a,this._round=!1,!f)return!1;for(;--f>-1;)d=a[f],e=b[f],d!==e&&g.push({i:f,s:d,c:e-d});return!0},round:function(a){"endArray"in a&&(this._round=!0)},set:function(a){var b,c,d=this.target,e=this.a,f=e.length;if(this._round)for(;--f>-1;)b=e[f],d[b.i]=Math.round(b.s+b.c*a);else for(;--f>-1;)b=e[f],c=b.s+b.c*a,d[b.i]=1e-6>c&&c>-1e-6?0:c}})}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/KineticPlugin.js b/resources/html5app/js/gsap/plugins/KineticPlugin.js new file mode 100644 index 000000000..6abc0b5a8 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/KineticPlugin.js @@ -0,0 +1,335 @@ +/*! + * VERSION: 0.5.2 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var _specialProps = {scale:1, shadowOffset:1, fillPatternOffset:1, offset:1, fill:2, stroke:2, shadowColor:2}, //type 1 is one that has "x" and "y" components that can be split apart but in order to set them, they must be combined into a single object and passed to one setter (like setScale({x:0.5, y:0.6})). Type 2 is for colors. + _getterFuncs = {}, + _setterFuncs = {}, + _numExp = /(\d|\.)+/g, + _directionalRotationExp = /(?:_cw|_ccw|_short)/, + _plugins = _gsScope._gsDefine.globals.com.greensock.plugins, + _colorLookup = {aqua:[0,255,255], + lime:[0,255,0], + silver:[192,192,192], + black:[0,0,0], + maroon:[128,0,0], + teal:[0,128,128], + blue:[0,0,255], + navy:[0,0,128], + white:[255,255,255], + fuchsia:[255,0,255], + olive:[128,128,0], + yellow:[255,255,0], + orange:[255,165,0], + gray:[128,128,128], + purple:[128,0,128], + green:[0,128,0], + red:[255,0,0], + pink:[255,192,203], + cyan:[0,255,255], + transparent:[255,255,255,0]}, + _hue = function(h, m1, m2) { + h = (h < 0) ? h + 1 : (h > 1) ? h - 1 : h; + return ((((h * 6 < 1) ? m1 + (m2 - m1) * h * 6 : (h < 0.5) ? m2 : (h * 3 < 2) ? m1 + (m2 - m1) * (2 / 3 - h) * 6 : m1) * 255) + 0.5) | 0; + }, + _parseColor = function(color) { + if (color === "" || color == null || color === "none") { + return _colorLookup.transparent; + } + if (_colorLookup[color]) { + return _colorLookup[color]; + } + if (typeof(color) === "number") { + return [color >> 16, (color >> 8) & 255, color & 255]; + } + if (color.charAt(0) === "#") { + if (color.length === 4) { //for shorthand like #9F0 + color = "#" + color.charAt(1) + color.charAt(1) + color.charAt(2) + color.charAt(2) + color.charAt(3) + color.charAt(3); + } + color = parseInt(color.substr(1), 16); + return [color >> 16, (color >> 8) & 255, color & 255]; + } + if (color.substr(0, 3) === "hsl") { + color = color.match(_numExp); + var h = (Number(color[0]) % 360) / 360, + s = Number(color[1]) / 100, + l = Number(color[2]) / 100, + m2 = (l <= 0.5) ? l * (s + 1) : l + s - l * s, + m1 = l * 2 - m2; + if (color.length > 3) { + color[3] = Number(color[3]); + } + color[0] = _hue(h + 1 / 3, m1, m2); + color[1] = _hue(h, m1, m2); + color[2] = _hue(h - 1 / 3, m1, m2); + return color; + } + var a = color.match(_numExp) || _colorLookup.transparent, + i = a.length; + while (--i > -1) { + a[i] = Number(a[i]); + } + return a; + }, + ColorProp = function(target, getter, setter, next) { + this.getter = getter; + this.setter = setter; + var val = _parseColor( target[getter]() ); + this.proxy = {r:val[0], g:val[1], b:val[2], a:(val.length > 3 ? val[3] : 1)}; + if (next) { + this._next = next; + next._prev = this; + } + }, + _layersToDraw = [], + _ticker, _listening, + _onTick = function() { + var i = _layersToDraw.length; + if (i !== 0) { + while (--i > -1) { + _layersToDraw[i].draw(); + _layersToDraw[i]._gsDraw = false; + } + _layersToDraw.length = 0; + } else { + _ticker.removeEventListener("tick", _onTick); + _listening = false; + } + }, + _prepDimensionProp = function(p, dimension) { + var alt = (dimension === "x") ? "y" : "x", + proxyName = "_gs_" + p; + _getterFuncs[p] = function() { + return this["get" + p]()[dimension]; + }; + _setterFuncs[p] = function(value) { + var cur = this["get" + p](), + proxy = this[proxyName]; + if (!proxy) { + proxy = this[proxyName] = {}; + } + proxy[dimension] = value; + proxy[alt] = cur[alt]; + this[p](proxy); + return this; + }; + }, + _createGetterSetter = function(getter, setter) { + return function(value) {return (arguments.length) ? setter(value) : getter(); }; + }, + //looks at every property in the vars and converts them (when appropriate) to the KineticJS equivalent. If it finds a special property for which "x" and "y" must be split apart (like scale, offset, shadowOffset, etc.), it will do that as well. This method returns an array of any names it had to change (like "x", "y", "scale", etc.) so that they can be used in the overwriteProps array. + _convertProps = function(target, vars) { + var converted = [], + p, val, i, proto; + for (p in vars) { + val = vars[p]; + if (p !== "bezier" && p !== "autoDraw" && p.substr(0,3) !== "set" && target[p] === undefined) { + converted.push(p); + delete vars[p]; + p = "set" + p.charAt(0).toUpperCase() + p.substr(1); + vars[p] = val; + } + if (_specialProps[p]) { + if (_specialProps[p] === 1) { + vars[p + "X"] = vars[p + "Y"] = vars[p]; + delete vars[p]; + return _convertProps(target, vars); + } else if (!target[p] && _setterFuncs[p]) { + proto = target.prototype || target; + proto[p] = _createGetterSetter(_getterFuncs[p], _setterFuncs[p]); + } + } else if (p === "bezier") { + val = (val instanceof Array) ? val : val.values || []; + i = val.length; + while (--i > -1) { + if (i === 0) { + converted = converted.concat( _convertProps(target, val[i]) ); + } else { + _convertProps(target, val[i]); + } + } + } + } + return converted; + }, + _copy = function(obj) { + var result = {}, + p; + for (p in obj) { + result[p] = obj[p]; + } + return result; + }, + versionValid, p; + + for (p in _specialProps) { + if (_specialProps[p] === 1) { + _prepDimensionProp(p, "x"); + _prepDimensionProp(p, "y"); + } + } + + var KineticPlugin = _gsScope._gsDefine.plugin({ + propName: "kinetic", + API: 2, + version: "0.5.2", + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + var p, val, gp, sp, bezierPlugin, directionalRotationPlugin; + if (!versionValid && (versionValid = (parseInt(Kinetic.version.split(".")[0], 10)) < 5)) { + throw ("The GSAP KineticPlugin that's loaded requires KineticJS version 5.0.0 or later. For earlier versions, use KineticPlugin from GSAP 1.11.3 or earlier."); + } + this._overwriteProps = _convertProps(target, value); //allow users to pass in shorter names like "x" instead of "setX" and "rotationDeg" instead of "setRotationDeg" + this._target = target; + this._layer = (value.autoDraw !== false) ? target.getLayer() : null; + if (!_ticker && this._layer) { + _ticker = tween.constructor.ticker; + } + for (p in value) { + val = value[p]; + //we must handle colors in a special way, splitting apart the red, green, blue, and alpha. + if (_specialProps[p] === 2) { + sp = this._firstSP = new ColorProp(target, p, p, this._firstSP); + val = _parseColor(val); + if (sp.proxy.r !== val[0]) { + this._addTween(sp.proxy, "r", sp.proxy.r, val[0], p); + } + if (sp.proxy.g !== val[1]) { + this._addTween(sp.proxy, "g", sp.proxy.g, val[1], p); + } + if (sp.proxy.b !== val[2]) { + this._addTween(sp.proxy, "b", sp.proxy.b, val[2], p); + } + if ((val.length > 3 || sp.proxy.a !== 1) && sp.proxy.a !== val[3]) { + this._addTween(sp.proxy, "a", sp.proxy.a, (val.length > 3 ? val[3] : 1), p); + } + } else if (p === "bezier") { + bezierPlugin = _plugins.BezierPlugin; + if (!bezierPlugin) { + throw("BezierPlugin not loaded"); + } + bezierPlugin = this._bezier = new bezierPlugin(); + if (typeof(val) === "object" && val.autoRotate === true) { + val.autoRotate = ["x","y","rotation",0,false]; + } + bezierPlugin._onInitTween(target, val, tween); + this._overwriteProps = this._overwriteProps.concat(bezierPlugin._overwriteProps); + this._addTween(bezierPlugin, "setRatio", 0, 1, p); + + } else if ((p === "rotation" || p === "rotationDeg") && typeof(val) === "string" && _directionalRotationExp.test(val)) { + directionalRotationPlugin = _plugins.DirectionalRotationPlugin; + if (!directionalRotationPlugin) { + throw("DirectionalRotationPlugin not loaded"); + } + directionalRotationPlugin = this._directionalRotation = new directionalRotationPlugin(); + gp = {useRadians:false}; + gp[p] = val; + directionalRotationPlugin._onInitTween(target, gp, tween); + this._addTween(directionalRotationPlugin, "setRatio", 0, 1, p); + + } else if (val instanceof Array) { //for array-based values like "points" + this._initArrayTween(target[p](), val, p); + + } else if (p !== "autoDraw") { + gp = "get" + p.substr(3); + this._addTween(target, p, ((typeof(target[p]) === "function") ? target[( (gp !== "get" && typeof(target[gp]) === "function") ? gp : p)]() : target[p]) || 0, val, p); + } + this._overwriteProps.push(p); + } + return true; + }, + + kill: function(lookup) { + lookup = _copy(lookup); + _convertProps(this._target, lookup); + if (this._bezier) { + this._bezier._kill(lookup); + } + if (this._directionalRotation) { + this._directionalRotation._kill(lookup); + } + return this._super._kill.call(this, lookup); + }, + + round:function(lookup, value) { + lookup = _copy(lookup); + _convertProps(this._target, lookup); + if (this._bezier) { + this._bezier._roundProps(lookup, value); + } + return this._super._roundProps.call(this, lookup, value); + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(ratio) { + this._super.setRatio.call(this, ratio); + var sp = this._firstSP, + layer = this._layer, + arrayTweens = this._arrayTweens, + i, e, p, val, t, proxy; + if (sp) { + t = this._target; + while (sp) { + proxy = sp.proxy; + t[sp.setter]( (proxy.a !== 1 ? "rgba(" : "rgb(") + (proxy.r | 0) + ", " + (proxy.g | 0) + ", " + (proxy.b | 0) + (proxy.a !== 1 ? ", " + proxy.a : "") + ")"); + sp = sp._next; + } + } + if (arrayTweens) { + i = arrayTweens.length; + while (--i > -1) { + e = arrayTweens[i]; + val = e.s + e.c * ratio; + e.a[e.i] = (val < 0.000001 && val > -0.000001) ? 0 : val; + } + for (p in this._arrayProps) { + this._target[p](this._arrayProps[p]); + } + } + if (layer && !layer._gsDraw) { + _layersToDraw.push(layer); + layer._gsDraw = true; //a flag indicating that we need to draw() this layer as soon as all the tweens have finished updating (using a "tick" event listener) + if (!_listening) { + _ticker.addEventListener("tick", _onTick); + _listening = true; + } + } + } + + }); + + p = KineticPlugin.prototype; + p._initArrayTween = function(a, b, prop) { + if (!this._arrayTweens) { + this._arrayTweens = []; //stores data about any elements that must tween (ones that match in a and b are ignored (no need to waste resources). For example, {a:array, i:0, s:100, c:50} + this._arrayProps = {}; //stores data about which properties are associted with which arrays so that we can apply them in the setRatio() method, like target[property](array), as in target.points([1,2,500,600]); + } + var i = a.length, + tweens = this._arrayTweens, + start, end; + while (--i > -1) { + start = a[i]; + end = b[i]; + if (start !== end) { + tweens.push({a:a, i:i, s:start, c:end - start}); + } + } + if (tweens.length) { + this._arrayProps[prop] = a; + } + }; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/KineticPlugin.min.js b/resources/html5app/js/gsap/plugins/KineticPlugin.min.js new file mode 100644 index 000000000..449e148b6 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/KineticPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 0.5.2 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a,b,c,d,e={scale:1,shadowOffset:1,fillPatternOffset:1,offset:1,fill:2,stroke:2,shadowColor:2},f={},g={},h=/(\d|\.)+/g,i=/(?:_cw|_ccw|_short)/,j=_gsScope._gsDefine.globals.com.greensock.plugins,k={aqua:[0,255,255],lime:[0,255,0],silver:[192,192,192],black:[0,0,0],maroon:[128,0,0],teal:[0,128,128],blue:[0,0,255],navy:[0,0,128],white:[255,255,255],fuchsia:[255,0,255],olive:[128,128,0],yellow:[255,255,0],orange:[255,165,0],gray:[128,128,128],purple:[128,0,128],green:[0,128,0],red:[255,0,0],pink:[255,192,203],cyan:[0,255,255],transparent:[255,255,255,0]},l=function(a,b,c){return a=0>a?a+1:a>1?a-1:a,255*(1>6*a?b+(c-b)*a*6:.5>a?c:2>3*a?b+(c-b)*(2/3-a)*6:b)+.5|0},m=function(a){if(""===a||null==a||"none"===a)return k.transparent;if(k[a])return k[a];if("number"==typeof a)return[a>>16,a>>8&255,255&a];if("#"===a.charAt(0))return 4===a.length&&(a="#"+a.charAt(1)+a.charAt(1)+a.charAt(2)+a.charAt(2)+a.charAt(3)+a.charAt(3)),a=parseInt(a.substr(1),16),[a>>16,a>>8&255,255&a];if("hsl"===a.substr(0,3)){a=a.match(h);var b=Number(a[0])%360/360,c=Number(a[1])/100,d=Number(a[2])/100,e=.5>=d?d*(c+1):d+c-d*c,f=2*d-e;return a.length>3&&(a[3]=Number(a[3])),a[0]=l(b+1/3,f,e),a[1]=l(b,f,e),a[2]=l(b-1/3,f,e),a}for(var g=a.match(h)||k.transparent,i=g.length;--i>-1;)g[i]=Number(g[i]);return g},n=function(a,b,c,d){this.getter=b,this.setter=c;var e=m(a[b]());this.proxy={r:e[0],g:e[1],b:e[2],a:e.length>3?e[3]:1},d&&(this._next=d,d._prev=this)},o=[],p=function(){var c=o.length;if(0!==c){for(;--c>-1;)o[c].draw(),o[c]._gsDraw=!1;o.length=0}else a.removeEventListener("tick",p),b=!1},q=function(a,b){var c="x"===b?"y":"x",d="_gs_"+a;f[a]=function(){return this["get"+a]()[b]},g[a]=function(e){var f=this["get"+a](),g=this[d];return g||(g=this[d]={}),g[b]=e,g[c]=f[c],this[a](g),this}},r=function(a,b){return function(c){return arguments.length?b(c):a()}},s=function(a,b){var c,d,h,i,j=[];for(c in b)if(d=b[c],"bezier"!==c&&"autoDraw"!==c&&"set"!==c.substr(0,3)&&void 0===a[c]&&(j.push(c),delete b[c],c="set"+c.charAt(0).toUpperCase()+c.substr(1),b[c]=d),e[c]){if(1===e[c])return b[c+"X"]=b[c+"Y"]=b[c],delete b[c],s(a,b);!a[c]&&g[c]&&(i=a.prototype||a,i[c]=r(f[c],g[c]))}else if("bezier"===c)for(d=d instanceof Array?d:d.values||[],h=d.length;--h>-1;)0===h?j=j.concat(s(a,d[h])):s(a,d[h]);return j},t=function(a){var b,c={};for(b in a)c[b]=a[b];return c};for(d in e)1===e[d]&&(q(d,"x"),q(d,"y"));var u=_gsScope._gsDefine.plugin({propName:"kinetic",API:2,version:"0.5.2",init:function(b,d,f){var g,h,k,l,o,p;if(!c&&(c=parseInt(Kinetic.version.split(".")[0],10)<5))throw"The GSAP KineticPlugin that's loaded requires KineticJS version 5.0.0 or later. For earlier versions, use KineticPlugin from GSAP 1.11.3 or earlier.";this._overwriteProps=s(b,d),this._target=b,this._layer=d.autoDraw!==!1?b.getLayer():null,!a&&this._layer&&(a=f.constructor.ticker);for(g in d){if(h=d[g],2===e[g])l=this._firstSP=new n(b,g,g,this._firstSP),h=m(h),l.proxy.r!==h[0]&&this._addTween(l.proxy,"r",l.proxy.r,h[0],g),l.proxy.g!==h[1]&&this._addTween(l.proxy,"g",l.proxy.g,h[1],g),l.proxy.b!==h[2]&&this._addTween(l.proxy,"b",l.proxy.b,h[2],g),(h.length>3||1!==l.proxy.a)&&l.proxy.a!==h[3]&&this._addTween(l.proxy,"a",l.proxy.a,h.length>3?h[3]:1,g);else if("bezier"===g){if(o=j.BezierPlugin,!o)throw"BezierPlugin not loaded";o=this._bezier=new o,"object"==typeof h&&h.autoRotate===!0&&(h.autoRotate=["x","y","rotation",0,!1]),o._onInitTween(b,h,f),this._overwriteProps=this._overwriteProps.concat(o._overwriteProps),this._addTween(o,"setRatio",0,1,g)}else if("rotation"!==g&&"rotationDeg"!==g||"string"!=typeof h||!i.test(h))h instanceof Array?this._initArrayTween(b[g](),h,g):"autoDraw"!==g&&(k="get"+g.substr(3),this._addTween(b,g,("function"==typeof b[g]?b["get"!==k&&"function"==typeof b[k]?k:g]():b[g])||0,h,g));else{if(p=j.DirectionalRotationPlugin,!p)throw"DirectionalRotationPlugin not loaded";p=this._directionalRotation=new p,k={useRadians:!1},k[g]=h,p._onInitTween(b,k,f),this._addTween(p,"setRatio",0,1,g)}this._overwriteProps.push(g)}return!0},kill:function(a){return a=t(a),s(this._target,a),this._bezier&&this._bezier._kill(a),this._directionalRotation&&this._directionalRotation._kill(a),this._super._kill.call(this,a)},round:function(a,b){return a=t(a),s(this._target,a),this._bezier&&this._bezier._roundProps(a,b),this._super._roundProps.call(this,a,b)},set:function(c){this._super.setRatio.call(this,c);var d,e,f,g,h,i,j=this._firstSP,k=this._layer,l=this._arrayTweens;if(j)for(h=this._target;j;)i=j.proxy,h[j.setter]((1!==i.a?"rgba(":"rgb(")+(0|i.r)+", "+(0|i.g)+", "+(0|i.b)+(1!==i.a?", "+i.a:"")+")"),j=j._next;if(l){for(d=l.length;--d>-1;)e=l[d],g=e.s+e.c*c,e.a[e.i]=1e-6>g&&g>-1e-6?0:g;for(f in this._arrayProps)this._target[f](this._arrayProps[f])}k&&!k._gsDraw&&(o.push(k),k._gsDraw=!0,b||(a.addEventListener("tick",p),b=!0))}});d=u.prototype,d._initArrayTween=function(a,b,c){this._arrayTweens||(this._arrayTweens=[],this._arrayProps={});for(var d,e,f=a.length,g=this._arrayTweens;--f>-1;)d=a[f],e=b[f],d!==e&&g.push({a:a,i:f,s:d,c:e-d});g.length&&(this._arrayProps[c]=a)}}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/RaphaelPlugin.js b/resources/html5app/js/gsap/plugins/RaphaelPlugin.js new file mode 100644 index 000000000..d4831646d --- /dev/null +++ b/resources/html5app/js/gsap/plugins/RaphaelPlugin.js @@ -0,0 +1,369 @@ +/*! + * VERSION: 0.2.2 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var _NaNExp = /[^\d\-\.]/g, + _DEG2RAD = Math.PI / 180, + _numExp = /(\d|\.)+/g, + _colorLookup = {aqua:[0,255,255], + lime:[0,255,0], + silver:[192,192,192], + black:[0,0,0], + maroon:[128,0,0], + teal:[0,128,128], + blue:[0,0,255], + navy:[0,0,128], + white:[255,255,255], + fuchsia:[255,0,255], + olive:[128,128,0], + yellow:[255,255,0], + orange:[255,165,0], + gray:[128,128,128], + purple:[128,0,128], + green:[0,128,0], + red:[255,0,0], + pink:[255,192,203], + cyan:[0,255,255], + transparent:[255,255,255,0]}, + //parses a color (like #9F0, #FF9900, or rgb(255,51,153)) into an array with 3 elements for red, green, and blue. Also handles rgba() values (splits into array of 4 elements of course) + _parseColor = function(color) { + if (typeof(color) === "number") { + return [color >> 16, (color >> 8) & 255, color & 255]; + } else if (color === "" || color == null || color === "none" || typeof(color) !== "string") { + return _colorLookup.transparent; + } else if (_colorLookup[color]) { + return _colorLookup[color]; + } else if (color.charAt(0) === "#") { + if (color.length === 4) { //for shorthand like #9F0 + color = "#" + color.charAt(1) + color.charAt(1) + color.charAt(2) + color.charAt(2) + color.charAt(3) + color.charAt(3); + } + color = parseInt(color.substr(1), 16); + return [color >> 16, (color >> 8) & 255, color & 255]; + } + return color.match(_numExp) || _colorLookup.transparent; + }, + + _transformMap = {scaleX:1, scaleY:1, tx:1, ty:1, rotation:1, shortRotation:1, skewX:1, skewY:1, scale:1}, + + //parses the transform values for an element, returning an object with x, y, scaleX, scaleY, rotation, skewX, and skewY properties. Note: by default (for performance reasons), all skewing is combined into skewX and rotation but skewY still has a place in the transform object so that we can record how much of the skew is attributed to skewX vs skewY. Remember, a skewY of 10 looks the same as a rotation of 10 and skewX of -10. + _getTransform = function(t, rec) { + var s = t.matrix, + min = 0.000001, + a = s.a, + b = s.b, + c = s.c, + d = s.d, + m = rec ? t._gsTransform || {skewY:0} : {skewY:0}, + invX = (m.scaleX < 0); //in order to interpret things properly, we need to know if the user applied a negative scaleX previously so that we can adjust the rotation and skewX accordingly. Otherwise, if we always interpret a flipped matrix as affecting scaleY and the user only wants to tween the scaleX on multiple sequential tweens, it would keep the negative scaleY without that being the user's intent. + + m.tx = s.e - (m.ox || 0); //ox is the offset x that we record in setRatio() whenever we apply a custom transform that might use a pivot point. Remember, s.e and s.f get affected by things like scale. For example, imagine an object whose top left corner is at 100,100 and then we scale it up to 300% using the center as the pivot point - that corner would now be very different even though to the user, they didn't intend to change/tween the x/y position per se. Therefore, we record whatever offsets we make so that we can compensate when reading the values back. + m.ty = s.f - (m.oy || 0); //oy is the offset y (see note above) + m.scaleX = Math.sqrt(a * a + b * b); + m.scaleY = Math.sqrt(d * d + c * c); + m.rotation = (a || b) ? Math.atan2(b, a) : m.rotation || 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist). + m.skewX = (c || d) ? Math.atan2(c, d) + m.rotation : m.skewX || 0; + if (Math.abs(m.skewX) > Math.PI / 2) { + if (invX) { + m.scaleX *= -1; + m.skewX += (m.rotation <= 0) ? Math.PI : -Math.PI; + m.rotation += (m.rotation <= 0) ? Math.PI : -Math.PI; + } else { + m.scaleY *= -1; + m.skewX += (m.skewX <= 0) ? Math.PI : -Math.PI; + } + } + //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 0 in these cases. The conditional logic here is faster than calling Math.abs(). + if (m.rotation < min) if (m.rotation > -min) if (a || b) { + m.rotation = 0; + } + if (m.skewX < min) if (m.skewX > -min) if (b || c) { + m.skewX = 0; + } + if (rec) { + t._gsTransform = m; //record to the object's _gsTransform which we use so that tweens can control individual properties independently (we need all the properties to accurately recompose the matrix in the setRatio() method) + } + return m; + }, + + //takes a value and a default number, checks if the value is relative, null, or numeric and spits back a normalized number accordingly. Primarily used in the _parseTransform() function. + _parseVal = function(v, d) { + return (v == null) ? d : (typeof(v) === "string" && v.indexOf("=") === 1) ? parseInt(v.charAt(0)+"1", 10) * Number(v.substr(2)) + d : Number(v); + }, + + //translates strings like "40deg" or "40" or 40rad" or "+=40deg" to a numeric radian angle, optionally relative to a default value (if "+=" or "-=" prefix is found) + _parseAngle = function(v, d) { + var m = (v.indexOf("rad") === -1) ? _DEG2RAD : 1, + r = (v.indexOf("=") === 1); + v = Number(v.replace(_NaNExp, "")) * m; + return r ? v + d : v; + }, + + + RaphaelPlugin = _gsScope._gsDefine.plugin({ + propName: "raphael", + version: "0.2.2", + API: 2, + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + if (!target.attr) { //raphael must have attr() method + return false; + } + this._target = target; + this._tween = tween; + this._props = target._gsProps = target._gsProps || {}; + var p, s, v, pt, clr1, clr2, rel; + + for (p in value) { + + v = value[p]; + + if (p === "transform") { + this._parseTransform(target, v); + continue; + } else if (_transformMap[p] || p === "pivot") { + this._parseTransform(target, value); + continue; + } + + s = target.attr(p); + + //Some of these properties are in place in order to conform with the standard PropTweens in TweenPlugins so that overwriting and roundProps occur properly. For example, f and r may seem unnecessary here, but they enable other functionality. + //_next:* next linked list node [object] + //t: * target [object] + //p: * property (camelCase) [string] + //s: * starting value [number] + //c: * change value [number] + //f: * is function [boolean] + //n: * name (for overwriting) [string] + //b: beginning value [string] + //i: intermediate value [string] + //e: ending value [string] + //r: * round [boolean] + //type: 0=normal, 1=color, 2=rgba, -1=non-tweening prop [number] + this._firstPT = pt = {_next:this._firstPT, + t:this._props, + p:p, + b:s, + f:false, + n:"raphael_" + p, + r:false, + type:0}; + + //color values must be split apart into their R, G, B (and sometimes alpha) values and tweened independently. + if (p === "fill" || p === "stroke") { + clr1 = _parseColor(s); + clr2 = _parseColor(v); + pt.e = v; + pt.s = Number(clr1[0]); //red starting value + pt.c = Number(clr2[0]) - pt.s; //red change + pt.gs = Number(clr1[1]); //green starting value + pt.gc = Number(clr2[1]) - pt.gs; //green change + pt.bs = Number(clr1[2]); //blue starting value + pt.bc = Number(clr2[2]) - pt.bs; //blue change + if (clr1.length > 3 || clr2.length > 3) { //detect an rgba() value + pt.as = (clr1.length < 4) ? 1 : Number(clr1[3]); + pt.ac = ((clr2.length < 4) ? 1 : Number(clr2[3])) - pt.as; + pt.type = 2; //2 = rgba() tween + } else { + pt.type = 1; //1 = color tween, -1 = no tween, just set the value at the end because there's no changes + } + + } else { + + s = (typeof(s) === "string") ? parseFloat(s.replace(_NaNExp, "")) : Number(s); + + if (typeof(v) === "string") { + rel = (v.charAt(1) === "="); + v = parseFloat(v.replace(_NaNExp, "")); + } else { + rel = false; + } + + pt.e = (v || v === 0) ? (rel ? v + s : v) : value[p]; //ensures that any += or -= prefixes are taken care of. + + if ((s || s === 0) && (v || v === 0) && (pt.c = (rel ? v : v - s))) { //faster than isNaN(). Also, we set pt.c (change) here because if it's 0, we'll just treat it like a non-tweening value. can't do (v !== start) because if it's a relative value and the CHANGE is identical to the START, the condition will fail unnecessarily. + pt.s = s; + } else { + pt.type = -1; + pt.i = value[p]; //intermediate value is typically the same as the end value. + pt.s = pt.c = 0; + } + + } + + this._overwriteProps.push("raphael_" + p); + if (pt._next) { + pt._next._prev = pt; + } + } + + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(v) { + var pt = this._firstPT, val; + + while (pt) { + val = pt.c * v + pt.s; + if (pt.r) { + val = Math.round(val); + } + if (!pt.type) { + pt.t[pt.p] = val; + } else if (pt.type === 1) { //rgb() + pt.t[pt.p] = "rgb(" + (val >> 0) + ", " + ((pt.gs + (v * pt.gc)) >> 0) + ", " + ((pt.bs + (v * pt.bc)) >> 0) + ")"; + } else if (pt.type === 2) { //rgba() + pt.t[pt.p] = "rgba(" + (val >> 0) + ", " + ((pt.gs + (v * pt.gc)) >> 0) + ", " + ((pt.bs + (v * pt.bc)) >> 0) + ", " + (pt.as + (v * pt.ac)) + ")"; + } else if (pt.type === -1) { //non-tweening + pt.t[pt.p] = pt.i; + } + pt = pt._next; + } + + this._target.attr(this._props); + + //apply transform values like x, y, scaleX, scaleY, rotation, skewX, or skewY. We do these after looping through all the PropTweens because those are where the changes are made to scaleX/scaleY/rotation/skewX/skewY/x/y. + if (this._transform) { + pt = this._transform; //to improve speed and reduce size, reuse the pt variable as an alias to the _transform property + var ang = pt.rotation, + skew = ang - pt.skewX, + a = Math.cos(ang) * pt.scaleX, + b = Math.sin(ang) * pt.scaleX, + c = Math.sin(skew) * -pt.scaleY, + d = Math.cos(skew) * pt.scaleY, + min = 0.000001, + pxl = this._pxl, + pyl = this._pyl; + + //some browsers have a hard time with very small values like 2.4492935982947064e-16 (notice the "e-" towards the end) and would render the object slightly off. So we round to 0 in these cases for both b and c. The conditional logic here is faster than calling Math.abs(). + if (b < min) if (b > -min) { + b = 0; + } + if (c < min) if (c > -min) { + c = 0; + } + pt.ox = this._pxg - (pxl * a + pyl * c); //we must record the offset x/y that we're making from the regular tx/ty (matrix.e and f) so that we can correctly interpret positional data in _getTransform(). See note there on tx and ox. + pt.oy = this._pyg - (pxl * b + pyl * d); + this._target.transform("m" + a + "," + b + "," + c + "," + d + "," + (pt.tx + pt.ox) + "," + (pt.ty + pt.oy)); + } + + } + + }), + p = RaphaelPlugin.prototype; + + //compares the beginning x, y, scaleX, scaleY, rotation, and skewX properties with the ending ones and adds PropTweens accordingly wherever necessary. We must tween them individually (rather than just tweening the matrix values) so that elgant overwriting can occur, like if one tween is controlling scaleX, scaleY, and rotation and then another one starts mid-tween that is trying to control the scaleX only - this tween should continue tweening scaleY and rotation. + p._parseTransform = function(t, v) { + if (this._transform) { return; } //only need to parse the transform once, and only if the browser supports it. + + var m1 = this._transform = _getTransform(t, true), + min = 0.000001, + m2, skewY, p, pt, copy, dx, dy, mtx, pivot; + + if (typeof(v) === "object") { //for values like scaleX, scaleY, rotation, x, y, skewX, and skewY or transform:{...} (object) + + m2 = {scaleX:_parseVal((v.scaleX != null) ? v.scaleX : v.scale, m1.scaleX), + scaleY:_parseVal((v.scaleY != null) ? v.scaleY : v.scale, m1.scaleY), + tx:_parseVal(v.tx, m1.tx), + ty:_parseVal(v.ty, m1.ty)}; + + if (v.shortRotation != null) { + m2.rotation = (typeof(v.shortRotation) === "number") ? v.shortRotation * _DEG2RAD : _parseAngle(v.shortRotation, m1.rotation); + var dif = (m2.rotation - m1.rotation) % (Math.PI * 2); + if (dif !== dif % Math.PI) { + dif += Math.PI * ((dif < 0) ? 2 : -2); + } + m2.rotation = m1.rotation + dif; + + } else { + m2.rotation = (v.rotation == null) ? m1.rotation : (typeof(v.rotation) === "number") ? v.rotation * _DEG2RAD : _parseAngle(v.rotation, m1.rotation); + } + m2.skewX = (v.skewX == null) ? m1.skewX : (typeof(v.skewX) === "number") ? v.skewX * _DEG2RAD : _parseAngle(v.skewX, m1.skewX); + + //note: for performance reasons, we combine all skewing into the skewX and rotation values, ignoring skewY but we must still record it so that we can discern how much of the overall skew is attributed to skewX vs. skewY. Otherwise, if the skewY would always act relative (tween skewY to 10deg, for example, multiple times and if we always combine things into skewX, we can't remember that skewY was 10 from last time). Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of -10 degrees. + m2.skewY = (v.skewY == null) ? m1.skewY : (typeof(v.skewY) === "number") ? v.skewY * _DEG2RAD : _parseAngle(v.skewY, m1.skewY); + if ((skewY = m2.skewY - m1.skewY)) { + m2.skewX += skewY; + m2.rotation += skewY; + } + //don't allow rotation/skew values to be a SUPER small decimal because when they're translated back to strings for setting the css property, the browser reports them in a funky way, like 1-e7. Of course we could use toFixed() to resolve that issue but that hurts performance quite a bit with all those function calls on every frame, plus it is virtually impossible to discern values that small visually (nobody will notice changing a rotation of 0.0000001 to 0, so the performance improvement is well worth it). + if (m2.skewY < min) if (m2.skewY > -min) { + m2.skewY = 0; + } + if (m2.skewX < min) if (m2.skewX > -min) { + m2.skewX = 0; + } + if (m2.rotation < min) if (m2.rotation > -min) { + m2.rotation = 0; + } + + pivot = v.localPivot || v.globalPivot; + + if (typeof(pivot) === "string") { + copy = pivot.split(","); + dx = Number(copy[0]); + dy = Number(copy[1]); + } else if (typeof(pivot) === "object") { + dx = Number(pivot.x); + dy = Number(pivot.y); + } else if (v.localPivot) { + copy = t.getBBox(true); + dx = copy.width / 2; + dy = copy.height / 2; + } else { + copy = t.getBBox(); + dx = copy.x + copy.width / 2; + dy = copy.y + copy.height / 2; + } + + if (v.localPivot) { + mtx = t.matrix; + dx += t.attr("x"); + dy += t.attr("y"); + this._pxl = dx; + this._pyl = dy; + this._pxg = dx * mtx.a + dy * mtx.c + mtx.e - m1.tx; + this._pyg = dx * mtx.b + dy * mtx.d + mtx.f - m1.ty; + } else { + mtx = t.matrix.invert(); + this._pxl = dx * mtx.a + dy * mtx.c + mtx.e; + this._pyl = dx * mtx.b + dy * mtx.d + mtx.f; + this._pxg = dx - m1.tx; + this._pyg = dy - m1.ty; + } + + } else if (typeof(v) === "string") { //for values like transform:"rotate(60deg) scale(0.5, 0.8)" + copy = this._target.transform(); + t.transform(v); + m2 = _getTransform(t, false); + t.transform(copy); + } else { + return; + } + + for (p in _transformMap) { + if (m1[p] !== m2[p]) if (p !== "shortRotation") if (p !== "scale") { + this._firstPT = pt = {_next:this._firstPT, t:m1, p:p, s:m1[p], c:m2[p] - m1[p], n:p, f:false, r:false, b:m1[p], e:m2[p], type:0}; + if (pt._next) { + pt._next._prev = pt; + } + this._overwriteProps.push("raphael_" + p); + } + } + }; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/RaphaelPlugin.min.js b/resources/html5app/js/gsap/plugins/RaphaelPlugin.min.js new file mode 100644 index 000000000..3fb2cfd9c --- /dev/null +++ b/resources/html5app/js/gsap/plugins/RaphaelPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 0.2.2 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a=/[^\d\-\.]/g,b=Math.PI/180,c=/(\d|\.)+/g,d={aqua:[0,255,255],lime:[0,255,0],silver:[192,192,192],black:[0,0,0],maroon:[128,0,0],teal:[0,128,128],blue:[0,0,255],navy:[0,0,128],white:[255,255,255],fuchsia:[255,0,255],olive:[128,128,0],yellow:[255,255,0],orange:[255,165,0],gray:[128,128,128],purple:[128,0,128],green:[0,128,0],red:[255,0,0],pink:[255,192,203],cyan:[0,255,255],transparent:[255,255,255,0]},e=function(a){return"number"==typeof a?[a>>16,a>>8&255,255&a]:""===a||null==a||"none"===a||"string"!=typeof a?d.transparent:d[a]?d[a]:"#"===a.charAt(0)?(4===a.length&&(a="#"+a.charAt(1)+a.charAt(1)+a.charAt(2)+a.charAt(2)+a.charAt(3)+a.charAt(3)),a=parseInt(a.substr(1),16),[a>>16,a>>8&255,255&a]):a.match(c)||d.transparent},f={scaleX:1,scaleY:1,tx:1,ty:1,rotation:1,shortRotation:1,skewX:1,skewY:1,scale:1},g=function(a,b){var c=a.matrix,d=1e-6,e=c.a,f=c.b,g=c.c,h=c.d,i=b?a._gsTransform||{skewY:0}:{skewY:0},j=i.scaleX<0;return i.tx=c.e-(i.ox||0),i.ty=c.f-(i.oy||0),i.scaleX=Math.sqrt(e*e+f*f),i.scaleY=Math.sqrt(h*h+g*g),i.rotation=e||f?Math.atan2(f,e):i.rotation||0,i.skewX=g||h?Math.atan2(g,h)+i.rotation:i.skewX||0,Math.abs(i.skewX)>Math.PI/2&&(j?(i.scaleX*=-1,i.skewX+=i.rotation<=0?Math.PI:-Math.PI,i.rotation+=i.rotation<=0?Math.PI:-Math.PI):(i.scaleY*=-1,i.skewX+=i.skewX<=0?Math.PI:-Math.PI)),i.rotation-d&&(e||f)&&(i.rotation=0),i.skewX-d&&(f||g)&&(i.skewX=0),b&&(a._gsTransform=i),i},h=function(a,b){return null==a?b:"string"==typeof a&&1===a.indexOf("=")?parseInt(a.charAt(0)+"1",10)*Number(a.substr(2))+b:Number(a)},i=function(c,d){var e=-1===c.indexOf("rad")?b:1,f=1===c.indexOf("=");return c=Number(c.replace(a,""))*e,f?c+d:c},j=_gsScope._gsDefine.plugin({propName:"raphael",version:"0.2.2",API:2,init:function(b,c,d){if(!b.attr)return!1;this._target=b,this._tween=d,this._props=b._gsProps=b._gsProps||{};var g,h,i,j,k,l,m;for(g in c)i=c[g],"transform"!==g?f[g]||"pivot"===g?this._parseTransform(b,c):(h=b.attr(g),this._firstPT=j={_next:this._firstPT,t:this._props,p:g,b:h,f:!1,n:"raphael_"+g,r:!1,type:0},"fill"===g||"stroke"===g?(k=e(h),l=e(i),j.e=i,j.s=Number(k[0]),j.c=Number(l[0])-j.s,j.gs=Number(k[1]),j.gc=Number(l[1])-j.gs,j.bs=Number(k[2]),j.bc=Number(l[2])-j.bs,k.length>3||l.length>3?(j.as=k.length<4?1:Number(k[3]),j.ac=(l.length<4?1:Number(l[3]))-j.as,j.type=2):j.type=1):(h="string"==typeof h?parseFloat(h.replace(a,"")):Number(h),"string"==typeof i?(m="="===i.charAt(1),i=parseFloat(i.replace(a,""))):m=!1,j.e=i||0===i?m?i+h:i:c[g],!h&&0!==h||!i&&0!==i||!(j.c=m?i:i-h)?(j.type=-1,j.i=c[g],j.s=j.c=0):j.s=h),this._overwriteProps.push("raphael_"+g),j._next&&(j._next._prev=j)):this._parseTransform(b,i);return!0},set:function(a){for(var b,c=this._firstPT;c;)b=c.c*a+c.s,c.r&&(b=Math.round(b)),c.type?1===c.type?c.t[c.p]="rgb("+(b>>0)+", "+(c.gs+a*c.gc>>0)+", "+(c.bs+a*c.bc>>0)+")":2===c.type?c.t[c.p]="rgba("+(b>>0)+", "+(c.gs+a*c.gc>>0)+", "+(c.bs+a*c.bc>>0)+", "+(c.as+a*c.ac)+")":-1===c.type&&(c.t[c.p]=c.i):c.t[c.p]=b,c=c._next;if(this._target.attr(this._props),this._transform){c=this._transform;var d=c.rotation,e=d-c.skewX,f=Math.cos(d)*c.scaleX,g=Math.sin(d)*c.scaleX,h=Math.sin(e)*-c.scaleY,i=Math.cos(e)*c.scaleY,j=1e-6,k=this._pxl,l=this._pyl;j>g&&g>-j&&(g=0),j>h&&h>-j&&(h=0),c.ox=this._pxg-(k*f+l*h),c.oy=this._pyg-(k*g+l*i),this._target.transform("m"+f+","+g+","+h+","+i+","+(c.tx+c.ox)+","+(c.ty+c.oy))}}}),k=j.prototype;k._parseTransform=function(a,c){if(!this._transform){var d,e,j,k,l,m,n,o,p,q=this._transform=g(a,!0),r=1e-6;if("object"==typeof c){if(d={scaleX:h(null!=c.scaleX?c.scaleX:c.scale,q.scaleX),scaleY:h(null!=c.scaleY?c.scaleY:c.scale,q.scaleY),tx:h(c.tx,q.tx),ty:h(c.ty,q.ty)},null!=c.shortRotation){d.rotation="number"==typeof c.shortRotation?c.shortRotation*b:i(c.shortRotation,q.rotation);var s=(d.rotation-q.rotation)%(2*Math.PI);s!==s%Math.PI&&(s+=Math.PI*(0>s?2:-2)),d.rotation=q.rotation+s}else d.rotation=null==c.rotation?q.rotation:"number"==typeof c.rotation?c.rotation*b:i(c.rotation,q.rotation);d.skewX=null==c.skewX?q.skewX:"number"==typeof c.skewX?c.skewX*b:i(c.skewX,q.skewX),d.skewY=null==c.skewY?q.skewY:"number"==typeof c.skewY?c.skewY*b:i(c.skewY,q.skewY),(e=d.skewY-q.skewY)&&(d.skewX+=e,d.rotation+=e),d.skewY-r&&(d.skewY=0),d.skewX-r&&(d.skewX=0),d.rotation-r&&(d.rotation=0),p=c.localPivot||c.globalPivot,"string"==typeof p?(l=p.split(","),m=Number(l[0]),n=Number(l[1])):"object"==typeof p?(m=Number(p.x),n=Number(p.y)):c.localPivot?(l=a.getBBox(!0),m=l.width/2,n=l.height/2):(l=a.getBBox(),m=l.x+l.width/2,n=l.y+l.height/2),c.localPivot?(o=a.matrix,m+=a.attr("x"),n+=a.attr("y"),this._pxl=m,this._pyl=n,this._pxg=m*o.a+n*o.c+o.e-q.tx,this._pyg=m*o.b+n*o.d+o.f-q.ty):(o=a.matrix.invert(),this._pxl=m*o.a+n*o.c+o.e,this._pyl=m*o.b+n*o.d+o.f,this._pxg=m-q.tx,this._pyg=n-q.ty)}else{if("string"!=typeof c)return;l=this._target.transform(),a.transform(c),d=g(a,!1),a.transform(l)}for(j in f)q[j]!==d[j]&&"shortRotation"!==j&&"scale"!==j&&(this._firstPT=k={_next:this._firstPT,t:q,p:j,s:q[j],c:d[j]-q[j],n:j,f:!1,r:!1,b:q[j],e:d[j],type:0},k._next&&(k._next._prev=k),this._overwriteProps.push("raphael_"+j))}}}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/RoundPropsPlugin.js b/resources/html5app/js/gsap/plugins/RoundPropsPlugin.js new file mode 100644 index 000000000..ab4617b6f --- /dev/null +++ b/resources/html5app/js/gsap/plugins/RoundPropsPlugin.js @@ -0,0 +1,87 @@ +/*! + * VERSION: 1.5 + * DATE: 2015-08-28 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var RoundPropsPlugin = _gsScope._gsDefine.plugin({ + propName: "roundProps", + version: "1.5", + priority: -1, + API: 2, + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + this._tween = tween; + return true; + } + + }), + _roundLinkedList = function(node) { + while (node) { + if (!node.f && !node.blob) { + node.r = 1; + } + node = node._next; + } + }, + p = RoundPropsPlugin.prototype; + + p._onInitAllProps = function() { + var tween = this._tween, + rp = (tween.vars.roundProps.join) ? tween.vars.roundProps : tween.vars.roundProps.split(","), + i = rp.length, + lookup = {}, + rpt = tween._propLookup.roundProps, + prop, pt, next; + while (--i > -1) { + lookup[rp[i]] = 1; + } + i = rp.length; + while (--i > -1) { + prop = rp[i]; + pt = tween._firstPT; + while (pt) { + next = pt._next; //record here, because it may get removed + if (pt.pg) { + pt.t._roundProps(lookup, true); + } else if (pt.n === prop) { + if (pt.f === 2 && pt.t) { //a blob (text containing multiple numeric values) + _roundLinkedList(pt.t._firstPT); + } else { + this._add(pt.t, prop, pt.s, pt.c); + //remove from linked list + if (next) { + next._prev = pt._prev; + } + if (pt._prev) { + pt._prev._next = next; + } else if (tween._firstPT === pt) { + tween._firstPT = next; + } + pt._next = pt._prev = null; + tween._propLookup[prop] = rpt; + } + } + pt = next; + } + } + return false; + }; + + p._add = function(target, p, s, c) { + this._addTween(target, p, s, s + c, p, true); + this._overwriteProps.push(p); + }; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/RoundPropsPlugin.min.js b/resources/html5app/js/gsap/plugins/RoundPropsPlugin.min.js new file mode 100644 index 000000000..7d2d92a96 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/RoundPropsPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 1.5 + * DATE: 2015-08-28 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a=_gsScope._gsDefine.plugin({propName:"roundProps",version:"1.5",priority:-1,API:2,init:function(a,b,c){return this._tween=c,!0}}),b=function(a){for(;a;)a.f||a.blob||(a.r=1),a=a._next},c=a.prototype;c._onInitAllProps=function(){for(var a,c,d,e=this._tween,f=e.vars.roundProps.join?e.vars.roundProps:e.vars.roundProps.split(","),g=f.length,h={},i=e._propLookup.roundProps;--g>-1;)h[f[g]]=1;for(g=f.length;--g>-1;)for(a=f[g],c=e._firstPT;c;)d=c._next,c.pg?c.t._roundProps(h,!0):c.n===a&&(2===c.f&&c.t?b(c.t._firstPT):(this._add(c.t,a,c.s,c.c),d&&(d._prev=c._prev),c._prev?c._prev._next=d:e._firstPT===c&&(e._firstPT=d),c._next=c._prev=null,e._propLookup[a]=i)),c=d;return!1},c._add=function(a,b,c,d){this._addTween(a,b,c,c+d,b,!0),this._overwriteProps.push(b)}}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/ScrollToPlugin.js b/resources/html5app/js/gsap/plugins/ScrollToPlugin.js new file mode 100644 index 000000000..852676432 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/ScrollToPlugin.js @@ -0,0 +1,126 @@ +/*! + * VERSION: 1.7.6 + * DATE: 2015-12-10 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + var _doc = document.documentElement, + _window = window, + _max = function(element, axis) { + var dim = (axis === "x") ? "Width" : "Height", + scroll = "scroll" + dim, + client = "client" + dim, + body = document.body; + return (element === _window || element === _doc || element === body) ? Math.max(_doc[scroll], body[scroll]) - (_window["inner" + dim] || _doc[client] || body[client]) : element[scroll] - element["offset" + dim]; + }, + + ScrollToPlugin = _gsScope._gsDefine.plugin({ + propName: "scrollTo", + API: 2, + version:"1.7.6", + + //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run. + init: function(target, value, tween) { + this._wdw = (target === _window); + this._target = target; + this._tween = tween; + if (typeof(value) !== "object") { + value = {y:value}; //if we don't receive an object as the parameter, assume the user intends "y". + } + this.vars = value; + this._autoKill = (value.autoKill !== false); + this.x = this.xPrev = this.getX(); + this.y = this.yPrev = this.getY(); + if (value.x != null) { + this._addTween(this, "x", this.x, (value.x === "max") ? _max(target, "x") : value.x, "scrollTo_x", true); + this._overwriteProps.push("scrollTo_x"); + } else { + this.skipX = true; + } + if (value.y != null) { + this._addTween(this, "y", this.y, (value.y === "max") ? _max(target, "y") : value.y, "scrollTo_y", true); + this._overwriteProps.push("scrollTo_y"); + } else { + this.skipY = true; + } + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(v) { + this._super.setRatio.call(this, v); + + var x = (this._wdw || !this.skipX) ? this.getX() : this.xPrev, + y = (this._wdw || !this.skipY) ? this.getY() : this.yPrev, + yDif = y - this.yPrev, + xDif = x - this.xPrev; + + if (this.x < 0) { //can't scroll to a position less than 0! Might happen if someone uses a Back.easeOut or Elastic.easeOut when scrolling back to the top of the page (for example) + this.x = 0; + } + if (this.y < 0) { + this.y = 0; + } + if (this._autoKill) { + //note: iOS has a bug that throws off the scroll by several pixels, so we need to check if it's within 7 pixels of the previous one that we set instead of just looking for an exact match. + if (!this.skipX && (xDif > 7 || xDif < -7) && x < _max(this._target, "x")) { + this.skipX = true; //if the user scrolls separately, we should stop tweening! + } + if (!this.skipY && (yDif > 7 || yDif < -7) && y < _max(this._target, "y")) { + this.skipY = true; //if the user scrolls separately, we should stop tweening! + } + if (this.skipX && this.skipY) { + this._tween.kill(); + if (this.vars.onAutoKill) { + this.vars.onAutoKill.apply(this.vars.onAutoKillScope || this._tween, this.vars.onAutoKillParams || []); + } + } + } + if (this._wdw) { + _window.scrollTo((!this.skipX) ? this.x : x, (!this.skipY) ? this.y : y); + } else { + if (!this.skipY) { + this._target.scrollTop = this.y; + } + if (!this.skipX) { + this._target.scrollLeft = this.x; + } + } + this.xPrev = this.x; + this.yPrev = this.y; + } + + }), + p = ScrollToPlugin.prototype; + + ScrollToPlugin.max = _max; + + p.getX = function() { + return (!this._wdw) ? this._target.scrollLeft : (_window.pageXOffset != null) ? _window.pageXOffset : (_doc.scrollLeft != null) ? _doc.scrollLeft : document.body.scrollLeft; + }; + + p.getY = function() { + return (!this._wdw) ? this._target.scrollTop : (_window.pageYOffset != null) ? _window.pageYOffset : (_doc.scrollTop != null) ? _doc.scrollTop : document.body.scrollTop; + }; + + p._kill = function(lookup) { + if (lookup.scrollTo_x) { + this.skipX = true; + } + if (lookup.scrollTo_y) { + this.skipY = true; + } + return this._super._kill.call(this, lookup); + }; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/ScrollToPlugin.min.js b/resources/html5app/js/gsap/plugins/ScrollToPlugin.min.js new file mode 100644 index 000000000..b9106feb6 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/ScrollToPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 1.7.6 + * DATE: 2015-12-10 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + **/ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a=document.documentElement,b=window,c=function(c,d){var e="x"===d?"Width":"Height",f="scroll"+e,g="client"+e,h=document.body;return c===b||c===a||c===h?Math.max(a[f],h[f])-(b["inner"+e]||a[g]||h[g]):c[f]-c["offset"+e]},d=_gsScope._gsDefine.plugin({propName:"scrollTo",API:2,version:"1.7.6",init:function(a,d,e){return this._wdw=a===b,this._target=a,this._tween=e,"object"!=typeof d&&(d={y:d}),this.vars=d,this._autoKill=d.autoKill!==!1,this.x=this.xPrev=this.getX(),this.y=this.yPrev=this.getY(),null!=d.x?(this._addTween(this,"x",this.x,"max"===d.x?c(a,"x"):d.x,"scrollTo_x",!0),this._overwriteProps.push("scrollTo_x")):this.skipX=!0,null!=d.y?(this._addTween(this,"y",this.y,"max"===d.y?c(a,"y"):d.y,"scrollTo_y",!0),this._overwriteProps.push("scrollTo_y")):this.skipY=!0,!0},set:function(a){this._super.setRatio.call(this,a);var d=this._wdw||!this.skipX?this.getX():this.xPrev,e=this._wdw||!this.skipY?this.getY():this.yPrev,f=e-this.yPrev,g=d-this.xPrev;this.x<0&&(this.x=0),this.y<0&&(this.y=0),this._autoKill&&(!this.skipX&&(g>7||-7>g)&&d7||-7>f)&&e -1) { + shrt.push(this._fillChar); + } + return true; + }, + + //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.) + set: function(ratio) { + if (ratio > 1) { + ratio = 1; + } else if (ratio < 0) { + ratio = 0; + } + if (this._runBackwards) { + ratio = 1 - ratio; + } + var l = this._text.length, + i = (ratio * l + 0.5) | 0, + applyNew, applyOld, str; + if (this._hasClass) { + applyNew = (this._newClass && i !== 0); + applyOld = (this._oldClass && i !== l); + str = (applyNew ? "" : "") + this._text.slice(0, i).join(this._delimiter) + (applyNew ? "" : "") + (applyOld ? "" : "") + this._delimiter + this._original.slice(i).join(this._delimiter) + (applyOld ? "" : ""); + } else { + str = this._text.slice(0, i).join(this._delimiter) + this._delimiter + this._original.slice(i).join(this._delimiter); + } + this._target.innerHTML = (this._fillChar === " " && str.indexOf(" ") !== -1) ? str.split(" ").join("  ") : str; + } + + }), + p = TextPlugin.prototype; + + p._newClass = p._oldClass = p._delimiter = ""; + +}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); } \ No newline at end of file diff --git a/resources/html5app/js/gsap/plugins/TextPlugin.min.js b/resources/html5app/js/gsap/plugins/TextPlugin.min.js new file mode 100644 index 000000000..618292508 --- /dev/null +++ b/resources/html5app/js/gsap/plugins/TextPlugin.min.js @@ -0,0 +1,12 @@ +/*! + * VERSION: 0.5.1 + * DATE: 2014-07-17 + * UPDATES AND DOCS AT: http://greensock.com + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a=function(b){var c=b.nodeType,d="";if(1===c||9===c||11===c){if("string"==typeof b.textContent)return b.textContent;for(b=b.firstChild;b;b=b.nextSibling)d+=a(b)}else if(3===c||4===c)return b.nodeValue;return d},b=_gsScope._gsDefine.plugin({propName:"text",API:2,version:"0.5.1",init:function(b,c,d){var e,f;if(!("innerHTML"in b))return!1;if(this._target=b,"object"!=typeof c&&(c={value:c}),void 0===c.value)return this._text=this._original=[""],!0;for(this._delimiter=c.delimiter||"",this._original=a(b).replace(/\s+/g," ").split(this._delimiter),this._text=c.value.replace(/\s+/g," ").split(this._delimiter),this._runBackwards=d.vars.runBackwards===!0,this._runBackwards&&(e=this._original,this._original=this._text,this._text=e),"string"==typeof c.newClass&&(this._newClass=c.newClass,this._hasClass=!0),"string"==typeof c.oldClass&&(this._oldClass=c.oldClass,this._hasClass=!0),e=this._original.length-this._text.length,f=0>e?this._original:this._text,this._fillChar=c.fillChar||(c.padSpace?" ":""),0>e&&(e=-e);--e>-1;)f.push(this._fillChar);return!0},set:function(a){a>1?a=1:0>a&&(a=0),this._runBackwards&&(a=1-a);var b,c,d,e=this._text.length,f=a*e+.5|0;this._hasClass?(b=this._newClass&&0!==f,c=this._oldClass&&f!==e,d=(b?"":"")+this._text.slice(0,f).join(this._delimiter)+(b?"":"")+(c?"":"")+this._delimiter+this._original.slice(f).join(this._delimiter)+(c?"":"")):d=this._text.slice(0,f).join(this._delimiter)+this._delimiter+this._original.slice(f).join(this._delimiter),this._target.innerHTML=" "===this._fillChar&&-1!==d.indexOf(" ")?d.split(" ").join("  "):d}}),c=b.prototype;c._newClass=c._oldClass=c._delimiter=""}),_gsScope._gsDefine&&_gsScope._gsQueue.pop()(); \ No newline at end of file diff --git a/resources/html5app/js/gsap/utils/Draggable.js b/resources/html5app/js/gsap/utils/Draggable.js new file mode 100644 index 000000000..65c723466 --- /dev/null +++ b/resources/html5app/js/gsap/utils/Draggable.js @@ -0,0 +1,2283 @@ +/*! + * VERSION: 0.14.7 + * DATE: 2016-05-25 + * UPDATES AND DOCS AT: http://greensock.com + * + * Requires TweenLite and CSSPlugin version 1.17.0 or later (TweenMax contains both TweenLite and CSSPlugin). ThrowPropsPlugin is required for momentum-based continuation of movement after the mouse/touch is released (ThrowPropsPlugin is a membership benefit of Club GreenSock - http://greensock.com/club/). + * + * @license Copyright (c) 2008-2016, GreenSock. All rights reserved. + * This work is subject to the terms at http://greensock.com/standard-license or for + * Club GreenSock members, the software agreement that was issued with your membership. + * + * @author: Jack Doyle, jack@greensock.com + */ +var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node +(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() { + + "use strict"; + + _gsScope._gsDefine("utils.Draggable", ["events.EventDispatcher","TweenLite","plugins.CSSPlugin"], function(EventDispatcher, TweenLite, CSSPlugin) { + + var _tempVarsXY = {css:{}}, //speed optimization - we reuse the same vars object for x/y TweenLite.set() calls to minimize garbage collection tasks and improve performance. + _tempVarsX = {css:{}}, + _tempVarsY = {css:{}}, + _tempVarsRotation = {css:{}}, + _globals = _gsScope._gsDefine.globals, + _tempEvent = {}, //for populating with pageX/pageY in old versions of IE + _doc = document, + _docElement = _doc.documentElement || {}, + _createElement = function(type) { + return _doc.createElementNS ? _doc.createElementNS("http://www.w3.org/1999/xhtml", type) : _doc.createElement(type); + }, + _tempDiv = _createElement("div"), + _emptyArray = [], + _emptyFunc = function() { return false; }, + _RAD2DEG = 180 / Math.PI, + _max = 999999999999999, + _getTime = Date.now || function() {return new Date().getTime();}, + _isOldIE = !!(!_doc.addEventListener && _doc.all), + _placeholderDiv = _doc.createElement("div"), + _renderQueue = [], + _lookup = {}, //when a Draggable is created, the target gets a unique _gsDragID property that allows gets associated with the Draggable instance for quick lookups in Draggable.get(). This avoids circular references that could cause gc problems. + _lookupCount = 0, + _clickableTagExp = /^(?:a|input|textarea|button|select)$/i, + _dragCount = 0, //total number of elements currently being dragged + _prefix, + _isMultiTouching, + _isAndroid = (navigator.userAgent.toLowerCase().indexOf("android") !== -1), //Android handles touch events in an odd way and it's virtually impossible to "feature test" so we resort to UA sniffing + _lastDragTime = 0, + _temp1 = {}, // a simple object we reuse and populate (usually x/y properties) to conserve memory and improve performance. + _windowProxy = {}, //memory/performance optimization - we reuse this object during autoScroll to store window-related bounds/offsets. + _slice = function(a) { //don't use Array.prototype.slice.call(target, 0) because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll() + if (typeof(a) === "string") { + a = TweenLite.selector(a); + } + if (!a || a.nodeType) { //if it's not an array, wrap it in one. + return [a]; + } + var b = [], + l = a.length, + i; + for (i = 0; i !== l; b.push(a[i++])); + return b; + }, + _copy = function(obj) { + var copy = {}, p; + for (p in obj) { + copy[p] = obj[p]; + } + return copy; + }, + ThrowPropsPlugin, + + _renderQueueTick = function() { + var i = _renderQueue.length; + while (--i > -1) { + _renderQueue[i](); + } + }, + _addToRenderQueue = function(func) { + _renderQueue.push(func); + if (_renderQueue.length === 1) { + TweenLite.ticker.addEventListener("tick", _renderQueueTick, this, false, 1); + } + }, + _removeFromRenderQueue = function(func) { + var i = _renderQueue.length; + while (--i > -1) { + if (_renderQueue[i] === func) { + _renderQueue.splice(i, 1); + } + } + TweenLite.to(_renderQueueTimeout, 0, {overwrite:"all", delay:15, onComplete:_renderQueueTimeout}); //remove the "tick" listener only after the render queue is empty for 15 seconds (to improve performance). Adding/removing it constantly for every click/touch wouldn't deliver optimal speed, and we also don't want the ticker to keep calling the render method when things are idle for long periods of time (we want to improve battery life on mobile devices). + }, + _renderQueueTimeout = function() { + if (!_renderQueue.length) { + TweenLite.ticker.removeEventListener("tick", _renderQueueTick); + } + }, + + _extend = function(obj, defaults) { + var p; + for (p in defaults) { + if (obj[p] === undefined) { + obj[p] = defaults[p]; + } + } + return obj; + }, + _getDocScrollTop = function() { + return (window.pageYOffset != null) ? window.pageYOffset : (_doc.scrollTop != null) ? _doc.scrollTop : _docElement.scrollTop || _doc.body.scrollTop || 0; + }, + _getDocScrollLeft = function() { + return (window.pageXOffset != null) ? window.pageXOffset : (_doc.scrollLeft != null) ? _doc.scrollLeft : _docElement.scrollLeft || _doc.body.scrollLeft || 0; + }, + _addScrollListener = function(e, callback) { + _addListener(e, "scroll", callback); + if (!_isRoot(e.parentNode)) { + _addScrollListener(e.parentNode, callback); + } + }, + _removeScrollListener = function(e, callback) { + _removeListener(e, "scroll", callback); + if (!_isRoot(e.parentNode)) { + _removeScrollListener(e.parentNode, callback); + } + }, + _isRoot = function (e) { + return !!(!e || e === _docElement || e === _doc || e === _doc.body || e === window || !e.nodeType || !e.parentNode); + }, + _getMaxScroll = function(element, axis) { + var dim = (axis === "x") ? "Width" : "Height", + scroll = "scroll" + dim, + client = "client" + dim, + body = _doc.body; + return Math.max(0, _isRoot(element) ? Math.max(_docElement[scroll], body[scroll]) - (window["inner" + dim] || _docElement[client] || body[client]) : element[scroll] - element[client]); + }, + _recordMaxScrolls = function(e) { //records _gsMaxScrollX and _gsMaxScrollY properties for the element and all ancestors up the chain so that we can cap it, otherwise dragging beyond the edges with autoScroll on can endlessly scroll. + var isRoot = _isRoot(e), + x = _getMaxScroll(e, "x"), + y = _getMaxScroll(e, "y"); + if (isRoot) { + e = _windowProxy; + } else { + _recordMaxScrolls(e.parentNode); + } + e._gsMaxScrollX = x; + e._gsMaxScrollY = y; + e._gsScrollX = e.scrollLeft || 0; + e._gsScrollY = e.scrollTop || 0; + }, + + //just used for IE8 and earlier to normalize events and populate pageX/pageY + _populateIEEvent = function(e, preventDefault) { + e = e || window.event; + _tempEvent.pageX = e.clientX + _doc.body.scrollLeft + _docElement.scrollLeft; + _tempEvent.pageY = e.clientY + _doc.body.scrollTop + _docElement.scrollTop; + if (preventDefault) { + e.returnValue = false; + } + return _tempEvent; + }, + + //grabs the first element it finds (and we include the window as an element), so if it's selector text, it'll feed that value to TweenLite.selector, if it's a jQuery object or some other selector engine's result, it'll grab the first one, and same for an array. If the value doesn't contain a DOM element, it'll just return null. + _unwrapElement = function(value) { + if (!value) { + return value; + } + if (typeof(value) === "string") { + value = TweenLite.selector(value); + } + if (value.length && value !== window && value[0] && value[0].style && !value.nodeType) { + value = value[0]; + } + return (value === window || (value.nodeType && value.style)) ? value : null; + }, + + _checkPrefix = function(e, p) { + var s = e.style, + capped, i, a; + if (s[p] === undefined) { + a = ["O","Moz","ms","Ms","Webkit"]; + i = 5; + capped = p.charAt(0).toUpperCase() + p.substr(1); + while (--i > -1 && s[a[i]+capped] === undefined) { } + if (i < 0) { + return ""; + } + _prefix = (i === 3) ? "ms" : a[i]; + p = _prefix + capped; + } + return p; + }, + + _setStyle = function(e, p, value) { + var s = e.style; + if (!s) { + return; + } + if (s[p] === undefined) { + p = _checkPrefix(e, p); + } + if (value == null) { + if (s.removeProperty) { + s.removeProperty(p.replace(/([A-Z])/g, "-$1").toLowerCase()); + } else { //note: old versions of IE use "removeAttribute()" instead of "removeProperty()" + s.removeAttribute(p); + } + } else if (s[p] !== undefined) { + s[p] = value; + } + }, + + _getComputedStyle = _doc.defaultView ? _doc.defaultView.getComputedStyle : _emptyFunc, + _horizExp = /(?:Left|Right|Width)/i, + _suffixExp = /(?:\d|\-|\+|=|#|\.)*/g, + _convertToPixels = function(t, p, v, sfx, recurse) { + if (sfx === "px" || !sfx) { return v; } + if (sfx === "auto" || !v) { return 0; } + var horiz = _horizExp.test(p), + node = t, + style = _tempDiv.style, + neg = (v < 0), + pix; + if (neg) { + v = -v; + } + if (sfx === "%" && p.indexOf("border") !== -1) { + pix = (v / 100) * (horiz ? t.clientWidth : t.clientHeight); + } else { + style.cssText = "border:0 solid red;position:" + _getStyle(t, "position", true) + ";line-height:0;"; + if (sfx === "%" || !node.appendChild) { + node = t.parentNode || _doc.body; + style[(horiz ? "width" : "height")] = v + sfx; + } else { + style[(horiz ? "borderLeftWidth" : "borderTopWidth")] = v + sfx; + } + node.appendChild(_tempDiv); + pix = parseFloat(_tempDiv[(horiz ? "offsetWidth" : "offsetHeight")]); + node.removeChild(_tempDiv); + if (pix === 0 && !recurse) { + pix = _convertToPixels(t, p, v, sfx, true); + } + } + return neg ? -pix : pix; + }, + _calculateOffset = function(t, p) { //for figuring out "top" or "left" in px when it's "auto". We need to factor in margin with the offsetLeft/offsetTop + if (_getStyle(t, "position", true) !== "absolute") { return 0; } + var dim = ((p === "left") ? "Left" : "Top"), + v = _getStyle(t, "margin" + dim, true); + return t["offset" + dim] - (_convertToPixels(t, p, parseFloat(v), (v + "").replace(_suffixExp, "")) || 0); + }, + + _getStyle = function(element, prop, keepUnits) { + var rv = (element._gsTransform || {})[prop], + cs; + if (rv || rv === 0) { + return rv; + } else if (element.style[prop]) { + rv = element.style[prop]; + } else if ((cs = _getComputedStyle(element))) { + rv = cs.getPropertyValue(prop.replace(/([A-Z])/g, "-$1").toLowerCase()); + rv = (rv || cs.length) ? rv : cs[prop]; //Opera behaves VERY strangely - length is usually 0 and cs[prop] is the only way to get accurate results EXCEPT when checking for -o-transform which only works with cs.getPropertyValue()! + } else if (element.currentStyle) { + rv = element.currentStyle[prop]; + } + if (rv === "auto" && (prop === "top" || prop === "left")) { + rv = _calculateOffset(element, prop); + } + return keepUnits ? rv : parseFloat(rv) || 0; + }, + + _dispatchEvent = function(instance, type, callbackName) { + var vars = instance.vars, + callback = vars[callbackName], + listeners = instance._listeners[type]; + if (typeof(callback) === "function") { + callback.apply(vars[callbackName + "Scope"] || vars.callbackScope || instance, vars[callbackName + "Params"] || [instance.pointerEvent]); + } + if (listeners) { + instance.dispatchEvent(type); + } + }, + _getBounds = function(obj, context) { //accepts any of the following: a DOM element, jQuery object, selector text, or an object defining bounds as {top, left, width, height} or {minX, maxX, minY, maxY}. Returns an object with left, top, width, and height properties. + var e = _unwrapElement(obj), + top, left, offset; + if (!e) { + if (obj.left !== undefined) { + offset = _getOffsetTransformOrigin(context); //the bounds should be relative to the origin + return {left: obj.left - offset.x, top: obj.top - offset.y, width: obj.width, height: obj.height}; + } + left = obj.min || obj.minX || obj.minRotation || 0; + top = obj.min || obj.minY || 0; + return {left:left, top:top, width:(obj.max || obj.maxX || obj.maxRotation || 0) - left, height:(obj.max || obj.maxY || 0) - top}; + } + return _getElementBounds(e, context); + }, + + _svgBorderFactor, + _svgBorderScales, + _svgScrollOffset, + _hasBorderBug, + _hasReparentBug,//some browsers, like Chrome 49, alter the offsetTop/offsetLeft/offsetParent of elements when a non-identity transform is applied. + _setEnvironmentVariables = function() { //some browsers factor the border into the SVG coordinate space, some don't (like Firefox). Some apply transforms to them, some don't. We feature-detect here so we know how to handle the border(s). We can't do this immediately - we must wait for the document.body to exist. + if (!_doc.createElementNS) { + _svgBorderFactor = 0; + _svgBorderScales = false; + return; + } + var div = _createElement("div"), + svg = _doc.createElementNS("http://www.w3.org/2000/svg", "svg"), + wrapper = _createElement("div"), + style = div.style, + parent = _doc.body || _docElement, + matrix, e1, point, oldValue; + if (_doc.body && _transformProp) { + style.position = "absolute"; + parent.appendChild(wrapper); + wrapper.appendChild(div); + oldValue = div.offsetParent; + wrapper.style[_transformProp] = "rotate(1deg)"; + _hasReparentBug = (div.offsetParent === oldValue); + wrapper.style.position = "absolute"; + style.height = "10px"; + oldValue = div.offsetTop; + wrapper.style.border = "5px solid red"; + _hasBorderBug = (oldValue !== div.offsetTop); //some browsers, like Firefox 38, cause the offsetTop/Left to be affected by a parent's border. + parent.removeChild(wrapper); + } + style = svg.style; + svg.setAttributeNS(null, "width", "400px"); + svg.setAttributeNS(null, "height", "400px"); + svg.setAttributeNS(null, "viewBox", "0 0 400 400"); + style.display = "block"; + style.boxSizing = "border-box"; + style.border = "0px solid red"; + style.transform = "none"; + // in some browsers (like certain flavors of Android), the getScreenCTM() matrix is contaminated by the scroll position. We can run some logic here to detect that condition, but we ended up not needing this because we found another workaround using getBoundingClientRect(). + div.style.cssText = "width:100px;height:100px;overflow:scroll;-ms-overflow-style:none;"; + parent.appendChild(div); + div.appendChild(svg); + point = svg.createSVGPoint().matrixTransform(svg.getScreenCTM()); + e1 = point.y; + div.scrollTop = 100; + point.x = point.y = 0; + point = point.matrixTransform(svg.getScreenCTM()); + _svgScrollOffset = (e1 - point.y < 100.1) ? 0 : e1 - point.y - 150; + div.removeChild(svg); + parent.removeChild(div); + // -- end _svgScrollOffset calculation. + parent.appendChild(svg); + matrix = svg.getScreenCTM(); + e1 = matrix.e; + style.border = "50px solid red"; + matrix = svg.getScreenCTM(); + if (e1 === 0 && matrix.e === 0 && matrix.f === 0 && matrix.a === 1) { //Opera has a bunch of bugs - it doesn't adjust the x/y of the matrix, nor does it scale when box-sizing is border-box but it does so elsewhere; to get the correct behavior we set _svgBorderScales to true. + _svgBorderFactor = 1; + _svgBorderScales = true; + } else { + _svgBorderFactor = (e1 !== matrix.e) ? 1 : 0; + _svgBorderScales = (matrix.a !== 1); + } + parent.removeChild(svg); + }, + + _supports3D = (_checkPrefix(_tempDiv, "perspective") !== ""), + + // start matrix and point conversion methods... + _transformOriginProp = _checkPrefix(_tempDiv, "transformOrigin").replace(/^ms/g, "Ms").replace(/([A-Z])/g, "-$1").toLowerCase(), + _transformProp = _checkPrefix(_tempDiv, "transform"), + _transformPropCSS = _transformProp.replace(/^ms/g, "Ms").replace(/([A-Z])/g, "-$1").toLowerCase(), + _point1 = {}, //we reuse _point1 and _point2 objects inside matrix and point conversion methods to conserve memory and minimize garbage collection tasks. + _point2 = {}, + _SVGElement = window.SVGElement, + _isSVG = function(e) { + return !!(_SVGElement && typeof(e.getBBox) === "function" && e.getCTM && (!e.parentNode || (e.parentNode.getBBox && e.parentNode.getCTM))); + }, + _isIE10orBelow = (((/MSIE ([0-9]{1,}[\.0-9]{0,})/).exec(navigator.userAgent) || (/Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/).exec(navigator.userAgent)) && parseFloat( RegExp.$1 ) < 11), //Ideally we'd avoid user agent sniffing, but there doesn't seem to be a way to feature-detect and sense a border-related bug that only affects IE10 and IE9. + _tempTransforms = [], + _tempElements = [], + _getSVGOffsets = function(e) { //SVG elements don't always report offsetTop/offsetLeft/offsetParent at all (I'm looking at you, Firefox 29 and Android), so we have to do some work to manufacture those values. You can pass any SVG element and it'll spit back an object with offsetTop, offsetLeft, offsetParent, scaleX, and scaleY properties. We need the scaleX and scaleY to handle the way SVG can resize itself based on the container. + if (!e.getBoundingClientRect || !e.parentNode || !_transformProp) { + return {offsetTop:0, offsetLeft:0, scaleX:1, scaleY:1, offsetParent:_docElement}; + } + if (Draggable.cacheSVGData !== false && e._gsCache && e._gsCache.lastUpdate === TweenLite.ticker.frame) { //performance optimization. Assume that if the offsets are requested again on the same tick, we can just feed back the values we already calculated (no need to keep recalculating until another tick elapses). + return e._gsCache; + } + var curElement = e, + cache = _cache(e), + eRect, parentRect, offsetParent, cs, m, i, point1, point2, borderWidth, borderHeight, width, height; + cache.lastUpdate = TweenLite.ticker.frame; + if (e.getBBox && !cache.isSVGRoot) { //if it's a nested/child SVG element, we must find the parent SVG canvas and measure the offset from there. + curElement = e.parentNode; + eRect = e.getBBox(); + while (curElement && (curElement.nodeName + "").toLowerCase() !== "svg") { + curElement = curElement.parentNode; + } + cs = _getSVGOffsets(curElement); + cache.offsetTop = eRect.y * cs.scaleY; + cache.offsetLeft = eRect.x * cs.scaleX; + cache.scaleX = cs.scaleX; + cache.scaleY = cs.scaleY; + cache.offsetParent = curElement || _docElement; + return cache; + } + //only root SVG elements continue here... + offsetParent = cache.offsetParent; + if (offsetParent === _doc.body) { + offsetParent = _docElement; //avoids problems with margins/padding on the body + } + //walk up the ancestors and record any non-identity transforms (and reset them to "none") until we reach the offsetParent. We must do this so that the getBoundingClientRect() is accurate for measuring the offsetTop/offsetLeft. We'll revert the values later... + _tempElements.length = _tempTransforms.length = 0; + while (curElement) { + m = _getStyle(curElement, _transformProp, true); + if (m !== "matrix(1, 0, 0, 1, 0, 0)" && m !== "none" && m !== "translate3d(0px, 0px, 0px)") { + _tempElements.push(curElement); + _tempTransforms.push(curElement.style[_transformProp]); + curElement.style[_transformProp] = "none"; + } + if (curElement === offsetParent) { + break; + } + curElement = curElement.parentNode; + } + parentRect = offsetParent.getBoundingClientRect(); + m = e.getScreenCTM(); + point2 = e.createSVGPoint(); + point1 = point2.matrixTransform(m); + point2.x = point2.y = 10; + point2 = point2.matrixTransform(m); + cache.scaleX = (point2.x - point1.x) / 10; + cache.scaleY = (point2.y - point1.y) / 10; + if (_svgBorderFactor === undefined) { + _setEnvironmentVariables(); + } + if (cache.borderBox && !_svgBorderScales && e.getAttribute("width")) { //some browsers (like Safari) don't properly scale the matrix to accommodate the border when box-sizing is border-box, so we must calculate it here... + cs = _getComputedStyle(e) || {}; + borderWidth = (parseFloat(cs.borderLeftWidth) + parseFloat(cs.borderRightWidth)) || 0; + borderHeight = (parseFloat(cs.borderTopWidth) + parseFloat(cs.borderBottomWidth)) || 0; + width = parseFloat(cs.width) || 0; + height = parseFloat(cs.height) || 0; + cache.scaleX *= (width - borderWidth) / width; + cache.scaleY *= (height - borderHeight) / height; + } + if (_svgScrollOffset) { //some browsers (like Chrome for Android) have bugs in the way getScreenCTM() is reported (it doesn't factor in scroll position), so we must revert to a more expensive technique for calculating offsetTop/Left. + eRect = e.getBoundingClientRect(); + cache.offsetLeft = eRect.left - parentRect.left; + cache.offsetTop = eRect.top - parentRect.top; + } else { + cache.offsetLeft = point1.x - parentRect.left; + cache.offsetTop = point1.y - parentRect.top; + } + cache.offsetParent = offsetParent; + i = _tempElements.length; + while (--i > -1) { + _tempElements[i].style[_transformProp] = _tempTransforms[i]; + } + return cache; + }, + _getOffsetTransformOrigin = function(e, decoratee) { //returns the x/y position of the transformOrigin of the element, in its own local coordinate system (pixels), offset from the top left corner. + decoratee = decoratee || {}; + if (!e || e === _docElement || !e.parentNode || e === window) { + return {x:0, y:0}; + } + var cs = _getComputedStyle(e), + v = (_transformOriginProp && cs) ? cs.getPropertyValue(_transformOriginProp) : "50% 50%", + a = v.split(" "), + x = (v.indexOf("left") !== -1) ? "0%" : (v.indexOf("right") !== -1) ? "100%" : a[0], + y = (v.indexOf("top") !== -1) ? "0%" : (v.indexOf("bottom") !== -1) ? "100%" : a[1]; + if (y === "center" || y == null) { + y = "50%"; + } + if (x === "center" || isNaN(parseFloat(x))) { //remember, the user could flip-flop the values and say "bottom center" or "center bottom", etc. "center" is ambiguous because it could be used to describe horizontal or vertical, hence the isNaN(). If there's an "=" sign in the value, it's relative. + x = "50%"; + } + if (e.getBBox && _isSVG(e)) { //SVG elements must be handled in a special way because their origins are calculated from the top left. + if (!e._gsTransform) { + TweenLite.set(e, {x:"+=0", overwrite:false}); //forces creation of the _gsTransform where we store all the transform components including xOrigin and yOrigin for SVG elements, as of GSAP 1.15.0 which also takes care of calculating the origin from the upper left corner of the SVG canvas. + if (e._gsTransform.xOrigin === undefined) { + console.log("Draggable requires at least GSAP 1.17.0"); + } + } + v = e.getBBox(); + decoratee.x = (e._gsTransform.xOrigin - v.x); + decoratee.y = (e._gsTransform.yOrigin - v.y); + } else { + if (e.getBBox && (x + y).indexOf("%") !== -1) { //Firefox doesn't report offsetWidth/height on elements. + e = e.getBBox(); + e = {offsetWidth: e.width, offsetHeight: e.height}; + } + decoratee.x = ((x.indexOf("%") !== -1) ? e.offsetWidth * parseFloat(x) / 100 : parseFloat(x)); + decoratee.y = ((y.indexOf("%") !== -1) ? e.offsetHeight * parseFloat(y) / 100 : parseFloat(y)); + + } + return decoratee; + }, + _cache = function(e) { //computes some important values and stores them in a _gsCache object attached to the element itself so that we can optimize performance + if (Draggable.cacheSVGData !== false && e._gsCache && e._gsCache.lastUpdate === TweenLite.ticker.frame) { //performance optimization. Assume that if the offsets are requested again on the same tick, we can just feed back the values we already calculated (no need to keep recalculating until another tick elapses). + return e._gsCache; + } + var cache = e._gsCache = e._gsCache || {}, + cs = _getComputedStyle(e), + isSVG = (e.getBBox && _isSVG(e)), + isSVGRoot = ((e.nodeName + "").toLowerCase() === "svg"), + curSVG; + cache.isSVG = isSVG; + cache.isSVGRoot = isSVGRoot; + cache.borderBox = (cs.boxSizing === "border-box"); + cache.computedStyle = cs; + if (isSVGRoot) { //some browsers don't report parentNode on SVG elements. + curSVG = e.parentNode || _docElement; + curSVG.insertBefore(_tempDiv, e); + cache.offsetParent = _tempDiv.offsetParent || _docElement; //in some cases, Firefox still reports offsetParent as null. + curSVG.removeChild(_tempDiv); + } else if (isSVG) { + curSVG = e.parentNode; + while (curSVG && (curSVG.nodeName + "").toLowerCase() !== "svg") { //offsetParent is always the SVG canvas for SVG elements. + curSVG = curSVG.parentNode; + } + cache.offsetParent = curSVG; + } else { + cache.offsetParent = e.offsetParent; + } + return cache; + }, + _getOffset2DMatrix = function(e, offsetOrigin, parentOffsetOrigin, zeroOrigin) { + if (e === window || !e || !e.style || !e.parentNode) { + return [1,0,0,1,0,0]; + } + var cache = e._gsCache || _cache(e), + parent = e.parentNode, + parentCache = parent._gsCache || _cache(parent), + cs = cache.computedStyle, + parentOffsetParent = cache.isSVG ? parentCache.offsetParent : parent.offsetParent, + m, isRoot, offsets, rect, t, sx, sy, offsetX, offsetY, parentRect, borderTop, borderLeft, borderTranslateX, borderTranslateY; + m = (cache.isSVG && (e.style[_transformProp] + "").indexOf("matrix") !== -1) ? e.style[_transformProp] : cs ? cs.getPropertyValue(_transformPropCSS) : e.currentStyle ? e.currentStyle[_transformProp] : "1,0,0,1,0,0"; //some browsers (like Chrome 40) don't correctly report transforms that are applied inline on an SVG element (they don't get included in the computed style), so we double-check here and accept matrix values + + if (e.getBBox && (e.getAttribute("transform") + "").indexOf("matrix") !== -1) { //SVG can store transform data in its "transform" attribute instead of the CSS, so look for that here (only accept matrix()). + m = e.getAttribute("transform"); + } + m = (m + "").match(/(?:\-|\.|\b)(\d|\.|e\-)+/g) || [1,0,0,1,0,0]; + if (m.length > 6) { + m = [m[0], m[1], m[4], m[5], m[12], m[13]]; + } + if (zeroOrigin) { + m[4] = m[5] = 0; + } else if (cache.isSVG && (t = e._gsTransform) && (t.xOrigin || t.yOrigin)) { + //SVGs handle origin very differently. Factor in GSAP's handling of origin values here: + m[0] = parseFloat(m[0]); + m[1] = parseFloat(m[1]); + m[2] = parseFloat(m[2]); + m[3] = parseFloat(m[3]); + m[4] = parseFloat(m[4]) - (t.xOrigin - (t.xOrigin * m[0] + t.yOrigin * m[2])); + m[5] = parseFloat(m[5]) - (t.yOrigin - (t.xOrigin * m[1] + t.yOrigin * m[3])); + } + if (offsetOrigin) { + if (_svgBorderFactor === undefined) { + _setEnvironmentVariables(); + } + offsets = (cache.isSVG || cache.isSVGRoot) ? _getSVGOffsets(e) : e; + if (cache.isSVG) { //don't just rely on "instanceof _SVGElement" because if the SVG is embedded via an object tag, it won't work (SVGElement is mapped to a different object)) + rect = e.getBBox(); + parentRect = (parentCache.isSVGRoot) ? {x:0, y:0} : parent.getBBox(); + offsets = {offsetLeft:rect.x - parentRect.x, offsetTop:rect.y - parentRect.y, offsetParent:cache.offsetParent}; + } else if (cache.isSVGRoot) { + borderTop = parseInt(cs.borderTopWidth, 10) || 0; + borderLeft = parseInt(cs.borderLeftWidth, 10) || 0; + borderTranslateX = ((m[0] - _svgBorderFactor) * borderLeft + m[2] * borderTop); + borderTranslateY = (m[1] * borderLeft + (m[3] - _svgBorderFactor) * borderTop); + + sx = offsetOrigin.x; + sy = offsetOrigin.y; + offsetX = (sx - (sx * m[0] + sy * m[2])); //accommodate the SVG root's transforms when the origin isn't in the top left. + offsetY = (sy - (sx * m[1] + sy * m[3])); + + m[4] = parseFloat(m[4]) + offsetX; + m[5] = parseFloat(m[5]) + offsetY; + offsetOrigin.x -= offsetX; + offsetOrigin.y -= offsetY; + sx = offsets.scaleX; + sy = offsets.scaleY; + offsetOrigin.x *= sx; + offsetOrigin.y *= sy; + m[0] *= sx; + m[1] *= sy; + m[2] *= sx; + m[3] *= sy; + + if (!_isIE10orBelow) { + offsetOrigin.x += borderTranslateX; + offsetOrigin.y += borderTranslateY; + } + } else if (!_hasBorderBug && e.offsetParent) { + offsetOrigin.x += parseInt(_getStyle(e.offsetParent, "borderLeftWidth"), 10) || 0; + offsetOrigin.y += parseInt(_getStyle(e.offsetParent, "borderTopWidth"), 10) || 0; + } + isRoot = (parent === _docElement || parent === _doc.body); + m[4] = Number(m[4]) + offsetOrigin.x + (offsets.offsetLeft || 0) - parentOffsetOrigin.x - (isRoot ? 0 : parent.scrollLeft || 0); + m[5] = Number(m[5]) + offsetOrigin.y + (offsets.offsetTop || 0) - parentOffsetOrigin.y - (isRoot ? 0 : parent.scrollTop || 0); + if (parent && _getStyle(e, "position", cs) === "fixed") { //fixed position elements should factor in the scroll position of the document. + m[4] += _getDocScrollLeft(); + m[5] += _getDocScrollTop(); + } + if (parent && parent !== _docElement && parentOffsetParent === offsets.offsetParent && !parentCache.isSVG && (!_hasReparentBug || _getOffset2DMatrix(parent).join("") === "100100")) { + offsets = (parentCache.isSVGRoot) ? _getSVGOffsets(parent) : parent; + m[4] -= offsets.offsetLeft || 0; + m[5] -= offsets.offsetTop || 0; + if (!_hasBorderBug && parentCache.offsetParent && !cache.isSVG && !cache.isSVGRoot) { + m[4] -= parseInt(_getStyle(parentCache.offsetParent, "borderLeftWidth"), 10) || 0; + m[5] -= parseInt(_getStyle(parentCache.offsetParent, "borderTopWidth"), 10) || 0; + } + } + } + return m; + }, + _getConcatenatedMatrix = function(e, invert) { + if (!e || e === window || !e.parentNode) { + return [1,0,0,1,0,0]; + } + //note: we keep reusing _point1 and _point2 in order to minimize memory usage and garbage collection chores. + var originOffset = _getOffsetTransformOrigin(e, _point1), + parentOriginOffset = _getOffsetTransformOrigin(e.parentNode, _point2), + m = _getOffset2DMatrix(e, originOffset, parentOriginOffset), + a, b, c, d, tx, ty, m2, determinant; + while ((e = e.parentNode) && e.parentNode && e !== _docElement) { + originOffset = parentOriginOffset; + parentOriginOffset = _getOffsetTransformOrigin(e.parentNode, (originOffset === _point1) ? _point2 : _point1); + m2 = _getOffset2DMatrix(e, originOffset, parentOriginOffset); + a = m[0]; + b = m[1]; + c = m[2]; + d = m[3]; + tx = m[4]; + ty = m[5]; + m[0] = a * m2[0] + b * m2[2]; + m[1] = a * m2[1] + b * m2[3]; + m[2] = c * m2[0] + d * m2[2]; + m[3] = c * m2[1] + d * m2[3]; + m[4] = tx * m2[0] + ty * m2[2] + m2[4]; + m[5] = tx * m2[1] + ty * m2[3] + m2[5]; + } + if (invert) { + a = m[0]; + b = m[1]; + c = m[2]; + d = m[3]; + tx = m[4]; + ty = m[5]; + determinant = (a * d - b * c); + m[0] = d / determinant; + m[1] = -b / determinant; + m[2] = -c / determinant; + m[3] = a / determinant; + m[4] = (c * ty - d * tx) / determinant; + m[5] = -(a * ty - b * tx) / determinant; + } + return m; + }, + _localToGlobal = function(e, p, fromTopLeft, decoratee, zeroOrigin) { + e = _unwrapElement(e); + var m = _getConcatenatedMatrix(e, false, zeroOrigin), + x = p.x, + y = p.y; + if (fromTopLeft) { + _getOffsetTransformOrigin(e, p); + x -= p.x; + y -= p.y; + } + decoratee = (decoratee === true) ? p : decoratee || {}; + decoratee.x = x * m[0] + y * m[2] + m[4]; + decoratee.y = x * m[1] + y * m[3] + m[5]; + return decoratee; + }, + _localizePoint = function(p, localToGlobal, globalToLocal) { + var x = p.x * localToGlobal[0] + p.y * localToGlobal[2] + localToGlobal[4], + y = p.x * localToGlobal[1] + p.y * localToGlobal[3] + localToGlobal[5]; + p.x = x * globalToLocal[0] + y * globalToLocal[2] + globalToLocal[4]; + p.y = x * globalToLocal[1] + y * globalToLocal[3] + globalToLocal[5]; + return p; + }, + + _getElementBounds = function(e, context, fromTopLeft) { + if (!(e = _unwrapElement(e))) { + return null; + } + context = _unwrapElement(context); + var isSVG = (e.getBBox && _isSVG(e)), + origin, left, right, top, bottom, mLocalToGlobal, mGlobalToLocal, p1, p2, p3, p4, bbox, width, height, cache, borderLeft, borderTop, viewBox, viewBoxX, viewBoxY, computedDimensions, cs; + if (e === window) { + top = _getDocScrollTop(); + left = _getDocScrollLeft(); + right = left + (_docElement.clientWidth || e.innerWidth || _doc.body.clientWidth || 0); + bottom = top + (((e.innerHeight || 0) - 20 < _docElement.clientHeight) ? _docElement.clientHeight : e.innerHeight || _doc.body.clientHeight || 0); //some browsers (like Firefox) ignore absolutely positioned elements, and collapse the height of the documentElement, so it could be 8px, for example, if you have just an absolutely positioned div. In that case, we use the innerHeight to resolve this. + } else if (context === undefined || context === window) { + return e.getBoundingClientRect(); + } else { + origin = _getOffsetTransformOrigin(e); + left = -origin.x; + top = -origin.y; + if (isSVG) { + bbox = e.getBBox(); + width = bbox.width; + height = bbox.height; + } else if ((e.nodeName + "").toLowerCase() !== "svg" && e.offsetWidth) { //Chrome dropped support for "offsetWidth" on SVG elements + width = e.offsetWidth; + height = e.offsetHeight; + } else { + computedDimensions = _getComputedStyle(e); + width = parseFloat(computedDimensions.width); + height = parseFloat(computedDimensions.height); + } + right = left + width; + bottom = top + height; + if (e.nodeName.toLowerCase() === "svg" && !_isOldIE) { //root SVG elements are a special beast because they have 2 types of scaling - transforms on themselves as well as the stretching of the SVG canvas itself based on the outer size and the viewBox. If, for example, the SVG's viewbox is "0 0 100 100" but the CSS is set to width:200px; height:200px, that'd make it appear at 2x scale even though the element itself has no CSS transforms but the offsetWidth/offsetHeight are based on that css, not the viewBox so we need to adjust them accordingly. + cache = _getSVGOffsets(e); + cs = cache.computedStyle || {}; + viewBox = (e.getAttribute("viewBox") || "0 0").split(" "); + viewBoxX = parseFloat(viewBox[0]); + viewBoxY = parseFloat(viewBox[1]); + borderLeft = parseFloat(cs.borderLeftWidth) || 0; + borderTop = parseFloat(cs.borderTopWidth) || 0; + right -= width - ((width - borderLeft) / cache.scaleX) - viewBoxX; + bottom -= height - ((height - borderTop) / cache.scaleY) - viewBoxY; + left -= borderLeft / cache.scaleX - viewBoxX; + top -= borderTop / cache.scaleY - viewBoxY; + if (computedDimensions) { //when we had to use computed styles, factor in the border now. + right += (parseFloat(cs.borderRightWidth) + borderLeft) / cache.scaleX; + bottom += (borderTop + parseFloat(cs.borderBottomWidth)) / cache.scaleY; + } + } + } + if (e === context) { + return {left:left, top:top, width: right - left, height: bottom - top}; + } + mLocalToGlobal = _getConcatenatedMatrix(e); + mGlobalToLocal = _getConcatenatedMatrix(context, true); + p1 = _localizePoint({x:left, y:top}, mLocalToGlobal, mGlobalToLocal); + p2 = _localizePoint({x:right, y:top}, mLocalToGlobal, mGlobalToLocal); + p3 = _localizePoint({x:right, y:bottom}, mLocalToGlobal, mGlobalToLocal); + p4 = _localizePoint({x:left, y:bottom}, mLocalToGlobal, mGlobalToLocal); + left = Math.min(p1.x, p2.x, p3.x, p4.x); + top = Math.min(p1.y, p2.y, p3.y, p4.y); + _temp1.x = _temp1.y = 0; + if (fromTopLeft) { + _getOffsetTransformOrigin(context, _temp1); + } + return {left:left + _temp1.x, top:top + _temp1.y, width:Math.max(p1.x, p2.x, p3.x, p4.x) - left, height:Math.max(p1.y, p2.y, p3.y, p4.y) - top}; + }, + // end matrix and point conversion methods + + + + _isArrayLike = function(e) { + return (e && e.length && e[0] && ((e[0].nodeType && e[0].style && !e.nodeType) || (e[0].length && e[0][0]))) ? true : false; //could be an array of jQuery objects too, so accommodate that. + }, + + _flattenArray = function(a) { + var result = [], + l = a.length, + i, e, j; + for (i = 0; i < l; i++) { + e = a[i]; + if (_isArrayLike(e)) { + j = e.length; + for (j = 0; j < e.length; j++) { + result.push(e[j]); + } + } else if (e && e.length !== 0) { + result.push(e); + } + } + return result; + }, + + _isTouchDevice = (("ontouchstart" in _docElement) && ("orientation" in window)), + _touchEventLookup = (function(types) { //we create an object that makes it easy to translate touch event types into their "pointer" counterparts if we're in a browser that uses those instead. Like IE10 uses "MSPointerDown" instead of "touchstart", for example. + var standard = types.split(","), + converted = ((_tempDiv.onpointerdown !== undefined) ? "pointerdown,pointermove,pointerup,pointercancel" : (_tempDiv.onmspointerdown !== undefined) ? "MSPointerDown,MSPointerMove,MSPointerUp,MSPointerCancel" : types).split(","), + obj = {}, + i = 8; + while (--i > -1) { + obj[standard[i]] = converted[i]; + obj[converted[i]] = standard[i]; + } + return obj; + }("touchstart,touchmove,touchend,touchcancel")), + + _addListener = function(element, type, func, capture) { + if (element.addEventListener) { + element.addEventListener(_touchEventLookup[type] || type, func, capture); + } else if (element.attachEvent) { + element.attachEvent("on" + type, func); + } + }, + + _removeListener = function(element, type, func) { + if (element.removeEventListener) { + element.removeEventListener(_touchEventLookup[type] || type, func); + } else if (element.detachEvent) { + element.detachEvent("on" + type, func); + } + }, + + _hasTouchID = function(list, ID) { + var i = list.length; + while (--i > -1) { + if (list[i].identifier === ID) { + return true; + } + } + return false; + }, + + _onMultiTouchDocumentEnd = function(e) { + _isMultiTouching = (e.touches && _dragCount < e.touches.length); + _removeListener(e.target, "touchend", _onMultiTouchDocumentEnd); + }, + + _onMultiTouchDocument = function(e) { + _isMultiTouching = (e.touches && _dragCount < e.touches.length); + _addListener(e.target, "touchend", _onMultiTouchDocumentEnd); + }, + + _parseThrowProps = function(draggable, snap, max, min, factor, forceZeroVelocity) { + var vars = {}, + a, i, l; + if (snap) { + if (factor !== 1 && snap instanceof Array) { //some data must be altered to make sense, like if the user passes in an array of rotational values in degrees, we must convert it to radians. Or for scrollLeft and scrollTop, we invert the values. + vars.end = a = []; + l = snap.length; + for (i = 0; i < l; i++) { + a[i] = snap[i] * factor; + } + max += 1.1; //allow 1.1 pixels of wiggle room when snapping in order to work around some browser inconsistencies in the way bounds are reported which can make them roughly a pixel off. For example, if "snap:[-$('#menu').width(), 0]" was defined and #menu had a wrapper that was used as the bounds, some browsers would be one pixel off, making the minimum -752 for example when snap was [-753,0], thus instead of snapping to -753, it would snap to 0 since -753 was below the minimum. + min -= 1.1; + } else if (typeof(snap) === "function") { + vars.end = function(value) { + return snap.call(draggable, value) * factor; //we need to ensure that we can scope the function call to the Draggable instance itself so that users can access important values like maxX, minX, maxY, minY, x, and y from within that function. + }; + } else { + vars.end = snap; + } + } + if (max || max === 0) { + vars.max = max; + } + if (min || min === 0) { + vars.min = min; + } + if (forceZeroVelocity) { + vars.velocity = 0; + } + return vars; + }, + + _isClickable = function(e) { //sometimes it's convenient to mark an element as clickable by adding a data-clickable="true" attribute (in which case we won't preventDefault() the mouse/touch event). This method checks if the element is an , ","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};ma.optgroup=ma.option,ma.tbody=ma.tfoot=ma.colgroup=ma.caption=ma.thead,ma.th=ma.td;function na(a,b){var c;return c="undefined"!=typeof a.getElementsByTagName?a.getElementsByTagName(b||"*"):"undefined"!=typeof a.querySelectorAll?a.querySelectorAll(b||"*"):[],void 0===b||b&&B(a,b)?r.merge([a],c):c}function oa(a,b){for(var c=0,d=a.length;c-1)e&&e.push(f);else if(j=r.contains(f.ownerDocument,f),g=na(l.appendChild(f),"script"),j&&oa(g),c){k=0;while(f=g[k++])la.test(f.type||"")&&c.push(f)}return l}!function(){var a=d.createDocumentFragment(),b=a.appendChild(d.createElement("div")),c=d.createElement("input");c.setAttribute("type","radio"),c.setAttribute("checked","checked"),c.setAttribute("name","t"),b.appendChild(c),o.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,b.innerHTML="",o.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue}();var ra=d.documentElement,sa=/^key/,ta=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,ua=/^([^.]*)(?:\.(.+)|)/;function va(){return!0}function wa(){return!1}function xa(){try{return d.activeElement}catch(a){}}function ya(a,b,c,d,e,f){var g,h;if("object"==typeof b){"string"!=typeof c&&(d=d||c,c=void 0);for(h in b)ya(a,h,c,d,b[h],f);return a}if(null==d&&null==e?(e=c,d=c=void 0):null==e&&("string"==typeof c?(e=d,d=void 0):(e=d,d=c,c=void 0)),e===!1)e=wa;else if(!e)return a;return 1===f&&(g=e,e=function(a){return r().off(a),g.apply(this,arguments)},e.guid=g.guid||(g.guid=r.guid++)),a.each(function(){r.event.add(this,b,e,d,c)})}r.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.get(a);if(q){c.handler&&(f=c,c=f.handler,e=f.selector),e&&r.find.matchesSelector(ra,e),c.guid||(c.guid=r.guid++),(i=q.events)||(i=q.events={}),(g=q.handle)||(g=q.handle=function(b){return"undefined"!=typeof r&&r.event.triggered!==b.type?r.event.dispatch.apply(a,arguments):void 0}),b=(b||"").match(L)||[""],j=b.length;while(j--)h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n&&(l=r.event.special[n]||{},n=(e?l.delegateType:l.bindType)||n,l=r.event.special[n]||{},k=r.extend({type:n,origType:p,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&r.expr.match.needsContext.test(e),namespace:o.join(".")},f),(m=i[n])||(m=i[n]=[],m.delegateCount=0,l.setup&&l.setup.call(a,d,o,g)!==!1||a.addEventListener&&a.addEventListener(n,g)),l.add&&(l.add.call(a,k),k.handler.guid||(k.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,k):m.push(k),r.event.global[n]=!0)}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,n,o,p,q=W.hasData(a)&&W.get(a);if(q&&(i=q.events)){b=(b||"").match(L)||[""],j=b.length;while(j--)if(h=ua.exec(b[j])||[],n=p=h[1],o=(h[2]||"").split(".").sort(),n){l=r.event.special[n]||{},n=(d?l.delegateType:l.bindType)||n,m=i[n]||[],h=h[2]&&new RegExp("(^|\\.)"+o.join("\\.(?:.*\\.|)")+"(\\.|$)"),g=f=m.length;while(f--)k=m[f],!e&&p!==k.origType||c&&c.guid!==k.guid||h&&!h.test(k.namespace)||d&&d!==k.selector&&("**"!==d||!k.selector)||(m.splice(f,1),k.selector&&m.delegateCount--,l.remove&&l.remove.call(a,k));g&&!m.length&&(l.teardown&&l.teardown.call(a,o,q.handle)!==!1||r.removeEvent(a,n,q.handle),delete i[n])}else for(n in i)r.event.remove(a,n+b[j],c,d,!0);r.isEmptyObject(i)&&W.remove(a,"handle events")}},dispatch:function(a){var b=r.event.fix(a),c,d,e,f,g,h,i=new Array(arguments.length),j=(W.get(this,"events")||{})[b.type]||[],k=r.event.special[b.type]||{};for(i[0]=b,c=1;c=1))for(;j!==this;j=j.parentNode||this)if(1===j.nodeType&&("click"!==a.type||j.disabled!==!0)){for(f=[],g={},c=0;c-1:r.find(e,this,null,[j]).length),g[e]&&f.push(d);f.length&&h.push({elem:j,handlers:f})}return j=this,i\x20\t\r\n\f]*)[^>]*)\/>/gi,Aa=/\s*$/g;function Ea(a,b){return B(a,"table")&&B(11!==b.nodeType?b:b.firstChild,"tr")?r(">tbody",a)[0]||a:a}function Fa(a){return a.type=(null!==a.getAttribute("type"))+"/"+a.type,a}function Ga(a){var b=Ca.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ha(a,b){var c,d,e,f,g,h,i,j;if(1===b.nodeType){if(W.hasData(a)&&(f=W.access(a),g=W.set(b,f),j=f.events)){delete g.handle,g.events={};for(e in j)for(c=0,d=j[e].length;c1&&"string"==typeof q&&!o.checkClone&&Ba.test(q))return a.each(function(e){var f=a.eq(e);s&&(b[0]=q.call(this,e,f.html())),Ja(f,b,c,d)});if(m&&(e=qa(b,a[0].ownerDocument,!1,a,d),f=e.firstChild,1===e.childNodes.length&&(e=f),f||d)){for(h=r.map(na(e,"script"),Fa),i=h.length;l")},clone:function(a,b,c){var d,e,f,g,h=a.cloneNode(!0),i=r.contains(a.ownerDocument,a);if(!(o.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||r.isXMLDoc(a)))for(g=na(h),f=na(a),d=0,e=f.length;d0&&oa(g,!i&&na(a,"script")),h},cleanData:function(a){for(var b,c,d,e=r.event.special,f=0;void 0!==(c=a[f]);f++)if(U(c)){if(b=c[W.expando]){if(b.events)for(d in b.events)e[d]?r.event.remove(c,d):r.removeEvent(c,d,b.handle);c[W.expando]=void 0}c[X.expando]&&(c[X.expando]=void 0)}}}),r.fn.extend({detach:function(a){return Ka(this,a,!0)},remove:function(a){return Ka(this,a)},text:function(a){return T(this,function(a){return void 0===a?r.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=a)})},null,a,arguments.length)},append:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.appendChild(a)}})},prepend:function(){return Ja(this,arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=Ea(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return Ja(this,arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},empty:function(){for(var a,b=0;null!=(a=this[b]);b++)1===a.nodeType&&(r.cleanData(na(a,!1)),a.textContent="");return this},clone:function(a,b){return a=null!=a&&a,b=null==b?a:b,this.map(function(){return r.clone(this,a,b)})},html:function(a){return T(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a&&1===b.nodeType)return b.innerHTML;if("string"==typeof a&&!Aa.test(a)&&!ma[(ka.exec(a)||["",""])[1].toLowerCase()]){a=r.htmlPrefilter(a);try{for(;c1)}});function _a(a,b,c,d,e){return new _a.prototype.init(a,b,c,d,e)}r.Tween=_a,_a.prototype={constructor:_a,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||r.easing._default,this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(r.cssNumber[c]?"":"px")},cur:function(){var a=_a.propHooks[this.prop];return a&&a.get?a.get(this):_a.propHooks._default.get(this)},run:function(a){var b,c=_a.propHooks[this.prop];return this.options.duration?this.pos=b=r.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):this.pos=b=a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):_a.propHooks._default.set(this),this}},_a.prototype.init.prototype=_a.prototype,_a.propHooks={_default:{get:function(a){var b;return 1!==a.elem.nodeType||null!=a.elem[a.prop]&&null==a.elem.style[a.prop]?a.elem[a.prop]:(b=r.css(a.elem,a.prop,""),b&&"auto"!==b?b:0)},set:function(a){r.fx.step[a.prop]?r.fx.step[a.prop](a):1!==a.elem.nodeType||null==a.elem.style[r.cssProps[a.prop]]&&!r.cssHooks[a.prop]?a.elem[a.prop]=a.now:r.style(a.elem,a.prop,a.now+a.unit)}}},_a.propHooks.scrollTop=_a.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},r.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2},_default:"swing"},r.fx=_a.prototype.init,r.fx.step={};var ab,bb,cb=/^(?:toggle|show|hide)$/,db=/queueHooks$/;function eb(){bb&&(d.hidden===!1&&a.requestAnimationFrame?a.requestAnimationFrame(eb):a.setTimeout(eb,r.fx.interval),r.fx.tick())}function fb(){return a.setTimeout(function(){ab=void 0}),ab=r.now()}function gb(a,b){var c,d=0,e={height:a};for(b=b?1:0;d<4;d+=2-b)c=ca[d],e["margin"+c]=e["padding"+c]=a;return b&&(e.opacity=e.width=a),e}function hb(a,b,c){for(var d,e=(kb.tweeners[b]||[]).concat(kb.tweeners["*"]),f=0,g=e.length;f1)},removeAttr:function(a){return this.each(function(){r.removeAttr(this,a)})}}),r.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return"undefined"==typeof a.getAttribute?r.prop(a,b,c):(1===f&&r.isXMLDoc(a)||(e=r.attrHooks[b.toLowerCase()]||(r.expr.match.bool.test(b)?lb:void 0)),void 0!==c?null===c?void r.removeAttr(a,b):e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:(a.setAttribute(b,c+""),c):e&&"get"in e&&null!==(d=e.get(a,b))?d:(d=r.find.attr(a,b), + null==d?void 0:d))},attrHooks:{type:{set:function(a,b){if(!o.radioValue&&"radio"===b&&B(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}},removeAttr:function(a,b){var c,d=0,e=b&&b.match(L);if(e&&1===a.nodeType)while(c=e[d++])a.removeAttribute(c)}}),lb={set:function(a,b,c){return b===!1?r.removeAttr(a,c):a.setAttribute(c,c),c}},r.each(r.expr.match.bool.source.match(/\w+/g),function(a,b){var c=mb[b]||r.find.attr;mb[b]=function(a,b,d){var e,f,g=b.toLowerCase();return d||(f=mb[g],mb[g]=e,e=null!=c(a,b,d)?g:null,mb[g]=f),e}});var nb=/^(?:input|select|textarea|button)$/i,ob=/^(?:a|area)$/i;r.fn.extend({prop:function(a,b){return T(this,r.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[r.propFix[a]||a]})}}),r.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&r.isXMLDoc(a)||(b=r.propFix[b]||b,e=r.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=r.find.attr(a,"tabindex");return b?parseInt(b,10):nb.test(a.nodeName)||ob.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),o.optSelected||(r.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),r.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){r.propFix[this.toLowerCase()]=this});function pb(a){var b=a.match(L)||[];return b.join(" ")}function qb(a){return a.getAttribute&&a.getAttribute("class")||""}r.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).addClass(a.call(this,b,qb(this)))});if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).removeClass(a.call(this,b,qb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(L)||[];while(c=this[i++])if(e=qb(c),d=1===c.nodeType&&" "+pb(e)+" "){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=pb(d),e!==h&&c.setAttribute("class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):r.isFunction(a)?this.each(function(c){r(this).toggleClass(a.call(this,c,qb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=r(this),f=a.match(L)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=qb(this),b&&W.set(this,"__className__",b),this.setAttribute&&this.setAttribute("class",b||a===!1?"":W.get(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+pb(qb(c))+" ").indexOf(b)>-1)return!0;return!1}});var rb=/\r/g;r.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=r.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,r(this).val()):a,null==e?e="":"number"==typeof e?e+="":Array.isArray(e)&&(e=r.map(e,function(a){return null==a?"":a+""})),b=r.valHooks[this.type]||r.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=r.valHooks[e.type]||r.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(rb,""):null==c?"":c)}}}),r.extend({valHooks:{option:{get:function(a){var b=r.find.attr(a,"value");return null!=b?b:pb(r.text(a))}},select:{get:function(a){var b,c,d,e=a.options,f=a.selectedIndex,g="select-one"===a.type,h=g?null:[],i=g?f+1:e.length;for(d=f<0?i:g?f:0;d-1)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),r.each(["radio","checkbox"],function(){r.valHooks[this]={set:function(a,b){if(Array.isArray(b))return a.checked=r.inArray(r(a).val(),b)>-1}},o.checkOn||(r.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var sb=/^(?:focusinfocus|focusoutblur)$/;r.extend(r.event,{trigger:function(b,c,e,f){var g,h,i,j,k,m,n,o=[e||d],p=l.call(b,"type")?b.type:b,q=l.call(b,"namespace")?b.namespace.split("."):[];if(h=i=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!sb.test(p+r.event.triggered)&&(p.indexOf(".")>-1&&(q=p.split("."),p=q.shift(),q.sort()),k=p.indexOf(":")<0&&"on"+p,b=b[r.expando]?b:new r.Event(p,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=q.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?[b]:r.makeArray(c,[b]),n=r.event.special[p]||{},f||!n.trigger||n.trigger.apply(e,c)!==!1)){if(!f&&!n.noBubble&&!r.isWindow(e)){for(j=n.delegateType||p,sb.test(j+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),i=h;i===(e.ownerDocument||d)&&o.push(i.defaultView||i.parentWindow||a)}g=0;while((h=o[g++])&&!b.isPropagationStopped())b.type=g>1?j:n.bindType||p,m=(W.get(h,"events")||{})[b.type]&&W.get(h,"handle"),m&&m.apply(h,c),m=k&&h[k],m&&m.apply&&U(h)&&(b.result=m.apply(h,c),b.result===!1&&b.preventDefault());return b.type=p,f||b.isDefaultPrevented()||n._default&&n._default.apply(o.pop(),c)!==!1||!U(e)||k&&r.isFunction(e[p])&&!r.isWindow(e)&&(i=e[k],i&&(e[k]=null),r.event.triggered=p,e[p](),r.event.triggered=void 0,i&&(e[k]=i)),b.result}},simulate:function(a,b,c){var d=r.extend(new r.Event,c,{type:a,isSimulated:!0});r.event.trigger(d,null,b)}}),r.fn.extend({trigger:function(a,b){return this.each(function(){r.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];if(c)return r.event.trigger(a,b,c,!0)}}),r.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(a,b){r.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),r.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}}),o.focusin="onfocusin"in a,o.focusin||r.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){r.event.simulate(b,a.target,r.event.fix(a))};r.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=W.access(d,b);e||d.addEventListener(a,c,!0),W.access(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=W.access(d,b)-1;e?W.access(d,b,e):(d.removeEventListener(a,c,!0),W.remove(d,b))}}});var tb=a.location,ub=r.now(),vb=/\?/;r.parseXML=function(b){var c;if(!b||"string"!=typeof b)return null;try{c=(new a.DOMParser).parseFromString(b,"text/xml")}catch(d){c=void 0}return c&&!c.getElementsByTagName("parsererror").length||r.error("Invalid XML: "+b),c};var wb=/\[\]$/,xb=/\r?\n/g,yb=/^(?:submit|button|image|reset|file)$/i,zb=/^(?:input|select|textarea|keygen)/i;function Ab(a,b,c,d){var e;if(Array.isArray(b))r.each(b,function(b,e){c||wb.test(a)?d(a,e):Ab(a+"["+("object"==typeof e&&null!=e?b:"")+"]",e,c,d)});else if(c||"object"!==r.type(b))d(a,b);else for(e in b)Ab(a+"["+e+"]",b[e],c,d)}r.param=function(a,b){var c,d=[],e=function(a,b){var c=r.isFunction(b)?b():b;d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(null==c?"":c)};if(Array.isArray(a)||a.jquery&&!r.isPlainObject(a))r.each(a,function(){e(this.name,this.value)});else for(c in a)Ab(c,a[c],b,e);return d.join("&")},r.fn.extend({serialize:function(){return r.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=r.prop(this,"elements");return a?r.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!r(this).is(":disabled")&&zb.test(this.nodeName)&&!yb.test(a)&&(this.checked||!ja.test(a))}).map(function(a,b){var c=r(this).val();return null==c?null:Array.isArray(c)?r.map(c,function(a){return{name:b.name,value:a.replace(xb,"\r\n")}}):{name:b.name,value:c.replace(xb,"\r\n")}}).get()}});var Bb=/%20/g,Cb=/#.*$/,Db=/([?&])_=[^&]*/,Eb=/^(.*?):[ \t]*([^\r\n]*)$/gm,Fb=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Gb=/^(?:GET|HEAD)$/,Hb=/^\/\//,Ib={},Jb={},Kb="*/".concat("*"),Lb=d.createElement("a");Lb.href=tb.href;function Mb(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(L)||[];if(r.isFunction(c))while(d=f[e++])"+"===d[0]?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nb(a,b,c,d){var e={},f=a===Jb;function g(h){var i;return e[h]=!0,r.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Ob(a,b){var c,d,e=r.ajaxSettings.flatOptions||{};for(c in b)void 0!==b[c]&&((e[c]?a:d||(d={}))[c]=b[c]);return d&&r.extend(!0,a,d),a}function Pb(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===d&&(d=a.mimeType||b.getResponseHeader("Content-Type"));if(d)for(e in h)if(h[e]&&h[e].test(d)){i.unshift(e);break}if(i[0]in c)f=i[0];else{for(e in c){if(!i[0]||a.converters[e+" "+i[0]]){f=e;break}g||(g=e)}f=f||g}if(f)return f!==i[0]&&i.unshift(f),c[f]}function Qb(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}r.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:tb.href,type:"GET",isLocal:Fb.test(tb.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kb,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":r.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Ob(Ob(a,r.ajaxSettings),b):Ob(r.ajaxSettings,a)},ajaxPrefilter:Mb(Ib),ajaxTransport:Mb(Jb),ajax:function(b,c){"object"==typeof b&&(c=b,b=void 0),c=c||{};var e,f,g,h,i,j,k,l,m,n,o=r.ajaxSetup({},c),p=o.context||o,q=o.context&&(p.nodeType||p.jquery)?r(p):r.event,s=r.Deferred(),t=r.Callbacks("once memory"),u=o.statusCode||{},v={},w={},x="canceled",y={readyState:0,getResponseHeader:function(a){var b;if(k){if(!h){h={};while(b=Eb.exec(g))h[b[1].toLowerCase()]=b[2]}b=h[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return k?g:null},setRequestHeader:function(a,b){return null==k&&(a=w[a.toLowerCase()]=w[a.toLowerCase()]||a,v[a]=b),this},overrideMimeType:function(a){return null==k&&(o.mimeType=a),this},statusCode:function(a){var b;if(a)if(k)y.always(a[y.status]);else for(b in a)u[b]=[u[b],a[b]];return this},abort:function(a){var b=a||x;return e&&e.abort(b),A(0,b),this}};if(s.promise(y),o.url=((b||o.url||tb.href)+"").replace(Hb,tb.protocol+"//"),o.type=c.method||c.type||o.method||o.type,o.dataTypes=(o.dataType||"*").toLowerCase().match(L)||[""],null==o.crossDomain){j=d.createElement("a");try{j.href=o.url,j.href=j.href,o.crossDomain=Lb.protocol+"//"+Lb.host!=j.protocol+"//"+j.host}catch(z){o.crossDomain=!0}}if(o.data&&o.processData&&"string"!=typeof o.data&&(o.data=r.param(o.data,o.traditional)),Nb(Ib,o,c,y),k)return y;l=r.event&&o.global,l&&0===r.active++&&r.event.trigger("ajaxStart"),o.type=o.type.toUpperCase(),o.hasContent=!Gb.test(o.type),f=o.url.replace(Cb,""),o.hasContent?o.data&&o.processData&&0===(o.contentType||"").indexOf("application/x-www-form-urlencoded")&&(o.data=o.data.replace(Bb,"+")):(n=o.url.slice(f.length),o.data&&(f+=(vb.test(f)?"&":"?")+o.data,delete o.data),o.cache===!1&&(f=f.replace(Db,"$1"),n=(vb.test(f)?"&":"?")+"_="+ub++ +n),o.url=f+n),o.ifModified&&(r.lastModified[f]&&y.setRequestHeader("If-Modified-Since",r.lastModified[f]),r.etag[f]&&y.setRequestHeader("If-None-Match",r.etag[f])),(o.data&&o.hasContent&&o.contentType!==!1||c.contentType)&&y.setRequestHeader("Content-Type",o.contentType),y.setRequestHeader("Accept",o.dataTypes[0]&&o.accepts[o.dataTypes[0]]?o.accepts[o.dataTypes[0]]+("*"!==o.dataTypes[0]?", "+Kb+"; q=0.01":""):o.accepts["*"]);for(m in o.headers)y.setRequestHeader(m,o.headers[m]);if(o.beforeSend&&(o.beforeSend.call(p,y,o)===!1||k))return y.abort();if(x="abort",t.add(o.complete),y.done(o.success),y.fail(o.error),e=Nb(Jb,o,c,y)){if(y.readyState=1,l&&q.trigger("ajaxSend",[y,o]),k)return y;o.async&&o.timeout>0&&(i=a.setTimeout(function(){y.abort("timeout")},o.timeout));try{k=!1,e.send(v,A)}catch(z){if(k)throw z;A(-1,z)}}else A(-1,"No Transport");function A(b,c,d,h){var j,m,n,v,w,x=c;k||(k=!0,i&&a.clearTimeout(i),e=void 0,g=h||"",y.readyState=b>0?4:0,j=b>=200&&b<300||304===b,d&&(v=Pb(o,y,d)),v=Qb(o,v,y,j),j?(o.ifModified&&(w=y.getResponseHeader("Last-Modified"),w&&(r.lastModified[f]=w),w=y.getResponseHeader("etag"),w&&(r.etag[f]=w)),204===b||"HEAD"===o.type?x="nocontent":304===b?x="notmodified":(x=v.state,m=v.data,n=v.error,j=!n)):(n=x,!b&&x||(x="error",b<0&&(b=0))),y.status=b,y.statusText=(c||x)+"",j?s.resolveWith(p,[m,x,y]):s.rejectWith(p,[y,x,n]),y.statusCode(u),u=void 0,l&&q.trigger(j?"ajaxSuccess":"ajaxError",[y,o,j?m:n]),t.fireWith(p,[y,x]),l&&(q.trigger("ajaxComplete",[y,o]),--r.active||r.event.trigger("ajaxStop")))}return y},getJSON:function(a,b,c){return r.get(a,b,c,"json")},getScript:function(a,b){return r.get(a,void 0,b,"script")}}),r.each(["get","post"],function(a,b){r[b]=function(a,c,d,e){return r.isFunction(c)&&(e=e||d,d=c,c=void 0),r.ajax(r.extend({url:a,type:b,dataType:e,data:c,success:d},r.isPlainObject(a)&&a))}}),r._evalUrl=function(a){return r.ajax({url:a,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,"throws":!0})},r.fn.extend({wrapAll:function(a){var b;return this[0]&&(r.isFunction(a)&&(a=a.call(this[0])),b=r(a,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstElementChild)a=a.firstElementChild;return a}).append(this)),this},wrapInner:function(a){return r.isFunction(a)?this.each(function(b){r(this).wrapInner(a.call(this,b))}):this.each(function(){var b=r(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=r.isFunction(a);return this.each(function(c){r(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(a){return this.parent(a).not("body").each(function(){r(this).replaceWith(this.childNodes)}),this}}),r.expr.pseudos.hidden=function(a){return!r.expr.pseudos.visible(a)},r.expr.pseudos.visible=function(a){return!!(a.offsetWidth||a.offsetHeight||a.getClientRects().length)},r.ajaxSettings.xhr=function(){try{return new a.XMLHttpRequest}catch(b){}};var Rb={0:200,1223:204},Sb=r.ajaxSettings.xhr();o.cors=!!Sb&&"withCredentials"in Sb,o.ajax=Sb=!!Sb,r.ajaxTransport(function(b){var c,d;if(o.cors||Sb&&!b.crossDomain)return{send:function(e,f){var g,h=b.xhr();if(h.open(b.type,b.url,b.async,b.username,b.password),b.xhrFields)for(g in b.xhrFields)h[g]=b.xhrFields[g];b.mimeType&&h.overrideMimeType&&h.overrideMimeType(b.mimeType),b.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest");for(g in e)h.setRequestHeader(g,e[g]);c=function(a){return function(){c&&(c=d=h.onload=h.onerror=h.onabort=h.onreadystatechange=null,"abort"===a?h.abort():"error"===a?"number"!=typeof h.status?f(0,"error"):f(h.status,h.statusText):f(Rb[h.status]||h.status,h.statusText,"text"!==(h.responseType||"text")||"string"!=typeof h.responseText?{binary:h.response}:{text:h.responseText},h.getAllResponseHeaders()))}},h.onload=c(),d=h.onerror=c("error"),void 0!==h.onabort?h.onabort=d:h.onreadystatechange=function(){4===h.readyState&&a.setTimeout(function(){c&&d()})},c=c("abort");try{h.send(b.hasContent&&b.data||null)}catch(i){if(c)throw i}},abort:function(){c&&c()}}}),r.ajaxPrefilter(function(a){a.crossDomain&&(a.contents.script=!1)}),r.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(a){return r.globalEval(a),a}}}),r.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET")}),r.ajaxTransport("script",function(a){if(a.crossDomain){var b,c;return{send:function(e,f){b=r("