You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6764 lines
204 KiB
6764 lines
204 KiB
/*
|
|
软件名称：ckplayer
|
|
软件版本：X
|
|
软件作者：http://www.ckplayer.com
|
|
---------------------------------------------------------------------------------------------
|
|
开发说明：
|
|
使用的主要程序语言：javascript(js)及actionscript3.0(as3.0)(as3.0主要用于flashplayer部分的开发，不在该页面呈现)
|
|
功能：播放视频
|
|
特点：兼容HTML5-VIDEO(优先)以及FlashPlayer
|
|
=====================================================================================================================
|
|
*/
|
|
function ckplayerConfig() {
|
|
return {
|
|
flashvars: {}, //用来补充flashvars里的对象
|
|
languagePath: '', //语言包文件地址
|
|
stylePath: '', //风格包文件地址
|
|
config: {
|
|
fullInteractive: true, //是否开启交互功能
|
|
delay: 30, //延迟加载视频，单位：毫秒
|
|
timeFrequency: 100, //计算当前播放时间和加载量的时间频率，单位：毫秒
|
|
autoLoad: true, //视频是否自动加载
|
|
loadNext: 0, //多段视频预加载的段数，设置成0则全部加载
|
|
definition: true, //是否使用清晰度组件
|
|
smartRemove: true, //是否使用智能清理，使用该功能则在多段时当前播放段之前的段都会被清除出内存，减少对内存的使用
|
|
bufferTime: 200, //缓存区的长度，单位：毫秒,不要小于10
|
|
click: true, //是否支持屏幕单击暂停
|
|
doubleClick: true, //是否支持屏幕双击全屏
|
|
doubleClickInterval: 200, //判断双击的标准，即二次单击间隔的时间差之内判断为是双击，单位：毫秒
|
|
keyDown: {
|
|
space: true, //是否启用空格键切换播放/暂停
|
|
left: true, //是否启用左方向键快退
|
|
right: true, //是否启用右方向键快进
|
|
up: true, //是否支持上方向键增加音量
|
|
down: true //是否支持下方向键减少音量
|
|
},
|
|
timeJump: 10, //快进快退时的秒数
|
|
volumeJump: 0.1, //音量调整的数量，大于0小于1的小数
|
|
timeScheduleAdjust: 1, //是否可调节调节栏,0不启用，1是启用，2是只能前进（向右拖动），3是只能后退，4是只能前进但能回到第一次拖动时的位置，5是看过的地方可以随意拖动
|
|
previewDefaultLoad: true, //预览图片是否默认加载，优点是鼠标第一次经过进度条即可显示预览图片
|
|
promptSpotTime: false, //提示点文字是否在前面加上对应时间
|
|
buttonMode: {
|
|
player: false, //鼠标在播放器上是否显示可点击形态
|
|
controlBar: false, //鼠标在控制栏上是否显示可点击形态
|
|
timeSchedule: true, //鼠标在时间进度条上是否显示可点击形态
|
|
volumeSchedule: true //鼠标在音量调节栏上是否显示可点击形态
|
|
},
|
|
liveAndVod: { //直播+点播=回播功能
|
|
open: false, //是否开启，开启该功能需要设置flashvars里live=true
|
|
vodTime: 2, //可以回看的整点数
|
|
start: 'start' //回看请求参数
|
|
},
|
|
errorNum: 3, //错误重连次数
|
|
playCorrect: false, //是否需要错误修正，这是针对rtmp的
|
|
timeCorrect: true, //http视频播放时间错误纠正，有些因为视频格式的问题导致视频没有实际播放结束视频文件就返回了stop命令
|
|
m3u8Definition: { //m3u8自动清晰度时按关键字来进行判断
|
|
//tags:['200k','110k','400k','600k','1000k']
|
|
},
|
|
m3u8MaxBufferLength: 30, //m3u8每次缓冲时间，单位：秒数
|
|
split: ',', //当视频地址采用字符形式并且需要使用逗号或其它符号来切割数组里定义
|
|
timeStamp: '', //一个地址，用来请求当前时间戳，用于播放器内部时间效准
|
|
addCallback: 'adPlay,adPause,playOrPause,videoPlay,videoPause,videoMute,videoEscMute,videoClear,changeVolume,fastBack,fastNext,videoSeek,newVideo,getMetaDate,videoRotation,videoBrightness,videoContrast,videoSaturation,videoHue,videoZoom,videoProportion,videoError,addListener,removeListener,addElement,getElement,deleteElement,animate,animateResume,animatePause,deleteAnimate,changeConfig,getConfig,openUrl,fullScreen,quitFullScreen,switchFull,screenshot,custom,changeControlBarShow,getCurrentSrc'
|
|
//需要支持的事件
|
|
},
|
|
menu: { //版权名称支持
|
|
ckkey: '',
|
|
name: '',
|
|
link: '',
|
|
version: '',
|
|
domain: '',
|
|
more: []
|
|
},
|
|
style: { //风格部分内容配置，这里主要配置loading和logo以及广告的部分内容
|
|
loading: {
|
|
file: 'data:image/swf;base64,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',
|
|
align: 'center',
|
|
vAlign: 'middle',
|
|
offsetX: -100,
|
|
offsetY: -40
|
|
},
|
|
logo: {
|
|
file: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFcAAAAUCAYAAAD4BKGuAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAVTSURBVHja1Fl/aJVVGP4cw/mH5tUWi3I53cA0WbeIzMgaq6lQoVawm0S6glHhIKM/TELICotqCxMSGWQRdFfRLEhc9mMxqA0rbdS2wsV0GkZXuaKUWlHvgeeNh7f3u1du3Ft74eGcnXu+c873vD/Pt0nZbDZyZL2gWZAQTBH8IjggeEjgPZASPIB+g/P7EsGT6J/BfHfjHFIv2Jpjj/+dlDskvCm42Jk7X3C7YJOgw/z2oOBGwdEYRW0RVAjOCZ4ugNggqwU3CTLRBJFyQ+xuwVRY14igB78tE9QKpgmeEHwkGKRnq9AeMesHRWwEsYGUxwSdBZ51ecweE4Lct0DsOVjaZvptA8jfC4JfghWpXIJ2jMY+EDShf1pwh6DvX5x1GtpDE43cNFlfhyFWpQ9xd5FgFo3fRi++C+2nCBNBRgU3O6RsEyyEQv4QLMb4CcE9RlFBLqS1WZ6BZ83A35ofVhuvfE5QJrjWebdgCJOx51qM1QgewbMzsO57MDQrB9DeC8ObHd5Xyb2eiNiQQxmtgkZBr+OuZwV7BIcF1RgbF1wTE2MbEccX48VY9sMzBilhTke/m+b1Q9lefpgruI7OsYhIGzPJuAnn3+6EM7vu1YKl5vkrYRSfCGZivCxoMklk7M5j6eFlXyRNRSAvAoFf0Fo/CC7LkbwuQjsZsf0qwbuI9wlYgIqGl6NEzDYibJ/gbmAfxpKoMDRcaSK8xZzjZbK+NMhSYoNSngV5e+ksKXp+JdqZwDDmdpSbsqa9gNAyi5JalSGv3iQ+dtNK9HvI+sNBh2AhvNYVaH+msRtAdsa4ehoKCuQsoP2PY8+kCSkJ5IRWjD2FZ4/BOFSWYv9KhI40eUKQ31CqdnLM1c1OOnHufKSS+iEZvgHNhji8g1yT5VZKdCnHO+ajvrYK/I7GkuSWjwvq8Mzl5M79NF89aCHaBNXmWv0sQVUUZEDwsDnbr2i9s31lKyGuFs7kITEBC+snJaToRYIFrRN0CeYgoSUxJ23WUm85eB41b4IUuIvGtyIMVMY8lzHGMoYworF7J/onKYk10/wVQL6zXYr+Zq9aOEhuXZPDel8Q3If+HMzTeHPKlForEK+mws3SMfH2UMxNLIJbasKsoIQZwVLbKFkN4T1C3HxUMM+EkCAfgjwNV40Y304KriOP+jIHqa+jvYsqnH/kqzKaGCFZxWnoTqooxky8+dHUsOGwr6Jfi9jmlVVTHGLnot9L3qGWqCToWYYRF5fDa96mtb93yI2g8B0IWxlTHWmi/hOG00D4mEJfJ5WhQX7ySCsDUaNkJeud6+sgXCgs3OLEG2/xdZSh10JBeiB1zQU0HuQdSib60rOdm9kFToIL8hmFiRHzm1YM0ylet5k579OFpcUk4I0oD0/QuJ7tcBy5ERY6ixdrh5uNwN3bUV7pd4E+J958HmPxbRRydqK/in6vxj5aH9din/udEPKtuU1GqBL24xJwBInQWiHLcbQVKBXTzkVpHP0tWHsIpZUqPeWcrScXuX2ImRkqlufBhdQl15ig3WLKH0/SeAmtD+uprBqGx1ThhlWN5LKG4lcNKbDblFDjVDU0wWK7yLLqnPNk6cKzKsfXt1GQmQQXSuwymhd3tr9lkvPJMUV152kc2PsmUEMxtzdPRk2SNX2DQ3Vhr02Is18LXjHVAz/bG0NEK8johus3UBiwyfkYlDkQUyLaWrwZBrbHMaB8Z3PJLaYk8IIVKKPSJdxbv3ecynNzLNr33GKLV1YVW4IyfycXfq0UxP4X5HJdXCqX4Wv0AKqYkkipw4LG6WxMNi+GhAtH+M/K8wVe7wuWvwQYAFT+UsGCXmX3AAAAAElFTkSuQmCC',
|
|
align: 'right',
|
|
vAlign: 'top',
|
|
offsetX: -100,
|
|
offsetY: 10
|
|
},
|
|
advertisement: { //广告相关的配置
|
|
time: 5, //广告默认播放时长以及多个广告时每个广告默认播放时间，单位：秒
|
|
method: 'get', //广告监测地址默认请求方式，get/post
|
|
videoForce: false, //频广告是否强制播放结束
|
|
videoVolume: 0.8, //视频音量
|
|
skipButtonShow: true, //是否显示跳过广告按钮
|
|
linkButtonShow: true, //是否显示广告链接按钮，如果选择显示，只有在提供了广告链接地址时才会显示
|
|
muteButtonShow: true, //是否显示跳过广告按钮
|
|
closeButtonShow: true, //暂停时是否显示关闭广告按钮
|
|
closeOtherButtonShow: true, //其它广告是否需要关闭广告按钮
|
|
frontSkipButtonDelay: 0, //前置广告跳过广告按钮延时显示的时间，单位：秒
|
|
insertSkipButtonDelay: 0, //插入广告跳过广告按钮延时显示的时间，单位：秒
|
|
endSkipButtonDelay: 0, //后置广告跳过广告按钮延时显示的时间，单位：秒
|
|
frontStretched: 2, //前置广告拉伸方式，0=原始大小，1=自动缩放，2=只有当广告的宽或高大于播放器宽高时才进行缩放，3=参考播放器宽高，4=宽度参考播放器宽、高度自动，5=高度参考播放器高、宽度自动
|
|
insertStretched: 2, //插入广告拉伸方式，0=原始大小，1=自动缩放，2=只有当广告的宽或高大于播放器宽高时才进行缩放，3=参考播放器宽高，4=宽度参考播放器宽、高度自动，5=高度参考播放器高、宽度自动
|
|
pauseStretched: 2, //暂停广告拉伸方式，0=原始大小，1=自动缩放，2=只有当广告的宽或高大于播放器宽高时才进行缩放，3=参考播放器宽高，4=宽度参考播放器宽、高度自动，5=高度参考播放器高、宽度自动
|
|
endStretched: 2 //结束广告拉伸方式，0=原始大小，1=自动缩放，2=只有当广告的宽或高大于播放器宽高时才进行缩放，3=参考播放器宽高，4=宽度参考播放器宽、高度自动，5=高度参考播放器高、宽度自动
|
|
},
|
|
video: { //视频的默认比例
|
|
defaultWidth: 4, //宽度
|
|
defaultHeight: 3 //高度
|
|
}
|
|
}
|
|
};
|
|
}
|
|
!(function() {
|
|
var javascriptPath = '';
|
|
! function() {
|
|
var scriptList = document.scripts,
|
|
thisPath = scriptList[scriptList.length - 1].src;
|
|
javascriptPath = thisPath.substring(0, thisPath.lastIndexOf('/') + 1);
|
|
}();
|
|
var ckplayer = function(obj) {
|
|
/*
|
|
javascript部分开发所用的注释说明：
|
|
1：初始化-程序调用时即运行的代码部分
|
|
2：定义样式-定义容器（div,p,canvas等）的样式表，即css
|
|
3：监听动作-监听元素节点（单击-click，鼠标进入-mouseover，鼠标离开-mouseout，鼠标移动-mousemove等）事件
|
|
4：监听事件-监听视频的状态（播放，暂停，全屏，音量调节等）事件
|
|
5：共用函数-这类函数在外部也可以使用
|
|
6：全局变量-定义成全局使用的变量
|
|
7：其它相关注释
|
|
全局变量说明：
|
|
在本软件中所使用到的全局变量（变量（类型）包括Boolean，String，Int，Object（包含元素对象和变量对象），Array，Function等）
|
|
下面列出重要的全局变量：
|
|
V:Object：视频对象
|
|
VA:Array：视频列表（包括视频地址，类型，清晰度说明）
|
|
ID:String：视频ID
|
|
CB:Object：控制栏各元素的集合对象
|
|
PD:Object：内部视频容器对象
|
|
---------------------------------------------------------------------------------------------
|
|
程序开始
|
|
下面为需要初始化配置的全局变量
|
|
初始化配置
|
|
config：全局变量/变量类型：Object/功能：定义一些基本配置
|
|
*/
|
|
this.config = {
|
|
videoClick: true, //是否支持单击播放/暂停动作
|
|
videoDbClick: true, //是否支持双击全屏/退出全屏动作
|
|
errorTime: 100, //延迟判断失败的时间，单位：毫秒
|
|
videoDrawImage: false //是否使用视频drawImage功能，注意，该功能在移动端表现不了
|
|
};
|
|
//全局变量/变量类型：Object/功能：播放器默认配置，在外部传递过来相应配置后，则进行相关替换
|
|
this.varsConfig = {
|
|
playerID: '', //播放器ID
|
|
container: '', //视频容器的ID
|
|
variable: 'ckplayer', //播放函数(变量)名称
|
|
volume: 0.8, //默认音量，范围0-1
|
|
poster: '', //封面图片地址
|
|
autoplay: false, //是否自动播放
|
|
loop: false, //是否需要循环播放
|
|
live: false, //是否是直播
|
|
duration: 0, //指定总时间
|
|
seek: 0, //默认需要跳转的秒数
|
|
drag: '', //拖动时支持的前置参数
|
|
front: '', //前一集按钮动作
|
|
next: '', //下一集按钮动作
|
|
loaded: '', //加载播放器后调用的函数
|
|
flashplayer: false, //设置成true则强制使用flashplayer
|
|
html5m3u8: false, //PC平台上是否使用h5播放器播放m3u8
|
|
track: null, //字幕轨道
|
|
cktrack: null, //ck字幕
|
|
preview: null, //预览图片对象
|
|
prompt: null, //提示点功能
|
|
video: null, //视频地址
|
|
config: '', //调用配置函数名称
|
|
type: '', //视频格式
|
|
crossorigin: '', //设置html5视频的crossOrigin属性
|
|
crossdomain: '', //安全策略文件地址
|
|
unescape: false, //默认flashplayer里需要解码
|
|
mobileCkControls: false, //移动端h5显示控制栏
|
|
playbackrate: 1, //默认倍速
|
|
debug: false //是否开启调试模式
|
|
};
|
|
this.vars = {};
|
|
//全局变量/变量类型：Object/功能：语言配置
|
|
this.language = {
|
|
volume: '音量：',
|
|
play: '点击播放',
|
|
pause: '点击暂停',
|
|
full: '点击全屏',
|
|
escFull: '退出全屏',
|
|
mute: '点击静音',
|
|
escMute: '取消静音',
|
|
front: '上一集',
|
|
next: '下一集',
|
|
definition: '点击选择清晰度',
|
|
playbackRate: '点击选择速度',
|
|
error: '加载出错'
|
|
};
|
|
//全局变量/变量类型：Array/功能：右键菜单：[菜单标题,类型(link:链接，default:灰色，function：调用函数，javascript:调用js函数),执行内容(包含链接地址，函数名称),[line(间隔线)]]
|
|
this.contextMenu = [
|
|
['ckplayer', 'link', 'http://www.ckplayer.com'],
|
|
['version:X', 'default', 'line']
|
|
];
|
|
//全局变量/变量类型：Array/功能：错误列表
|
|
this.errorList = [
|
|
['000', 'Object does not exist'],
|
|
['001', 'Variables type is not a object'],
|
|
['002', 'Video object does not exist'],
|
|
['003', 'Video object format error'],
|
|
['004', 'Video object format error'],
|
|
['005', 'Video object format error'],
|
|
['006', '[error] does not exist '],
|
|
['007', 'Ajax error'],
|
|
['008', 'Ajax error'],
|
|
['009', 'Ajax object format error'],
|
|
['010', 'Ajax.status:[error]']
|
|
];
|
|
//全局变量/变量类型：Array/功能：HTML5变速播放的值数组/如果不需要可以设置成null
|
|
this.playbackRateArr = [
|
|
[0.5, '0.5倍'],
|
|
[1, '正常'],
|
|
[1.25, '1.25倍'],
|
|
[1.5, '1.5倍'],
|
|
[2, '2倍速'],
|
|
[4, '4倍速']
|
|
];
|
|
//全局变量/变量类型：Array/功能：HTML5默认变速播放的值
|
|
this.playbackRateDefault = 1;
|
|
//全局变量/变量类型：String/功能：定义logo
|
|
this.logo = '';
|
|
//全局变量/变量类型：Boolean/功能：是否加载了播放器
|
|
this.loaded = false;
|
|
//全局变量/变量类型：计时器/功能：监听视频加载出错的状态
|
|
this.timerError = null;
|
|
//全局变量/变量类型：Boolean/功能：是否出错
|
|
this.error = false;
|
|
//全局变量/变量类型：Array/功能：出错地址的数组
|
|
this.errorUrl = [];
|
|
//全局变量/变量类型：计时器/功能：监听全屏与非全屏状态
|
|
this.timerFull = null;
|
|
//全局变量/变量类型：Boolean/功能：是否全屏状态
|
|
this.full = false;
|
|
//全局变量/变量类型：计时器/功能：监听当前的月/日 时=分=秒
|
|
this.timerTime = null;
|
|
//全局变量/变量类型：计时器/功能：监听视频加载
|
|
this.timerBuffer = null;
|
|
//全局变量/变量类型：Boolean/功能：设置进度按钮及进度条是否跟着时间变化，该属性主要用来在按下进度按钮时暂停进度按钮移动和进度条的长度变化
|
|
this.isTimeButtonMove = true;
|
|
//全局变量/变量类型：Boolean/功能：进度栏是否有效，如果是直播，则不需要监听时间让进度按钮和进度条变化
|
|
this.isTimeButtonDown = false;
|
|
//全局变量/变量类型：Boolean/功能：用来模拟双击功能的判断
|
|
this.isClick = false;
|
|
//全局变量/变量类型：计时器/功能：用来模拟双击功能的计时器
|
|
this.timerClick = null;
|
|
//全局变量/变量类型：计时器/功能：旋转loading
|
|
this.timerLoading = null;
|
|
//全局变量/变量类型：计时器/功能：监听鼠标在视频上移动显示控制栏
|
|
this.timerCBar = null;
|
|
//全局变量/变量类型：Int/功能：播放视频时如果该变量的值大于0，则进行跳转后设置该值为0
|
|
this.needSeek = 0;
|
|
//全局变量/变量类型：Int/功能：当前音量
|
|
this.volume = 0;
|
|
//全局变量/变量类型：Int/功能：静音时保存临时音量
|
|
this.volumeTemp = 0;
|
|
//全局变量/变量类型：Number/功能：当前播放时间
|
|
this.time = 0;
|
|
//全局变量/变量类型：Boolean/功能：定义首次调用
|
|
this.isFirst = true;
|
|
//全局变量/变量类型：Boolean/功能：是否使用HTML5-VIDEO播放
|
|
this.html5Video = true;
|
|
//全局变量/变量类型：Object/功能：记录视频容器节点的x;y
|
|
this.pdCoor = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
//全局变量/变量类型：String/功能：判断当前使用的播放器类型，html5video或flashplayer
|
|
this.playerType = '';
|
|
//全局变量/变量类型：Int/功能：加载进度条的长度
|
|
this.loadTime = 0;
|
|
//全局变量/body对象
|
|
this.body = document.body || document.documentElement;
|
|
//全局变量/V/播放器
|
|
this.V = null;
|
|
//全局变量/保存外部js监听事件数组
|
|
this.listenerJsArr = [];
|
|
//全局变量/保存控制栏显示元素的总宽度
|
|
this.buttonLen = 0;
|
|
//全局变量/保存控制栏显示元素的数组
|
|
this.buttonArr = [];
|
|
//全局变量/保存按钮元素的宽
|
|
this.buttonWidth = {};
|
|
//全局变量/保存播放器上新增元件的数组
|
|
this.elementArr = [];
|
|
//全局变量/字幕内容
|
|
this.track = [];
|
|
//全局变量/字幕索引
|
|
this.trackIndex = 0;
|
|
//全局变量/当前显示的字幕内容
|
|
this.nowTrackShow = {
|
|
sn: ''
|
|
};
|
|
//全局变量/保存字幕元件数组
|
|
this.trackElement = [];
|
|
//全局变量/将视频转换为图片
|
|
this.timerVCanvas = null;
|
|
//全局变量/animate
|
|
this.animateArray = [];
|
|
//全局变量/保存animate的元件
|
|
this.animateElementArray = [];
|
|
//全局变量/保存需要在暂停时停止缓动的数组
|
|
this.animatePauseArray = [];
|
|
//全局变量/预览图片加载状态/0=没有加载，1=正在加载，2=加载完成
|
|
this.previewStart = 0;
|
|
//全局变量/预览图片容器
|
|
this.previewDiv = null;
|
|
//全局变量/预览框
|
|
this.previewTop = null;
|
|
//全局变量/预览框的宽
|
|
this.previewWidth = 120;
|
|
//全局变量/预览图片容器缓动函数
|
|
this.previewTween = null;
|
|
//全局变量/是否是m3u8格式，是的话则可以加载hls.js
|
|
this.isM3u8 = false;
|
|
//全局变量/保存提示点数组
|
|
this.promptArr = [];
|
|
//全局变量/显示提示点文件的容器
|
|
this.promptElement = null;
|
|
//配置文件函数
|
|
this.ckplayerConfig = {};
|
|
//控制栏是否显示
|
|
this.showFace = true;
|
|
//是否监听过h5的错误
|
|
this.errorAdd = false;
|
|
//是否发送了错误
|
|
this.errorSend = false;
|
|
//控制栏是否隐藏
|
|
this.controlBarIsShow = true;
|
|
//字体
|
|
this.fontFamily = '"Microsoft YaHei"; YaHei; "\5FAE\8F6F\96C5\9ED1"; SimHei; "\9ED1\4F53";Arial';
|
|
//记录第一次拖动进度按钮时的位置
|
|
this.timeSliderLeftTemp = 0;
|
|
if(obj) {
|
|
this.embed(obj);
|
|
}
|
|
};
|
|
ckplayer.prototype = {
|
|
/*
|
|
主要函数部分开始
|
|
主接口函数：
|
|
调用播放器需初始化该函数
|
|
*/
|
|
embed: function(c) {
|
|
//c:Object：是调用接口传递的属性对象
|
|
if(window.location.href.substr(0, 7) == 'file://') {
|
|
alert('Please use the HTTP protocol to open the page');
|
|
return;
|
|
}
|
|
if(c == undefined || !c) {
|
|
this.eject(this.errorList[0]);
|
|
return;
|
|
}
|
|
if(typeof(c) != 'object') {
|
|
this.eject(this.errorList[1]);
|
|
}
|
|
this.vars = this.standardization(this.varsConfig, c);
|
|
if(!this.vars['mobileCkControls'] && this.isMobile()) {
|
|
this.vars['flashplayer'] = false;
|
|
this.showFace = false;
|
|
}
|
|
var videoString = this.vars['video'];
|
|
if(!videoString) {
|
|
this.eject(this.errorList[2]);
|
|
return;
|
|
}
|
|
if(typeof(videoString) == 'string') {
|
|
if(videoString.substr(0, 3) == 'CK:' || videoString.substr(0, 3) == 'CE:' || videoString.substr(8, 3) == 'CK:' || videoString.substr(8, 3) == 'CE:') {
|
|
this.vars['flashplayer'] = true;
|
|
}
|
|
}
|
|
if(this.vars['config']) {
|
|
this.ckplayerConfig = eval(this.vars['config'] + '()');
|
|
} else {
|
|
this.ckplayerConfig = ckplayerConfig();
|
|
}
|
|
if((!this.supportVideo() && this.vars['flashplayer'] != '') || (this.vars['flashplayer'] && this.uploadFlash()) || !this.isMsie()) {
|
|
this.html5Video = false;
|
|
this.getVideo();
|
|
} else if(videoString) {
|
|
//判断视频数据类型
|
|
this.analysedVideoUrl(videoString);
|
|
return this;
|
|
} else {
|
|
this.eject(this.errorList[2]);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
根据外部传递过来的video开始分析视频地址
|
|
*/
|
|
analysedVideoUrl: function(video) {
|
|
var i = 0,
|
|
y = 0;
|
|
var thisTemp = this;
|
|
//定义全局变量VA:Array：视频列表（包括视频地址，类型，清晰度说明）
|
|
this.VA = [];
|
|
if(typeof(video) == 'string') { //如果是字符形式的则判断后缀进行填充
|
|
if(video.substr(0, 8) != 'website:') {
|
|
this.VA = [
|
|
[video, '', '', 0]
|
|
];
|
|
var fileExt = this.getFileExt(video);
|
|
switch(fileExt) {
|
|
case '.mp4':
|
|
this.VA[0][1] = 'video/mp4';
|
|
break;
|
|
case '.ogg':
|
|
this.VA[0][1] = 'video/ogg';
|
|
break;
|
|
case '.webm':
|
|
this.VA[0][1] = 'video/webm';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
this.getVideo();
|
|
} else {
|
|
if(this.html5Video) {
|
|
var ajaxObj = {
|
|
url: video.substr(8),
|
|
success: function(data) {
|
|
if(data) {
|
|
thisTemp.analysedUrl(data);
|
|
} else {
|
|
thisTemp.eject(thisTemp.errorList[5]);
|
|
this.VA = video;
|
|
thisTemp.getVideo();
|
|
}
|
|
}
|
|
};
|
|
this.ajax(ajaxObj);
|
|
} else {
|
|
this.VA = video;
|
|
this.getVideo();
|
|
}
|
|
|
|
}
|
|
} else if(typeof(video) == 'object') { //对象或数组
|
|
if(!this.isUndefined(typeof(video.length))) { //说明是数组
|
|
if(!this.isUndefined(typeof(video[0].length))) { //说明是数组形式的数组
|
|
this.VA = video;
|
|
}
|
|
this.getVideo();
|
|
} else {
|
|
/*
|
|
如果video格式是对象形式，则分二种
|
|
如果video对象里包含type，则直接播放
|
|
*/
|
|
if(!this.isUndefined(video['type'])) {
|
|
this.VA.push([video['file'], video['type'], '', 0]);
|
|
this.getVideo();
|
|
} else {
|
|
this.eject(this.errorList[5]);
|
|
}
|
|
}
|
|
} else {
|
|
this.eject(this.errorList[4]);
|
|
}
|
|
},
|
|
/*
|
|
对请求到的视频地址进行重新分析
|
|
*/
|
|
analysedUrl: function(data) {
|
|
this.vars = this.standardization(this.vars, data);
|
|
if(!this.isUndefined(data['video'])) {
|
|
this.vars['video'] = data['video'];
|
|
}
|
|
this.analysedVideoUrl(this.vars['video']);
|
|
},
|
|
/*
|
|
内部函数
|
|
检查浏览器支持的视频格式，如果是则将支持的视频格式重新分组给播放列表
|
|
*/
|
|
getHtml5Video: function() {
|
|
var va = this.VA;
|
|
var nva = [];
|
|
var mobile = false;
|
|
var video = document.createElement('video');
|
|
var codecs = function(type) {
|
|
var cod = '';
|
|
switch(type) {
|
|
case 'video/mp4':
|
|
cod = 'avc1.4D401E, mp4a.40.2';
|
|
break;
|
|
case 'video/ogg':
|
|
cod = 'theora, vorbis';
|
|
break;
|
|
case 'video/webm':
|
|
cod = 'vp8.0, vorbis';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return cod;
|
|
};
|
|
var supportType = function(vidType, codType) {
|
|
if(!video.canPlayType) {
|
|
this.html5Video = false;
|
|
return;
|
|
}
|
|
var isSupp = video.canPlayType(vidType + ';codecs="' + codType + '"');
|
|
if(isSupp == '') {
|
|
return false
|
|
}
|
|
return true;
|
|
};
|
|
if(this.vars['flashplayer'] || !this.isMsie()) {
|
|
this.html5Video = false;
|
|
return;
|
|
}
|
|
if(this.isMobile()) {
|
|
mobile = true;
|
|
}
|
|
for(var i = 0; i < va.length; i++) {
|
|
var v = va[i];
|
|
if(v) {
|
|
if(v[1] != '' && !mobile && supportType(v[1], codecs(v[1])) && v[0].substr(0, 4) != 'rtmp') {
|
|
nva.push(v);
|
|
}
|
|
if((this.getFileExt(v[0]) == '.m3u8' || this.vars['type']=='video/m3u8' || this.vars['type']=='m3u8' || v[1]=='video/m3u8' || v[1]=='m3u8') && this.vars['html5m3u8']) {
|
|
this.isM3u8 = true;
|
|
nva.push(v);
|
|
}
|
|
}
|
|
}
|
|
if(nva.length > 0) {
|
|
this.VA = nva;
|
|
} else {
|
|
if(!mobile) {
|
|
this.html5Video = false;
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
根据视频地址开始构建播放器
|
|
*/
|
|
getVideo: function() {
|
|
//如果存在字幕则加载
|
|
if(this.V) { //如果播放器已存在，则认为是从newVideo函数发送过来的请求
|
|
this.changeVideo();
|
|
return;
|
|
}
|
|
if(this.vars['cktrack']) {
|
|
this.loadTrack();
|
|
}
|
|
if(this.supportVideo() && !this.vars['flashplayer']) {
|
|
this.getHtml5Video(); //判断浏览器支持的视频格式
|
|
}
|
|
var thisTemp = this;
|
|
var v = this.vars;
|
|
var src = '',
|
|
source = '',
|
|
poster = '',
|
|
loop = '',
|
|
autoplay = '',
|
|
track = '';
|
|
var video = v['video'];
|
|
var i = 0;
|
|
this.CD = this.getByElement(v['container']);
|
|
volume = v['volume'];
|
|
if(!this.CD) {
|
|
this.eject(this.errorList[6], v['container']);
|
|
return false;
|
|
}
|
|
//开始构建播放容器
|
|
var playerID = 'ckplayer' + this.randomString();
|
|
var playerDiv = document.createElement('div');
|
|
playerDiv.className = playerID;
|
|
this.V = undefined;
|
|
this.CD.innerHTML = '';
|
|
this.CD.appendChild(playerDiv);
|
|
this.PD = this.getByElement(playerID); //PD:定义播放器容器对象全局变量
|
|
this.css(this.CD, {
|
|
backgroundColor: '#000000',
|
|
overflow: 'hidden',
|
|
position: 'relative'
|
|
});
|
|
this.css(this.PD, {
|
|
backgroundColor: '#000000',
|
|
width: '100%',
|
|
height: '100%',
|
|
fontFamily: this.fontFamily
|
|
});
|
|
if(this.html5Video) { //如果支持HTML5-VIDEO则默认使用HTML5-VIDEO播放器
|
|
//禁止播放器容器上鼠标选择文本
|
|
this.PD.onselectstart = this.PD.ondrag = function() {
|
|
return false;
|
|
};
|
|
//播放容器构建完成并且设置好样式
|
|
//构建播放器
|
|
if(this.VA.length == 1) {
|
|
src = ' src="' + decodeURIComponent(this.VA[0][0]) + '"';
|
|
} else {
|
|
var videoArr = this.VA.slice(0);
|
|
videoArr = this.arrSort(videoArr);
|
|
for(i = 0; i < videoArr.length; i++) {
|
|
var type = '';
|
|
var va = videoArr[i];
|
|
if(va[1]) {
|
|
type = ' type="' + va[1] + '"';
|
|
if(type == ' type="video/m3u8"' || type == ' type="m3u8"') {
|
|
type = '';
|
|
}
|
|
}
|
|
source += '<source src="' + decodeURIComponent(va[0]) + '"' + type + '>';
|
|
}
|
|
}
|
|
//分析视频地址结束
|
|
if(v['autoplay']) {
|
|
autoplay = ' autoplay="autoplay"';
|
|
}
|
|
if(v['poster']) {
|
|
poster = ' poster="' + v['poster'] + '"';
|
|
}
|
|
if(v['loop']) {
|
|
loop = ' loop="loop"';
|
|
}
|
|
if(v['seek'] > 0) {
|
|
this.needSeek = v['seek'];
|
|
}
|
|
if(v['track'] != null && v['cktrack'] == null) {
|
|
var trackArr = v['track'];
|
|
var trackDefault = '';
|
|
var defaultHave = false;
|
|
for(i = 0; i < trackArr.length; i++) {
|
|
var trackObj = trackArr[i];
|
|
if(trackObj['default'] && !defaultHave) {
|
|
trackDefault = ' default';
|
|
defaultHave = true;
|
|
} else {
|
|
trackDefault = '';
|
|
}
|
|
track += '<track kind="' + trackObj['kind'] + '" src="' + trackObj['src'] + '" srclang="' + trackObj['srclang'] + '" label="' + trackObj['label'] + '"' + trackDefault + '>';
|
|
}
|
|
}
|
|
var autoLoad = this.ckplayerConfig['config']['autoLoad'];
|
|
var preload = '';
|
|
if(!autoLoad) {
|
|
preload = ' preload="meta"';
|
|
}
|
|
var vid = this.randomString();
|
|
var controls = '';
|
|
if(!this.showFace) {
|
|
controls = ' controls="controls"';
|
|
}
|
|
var html = '';
|
|
if(!this.isM3u8) {
|
|
html = '<video id="' + vid + '"' + src + ' width="100%" height="100%"' + autoplay + poster + loop + preload + controls + ' x5-playsinline="" playsinline="" webkit-playsinline="true">' + source + track + '</video>';
|
|
} else {
|
|
html = '<video id="' + vid + '" width="100%" height="100%"' + poster + loop + preload + controls + ' x5-playsinline="" playsinline="" webkit-playsinline="true">' + track + '</video>';
|
|
}
|
|
this.PD.innerHTML = html;
|
|
this.V = this.getByElement('#' + vid); //V：定义播放器对象全局变量
|
|
if(this.vars['crossorigin']) {
|
|
this.V.crossOrigin = this.vars['crossorigin'];
|
|
}
|
|
try {
|
|
this.V.volume = volume; //定义音量
|
|
if(this.playbackRateArr && this.vars['playbackrate'] > -1) {
|
|
if(this.vars['playbackrate'] < this.playbackRateArr.length) {
|
|
this.playbackRateDefault = this.vars['playbackrate'];
|
|
}
|
|
this.V.playbackRate = this.playbackRateArr[this.playbackRateDefault][0]; //定义倍速
|
|
}
|
|
} catch(error) {}
|
|
this.css(this.V, {
|
|
width: '100%',
|
|
height: '100%'
|
|
});
|
|
if(this.isM3u8) {
|
|
var loadJsHandler = function() {
|
|
thisTemp.embedHls(thisTemp.VA[0][0], v['autoplay']);
|
|
};
|
|
this.loadJs(javascriptPath + 'hls/hls.min.js', loadJsHandler);
|
|
}
|
|
this.css(this.V, 'backgroundColor', '#000000');
|
|
//创建一个画布容器
|
|
if(this.config['videoDrawImage']) {
|
|
var canvasID = 'vcanvas' + this.randomString();
|
|
var canvasDiv = document.createElement('div');
|
|
canvasDiv.className = canvasID;
|
|
this.PD.appendChild(canvasDiv);
|
|
this.MD = this.getByElement(canvasID); //定义画布存储容器
|
|
this.css(this.MD, {
|
|
backgroundColor: '#000000',
|
|
width: '100%',
|
|
height: '100%',
|
|
position: 'absolute',
|
|
display: 'none',
|
|
cursor: 'pointer',
|
|
left: '0px',
|
|
top: '0px',
|
|
zIndex: '10'
|
|
});
|
|
var cvid = 'ccanvas' + this.randomString();
|
|
this.MD.innerHTML = this.newCanvas(cvid, this.PD.offsetWidth, this.PD.offsetHeight);
|
|
this.MDC = this.getByElement(cvid + '-canvas');
|
|
this.MDCX = this.MDC.getContext('2d');
|
|
}
|
|
this.playerType = 'html5video';
|
|
//播放器构建完成并且设置好样式
|
|
//建立播放器的监听函数，包含操作监听及事件监听
|
|
this.addVEvent();
|
|
//根据清晰度的值构建清晰度切换按钮
|
|
if(this.showFace) {
|
|
this.definition();
|
|
if(!this.vars['live'] && this.playbackRateArr && this.vars['playbackrate'] > -1) {
|
|
this.playbackRate();
|
|
}
|
|
if(v['autoplay']) {
|
|
this.loadingStart(true);
|
|
}
|
|
}
|
|
this.playerLoad();
|
|
} else { //如果不支持HTML5-VIDEO则调用flashplayer
|
|
this.embedSWF();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
发送播放器加载成功的消息
|
|
*/
|
|
playerLoad: function() {
|
|
var thisTemp = this;
|
|
if(this.isFirst) {
|
|
this.isFirst = false;
|
|
window.setTimeout(function() {
|
|
thisTemp.loadedHandler();
|
|
}, 1);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
建立播放器的监听函数，包含操作监听及事件监听
|
|
*/
|
|
addVEvent: function() {
|
|
var thisTemp = this;
|
|
//监听视频单击事件
|
|
var eventVideoClick = function(event) {
|
|
thisTemp.videoClick();
|
|
};
|
|
this.addListenerInside('click', eventVideoClick);
|
|
this.addListenerInside('click', eventVideoClick, this.MDC);
|
|
//延迟计算加载失败事件
|
|
this.timerErrorFun();
|
|
//监听视频加载到元数据事件
|
|
var eventJudgeIsLive = function(event) {
|
|
thisTemp.sendJS('loadedmetadata');
|
|
thisTemp.sendJS('duration', thisTemp.V.duration);
|
|
thisTemp.judgeIsLive();
|
|
};
|
|
this.addListenerInside('loadedmetadata', eventJudgeIsLive);
|
|
//监听视频播放事件
|
|
var eventPlaying = function(event) {
|
|
thisTemp.playingHandler();
|
|
thisTemp.sendJS('play');
|
|
thisTemp.sendJS('paused', false);
|
|
};
|
|
this.addListenerInside('playing', eventPlaying);
|
|
//监听视频暂停事件
|
|
var eventPause = function(event) {
|
|
thisTemp.pauseHandler();
|
|
thisTemp.sendJS('pause');
|
|
thisTemp.sendJS('paused', true);
|
|
};
|
|
this.addListenerInside('pause', eventPause);
|
|
//监听视频播放时间事件
|
|
var eventTimeupdate = function(event) {
|
|
if(thisTemp.timerLoading != null) {
|
|
thisTemp.loadingStart(false);
|
|
}
|
|
if(thisTemp.time) {
|
|
thisTemp.sendJS('time', thisTemp.time);
|
|
}
|
|
};
|
|
this.addListenerInside('timeupdate', eventTimeupdate);
|
|
//监听视频缓冲事件
|
|
var eventWaiting = function(event) {
|
|
thisTemp.loadingStart(true);
|
|
};
|
|
this.addListenerInside('waiting', eventWaiting);
|
|
//监听视频seek开始事件
|
|
var eventSeeking = function(event) {
|
|
thisTemp.sendJS('seek', 'start');
|
|
};
|
|
this.addListenerInside('seeking', eventSeeking);
|
|
//监听视频seek结束事件
|
|
var eventSeeked = function(event) {
|
|
thisTemp.seekedHandler();
|
|
thisTemp.sendJS('seek', 'ended');
|
|
};
|
|
this.addListenerInside('seeked', eventSeeked);
|
|
//监听视频播放结束事件
|
|
var eventEnded = function(event) {
|
|
thisTemp.endedHandler();
|
|
thisTemp.sendJS('ended');
|
|
};
|
|
this.addListenerInside('ended', eventEnded);
|
|
//监听视频音量
|
|
var eventVolumeChange = function(event) {
|
|
try {
|
|
thisTemp.volumechangeHandler();
|
|
thisTemp.sendJS('volume', thisTemp.volume || thisTemp.V.volume);
|
|
} catch(event) {}
|
|
};
|
|
this.addListenerInside('volumechange', eventVolumeChange);
|
|
//监听全屏事件
|
|
var eventFullChange = function(event) {
|
|
var fullState = document.fullScreen || document.mozFullScreen || document.webkitIsFullScreen;
|
|
thisTemp.sendJS('full', fullState);
|
|
};
|
|
this.addListenerInside('fullscreenchange', eventFullChange);
|
|
this.addListenerInside('webkitfullscreenchange', eventFullChange);
|
|
this.addListenerInside('mozfullscreenchange', eventFullChange);
|
|
//建立界面
|
|
if(this.showFace) {
|
|
this.interFace();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
重置界面元素
|
|
*/
|
|
resetPlayer: function() {
|
|
this.timeTextHandler();
|
|
if(this.showFace) {
|
|
this.timeProgress(0, 1); //改变时间进度条宽
|
|
this.changeLoad(0);
|
|
this.initPlayPause(); //判断显示播放或暂停按钮
|
|
this.definition(); //构建清晰度按钮
|
|
this.showFrontNext(); //构建上一集下一集按钮
|
|
this.deletePrompt(); //删除提示点
|
|
this.deletePreview(); //删除预览图
|
|
this.trackHide(); //重置字幕
|
|
this.resetTrack();
|
|
this.trackElement = [];
|
|
this.track = [];
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
构建界面元素
|
|
*/
|
|
interFace: function() {
|
|
this.showFace = true;
|
|
var thisTemp = this;
|
|
var html = ''; //控制栏内容
|
|
var i = 0;
|
|
var bWidth = 38, //按钮的宽
|
|
bHeight = 38; //按钮的高
|
|
var bBgColor = '#FFFFFF', //按钮元素默认颜色
|
|
bOverColor = '#0782F5'; //按钮元素鼠标经过时的颜色
|
|
var timeInto = this.formatTime(0) + ' / ' + this.formatTime(this.vars['duration']); //时间显示框默认显示内容
|
|
var randomS = this.randomString(10); //获取一个随机字符串
|
|
/*
|
|
以下定义界面各元素的ID，统一以ID结束
|
|
*/
|
|
var controlBarBgID = 'controlbgbar' + randomS, //控制栏背景
|
|
controlBarID = 'controlbar' + randomS, //控制栏容器
|
|
timeProgressBgID = 'timeprogressbg' + randomS, //播放进度条背景
|
|
loadProgressID = 'loadprogress' + randomS, //加载进度条
|
|
timeProgressID = 'timeprogress' + randomS, //播放进度条
|
|
timeBOBGID = 'timebobg' + randomS, //播放进度按钮容器，该元素为一个透明覆盖在播放进度条上
|
|
timeBOID = 'timebo' + randomS, //播放进度可拖动按钮外框
|
|
timeBWID = 'timebw' + randomS, //播放进度可拖动按钮内框
|
|
timeTextID = 'timetext' + randomS, //时间文本框
|
|
playID = 'play' + randomS, //播放按钮
|
|
pauseID = 'pause' + randomS, //暂停按钮
|
|
frontID = 'front' + randomS, //前一集按钮
|
|
nextID = 'next' + randomS, //下一集按钮
|
|
fullID = 'full' + randomS, //全屏按钮
|
|
escFullID = 'escfull' + randomS, //退出全屏按钮
|
|
muteID = 'mute' + randomS, //静音按钮
|
|
escMuteID = 'escmute' + randomS, //取消静音按钮
|
|
volumeID = 'volume' + randomS, //音量调节框容器
|
|
volumeDbgID = 'volumedbg' + randomS, //音量调节框容器背景
|
|
volumeBgID = 'volumebg' + randomS, //音量调节框背景层
|
|
volumeUpID = 'volumeup' + randomS, //音量调节框可变宽度层
|
|
volumeBOID = 'volumebo' + randomS, //音量调节按钮外框
|
|
volumeBWID = 'volumebw' + randomS, //音量调节按钮内框
|
|
definitionID = 'definition' + randomS, //清晰度容器
|
|
definitionPID = 'definitionp' + randomS, //清晰度列表容器
|
|
playbackRateID = 'playbackrate' + randomS, //清晰度容器
|
|
playbackRatePID = 'playbackratep' + randomS, //清晰度列表容器
|
|
promptBgID = 'promptbg' + randomS, //提示框背景
|
|
promptID = 'prompt' + randomS, //提示框
|
|
dlineID = 'dline' + randomS, //分隔线共用前缀
|
|
menuID = 'menu' + randomS, //右键容器
|
|
pauseCenterID = 'pausecenter' + randomS, //中间暂停按钮
|
|
loadingID = 'loading' + randomS, //缓冲
|
|
errorTextID = 'errortext' + randomS, //错误文本框
|
|
logoID = 'logo' + randomS; //logo
|
|
//构建一些PD（播放器容器）里使用的元素
|
|
var controlBarBg = document.createElement('div'),
|
|
controlBar = document.createElement('div'),
|
|
timeProgressBg = document.createElement('div'),
|
|
timeBoBg = document.createElement('div'),
|
|
pauseCenter = document.createElement('div'),
|
|
errorText = document.createElement('div'),
|
|
promptBg = document.createElement('div'),
|
|
prompt = document.createElement('div'),
|
|
menuDiv = document.createElement('div'),
|
|
definitionP = document.createElement('div'),
|
|
playbackrateP = document.createElement('div'),
|
|
loading = document.createElement('div'),
|
|
logo = document.createElement('div');
|
|
|
|
controlBarBg.className = controlBarBgID;
|
|
controlBar.className = controlBarID;
|
|
timeProgressBg.className = timeProgressBgID;
|
|
timeBoBg.className = timeBOBGID;
|
|
promptBg.className = promptBgID;
|
|
prompt.className = promptID;
|
|
menuDiv.className = menuID;
|
|
definitionP.className = definitionPID;
|
|
playbackrateP.className = playbackRatePID;
|
|
pauseCenter.className = pauseCenterID;
|
|
loading.className = loadingID;
|
|
logo.className = logoID;
|
|
errorText.className = errorTextID;
|
|
|
|
this.PD.appendChild(controlBarBg);
|
|
this.PD.appendChild(controlBar);
|
|
this.PD.appendChild(timeProgressBg);
|
|
this.PD.appendChild(timeBoBg);
|
|
this.PD.appendChild(promptBg);
|
|
this.PD.appendChild(prompt);
|
|
this.PD.appendChild(definitionP);
|
|
this.PD.appendChild(playbackrateP);
|
|
this.PD.appendChild(pauseCenter);
|
|
|
|
this.PD.appendChild(loading);
|
|
this.PD.appendChild(errorText);
|
|
this.PD.appendChild(logo);
|
|
this.body.appendChild(menuDiv);
|
|
//构建一些PD（播放器容器）里使用的元素结束
|
|
|
|
if(this.vars['live']) { //如果是直播，时间显示文本框里显示当前系统时间
|
|
timeInto = this.getNowDate();
|
|
}
|
|
//构建控制栏的内容
|
|
html += '<div class="' + playID + '" data-title="' + thisTemp.language['play'] + '">' + this.newCanvas(playID, bWidth, bHeight) + '</div>'; //播放按钮
|
|
html += '<div class="' + pauseID + '" data-title="' + thisTemp.language['pause'] + '">' + this.newCanvas(pauseID, bWidth, bHeight) + '</div>'; //暂停按钮
|
|
html += '<div class="' + dlineID + '-la"></div>'; //分隔线
|
|
html += '<div class="' + frontID + '" data-title="' + thisTemp.language['front'] + '">' + this.newCanvas(frontID, bWidth, bHeight) + '</div>'; //前一集按钮
|
|
html += '<div class="' + dlineID + '-lb"></div>'; //分隔线
|
|
html += '<div class="' + nextID + '" data-title="' + thisTemp.language['next'] + '">' + this.newCanvas(nextID, bWidth, bHeight) + '</div>'; //下一集按钮
|
|
html += '<div class="' + dlineID + '-lc"></div>'; //分隔线
|
|
|
|
html += '<div class="' + timeTextID + '">' + timeInto + '</div>'; //时间文本
|
|
html += '<div class="' + fullID + '" data-title="' + thisTemp.language['full'] + '">' + this.newCanvas(fullID, bWidth, bHeight) + '</div>'; //全屏按钮
|
|
html += '<div class="' + escFullID + '" data-title="' + thisTemp.language['escFull'] + '">' + this.newCanvas(escFullID, bWidth, bHeight) + '</div>'; //退出全屏按钮
|
|
html += '<div class="' + dlineID + '-ra"></div>'; //分隔线
|
|
html += '<div class="' + definitionID + '" data-title="' + thisTemp.language['definition'] + '"></div>'; //清晰度容器
|
|
html += '<div class="' + dlineID + '-rb"></div>'; //分隔线
|
|
html += '<div class="' + playbackRateID + '" data-title="' + thisTemp.language['playbackRate'] + '"></div>'; //倍速
|
|
html += '<div class="' + dlineID + '-rc"></div>'; //分隔线
|
|
html += '<div class="' + volumeID + '"><div class="' + volumeDbgID + '"><div class="' + volumeBgID + '"><div class="' + volumeUpID + '"></div></div><div class="' + volumeBOID + '"><div class="' + volumeBWID + '"></div></div></div></div>'; //音量调节框,音量调节按钮
|
|
html += '<div class="' + muteID + '" data-title="' + thisTemp.language['mute'] + '">' + this.newCanvas(muteID, bWidth, bHeight) + '</div>'; //静音按钮
|
|
html += '<div class="' + escMuteID + '" data-title="' + thisTemp.language['escMute'] + '">' + this.newCanvas(escMuteID, bWidth, bHeight) + '</div>'; //退出静音按钮
|
|
html += '<div class="' + dlineID + '-rd"></div>'; //分隔线
|
|
this.getByElement(controlBarID).innerHTML = html;
|
|
//构建控制栏内容结束
|
|
//构建进度条内容
|
|
this.getByElement(timeProgressBgID).innerHTML = '<div class="' + loadProgressID + '"></div><div class="' + timeProgressID + '"></div>';
|
|
this.getByElement(timeBOBGID).innerHTML = '<div class="' + timeBOID + '"><div class="' + timeBWID + '"></div></div>';
|
|
//构建进度条内容结束
|
|
this.getByElement(pauseCenterID).innerHTML = this.newCanvas(pauseCenterID, 80, 80); //构建中间暂停按钮
|
|
this.getByElement(loadingID).innerHTML = this.newCanvas(loadingID, 60, 60); //构建中间缓冲时显示的图标
|
|
this.getByElement(errorTextID).innerHTML = this.language['error']; //构建错误时显示的文本框
|
|
if(this.ckplayerConfig['style']['logo']) {
|
|
if(this.ckplayerConfig['style']['logo']['file']) {
|
|
var logoFile = this.ckplayerConfig['style']['logo']['file'];
|
|
if(logoFile.substr(0, 15) == 'data:image/png;' || logoFile.substr(0, 15) == 'data:image/jpg;' || logoFile.substr(0, 15) == 'data:image/jpeg;') {
|
|
this.getByElement(logoID).innerHTML = '<img src="' + logoFile + '" border="0">'; //构建logo
|
|
}
|
|
}
|
|
} else {
|
|
this.getByElement(logoID).innerHTML = this.vars['logo'] || this.logo || ''; //构建logo
|
|
}
|
|
//CB:Object：全局变量，将一些全局需要用到的元素统一放在CB对象里
|
|
var pd = this.PD;
|
|
this.CB = {
|
|
controlBarBg: this.getByElement(controlBarBgID, pd),
|
|
controlBar: this.getByElement(controlBarID, pd),
|
|
promptBg: this.getByElement(promptBgID, pd),
|
|
prompt: this.getByElement(promptID, pd),
|
|
timeProgressBg: this.getByElement(timeProgressBgID, pd),
|
|
loadProgress: this.getByElement(loadProgressID, pd),
|
|
timeProgress: this.getByElement(timeProgressID, pd),
|
|
timeBoBg: this.getByElement(timeBOBGID, pd),
|
|
timeButton: this.getByElement(timeBOID, pd),
|
|
timeText: this.getByElement(timeTextID, pd),
|
|
play: this.getByElement(playID, pd),
|
|
front: this.getByElement(frontID, pd),
|
|
next: this.getByElement(nextID, pd),
|
|
pause: this.getByElement(pauseID, pd),
|
|
definition: this.getByElement(definitionID, pd),
|
|
definitionP: this.getByElement(definitionPID, pd),
|
|
definitionLine: this.getByElement(dlineID + '-rb', pd),
|
|
playbackrate: this.getByElement(playbackRateID, pd),
|
|
playbackrateP: this.getByElement(playbackRatePID, pd),
|
|
playbackrateLine: this.getByElement(dlineID + '-rc', pd),
|
|
full: this.getByElement(fullID, pd),
|
|
escFull: this.getByElement(escFullID, pd),
|
|
mute: this.getByElement(muteID, pd),
|
|
escMute: this.getByElement(escMuteID, pd),
|
|
volume: this.getByElement(volumeID, pd),
|
|
volumeBg: this.getByElement(volumeBgID, pd),
|
|
volumeUp: this.getByElement(volumeUpID, pd),
|
|
volumeBO: this.getByElement(volumeBOID, pd),
|
|
pauseCenter: this.getByElement(pauseCenterID, pd),
|
|
menu: this.getByElement(menuID),
|
|
loading: this.getByElement(loadingID, pd),
|
|
loadingCanvas: this.getByElement(loadingID + '-canvas', pd),
|
|
errorText: this.getByElement(errorTextID, pd),
|
|
logo: this.getByElement(logoID, pd),
|
|
playLine: this.getByElement(dlineID + '-la', pd),
|
|
frontLine: this.getByElement(dlineID + '-lb', pd),
|
|
nextLine: this.getByElement(dlineID + '-lc', pd),
|
|
fullLine: this.getByElement(dlineID + '-ra'),
|
|
definitionLine: this.getByElement(dlineID + '-rb', pd),
|
|
muteLine: this.getByElement(dlineID + '-rd', pd)
|
|
};
|
|
this.buttonWidth = {
|
|
play: bWidth,
|
|
full: bWidth,
|
|
front: bWidth,
|
|
next: bWidth,
|
|
mute: bWidth
|
|
};
|
|
//定义界面元素的样式
|
|
//控制栏背景
|
|
this.css(controlBarBgID, {
|
|
width: '100%',
|
|
height: bHeight + 'px',
|
|
backgroundColor: '#000000',
|
|
position: 'absolute',
|
|
bottom: '0px',
|
|
filter: 'alpha(opacity:0.8)',
|
|
opacity: '0.8',
|
|
zIndex: '90'
|
|
});
|
|
//控制栏容器
|
|
this.css(controlBarID, {
|
|
width: '100%',
|
|
height: bHeight + 'px',
|
|
position: 'absolute',
|
|
bottom: '0px',
|
|
zIndex: '90'
|
|
});
|
|
//中间暂停按钮
|
|
this.css(pauseCenterID, {
|
|
width: '80px',
|
|
height: '80px',
|
|
borderRadius: '50%',
|
|
position: 'absolute',
|
|
display: 'none',
|
|
cursor: 'pointer',
|
|
zIndex: '100'
|
|
});
|
|
//loading
|
|
this.css(loadingID, {
|
|
width: '60px',
|
|
height: '60px',
|
|
position: 'absolute',
|
|
display: 'none',
|
|
zIndex: '100'
|
|
});
|
|
//出错文本框
|
|
this.css(errorTextID, {
|
|
width: '120px',
|
|
height: '30px',
|
|
lineHeight: '30px',
|
|
color: '#FFFFFF',
|
|
fontSize: '14px',
|
|
textAlign: 'center',
|
|
position: 'absolute',
|
|
display: 'none',
|
|
zIndex: '101',
|
|
cursor: 'default',
|
|
zIndex: '100'
|
|
});
|
|
//定义logo文字的样式
|
|
this.css(logoID, {
|
|
height: '30px',
|
|
lineHeight: '30px',
|
|
color: '#FFFFFF',
|
|
fontFamily: 'Arial',
|
|
fontSize: '28px',
|
|
textAlign: 'center',
|
|
position: 'absolute',
|
|
float: 'left',
|
|
left: '-1000px',
|
|
top: '20px',
|
|
zIndex: '100',
|
|
filter: 'alpha(opacity:0.8)',
|
|
opacity: '0.8',
|
|
cursor: 'default'
|
|
});
|
|
|
|
this.css(this.CB['loadingCanvas'], {
|
|
transform: 'rotate(0deg)',
|
|
msTransform: 'rotate(0deg)',
|
|
mozTransform: 'rotate(0deg)',
|
|
webkitTransform: 'rotate(0deg)',
|
|
oTransform: 'rotate(0deg)'
|
|
});
|
|
//定义提示语的样式
|
|
this.css([promptBgID, promptID], {
|
|
height: '30px',
|
|
lineHeight: '30px',
|
|
color: '#FFFFFF',
|
|
fontSize: '14px',
|
|
textAlign: 'center',
|
|
position: 'absolute',
|
|
borderRadius: '5px',
|
|
paddingLeft: '5px',
|
|
paddingRight: '5px',
|
|
bottom: '0px',
|
|
display: 'none',
|
|
zIndex: '95'
|
|
});
|
|
this.css(promptBgID, {
|
|
backgroundColor: '#000000',
|
|
filter: 'alpha(opacity:0.5)',
|
|
opacity: '0.5'
|
|
});
|
|
//时间进度条背景容器
|
|
this.css(timeProgressBgID, {
|
|
width: '100%',
|
|
height: '6px',
|
|
backgroundColor: '#3F3F3F',
|
|
overflow: 'hidden',
|
|
position: 'absolute',
|
|
bottom: '38px',
|
|
zIndex: '88'
|
|
});
|
|
//加载进度和时间进度
|
|
this.css([loadProgressID, timeProgressID], {
|
|
width: '1px',
|
|
height: '6px',
|
|
position: 'absolute',
|
|
bottom: '38px',
|
|
top: '0px',
|
|
zIndex: '91'
|
|
});
|
|
this.css(loadProgressID, 'backgroundColor', '#6F6F6F');
|
|
this.css(timeProgressID, 'backgroundColor', bOverColor);
|
|
//时间进度按钮
|
|
this.css(timeBOBGID, {
|
|
width: '100%',
|
|
height: '14px',
|
|
overflow: 'hidden',
|
|
position: 'absolute',
|
|
bottom: '34px',
|
|
cursor: 'pointer',
|
|
zIndex: '92'
|
|
});
|
|
this.css(timeBOID, {
|
|
width: '14px',
|
|
height: '14px',
|
|
overflow: 'hidden',
|
|
borderRadius: '50%',
|
|
backgroundColor: bBgColor,
|
|
cursor: 'pointer',
|
|
position: 'absolute',
|
|
top: '0px',
|
|
zIndex: '20'
|
|
});
|
|
this.css(timeBWID, {
|
|
width: '8px',
|
|
height: '8px',
|
|
overflow: 'hidden',
|
|
borderRadius: '50%',
|
|
position: 'absolute',
|
|
backgroundColor: bOverColor,
|
|
left: '3px',
|
|
top: '3px'
|
|
});
|
|
this.css(timeTextID, {
|
|
lineHeight: bHeight + 'px',
|
|
color: '#FFFFFF',
|
|
fontFamily: 'arial',
|
|
fontSize: '16px',
|
|
paddingLeft: '10px',
|
|
float: 'left',
|
|
overflow: 'hidden',
|
|
cursor: 'default'
|
|
});
|
|
//分隔线
|
|
this.css([dlineID + '-la', dlineID + '-lb', dlineID + '-lc', dlineID + '-ra', dlineID + '-rb', dlineID + '-rc', dlineID + '-rd'], {
|
|
width: '0px',
|
|
height: bHeight + 'px',
|
|
overflow: 'hidden',
|
|
borderLeft: '1px solid #303030',
|
|
borderRight: '1px solid #151515',
|
|
filter: 'alpha(opacity:0.9)',
|
|
opacity: '0.9'
|
|
});
|
|
this.css([dlineID + '-la', dlineID + '-lb', dlineID + '-lc'], 'float', 'left');
|
|
this.css([dlineID + '-ra', dlineID + '-rb', dlineID + '-rc', dlineID + '-rd'], 'float', 'right');
|
|
this.css([dlineID + '-lb', dlineID + '-lc', dlineID + '-rb', dlineID + '-rc'], 'display', 'none');
|
|
//播放/暂停/上一集/下一集按钮
|
|
this.css([playID, pauseID, frontID, nextID], {
|
|
width: bWidth + 'px',
|
|
height: bHeight + 'px',
|
|
float: 'left',
|
|
overflow: 'hidden',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css([frontID, nextID], 'display', 'none');
|
|
//初始化判断播放/暂停按钮隐藏项
|
|
this.initPlayPause();
|
|
|
|
//设置静音/取消静音的按钮样式
|
|
this.css([muteID, escMuteID], {
|
|
width: bWidth + 'px',
|
|
height: bHeight + 'px',
|
|
float: 'right',
|
|
overflow: 'hidden',
|
|
cursor: 'pointer'
|
|
});
|
|
if(this.vars['volume'] > 0) {
|
|
this.css(escMuteID, 'display', 'none');
|
|
} else {
|
|
this.css(muteID, 'display', 'none');
|
|
}
|
|
//音量调节框
|
|
this.css([volumeID, volumeDbgID], {
|
|
width: '110px',
|
|
height: bHeight + 'px',
|
|
overflow: 'hidden',
|
|
float: 'right'
|
|
});
|
|
this.css(volumeDbgID, {
|
|
position: 'absolute'
|
|
});
|
|
this.css([volumeBgID, volumeUpID], {
|
|
width: '100px',
|
|
height: '6px',
|
|
overflow: 'hidden',
|
|
borderRadius: '5px',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(volumeBgID, {
|
|
position: 'absolute',
|
|
top: '16px'
|
|
});
|
|
this.css(volumeBgID, 'backgroundColor', '#666666');
|
|
this.css(volumeUpID, 'backgroundColor', bOverColor);
|
|
this.buttonWidth['volume'] = 100;
|
|
//音量调节按钮
|
|
this.css(volumeBOID, {
|
|
width: '12px',
|
|
height: '12px',
|
|
overflow: 'hidden',
|
|
borderRadius: '50%',
|
|
position: 'absolute',
|
|
backgroundColor: bBgColor,
|
|
top: '13px',
|
|
left: '0px',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(volumeBWID, {
|
|
width: '6px',
|
|
height: '6px',
|
|
overflow: 'hidden',
|
|
borderRadius: '50%',
|
|
position: 'absolute',
|
|
backgroundColor: bOverColor,
|
|
left: '3px',
|
|
top: '3px'
|
|
});
|
|
//清晰度容器
|
|
this.css(definitionID, {
|
|
lineHeight: bHeight + 'px',
|
|
color: '#FFFFFF',
|
|
float: 'right',
|
|
fontSize: '14px',
|
|
textAlign: 'center',
|
|
overflow: 'hidden',
|
|
display: 'none',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(definitionPID, {
|
|
lineHeight: (bHeight - 8) + 'px',
|
|
color: '#FFFFFF',
|
|
overflow: 'hidden',
|
|
position: 'absolute',
|
|
bottom: '4px',
|
|
backgroundColor: '#000000',
|
|
textAlign: 'center',
|
|
zIndex: '95',
|
|
cursor: 'pointer',
|
|
display: 'none'
|
|
});
|
|
//倍速容器
|
|
this.css(playbackRateID, {
|
|
lineHeight: bHeight + 'px',
|
|
color: '#FFFFFF',
|
|
float: 'right',
|
|
fontSize: '14px',
|
|
textAlign: 'center',
|
|
overflow: 'hidden',
|
|
display: 'none',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(playbackRatePID, {
|
|
lineHeight: (bHeight - 8) + 'px',
|
|
color: '#FFFFFF',
|
|
overflow: 'hidden',
|
|
position: 'absolute',
|
|
bottom: '4px',
|
|
backgroundColor: '#000000',
|
|
textAlign: 'center',
|
|
zIndex: '95',
|
|
cursor: 'pointer',
|
|
display: 'none'
|
|
});
|
|
//设置全屏/退出全屏按钮样式
|
|
this.css([fullID, escFullID], {
|
|
width: bWidth + 'px',
|
|
height: bHeight + 'px',
|
|
float: 'right',
|
|
overflow: 'hidden',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(escFullID, 'display', 'none');
|
|
//构建各按钮的形状
|
|
//播放按钮
|
|
var cPlay = this.getByElement(playID + '-canvas').getContext('2d');
|
|
var cPlayFillRect = function() {
|
|
thisTemp.canvasFill(cPlay, [
|
|
[12, 10],
|
|
[29, 19],
|
|
[12, 28]
|
|
]);
|
|
};
|
|
cPlay.fillStyle = bBgColor;
|
|
cPlayFillRect();
|
|
var cPlayOver = function(event) {
|
|
cPlay.clearRect(0, 0, bWidth, bHeight);
|
|
cPlay.fillStyle = bOverColor;
|
|
cPlayFillRect();
|
|
};
|
|
var cPlayOut = function(event) {
|
|
cPlay.clearRect(0, 0, bWidth, bHeight);
|
|
cPlay.fillStyle = bBgColor;
|
|
cPlayFillRect();
|
|
};
|
|
|
|
this.addListenerInside('mouseover', cPlayOver, this.getByElement(playID + '-canvas'));
|
|
this.addListenerInside('mouseout', cPlayOut, this.getByElement(playID + '-canvas'));
|
|
//暂停按钮
|
|
var cPause = this.getByElement(pauseID + '-canvas').getContext('2d');
|
|
var cPauseFillRect = function() {
|
|
thisTemp.canvasFillRect(cPause, [
|
|
[10, 10, 5, 18],
|
|
[22, 10, 5, 18]
|
|
]);
|
|
};
|
|
cPause.fillStyle = bBgColor;
|
|
cPauseFillRect();
|
|
var cPauseOver = function(event) {
|
|
cPause.clearRect(0, 0, bWidth, bHeight);
|
|
cPause.fillStyle = bOverColor;
|
|
cPauseFillRect();
|
|
};
|
|
var cPauseOut = function(event) {
|
|
cPause.clearRect(0, 0, bWidth, bHeight);
|
|
cPause.fillStyle = bBgColor;
|
|
cPauseFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cPauseOver, this.getByElement(pauseID + '-canvas'));
|
|
this.addListenerInside('mouseout', cPauseOut, this.getByElement(pauseID + '-canvas'));
|
|
//前一集按钮
|
|
var cFront = this.getByElement(frontID + '-canvas').getContext('2d');
|
|
var cFrontFillRect = function() {
|
|
thisTemp.canvasFill(cFront, [
|
|
[16, 19],
|
|
[30, 10],
|
|
[30, 28]
|
|
]);
|
|
thisTemp.canvasFillRect(cFront, [
|
|
[8, 10, 5, 18]
|
|
]);
|
|
};
|
|
cFront.fillStyle = bBgColor;
|
|
cFrontFillRect();
|
|
var cFrontOver = function(event) {
|
|
cFront.clearRect(0, 0, bWidth, bHeight);
|
|
cFront.fillStyle = bOverColor;
|
|
cFrontFillRect();
|
|
};
|
|
var cFrontOut = function(event) {
|
|
cFront.clearRect(0, 0, bWidth, bHeight);
|
|
cFront.fillStyle = bBgColor;
|
|
cFrontFillRect();
|
|
};
|
|
|
|
this.addListenerInside('mouseover', cFrontOver, this.getByElement(frontID + '-canvas'));
|
|
this.addListenerInside('mouseout', cFrontOut, this.getByElement(frontID + '-canvas'));
|
|
//下一集按钮
|
|
var cNext = this.getByElement(nextID + '-canvas').getContext('2d');
|
|
var cNextFillRect = function() {
|
|
thisTemp.canvasFill(cNext, [
|
|
[8, 10],
|
|
[22, 19],
|
|
[8, 28]
|
|
]);
|
|
thisTemp.canvasFillRect(cNext, [
|
|
[25, 10, 5, 18]
|
|
]);
|
|
};
|
|
cNext.fillStyle = bBgColor;
|
|
cNextFillRect();
|
|
var cNextOver = function(event) {
|
|
cNext.clearRect(0, 0, bWidth, bHeight);
|
|
cNext.fillStyle = bOverColor;
|
|
cNextFillRect();
|
|
};
|
|
var cNextOut = function(event) {
|
|
cNext.clearRect(0, 0, bWidth, bHeight);
|
|
cNext.fillStyle = bBgColor;
|
|
cNextFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cNextOver, this.getByElement(nextID + '-canvas'));
|
|
this.addListenerInside('mouseout', cNextOut, this.getByElement(nextID + '-canvas'));
|
|
//全屏按钮
|
|
var cFull = this.getByElement(fullID + '-canvas').getContext('2d');
|
|
var cFullFillRect = function() {
|
|
thisTemp.canvasFillRect(cFull, [
|
|
[19, 10, 9, 3],
|
|
[25, 13, 3, 6],
|
|
[10, 19, 3, 9],
|
|
[13, 25, 6, 3]
|
|
]);
|
|
};
|
|
cFull.fillStyle = bBgColor;
|
|
cFullFillRect();
|
|
var cFullOver = function() {
|
|
cFull.clearRect(0, 0, bWidth, bHeight);
|
|
cFull.fillStyle = bOverColor;
|
|
cFullFillRect();
|
|
};
|
|
var cFullOut = function() {
|
|
cFull.clearRect(0, 0, bWidth, bHeight);
|
|
cFull.fillStyle = bBgColor;
|
|
cFullFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cFullOver, this.getByElement(fullID + '-canvas'));
|
|
this.addListenerInside('mouseout', cFullOut, this.getByElement(fullID + '-canvas'));
|
|
//定义退出全屏按钮样式
|
|
var cEscFull = this.getByElement(escFullID + '-canvas').getContext('2d');
|
|
var cEscFullFillRect = function() {
|
|
thisTemp.canvasFillRect(cEscFull, [
|
|
[20, 9, 3, 9],
|
|
[23, 15, 6, 3],
|
|
[9, 20, 9, 3],
|
|
[15, 23, 3, 6]
|
|
]);
|
|
};
|
|
cEscFull.fillStyle = bBgColor;
|
|
cEscFullFillRect();
|
|
|
|
var cEscFullOver = function() {
|
|
cEscFull.clearRect(0, 0, bWidth, bHeight);
|
|
cEscFull.fillStyle = bOverColor;
|
|
cEscFullFillRect();
|
|
};
|
|
var cEscFullOut = function() {
|
|
cEscFull.clearRect(0, 0, bWidth, bHeight);
|
|
cEscFull.fillStyle = bBgColor;
|
|
cEscFullFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cEscFullOver, this.getByElement(escFullID + '-canvas'));
|
|
this.addListenerInside('mouseout', cEscFullOut, this.getByElement(escFullID + '-canvas'));
|
|
//定义全屏按钮的样式
|
|
var cMute = this.getByElement(muteID + '-canvas').getContext('2d');
|
|
var cMuteFillRect = function() {
|
|
thisTemp.canvasFill(cMute, [
|
|
[10, 15],
|
|
[15, 15],
|
|
[21, 10],
|
|
[21, 28],
|
|
[15, 23],
|
|
[10, 23]
|
|
]);
|
|
thisTemp.canvasFillRect(cMute, [
|
|
[23, 15, 2, 8],
|
|
[27, 10, 2, 18]
|
|
]);
|
|
};
|
|
cMute.fillStyle = bBgColor;
|
|
cMuteFillRect();
|
|
var cMuteOver = function() {
|
|
cMute.clearRect(0, 0, bWidth, bHeight);
|
|
cMute.fillStyle = bOverColor;
|
|
cMuteFillRect();
|
|
};
|
|
var cMuteOut = function() {
|
|
cMute.clearRect(0, 0, bWidth, bHeight);
|
|
cMute.fillStyle = bBgColor;
|
|
cMuteFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cMuteOver, this.getByElement(muteID + '-canvas'));
|
|
this.addListenerInside('mouseout', cMuteOut, this.getByElement(muteID + '-canvas'));
|
|
//定义退出全屏按钮样式
|
|
var cEscMute = this.getByElement(escMuteID + '-canvas').getContext('2d');
|
|
var cEscMuteFillRect = function() {
|
|
thisTemp.canvasFill(cEscMute, [
|
|
[10, 15],
|
|
[15, 15],
|
|
[21, 10],
|
|
[21, 28],
|
|
[15, 23],
|
|
[10, 23]
|
|
]);
|
|
thisTemp.canvasFill(cEscMute, [
|
|
[23, 13],
|
|
[24, 13],
|
|
[33, 25],
|
|
[32, 25]
|
|
]);
|
|
thisTemp.canvasFill(cEscMute, [
|
|
[32, 13],
|
|
[33, 13],
|
|
[24, 25],
|
|
[23, 25]
|
|
]);
|
|
};
|
|
cEscMute.fillStyle = bBgColor;
|
|
cEscMuteFillRect();
|
|
var cEscMuteOver = function() {
|
|
cEscMute.clearRect(0, 0, bWidth, bHeight);
|
|
cEscMute.fillStyle = bOverColor;
|
|
cEscMuteFillRect();
|
|
};
|
|
var cEscMuteOut = function() {
|
|
cEscMute.clearRect(0, 0, bWidth, bHeight);
|
|
cEscMute.fillStyle = bBgColor;
|
|
cEscMuteFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cEscMuteOver, this.getByElement(escMuteID + '-canvas'));
|
|
this.addListenerInside('mouseout', cEscMuteOut, this.getByElement(escMuteID + '-canvas'));
|
|
//定义loading样式
|
|
var cLoading = this.getByElement(loadingID + '-canvas').getContext('2d');
|
|
var cLoadingFillRect = function() {
|
|
cLoading.save();
|
|
var grad = cLoading.createLinearGradient(0, 0, 60, 60);
|
|
grad.addColorStop(0, bBgColor);
|
|
var grad2 = cLoading.createLinearGradient(0, 0, 80, 60);
|
|
grad2.addColorStop(1, bOverColor);
|
|
var grad3 = cLoading.createLinearGradient(0, 0, 80, 60);
|
|
grad3.addColorStop(1, '#FF9900');
|
|
var grad4 = cLoading.createLinearGradient(0, 0, 80, 60);
|
|
grad4.addColorStop(1, '#CC3300');
|
|
cLoading.strokeStyle = grad; //设置描边样式
|
|
cLoading.lineWidth = 8; //设置线宽
|
|
cLoading.beginPath(); //路径开始
|
|
cLoading.arc(30, 30, 25, 0, 0.4 * Math.PI, false); //用于绘制圆弧context.arc(x坐标，y坐标，半径，起始角度，终止角度，顺时针/逆时针)
|
|
cLoading.stroke(); //绘制
|
|
cLoading.closePath(); //路径结束
|
|
cLoading.beginPath(); //路径开始
|
|
cLoading.strokeStyle = grad2; //设置描边样式
|
|
cLoading.arc(30, 30, 25, 0.5 * Math.PI, 0.9 * Math.PI, false); //用于绘制圆弧context.arc(x坐标，y坐标，半径，起始角度，终止角度，顺时针/逆时针)
|
|
cLoading.stroke(); //绘制
|
|
cLoading.beginPath(); //路径开始
|
|
cLoading.strokeStyle = grad3; //设置描边样式
|
|
cLoading.arc(30, 30, 25, Math.PI, 1.4 * Math.PI, false); //用于绘制圆弧context.arc(x坐标，y坐标，半径，起始角度，终止角度，顺时针/逆时针)
|
|
cLoading.stroke(); //绘制
|
|
cLoading.beginPath(); //路径开始
|
|
cLoading.strokeStyle = grad4; //设置描边样式
|
|
cLoading.arc(30, 30, 25, 1.5 * Math.PI, 1.9 * Math.PI, false); //用于绘制圆弧context.arc(x坐标，y坐标，半径，起始角度，终止角度，顺时针/逆时针)
|
|
cLoading.stroke(); //绘制
|
|
cLoading.closePath(); //路径结束
|
|
cLoading.restore();
|
|
};
|
|
cLoading.fillStyle = bBgColor;
|
|
cLoadingFillRect();
|
|
//定义中间暂停按钮的样式
|
|
var cPauseCenter = this.getByElement(pauseCenterID + '-canvas').getContext('2d');
|
|
var cPauseCenterFillRect = function() {
|
|
thisTemp.canvasFill(cPauseCenter, [
|
|
[28, 22],
|
|
[59, 38],
|
|
[28, 58]
|
|
]);
|
|
/* 指定几个颜色 */
|
|
cPauseCenter.save();
|
|
cPauseCenter.lineWidth = 5; //设置线宽
|
|
cPauseCenter.beginPath(); //路径开始
|
|
cPauseCenter.arc(40, 40, 35, 0, 2 * Math.PI, false); //用于绘制圆弧context.arc(x坐标，y坐标，半径，起始角度，终止角度，顺时针/逆时针)
|
|
cPauseCenter.stroke(); //绘制
|
|
cPauseCenter.closePath(); //路径结束
|
|
cPauseCenter.restore();
|
|
};
|
|
cPauseCenter.fillStyle = bBgColor;
|
|
cPauseCenter.strokeStyle = bBgColor;
|
|
cPauseCenterFillRect();
|
|
var cPauseCenterOver = function() {
|
|
cPauseCenter.clearRect(0, 0, 80, 80);
|
|
cPauseCenter.fillStyle = bOverColor;
|
|
cPauseCenter.strokeStyle = bOverColor;
|
|
cPauseCenterFillRect();
|
|
};
|
|
var cPauseCenterOut = function() {
|
|
cPauseCenter.clearRect(0, 0, 80, 80);
|
|
cPauseCenter.fillStyle = bBgColor;
|
|
cPauseCenter.strokeStyle = bBgColor;
|
|
cPauseCenterFillRect();
|
|
};
|
|
this.addListenerInside('mouseover', cPauseCenterOver, this.getByElement(pauseCenterID + '-canvas'));
|
|
this.addListenerInside('mouseout', cPauseCenterOut, this.getByElement(pauseCenterID + '-canvas'));
|
|
|
|
//鼠标经过/离开音量调节按钮
|
|
var volumeBOOver = function() {
|
|
thisTemp.css(volumeBOID, 'backgroundColor', bOverColor);
|
|
thisTemp.css(volumeBWID, 'backgroundColor', bBgColor);
|
|
};
|
|
var volumeBOOut = function() {
|
|
thisTemp.css(volumeBOID, 'backgroundColor', bBgColor);
|
|
thisTemp.css(volumeBWID, 'backgroundColor', bOverColor);
|
|
};
|
|
this.addListenerInside('mouseover', volumeBOOver, this.getByElement(volumeBOID));
|
|
this.addListenerInside('mouseout', volumeBOOut, this.getByElement(volumeBOID));
|
|
//鼠标经过/离开进度按钮
|
|
var timeBOOver = function() {
|
|
thisTemp.css(timeBOID, 'backgroundColor', bOverColor);
|
|
thisTemp.css(timeBWID, 'backgroundColor', bBgColor);
|
|
};
|
|
var timeBOOut = function() {
|
|
thisTemp.css(timeBOID, 'backgroundColor', bBgColor);
|
|
thisTemp.css(timeBWID, 'backgroundColor', bOverColor);
|
|
};
|
|
this.addListenerInside('mouseover', timeBOOver, this.getByElement(timeBOID));
|
|
this.addListenerInside('mouseout', timeBOOut, this.getByElement(timeBOID));
|
|
|
|
this.addButtonEvent(); //注册按钮及音量调节，进度操作事件
|
|
this.newMenu(); //单独设置右键的样式和事件
|
|
this.controlBarHide(); //单独注册控制栏隐藏事件
|
|
this.keypress(); //单独注册键盘事件
|
|
//初始化音量调节框
|
|
this.changeVolume(this.vars['volume']);
|
|
//初始化判断是否需要显示上一集和下一集按钮
|
|
this.showFrontNext();
|
|
window.setTimeout(function() {
|
|
thisTemp.elementCoordinate(); //调整中间暂停按钮/loading的位置/error的位置
|
|
}, 100);
|
|
this.checkBarWidth();
|
|
var resize = function() {
|
|
thisTemp.elementCoordinate();
|
|
thisTemp.timeUpdateHandler();
|
|
thisTemp.changeLoad();
|
|
thisTemp.checkBarWidth();
|
|
thisTemp.changeElementCoor(); //修改新加元件的坐标
|
|
thisTemp.changePrompt();
|
|
};
|
|
this.addListenerInside('resize', resize, window);
|
|
},
|
|
/*
|
|
内部函数
|
|
创建按钮，使用canvas画布
|
|
*/
|
|
newCanvas: function(id, width, height) {
|
|
return '<canvas class="' + id + '-canvas" width="' + width + '" height="' + height + '"></canvas>';
|
|
},
|
|
/*
|
|
内部函数
|
|
注册按钮，音量调节框，进度操作框事件
|
|
*/
|
|
addButtonEvent: function() {
|
|
var thisTemp = this;
|
|
//定义按钮的单击事件
|
|
var playClick = function(event) {
|
|
thisTemp.videoPlay();
|
|
thisTemp.sendJS('clickEvent', 'actionScript->videoPlay');
|
|
};
|
|
this.addListenerInside('click', playClick, this.CB['play']);
|
|
this.addListenerInside('click', playClick, this.CB['pauseCenter']);
|
|
var pauseClick = function(event) {
|
|
thisTemp.videoPause();
|
|
thisTemp.sendJS('clickEvent', 'actionScript->videoPause');
|
|
};
|
|
this.addListenerInside('click', pauseClick, this.CB['pause']);
|
|
var frontClick = function(event) {
|
|
if(thisTemp.vars['front']) {
|
|
eval(thisTemp.vars['front'] + '()');
|
|
thisTemp.sendJS('clickEvent', 'actionScript->' + thisTemp.vars['front']);
|
|
}
|
|
};
|
|
this.addListenerInside('click', frontClick, this.CB['front']);
|
|
var nextClick = function(event) {
|
|
if(thisTemp.vars['next']) {
|
|
eval(thisTemp.vars['next'] + '()');
|
|
thisTemp.sendJS('clickEvent', 'actionScript->' + thisTemp.vars['next']);
|
|
}
|
|
};
|
|
this.addListenerInside('click', nextClick, this.CB['next']);
|
|
var muteClick = function(event) {
|
|
thisTemp.videoMute();
|
|
thisTemp.sendJS('clickEvent', 'actionScript->videoMute');
|
|
};
|
|
this.addListenerInside('click', muteClick, this.CB['mute']);
|
|
var escMuteClick = function(event) {
|
|
thisTemp.videoEscMute();
|
|
thisTemp.sendJS('clickEvent', 'actionScript->videoEscMute');
|
|
};
|
|
this.addListenerInside('click', escMuteClick, this.CB['escMute']);
|
|
var fullClick = function(event) {
|
|
thisTemp.fullScreen();
|
|
thisTemp.sendJS('clickEvent', 'actionScript->fullScreen');
|
|
};
|
|
this.addListenerInside('click', fullClick, this.CB['full']);
|
|
var escFullClick = function(event) {
|
|
thisTemp.quitFullScreen();
|
|
thisTemp.sendJS('clickEvent', 'actionScript->quitFullScreen');
|
|
};
|
|
this.addListenerInside('click', escFullClick, this.CB['escFull']);
|
|
//定义各个按钮的鼠标经过/离开事件
|
|
var promptHide = function(event) {
|
|
thisTemp.promptShow(false);
|
|
};
|
|
var playOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['play']);
|
|
};
|
|
this.addListenerInside('mouseover', playOver, this.CB['play']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['play']);
|
|
var pauseOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['pause']);
|
|
};
|
|
this.addListenerInside('mouseover', pauseOver, this.CB['pause']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['pause']);
|
|
var frontOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['front']);
|
|
};
|
|
this.addListenerInside('mouseover', frontOver, this.CB['front']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['front']);
|
|
var nextOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['next']);
|
|
};
|
|
this.addListenerInside('mouseover', nextOver, this.CB['next']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['next']);
|
|
var muteOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['mute']);
|
|
};
|
|
this.addListenerInside('mouseover', muteOver, this.CB['mute']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['mute']);
|
|
var escMuteOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['escMute']);
|
|
};
|
|
this.addListenerInside('mouseover', escMuteOver, this.CB['escMute']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['escMute']);
|
|
var fullOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['full']);
|
|
};
|
|
this.addListenerInside('mouseover', fullOver, this.CB['full']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['full']);
|
|
var escFullOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['escFull']);
|
|
};
|
|
this.addListenerInside('mouseover', escFullOver, this.CB['escFull']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['escFull']);
|
|
var definitionOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['definition']);
|
|
};
|
|
this.addListenerInside('mouseover', definitionOver, this.CB['definition']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['definition']);
|
|
var playbackrateOver = function(event) {
|
|
thisTemp.promptShow(thisTemp.CB['playbackrate']);
|
|
};
|
|
this.addListenerInside('mouseover', playbackrateOver, this.CB['playbackrate']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['playbackrate']);
|
|
//定义音量和进度按钮的滑块事件
|
|
|
|
var volumePrompt = function(vol) {
|
|
var volumeBOXY = thisTemp.getCoor(thisTemp.CB['volumeBO']);
|
|
var promptObj = {
|
|
title: thisTemp.language['volume'] + vol + '%',
|
|
x: volumeBOXY['x'] + thisTemp.CB['volumeBO'].offsetWidth * 0.5,
|
|
y: volumeBOXY['y']
|
|
};
|
|
thisTemp.promptShow(false, promptObj);
|
|
};
|
|
var volumeObj = {
|
|
slider: this.CB['volumeBO'],
|
|
follow: this.CB['volumeUp'],
|
|
refer: this.CB['volumeBg'],
|
|
grossValue: 'volume',
|
|
pd: true,
|
|
startFun: function(vol) {},
|
|
monitorFun: function(vol) {
|
|
thisTemp.changeVolume(vol * 0.01, false, false);
|
|
volumePrompt(vol);
|
|
},
|
|
endFun: function(vol) {},
|
|
overFun: function(vol) {
|
|
volumePrompt(vol);
|
|
}
|
|
};
|
|
this.slider(volumeObj);
|
|
var volumeClickObj = {
|
|
refer: this.CB['volumeBg'],
|
|
grossValue: 'volume',
|
|
fun: function(vol) {
|
|
thisTemp.changeVolume(vol * 0.01, true, true);
|
|
}
|
|
};
|
|
this.progressClick(volumeClickObj);
|
|
this.timeButtonMouseDown(); //用单击的函数来判断是否需要建立控制栏监听
|
|
//鼠标经过/离开音量调节框时的
|
|
var volumeBgMove = function(event) {
|
|
var volumeBgXY = thisTemp.getCoor(thisTemp.CB['volumeBg']);
|
|
var eventX = thisTemp.client(event)['x'];
|
|
var eventVolume = parseInt((eventX - volumeBgXY['x']) * 100 / thisTemp.CB['volumeBg'].offsetWidth);
|
|
var buttonPromptObj = {
|
|
title: thisTemp.language['volume'] + eventVolume + '%',
|
|
x: eventX,
|
|
y: volumeBgXY['y']
|
|
};
|
|
thisTemp.promptShow(false, buttonPromptObj);
|
|
};
|
|
this.addListenerInside('mousemove', volumeBgMove, this.CB['volumeBg']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['volumeBg']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['volumeBO']);
|
|
//注册清晰度相关事件
|
|
this.addDefListener();
|
|
//注册倍速相关事件
|
|
this.addPlaybackrate();
|
|
},
|
|
/*
|
|
内部函数
|
|
注册单击视频动作
|
|
*/
|
|
videoClick: function() {
|
|
var thisTemp = this;
|
|
var clearTimerClick = function() {
|
|
if(thisTemp.timerClick != null) {
|
|
if(thisTemp.timerClick.runing) {
|
|
thisTemp.timerClick.stop();
|
|
}
|
|
thisTemp.timerClick = null;
|
|
}
|
|
};
|
|
var timerClickFun = function() {
|
|
clearTimerClick();
|
|
thisTemp.isClick = false;
|
|
thisTemp.playOrPause();
|
|
|
|
};
|
|
clearTimerClick();
|
|
if(this.isClick) {
|
|
this.isClick = false;
|
|
if(thisTemp.config['videoDbClick']) {
|
|
if(!this.full) {
|
|
thisTemp.fullScreen();
|
|
} else {
|
|
thisTemp.quitFullScreen();
|
|
}
|
|
}
|
|
|
|
} else {
|
|
this.isClick = true;
|
|
this.timerClick = new this.timer(300, timerClickFun, 1)
|
|
//this.timerClick.start();
|
|
}
|
|
|
|
},
|
|
/*
|
|
内部函数
|
|
注册鼠标经过进度滑块的事件
|
|
*/
|
|
timeButtonMouseDown: function() {
|
|
var thisTemp = this;
|
|
var timePrompt = function(time) {
|
|
if(isNaN(time)) {
|
|
time = 0;
|
|
}
|
|
var timeButtonXY = thisTemp.getCoor(thisTemp.CB['timeButton']);
|
|
var promptObj = {
|
|
title: thisTemp.formatTime(time),
|
|
x: timeButtonXY['x'] - thisTemp.pdCoor['x'] + thisTemp.CB['timeButton'].offsetWidth * 0.5,
|
|
y: timeButtonXY['y'] - thisTemp.pdCoor['y']
|
|
};
|
|
thisTemp.promptShow(false, promptObj);
|
|
};
|
|
var timeObj = {
|
|
slider: this.CB['timeButton'],
|
|
follow: this.CB['timeProgress'],
|
|
refer: this.CB['timeBoBg'],
|
|
grossValue: 'time',
|
|
pd: false,
|
|
startFun: function(time) {
|
|
thisTemp.isTimeButtonMove = false;
|
|
},
|
|
monitorFun: function(time) {},
|
|
endFun: function(time) {
|
|
if(thisTemp.V) {
|
|
if(thisTemp.V.duration > 0) {
|
|
thisTemp.needSeek = 0;
|
|
thisTemp.videoSeek(parseInt(time));
|
|
}
|
|
}
|
|
},
|
|
overFun: function(time) {
|
|
timePrompt(time);
|
|
}
|
|
};
|
|
var timeClickObj = {
|
|
refer: this.CB['timeBoBg'],
|
|
grossValue: 'time',
|
|
fun: function(time) {
|
|
if(thisTemp.V) {
|
|
if(thisTemp.V.duration > 0) {
|
|
thisTemp.needSeek = 0;
|
|
thisTemp.videoSeek(parseInt(time));
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var timeBoBgmousemove = function(event) {
|
|
var timeBoBgXY = thisTemp.getCoor(thisTemp.CB['timeBoBg']);
|
|
var eventX = thisTemp.client(event)['x'];
|
|
var eventTime = parseInt((eventX - timeBoBgXY['x']) * thisTemp.V.duration / thisTemp.CB['timeBoBg'].offsetWidth);
|
|
var buttonPromptObj = {
|
|
title: thisTemp.formatTime(eventTime),
|
|
x: eventX,
|
|
y: timeBoBgXY['y']
|
|
};
|
|
thisTemp.promptShow(false, buttonPromptObj);
|
|
var def = false;
|
|
if(!thisTemp.isUndefined(thisTemp.CB['definitionP'])) {
|
|
if(thisTemp.css(thisTemp.CB['definitionP'], 'display') != 'block') {
|
|
def = true;
|
|
}
|
|
}
|
|
if(thisTemp.vars['preview'] != null && def) {
|
|
buttonPromptObj['time'] = eventTime;
|
|
thisTemp.preview(buttonPromptObj);
|
|
}
|
|
};
|
|
var promptHide = function(event) {
|
|
thisTemp.promptShow(false);
|
|
if(thisTemp.previewDiv != null) {
|
|
thisTemp.css([thisTemp.previewDiv, thisTemp.previewTop], 'display', 'none');
|
|
}
|
|
};
|
|
if(!this.vars['live']) { //如果不是直播
|
|
this.isTimeButtonDown = true;
|
|
this.addListenerInside('mousemove', timeBoBgmousemove, this.CB['timeBoBg']);
|
|
this.addListenerInside('mouseout', promptHide, this.CB['timeBoBg']);
|
|
} else {
|
|
this.isTimeButtonDown = false;
|
|
timeObj['removeListenerInside'] = true;
|
|
timeClickObj['removeListenerInside'] = true;
|
|
}
|
|
this.slider(timeObj);
|
|
this.progressClick(timeClickObj);
|
|
|
|
},
|
|
/*
|
|
内部函数
|
|
注册调节框上单击事件，包含音量调节框和播放时度调节框
|
|
*/
|
|
progressClick: function(obj) {
|
|
/*
|
|
refer:参考对象
|
|
fun:返回函数
|
|
refer:参考元素，即背景
|
|
grossValue:调用的参考值类型
|
|
pd:
|
|
*/
|
|
//建立参考元素的mouseClick事件，用来做为鼠标在其上按下时触发的状态
|
|
var thisTemp = this;
|
|
var referMouseClick = function(event) {
|
|
var referX = thisTemp.client(event)['x'] - thisTemp.getCoor(obj['refer'])['x'];
|
|
var rWidth = obj['refer'].offsetWidth;
|
|
var grossValue = 0;
|
|
if(obj['grossValue'] == 'volume') {
|
|
grossValue = 100;
|
|
} else {
|
|
if(thisTemp.V) {
|
|
grossValue = thisTemp.V.duration;
|
|
}
|
|
}
|
|
var nowZ = parseInt(referX * grossValue / rWidth);
|
|
if(obj['fun']) {
|
|
if(obj['grossValue'] === 'time') {
|
|
var sliderXY = thisTemp.getCoor(thisTemp.CB['timeButton']);
|
|
sliderLeft = sliderXY['x'];
|
|
if(!thisTemp.checkSlideLeft(referX, sliderLeft, rWidth)) {
|
|
return;
|
|
}
|
|
var bimeButtonWB = thisTemp.CB['timeButton'].offsetWidth * 0.5;
|
|
thisTemp.css(thisTemp.CB['timeButton'], 'left', (referX - bimeButtonWB) + 'px');
|
|
thisTemp.css(thisTemp.CB['timeProgress'], 'width', (referX) + 'px');
|
|
}
|
|
obj['fun'](nowZ);
|
|
}
|
|
};
|
|
if(this.isUndefined(obj['removeListenerInside'])) {
|
|
this.addListenerInside('click', referMouseClick, obj['refer']);
|
|
} else {
|
|
this.removeListenerInside('click', referMouseClick, obj['refer']);
|
|
}
|
|
|
|
},
|
|
|
|
/*
|
|
内部函数
|
|
共用的注册滑块事件
|
|
*/
|
|
slider: function(obj) {
|
|
/*
|
|
obj={
|
|
slider:滑块元素
|
|
follow:跟随滑块的元素
|
|
refer:参考元素，即背景
|
|
grossValue:调用的参考值类型
|
|
startFun:开始调用的元素
|
|
monitorFun:监听函数
|
|
endFun:结束调用的函数
|
|
overFun:鼠标放上去后调用的函数
|
|
pd:是否需要修正
|
|
}
|
|
*/
|
|
var thisTemp = this;
|
|
var clientX = 0,
|
|
criterionWidth = 0,
|
|
sliderLeft = 0,
|
|
referLeft = 0;
|
|
var value = 0;
|
|
var calculation = function() { //根据滑块的left计算百分比
|
|
var sLeft = parseInt(thisTemp.css(obj['slider'], 'left'));
|
|
var rWidth = obj['refer'].offsetWidth - obj['slider'].offsetWidth;
|
|
var grossValue = 0;
|
|
if(thisTemp.isUndefined(sLeft) || isNaN(sLeft)) {
|
|
sLeft = 0;
|
|
}
|
|
if(obj['grossValue'] == 'volume') {
|
|
grossValue = 100;
|
|
} else {
|
|
if(thisTemp.V) {
|
|
grossValue = thisTemp.V.duration;
|
|
}
|
|
}
|
|
return parseInt(sLeft * grossValue / rWidth);
|
|
};
|
|
var mDown = function(event) {
|
|
thisTemp.addListenerInside('mousemove', mMove, document);
|
|
thisTemp.addListenerInside('mouseup', mUp, document);
|
|
var referXY = thisTemp.getCoor(obj['refer']);
|
|
var sliderXY = thisTemp.getCoor(obj['slider']);
|
|
clientX = thisTemp.client(event)['x'];
|
|
referLeft = referXY['x'];
|
|
sliderLeft = sliderXY['x'];
|
|
criterionWidth = clientX - sliderLeft;
|
|
if(obj['startFun']) {
|
|
obj['startFun'](calculation());
|
|
}
|
|
};
|
|
var mMove = function(event) {
|
|
clientX = thisTemp.client(event)['x'];
|
|
var newX = clientX - criterionWidth - referLeft;
|
|
if(newX < 0) {
|
|
newX = 0;
|
|
}
|
|
if(newX > obj['refer'].offsetWidth - obj['slider'].offsetWidth) {
|
|
newX = obj['refer'].offsetWidth - obj['slider'].offsetWidth;
|
|
}
|
|
if(obj['slider'] === thisTemp.CB['timeButton']) {
|
|
if(!thisTemp.checkSlideLeft(newX, sliderLeft, obj['refer'].offsetWidth)) {
|
|
return;
|
|
}
|
|
}
|
|
thisTemp.css(obj['slider'], 'left', newX + 'px');
|
|
thisTemp.css(obj['follow'], 'width', (newX + obj['slider'].offsetWidth * 0.5) + 'px');
|
|
var nowZ = calculation();
|
|
if(obj['monitorFun']) {
|
|
obj['monitorFun'](nowZ);
|
|
}
|
|
};
|
|
var mUp = function(event) {
|
|
thisTemp.removeListenerInside('mousemove', mMove, document);
|
|
thisTemp.removeListenerInside('mouseup', mUp, document);
|
|
if(obj['endFun']) {
|
|
obj['endFun'](calculation());
|
|
}
|
|
};
|
|
var mOver = function(event) {
|
|
if(obj['overFun']) {
|
|
obj['overFun'](calculation());
|
|
}
|
|
|
|
};
|
|
if(this.isUndefined(obj['removeListenerInside'])) {
|
|
this.addListenerInside('mousedown', mDown, obj['slider']);
|
|
this.addListenerInside('mouseover', mOver, obj['slider']);
|
|
} else {
|
|
this.removeListenerInside('mousedown', mDown, obj['slider']);
|
|
this.removeListenerInside('mouseover', mOver, obj['slider']);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
判断是否可以拖动进度按钮或点击进度栏
|
|
*/
|
|
checkSlideLeft: function(newX, sliderLeft, refer) {
|
|
var timeSA = this.ckplayerConfig['config']['timeScheduleAdjust'];
|
|
switch(timeSA) {
|
|
case 0:
|
|
return false;
|
|
break;
|
|
case 2:
|
|
if(newX < sliderLeft) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 3:
|
|
if(newX > sliderLeft) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 4:
|
|
if(!this.timeSliderLeftTemp) {
|
|
this.timeSliderLeftTemp = sliderLeft / refer;
|
|
}
|
|
if(newX < this.timeSliderLeftTemp * refer) {
|
|
return false;
|
|
}
|
|
break;
|
|
case 5:
|
|
if(!this.timeSliderLeftTemp) {
|
|
this.timeSliderLeftTemp = sliderLeft / refer;
|
|
} else {
|
|
var timeSliderMax = sliderLeft / refer;
|
|
if(timeSliderMax > this.timeSliderLeftTemp) {
|
|
this.timeSliderLeftTemp = timeSliderMax;
|
|
}
|
|
}
|
|
if(newX > this.timeSliderLeftTemp * refer) {
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
return true;
|
|
break;
|
|
}
|
|
return true;
|
|
},
|
|
/*
|
|
内部函数
|
|
显示loading
|
|
*/
|
|
loadingStart: function(rot) {
|
|
var thisTemp = this;
|
|
if(this.isUndefined(rot)) {
|
|
rot = true;
|
|
}
|
|
if(this.showFace) {
|
|
this.css(thisTemp.CB['loading'], 'display', 'none');
|
|
}
|
|
if(this.timerLoading != null) {
|
|
if(this.timerLoading.runing) {
|
|
this.timerLoading.stop();
|
|
}
|
|
this.timerLoading = null;
|
|
}
|
|
var buffer = 0;
|
|
var loadingFun = function() {
|
|
var nowRotate = '0';
|
|
try {
|
|
nowRotate = thisTemp.css(thisTemp.CB['loadingCanvas'], 'transform') || thisTemp.css(thisTemp.CB['loadingCanvas'], '-ms-transform') || thisTemp.css(thisTemp.CB['loadingCanvas'], '-moz-transform') || thisTemp.css(thisTemp.CB['loadingCanvas'], '-webkit-transform') || thisTemp.css(thisTemp.CB['loadingCanvas'], '-o-transform') || '0';
|
|
} catch(event) {}
|
|
nowRotate = parseInt(nowRotate.replace('rotate(', '').replace('deg);', ''));
|
|
nowRotate += 4;
|
|
if(nowRotate > 360) {
|
|
nowRotate = 0;
|
|
}
|
|
if(thisTemp.showFace) {
|
|
thisTemp.css(thisTemp.CB['loadingCanvas'], {
|
|
transform: 'rotate(' + nowRotate + 'deg)',
|
|
msTransform: 'rotate(' + nowRotate + 'deg)',
|
|
mozTransform: 'rotate(' + nowRotate + 'deg)',
|
|
webkitTransform: 'rotate(' + nowRotate + 'deg)',
|
|
oTransform: 'rotate(' + nowRotate + 'deg)'
|
|
});
|
|
}
|
|
buffer++;
|
|
if(buffer >= 99) {
|
|
buffer = 99;
|
|
}
|
|
thisTemp.sendJS('buffer', buffer);
|
|
};
|
|
if(rot) {
|
|
this.timerLoading = new this.timer(10, loadingFun);
|
|
//this.timerLoading.start();
|
|
if(this.showFace) {
|
|
this.css(thisTemp.CB['loading'], 'display', 'block');
|
|
}
|
|
} else {
|
|
thisTemp.sendJS('buffer', 100);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
判断是否需要显示上一集和下一集
|
|
*/
|
|
showFrontNext: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
if(this.vars['front']) {
|
|
this.css([this.CB['front'], this.CB['frontLine']], 'display', 'block');
|
|
} else {
|
|
this.css([this.CB['front'], this.CB['frontLine']], 'display', 'none');
|
|
}
|
|
if(this.vars['next']) {
|
|
this.css([this.CB['next'], this.CB['nextLine']], 'display', 'block');
|
|
} else {
|
|
this.css([this.CB['next'], this.CB['nextLine']], 'display', 'none');
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
显示提示语
|
|
*/
|
|
promptShow: function(ele, data) {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var obj = {};
|
|
if(ele || data) {
|
|
if(!this.isUndefined(data)) {
|
|
obj = data;
|
|
} else {
|
|
var offsetCoor = this.getCoor(ele);
|
|
obj = {
|
|
title: this.getDataset(ele, 'title'),
|
|
x: offsetCoor['x'] + ele.offsetWidth * 0.5,
|
|
y: offsetCoor['y']
|
|
};
|
|
}
|
|
this.CB['prompt'].innerHTML = obj['title'];
|
|
this.css(this.CB['prompt'], 'display', 'block');
|
|
var promoptWidth = this.getStringLen(obj['title']) * 10;
|
|
this.css(this.CB['promptBg'], 'width', promoptWidth + 'px');
|
|
this.css(this.CB['prompt'], 'width', promoptWidth + 'px');
|
|
promoptWidth += 10;
|
|
var x = obj['x'] - (promoptWidth * 0.5);
|
|
var y = this.PD.offsetHeight - obj['y'] + 8;
|
|
if(x < 0) {
|
|
x = 0;
|
|
}
|
|
if(x > this.PD.offsetWidth - promoptWidth) {
|
|
x = this.PD.offsetWidth - promoptWidth;
|
|
}
|
|
this.css([this.CB['promptBg'], this.CB['prompt']], {
|
|
display: 'block',
|
|
left: x + 'px',
|
|
bottom: y + 'px'
|
|
});
|
|
} else {
|
|
this.css([this.CB['promptBg'], this.CB['prompt']], {
|
|
display: 'none'
|
|
});
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听错误
|
|
*/
|
|
timerErrorFun: function() {
|
|
var thisTemp = this;
|
|
this.errorSend = false;
|
|
var clearIntervalError = function(event) {
|
|
if(thisTemp.timerError != null) {
|
|
if(thisTemp.timerError.runing) {
|
|
thisTemp.timerError.stop();
|
|
}
|
|
thisTemp.timerError = null;
|
|
}
|
|
};
|
|
var errorFun = function(event) {
|
|
clearIntervalError();
|
|
thisTemp.error = true;
|
|
//提取错误播放地址
|
|
thisTemp.errorUrl = thisTemp.getVideoUrl();
|
|
//提取错误播放地址结束
|
|
if(!thisTemp.errorSend) {
|
|
thisTemp.errorSend = true;
|
|
thisTemp.sendJS('error');
|
|
}
|
|
if(thisTemp.showFace) {
|
|
thisTemp.css(thisTemp.CB['errorText'], 'display', 'block');
|
|
thisTemp.css(thisTemp.CB['pauseCenter'], 'display', 'none');
|
|
thisTemp.css(thisTemp.CB['loading'], 'display', 'none');
|
|
}
|
|
thisTemp.V.removeAttribute('poster');
|
|
thisTemp.resetPlayer();
|
|
};
|
|
var errorListenerFun = function(event) {
|
|
window.setTimeout(function() {
|
|
if(isNaN(thisTemp.V.duration)) {
|
|
errorFun(event);
|
|
}
|
|
}, 500);
|
|
|
|
};
|
|
if(!this.errorAdd) {
|
|
this.errorAdd = true;
|
|
this.addListenerInside('error', errorListenerFun, this.V);
|
|
}
|
|
clearIntervalError();
|
|
var timerErrorFun = function() {
|
|
if(thisTemp.V && parseInt(thisTemp.V.networkState) == 3) {
|
|
errorFun();
|
|
}
|
|
};
|
|
this.timerError = new this.timer(this.config['errorTime'], timerErrorFun);
|
|
//this.timerError.start();
|
|
},
|
|
/*
|
|
内部函数
|
|
构建判断全屏还是非全屏的判断
|
|
*/
|
|
judgeFullScreen: function() {
|
|
var thisTemp = this;
|
|
if(this.timerFull != null) {
|
|
if(this.timerFull.runing) {
|
|
this.timerFull.stop();
|
|
}
|
|
this.timerFull = null;
|
|
}
|
|
var fullFun = function() {
|
|
thisTemp.isFullScreen();
|
|
};
|
|
this.timerFull = new this.timer(20, fullFun);
|
|
},
|
|
/*
|
|
内部函数
|
|
判断是否是全屏
|
|
*/
|
|
isFullScreen: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var fullState = document.fullScreen || document.mozFullScreen || document.webkitIsFullScreen || document.msFullscreenElement;
|
|
if(fullState && !this.full) {
|
|
this.full = true;
|
|
this.sendJS('full', true);
|
|
this.elementCoordinate();
|
|
this.css(this.CB['full'], 'display', 'none');
|
|
this.css(this.CB['escFull'], 'display', 'block');
|
|
if(this.vars['live'] == 0) {
|
|
this.timeUpdateHandler();
|
|
}
|
|
this.PD.appendChild(this.CB['menu']);
|
|
}
|
|
if(!fullState && this.full) {
|
|
this.full = false;
|
|
this.sendJS('full', false);
|
|
this.elementCoordinate();
|
|
this.css(this.CB['full'], 'display', 'block');
|
|
this.css(this.CB['escFull'], 'display', 'none');
|
|
if(this.timerFull != null) {
|
|
if(this.timerFull.runing) {
|
|
this.timerFull.stop();
|
|
}
|
|
this.timerFull = null;
|
|
}
|
|
if(this.vars['live'] == 0) {
|
|
this.timeUpdateHandler();
|
|
}
|
|
this.body.appendChild(this.CB['menu']);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
构建右键内容及注册相关动作事件
|
|
*/
|
|
newMenu: function() {
|
|
var thisTemp = this;
|
|
var i = 0;
|
|
this.css(this.CB['menu'], {
|
|
backgroundColor: '#FFFFFF',
|
|
padding: '5px',
|
|
position: 'absolute',
|
|
left: '10px',
|
|
top: '20px',
|
|
display: 'none',
|
|
zIndex: '999',
|
|
color: '#A1A9BE',
|
|
boxShadow: '2px 2px 3px #AAAAAA'
|
|
});
|
|
var mArr = this.contextMenu;
|
|
var cMenu = this.ckplayerConfig['menu'];
|
|
if(cMenu['name']) {
|
|
if(cMenu['link']) {
|
|
mArr[0] = [cMenu['name'], 'link', cMenu['link']];
|
|
} else {
|
|
mArr[0] = [cMenu['name'], 'default'];
|
|
}
|
|
}
|
|
if(cMenu['version']) {
|
|
mArr[1] = [cMenu['version'], 'default', 'line'];
|
|
}
|
|
if(cMenu['more']) {
|
|
if(typeof(cMenu['more']) == 'object') {
|
|
if(cMenu['more'].length > 0) {
|
|
var moreArr = cMenu['more'];
|
|
for(i = 0; i < moreArr.length; i++) {
|
|
var mTemp = moreArr[i];
|
|
var arrTemp = [];
|
|
if(mTemp['name']) {
|
|
arrTemp.push(mTemp['name']);
|
|
}
|
|
if(mTemp['clickEvent'] && mTemp['clickEvent'] != 'none') {
|
|
var eveObj = this.clickEvent(mTemp['clickEvent']);
|
|
arrTemp.push(eveObj['type']);
|
|
if(eveObj['fun']) {
|
|
arrTemp.push(eveObj['fun']);
|
|
}
|
|
if(eveObj['link']) {
|
|
arrTemp.push(eveObj['link']);
|
|
}
|
|
if(eveObj['target']) {
|
|
arrTemp.push(' target="' + eveObj['target'] + '"');
|
|
}
|
|
}
|
|
if(mTemp['separatorBefore']) {
|
|
arrTemp.push('line');
|
|
}
|
|
mArr.push(arrTemp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var html = '';
|
|
for(i = 0; i < mArr.length; i++) {
|
|
var me = mArr[i];
|
|
switch(me[1]) {
|
|
case 'default':
|
|
html += '<p>' + me[0] + '</p>';
|
|
break;
|
|
case 'link':
|
|
html += '<p><a href="' + me[2] + '"' + me[3] + '>' + me[0] + '</a></p>';
|
|
break;
|
|
case 'javaScript':
|
|
html += '<p><a href="javascript:' + me[2] + '">' + me[0] + '</a></p>';
|
|
break;
|
|
case 'actionScript':
|
|
html += '<p><a href="javascript:' + this.vars['variable'] + me[2].replace('thisTemp', '') + '">' + me[0] + '</a></p>';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
this.CB['menu'].innerHTML = html;
|
|
var pArr = this.CB['menu'].childNodes;
|
|
for(i = 0; i < pArr.length; i++) {
|
|
this.css(pArr[i], {
|
|
height: '30px',
|
|
lineHeight: '30px',
|
|
margin: '0px',
|
|
fontFamily: this.fontFamily,
|
|
fontSize: '12px',
|
|
paddingLeft: '10px',
|
|
paddingRight: '30px'
|
|
});
|
|
if(mArr[i][mArr[i].length - 1] == 'line') {
|
|
this.css(pArr[i], 'borderBottom', '1px solid #e9e9e9');
|
|
}
|
|
var aArr = pArr[i].childNodes;
|
|
for(var n = 0; n < aArr.length; n++) {
|
|
if(aArr[n].localName == 'a') {
|
|
this.css(aArr[n], {
|
|
color: '#000000',
|
|
textDecoration: 'none'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
this.PD.oncontextmenu = function(event) {
|
|
var eve = event || window.event;
|
|
var client = thisTemp.client(event);
|
|
if(eve.button == 2) {
|
|
eve.returnvalue = false;
|
|
var x = client['x'] + thisTemp.pdCoor['x'] - 2;
|
|
var y = client['y'] + thisTemp.pdCoor['y'] - 2;
|
|
thisTemp.css(thisTemp.CB['menu'], {
|
|
display: 'block',
|
|
left: x + 'px',
|
|
top: y + 'px'
|
|
});
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
var setTimeOutPClose = function() {
|
|
if(setTimeOutP) {
|
|
window.clearTimeout(setTimeOutP);
|
|
setTimeOutP = null;
|
|
}
|
|
};
|
|
var setTimeOutP = null;
|
|
var mouseOut = function(event) {
|
|
setTimeOutPClose();
|
|
setTimeOutP = window.setTimeout(function(event) {
|
|
thisTemp.css(thisTemp.CB['menu'], 'display', 'none');
|
|
}, 500);
|
|
};
|
|
this.addListenerInside('mouseout', mouseOut, thisTemp.CB['menu']);
|
|
var mouseOver = function(event) {
|
|
setTimeOutPClose();
|
|
};
|
|
this.addListenerInside('mouseover', mouseOver, thisTemp.CB['menu']);
|
|
|
|
},
|
|
/*
|
|
内部函数
|
|
构建控制栏隐藏事件
|
|
*/
|
|
controlBarHide: function(hide) {
|
|
var thisTemp = this;
|
|
var client = {
|
|
x: 0,
|
|
y: 0
|
|
},
|
|
oldClient = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
var cShow = true,
|
|
force = false;
|
|
var oldCoor = [0, 0];
|
|
var controlBarShow = function(show) {
|
|
if(show && !cShow && thisTemp.controlBarIsShow) {
|
|
cShow = true;
|
|
thisTemp.sendJS('controlBar', true);
|
|
thisTemp.css(thisTemp.CB['controlBarBg'], 'display', 'block');
|
|
thisTemp.css(thisTemp.CB['controlBar'], 'display', 'block');
|
|
thisTemp.css(thisTemp.CB['timeProgressBg'], 'display', 'block');
|
|
thisTemp.css(thisTemp.CB['timeBoBg'], 'display', 'block');
|
|
thisTemp.changeVolume(thisTemp.volume);
|
|
thisTemp.changeLoad();
|
|
if(!thisTemp.timerBuffer) {
|
|
thisTemp.bufferEdHandler();
|
|
}
|
|
} else {
|
|
if(cShow) {
|
|
cShow = false;
|
|
var paused = thisTemp.getMetaDate()['paused'];
|
|
if(force) {
|
|
paused = false;
|
|
}
|
|
if(!paused) {
|
|
thisTemp.sendJS('controlBar', false);
|
|
thisTemp.css(thisTemp.CB['controlBarBg'], 'display', 'none');
|
|
thisTemp.css(thisTemp.CB['controlBar'], 'display', 'none');
|
|
thisTemp.css(thisTemp.CB['timeProgressBg'], 'display', 'none');
|
|
thisTemp.css(thisTemp.CB['timeBoBg'], 'display', 'none');
|
|
thisTemp.promptShow(false);
|
|
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var cbarFun = function(event) {
|
|
if(client['x'] == oldClient['x'] && client['y'] == oldClient['y']) {
|
|
var cdH = parseInt(thisTemp.CD.offsetHeight);
|
|
if((client['y'] < cdH - 50 || client['y'] > cdH - 2) && cShow) {
|
|
controlBarShow(false);
|
|
}
|
|
} else {
|
|
if(!cShow) {
|
|
controlBarShow(true);
|
|
}
|
|
}
|
|
oldClient = {
|
|
x: client['x'],
|
|
y: client['y']
|
|
}
|
|
};
|
|
this.timerCBar = new this.timer(2000, cbarFun);
|
|
var cdMove = function(event) {
|
|
var getClient = thisTemp.client(event);
|
|
client['x'] = getClient['x'];
|
|
client['y'] = getClient['y'];
|
|
if(!cShow) {
|
|
controlBarShow(true);
|
|
}
|
|
};
|
|
this.addListenerInside('mousemove', cdMove, thisTemp.CD);
|
|
this.addListenerInside('ended', cdMove);
|
|
this.addListenerInside('resize', cdMove, window);
|
|
if(hide === true) {
|
|
cShow = true;
|
|
force = true;
|
|
controlBarShow(false);
|
|
}
|
|
if(hide === false) {
|
|
cShow = false;
|
|
force = true;
|
|
controlBarShow(true);
|
|
}
|
|
},
|
|
|
|
/*
|
|
内部函数
|
|
注册键盘按键事件
|
|
*/
|
|
keypress: function() {
|
|
var thisTemp = this;
|
|
var keyDown = function(eve) {
|
|
var keycode = eve.keyCode || eve.which;
|
|
switch(keycode) {
|
|
case 32:
|
|
thisTemp.playOrPause();
|
|
break;
|
|
case 37:
|
|
thisTemp.fastBack();
|
|
break;
|
|
case 39:
|
|
thisTemp.fastNext();
|
|
break;
|
|
case 38:
|
|
now = thisTemp.volume + thisTemp.ckplayerConfig['config']['volumeJump'];
|
|
thisTemp.changeVolume(now > 1 ? 1 : now);
|
|
break;
|
|
case 40:
|
|
now = thisTemp.volume - thisTemp.ckplayerConfig['config']['volumeJump'];
|
|
thisTemp.changeVolume(now < 0 ? 0 : now);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
this.addListenerInside('keydown', keyDown, window || document);
|
|
},
|
|
/*
|
|
内部函数
|
|
注册倍速相关
|
|
*/
|
|
playbackRate: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var thisTemp = this;
|
|
var vArr = this.playbackRateArr;
|
|
var html = '';
|
|
var nowD = ''; //当前的清晰度
|
|
var i = 0;
|
|
if(!nowD) {
|
|
nowD = vArr[this.playbackRateDefault][1];
|
|
}
|
|
if(vArr.length > 1) {
|
|
var zlen = 0;
|
|
for(i = 0; i < vArr.length; i++) {
|
|
html = '<p>' + vArr[i][1] + '</p>' + html;
|
|
var dlen = this.getStringLen(vArr[i][1]);
|
|
if(dlen > zlen) {
|
|
zlen = dlen;
|
|
}
|
|
}
|
|
if(html) {
|
|
html += '<p>' + nowD + '</p>';
|
|
}
|
|
this.CB['playbackrate'].innerHTML = nowD;
|
|
this.CB['playbackrateP'].innerHTML = html;
|
|
this.css([this.CB['playbackrate'], this.CB['playbackrateLine']], 'display', 'block');
|
|
var pArr = this.CB['playbackrateP'].childNodes;
|
|
for(var i = 0; i < pArr.length; i++) {
|
|
var fontColor = '#FFFFFF';
|
|
if(pArr[i].innerHTML == nowD) {
|
|
fontColor = '#0782F5';
|
|
}
|
|
this.css(pArr[i], {
|
|
color: fontColor,
|
|
margin: '0px',
|
|
padding: '0px',
|
|
fontSize: '14px'
|
|
});
|
|
if(i < pArr.length - 1) {
|
|
this.css(pArr[i], 'borderBottom', '1px solid #282828')
|
|
}
|
|
var defClick = function(event) {
|
|
if(nowD != this.innerHTML) {
|
|
thisTemp.css(thisTemp.CB['playbackrateP'], 'display', 'none');
|
|
thisTemp.newPlaybackrate(this.innerHTML);
|
|
thisTemp.sendJS('clickEvent', 'actionScript->newPlaybackrate');
|
|
}
|
|
};
|
|
this.addListenerInside('click', defClick, pArr[i]);
|
|
|
|
}
|
|
var pW = (zlen * 10) + 20;
|
|
this.css(this.CB['playbackrateP'], {
|
|
width: pW + 'px'
|
|
});
|
|
this.css(this.CB['playbackrate'], {
|
|
width: pW + 'px'
|
|
});
|
|
this.buttonWidth['playbackrate'] = this.CB['playbackrate'].offsetWidth;
|
|
} else {
|
|
this.CB['playbackrate'].innerHTML = '';
|
|
this.CB['playbackrateP'].innerHTML = '';
|
|
this.css([this.CB['playbackrate'], this.CB['playbackrateLine']], 'display', 'none');
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
注册切换倍速播放相关事件
|
|
*/
|
|
addPlaybackrate: function() {
|
|
var thisTemp = this;
|
|
var setTimeOutP = null;
|
|
var defClick = function(event) {
|
|
thisTemp.css(thisTemp.CB['playbackrateP'], {
|
|
left: thisTemp.getCoor(thisTemp.CB['playbackrate'])['x'] + 'px',
|
|
display: 'block'
|
|
});
|
|
};
|
|
this.addListenerInside('click', defClick, this.CB['playbackrate']);
|
|
var defMouseOut = function(event) {
|
|
if(setTimeOutP) {
|
|
window.clearTimeout(setTimeOutP);
|
|
setTimeOutP = null;
|
|
}
|
|
setTimeOutP = window.setTimeout(function(event) {
|
|
thisTemp.css(thisTemp.CB['playbackrateP'], 'display', 'none');
|
|
}, 500);
|
|
};
|
|
this.addListenerInside('mouseout', defMouseOut, thisTemp.CB['playbackrateP']);
|
|
var defMouseOver = function(event) {
|
|
if(setTimeOutP) {
|
|
window.clearTimeout(setTimeOutP);
|
|
setTimeOutP = null;
|
|
}
|
|
};
|
|
this.addListenerInside('mouseover', defMouseOver, thisTemp.CB['playbackrateP']);
|
|
},
|
|
/*
|
|
内部函数
|
|
切换倍速后发生的动作
|
|
*/
|
|
newPlaybackrate: function(title) {
|
|
var vArr = this.playbackRateArr;
|
|
var nVArr = [];
|
|
var i = 0;
|
|
for(i = 0; i < vArr.length; i++) {
|
|
var v = vArr[i];
|
|
if(v[1] == title) {
|
|
this.playbackRateDefault = i;
|
|
this.V.playbackRate = v[0];
|
|
if(this.showFace) {
|
|
this.CB['playbackrate'].innerHTML = v[1];
|
|
this.playbackRate();
|
|
}
|
|
this.sendJS('playbackRate', v);
|
|
}
|
|
}
|
|
},
|
|
|
|
/*
|
|
内部函数
|
|
构建清晰度按钮及切换事件(Click事件)
|
|
*/
|
|
definition: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var thisTemp = this;
|
|
var vArr = this.VA;
|
|
var dArr = [];
|
|
var html = '';
|
|
var nowD = ''; //当前的清晰度
|
|
var i = 0;
|
|
for(i = 0; i < vArr.length; i++) {
|
|
var d = vArr[i][2];
|
|
if(dArr.indexOf(d) == -1) {
|
|
dArr.push(d);
|
|
}
|
|
if(this.V) {
|
|
if(vArr[i][0] == this.V.currentSrc) {
|
|
nowD = d;
|
|
}
|
|
}
|
|
}
|
|
if(!nowD) {
|
|
nowD = dArr[0];
|
|
}
|
|
if(dArr.length > 1) {
|
|
var zlen = 0;
|
|
for(i = dArr.length - 1; i > -1; i--) {
|
|
html = '<p>' + dArr[i] + '</p>' + html;
|
|
var dlen = this.getStringLen(dArr[i]);
|
|
if(dlen > zlen) {
|
|
zlen = dlen;
|
|
}
|
|
}
|
|
if(html) {
|
|
html += '<p>' + nowD + '</p>';
|
|
}
|
|
this.CB['definition'].innerHTML = nowD;
|
|
this.CB['definitionP'].innerHTML = html;
|
|
this.css([this.CB['definition'], this.CB['definitionLine']], 'display', 'block');
|
|
var pArr = this.CB['definitionP'].childNodes;
|
|
for(var i = 0; i < pArr.length; i++) {
|
|
var fontColor = '#FFFFFF';
|
|
if(pArr[i].innerHTML == nowD) {
|
|
fontColor = '#0782F5';
|
|
}
|
|
this.css(pArr[i], {
|
|
color: fontColor,
|
|
margin: '0px',
|
|
padding: '0px',
|
|
fontSize: '14px'
|
|
});
|
|
if(i < pArr.length - 1) {
|
|
this.css(pArr[i], 'borderBottom', '1px solid #282828')
|
|
}
|
|
var defClick = function() {
|
|
if(nowD != this.innerHTML) {
|
|
thisTemp.css(thisTemp.CB['definitionP'], 'display', 'none');
|
|
thisTemp.newDefinition(this.innerHTML);
|
|
}
|
|
};
|
|
this.addListenerInside('click', defClick, pArr[i]);
|
|
|
|
}
|
|
var pW = (zlen * 10) + 20;
|
|
this.css(this.CB['definitionP'], {
|
|
width: pW + 'px'
|
|
});
|
|
this.css(this.CB['definition'], {
|
|
width: pW + 'px'
|
|
});
|
|
this.buttonWidth['definition'] = this.CB['definition'].offsetWidth;
|
|
} else {
|
|
this.CB['definition'].innerHTML = '';
|
|
this.CB['definitionP'].innerHTML = '';
|
|
this.css([this.CB['definition'], this.CB['definitionLine']], 'display', 'none');
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
注册清晰度相关事件
|
|
*/
|
|
addDefListener: function() {
|
|
var thisTemp = this;
|
|
var setTimeOutP = null;
|
|
var defClick = function(event) {
|
|
thisTemp.css(thisTemp.CB['definitionP'], {
|
|
left: thisTemp.getCoor(thisTemp.CB['definition'])['x'] + 'px',
|
|
display: 'block'
|
|
});
|
|
};
|
|
this.addListenerInside('click', defClick, this.CB['definition']);
|
|
var defMouseOut = function(event) {
|
|
if(setTimeOutP) {
|
|
window.clearTimeout(setTimeOutP);
|
|
setTimeOutP = null;
|
|
}
|
|
setTimeOutP = window.setTimeout(function(event) {
|
|
thisTemp.css(thisTemp.CB['definitionP'], 'display', 'none');
|
|
}, 500);
|
|
};
|
|
this.addListenerInside('mouseout', defMouseOut, thisTemp.CB['definitionP']);
|
|
var defMouseOver = function(event) {
|
|
if(setTimeOutP) {
|
|
window.clearTimeout(setTimeOutP);
|
|
setTimeOutP = null;
|
|
}
|
|
};
|
|
this.addListenerInside('mouseover', defMouseOver, thisTemp.CB['definitionP']);
|
|
},
|
|
/*
|
|
内部函数
|
|
切换清晰度后发生的动作
|
|
*/
|
|
newDefinition: function(title) {
|
|
var vArr = this.VA;
|
|
var nVArr = [];
|
|
var i = 0;
|
|
for(i = 0; i < vArr.length; i++) {
|
|
var v = vArr[i];
|
|
if(v[2] == title) {
|
|
nVArr.push(v);
|
|
this.sendJS('definitionChange', i + '');
|
|
}
|
|
}
|
|
if(nVArr.length < 1) {
|
|
return;
|
|
}
|
|
if(this.V != null && this.needSeek == 0) {
|
|
this.needSeek = this.V.currentTime;
|
|
}
|
|
if(this.getFileExt(nVArr[0][0]) != '.m3u8') {
|
|
this.isM3u8 = false;
|
|
}
|
|
if(!this.isM3u8) {
|
|
if(nVArr.length == 1) {
|
|
this.V.innerHTML = '';
|
|
this.V.src = nVArr[0][0];
|
|
} else {
|
|
var source = '';
|
|
nVArr = this.arrSort(nVArr);
|
|
for(i = 0; i < nVArr.length; i++) {
|
|
var type = '';
|
|
var va = nVArr[i];
|
|
if(va[1]) {
|
|
type = ' type="' + va[1] + '"';
|
|
}
|
|
source += '<source src="' + va[0] + '"' + type + '>';
|
|
}
|
|
this.V.removeAttribute('src');
|
|
this.V.innerHTML = source;
|
|
}
|
|
} else {
|
|
this.embedHls(vArr[0][0], this.vars['autoplay']);
|
|
}
|
|
this.V.autoplay = 'autoplay';
|
|
this.V.load();
|
|
this.timerErrorFun();
|
|
},
|
|
/*
|
|
内置函数
|
|
播放hls
|
|
*/
|
|
embedHls: function(url, autoplay) {
|
|
var thisTemp = this;
|
|
if(Hls.isSupported()) {
|
|
var hls = new Hls();
|
|
hls.loadSource(url);
|
|
hls.attachMedia(this.V);
|
|
hls.on(Hls.Events.MANIFEST_PARSED, function() {
|
|
thisTemp.playerLoad();
|
|
if(autoplay) {
|
|
thisTemp.videoPlay();
|
|
}
|
|
});
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
构建提示点
|
|
*/
|
|
prompt: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var thisTemp = this;
|
|
var prompt = this.vars['promptSpot'];
|
|
if(prompt == null || this.promptArr.length > 0) {
|
|
return;
|
|
}
|
|
var showPrompt = function(event) {
|
|
if(thisTemp.promptElement == null) {
|
|
var random2 = 'prompte' + thisTemp.randomString(5);
|
|
var ele2 = document.createElement('div');
|
|
ele2.className = random2;
|
|
thisTemp.PD.appendChild(ele2);
|
|
thisTemp.promptElement = thisTemp.getByElement(random2);
|
|
thisTemp.css(thisTemp.promptElement, {
|
|
overflowX: 'hidden',
|
|
lineHeight: '22px',
|
|
fontSize: '14px',
|
|
color: '#FFFFFF',
|
|
position: 'absolute',
|
|
display: 'block',
|
|
zIndex: '90'
|
|
});
|
|
}
|
|
var pcon = thisTemp.getPromptTest();
|
|
var pW = pcon['pW'],
|
|
pT = pcon['pT'],
|
|
pL = parseInt(thisTemp.css(this, 'left')) - parseInt(pW * 0.5);
|
|
if(pcon['pL'] > 10) {
|
|
pL = pcon['pL'];
|
|
}
|
|
if(pL < 0) {
|
|
pL = 0;
|
|
}
|
|
thisTemp.css(thisTemp.promptElement, {
|
|
width: pW + 'px',
|
|
left: (-pW - 10) + 'px',
|
|
display: 'block'
|
|
});
|
|
thisTemp.promptElement.innerHTML = thisTemp.getDataset(this, 'words');
|
|
thisTemp.css(thisTemp.promptElement, {
|
|
left: pL + 'px',
|
|
top: (pT - thisTemp.promptElement.offsetHeight - 10) + 'px'
|
|
});
|
|
};
|
|
var hidePrompt = function(event) {
|
|
if(thisTemp.promptElement != null) {
|
|
thisTemp.css(thisTemp.promptElement, {
|
|
display: 'none'
|
|
});
|
|
}
|
|
};
|
|
var i = 0;
|
|
for(i = 0; i < prompt.length; i++) {
|
|
var pr = prompt[i];
|
|
var words = pr['words'];
|
|
var time = pr['time'];
|
|
var random = 'prompt' + this.randomString(5);
|
|
var ele = document.createElement('div');
|
|
ele.className = random;
|
|
this.CB['timeBoBg'].appendChild(ele);
|
|
var div = this.getByElement(random);
|
|
div.setAttribute('data-time', time);
|
|
div.setAttribute('data-words', words);
|
|
this.css(div, {
|
|
width: '6px',
|
|
height: '6px',
|
|
backgroundColor: '#FFFFFF',
|
|
position: 'absolute',
|
|
top: '4px',
|
|
left: '-100px',
|
|
display: 'none',
|
|
zIndex: '1',
|
|
borderRadius: '6px'
|
|
});
|
|
|
|
this.addListenerInside('mouseover', showPrompt, div);
|
|
this.addListenerInside('mouseout', hidePrompt, div);
|
|
this.promptArr.push(div);
|
|
}
|
|
this.changePrompt();
|
|
},
|
|
/*
|
|
内部函数
|
|
计算提示文本的位置
|
|
*/
|
|
getPromptTest: function() {
|
|
var pW = this.previewWidth,
|
|
pT = this.getCoor(this.CB['timeButton'])['y'],
|
|
pL = 0;
|
|
if(this.previewTop != null) {
|
|
pT -= parseInt(this.css(this.previewTop, 'height'));
|
|
pL = parseInt(this.css(this.previewTop, 'left'));
|
|
} else {
|
|
pT -= 35;
|
|
}
|
|
pL += 2;
|
|
if(pL < 0) {
|
|
pL = 0;
|
|
}
|
|
if(pL > this.PD.offsetWidth - pW) {
|
|
pL = this.PD.offsetWidth - pW;
|
|
}
|
|
return {
|
|
pW: pW,
|
|
pT: pT,
|
|
pL: pL
|
|
};
|
|
},
|
|
/*
|
|
内部函数
|
|
删除提示点
|
|
*/
|
|
deletePrompt: function() {
|
|
var arr = this.promptArr;
|
|
if(arr.length > 0) {
|
|
for(var i = 0; i < arr.length; i++) {
|
|
if(arr[i]) {
|
|
this.deleteChild(arr[i]);
|
|
}
|
|
}
|
|
}
|
|
this.promptArr = [];
|
|
},
|
|
/*
|
|
内部函数
|
|
计算提示点坐标
|
|
*/
|
|
changePrompt: function() {
|
|
if(this.promptArr.length == 0) {
|
|
return;
|
|
}
|
|
var arr = this.promptArr;
|
|
var duration = this.getMetaDate()['duration'];
|
|
var bw = this.CB['timeBoBg'].offsetWidth;
|
|
for(var i = 0; i < arr.length; i++) {
|
|
var time = parseInt(this.getDataset(arr[i], 'time'));
|
|
var left = parseInt(time * bw / duration) - parseInt(arr[i].offsetWidth * 0.5);
|
|
if(left < 0) {
|
|
left = 0;
|
|
}
|
|
if(left > bw - parseInt(arr[i].offsetWidth * 0.5)) {
|
|
left = bw - parseInt(arr[i].offsetWidth * 0.5);
|
|
}
|
|
this.css(arr[i], {
|
|
left: left + 'px',
|
|
display: 'block'
|
|
});
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
构建预览图片效果
|
|
*/
|
|
preview: function(obj) {
|
|
var thisTemp = this;
|
|
var preview = {
|
|
file: null,
|
|
scale: 0
|
|
};
|
|
preview = this.standardization(preview, this.vars['preview']);
|
|
if(preview['file'] == null || preview['scale'] <= 0) {
|
|
return;
|
|
}
|
|
var srcArr = preview['file'];
|
|
if(this.previewStart == 0) { //如果还没有构建，则先进行构建
|
|
this.previewStart = 1;
|
|
if(srcArr.length > 0) {
|
|
var i = 0;
|
|
var imgW = 0,
|
|
imgH = 0;
|
|
var random = thisTemp.randomString(10);
|
|
var loadNum = 0;
|
|
var loadImg = function(i) {
|
|
srcArr[i] = thisTemp.getNewUrl(srcArr[i]);
|
|
var n = 0;
|
|
var img = new Image();
|
|
img.src = srcArr[i];
|
|
img.className = random + i;
|
|
img.onload = function(event) {
|
|
loadNum++;
|
|
if(thisTemp.previewDiv == null) { //如果没有建立DIV，则建
|
|
imgW = img.width;
|
|
imgH = img.height;
|
|
thisTemp.previewWidth = parseInt(imgW * 0.1);
|
|
var ele = document.createElement('div');
|
|
ele.className = random;
|
|
thisTemp.PD.appendChild(ele);
|
|
thisTemp.previewDiv = thisTemp.getByElement(random);
|
|
var eleTop = (obj['y'] - parseInt(imgH * 0.1) + 2);
|
|
thisTemp.css(thisTemp.previewDiv, {
|
|
width: srcArr.length * imgW * 10 + 'px',
|
|
height: parseInt(imgH * 0.1) + 'px',
|
|
backgroundColor: '#000000',
|
|
position: 'absolute',
|
|
left: '0px',
|
|
top: eleTop + 'px',
|
|
display: 'none',
|
|
zIndex: '80'
|
|
});
|
|
ele.setAttribute('data-x', '0');
|
|
ele.setAttribute('data-y', eleTop);
|
|
var ele2 = document.createElement('div');
|
|
ele2.className = random + 'd2';
|
|
thisTemp.PD.appendChild(ele2);
|
|
thisTemp.previewTop = thisTemp.getByElement(ele2.className);
|
|
thisTemp.css(thisTemp.previewTop, {
|
|
width: parseInt(imgW * 0.1) + 'px',
|
|
height: parseInt(imgH * 0.1) + 'px',
|
|
position: 'absolute',
|
|
border: '5px solid ' + thisTemp.css(thisTemp.CB['timeProgress'], 'backgroundColor'),
|
|
left: '0px',
|
|
top: (obj['y'] - parseInt(imgH * 0.1) + 2) + 'px',
|
|
display: 'none',
|
|
zIndex: '81'
|
|
});
|
|
var html = '';
|
|
for(n = 0; n < srcArr.length; n++) {
|
|
html += thisTemp.newCanvas(random + n, imgW * 10, parseInt(imgH * 0.1))
|
|
}
|
|
thisTemp.previewDiv.innerHTML = html;
|
|
}
|
|
thisTemp.previewDiv.appendChild(img);
|
|
var cimg = thisTemp.getByElement(img.className);
|
|
var canvas = thisTemp.getByElement(img.className + '-canvas');
|
|
var context = canvas.getContext('2d');
|
|
var sx = 0,
|
|
sy = 0,
|
|
x = 0,
|
|
h = parseInt(imgH * 0.1);
|
|
for(n = 0; n < 100; n++) {
|
|
x = parseInt(n * imgW * 0.1);
|
|
context.drawImage(cimg, sx, sy, parseInt(imgW * 0.1), h, x, 0, parseInt(imgW * 0.1), h);
|
|
sx += parseInt(imgW * 0.1);
|
|
if(sx >= imgW) {
|
|
sx = 0;
|
|
sy += h;
|
|
}
|
|
thisTemp.css(cimg, 'display', 'none');
|
|
}
|
|
if(loadNum == srcArr.length) {
|
|
thisTemp.previewStart = 2;
|
|
} else {
|
|
i++;
|
|
loadImg(i);
|
|
}
|
|
};
|
|
};
|
|
}
|
|
loadImg(i);
|
|
return;
|
|
}
|
|
if(this.previewStart == 2) {
|
|
var isTween = true;
|
|
var nowNum = parseInt(obj['time'] / this.vars['preview']['scale']);
|
|
var numTotal = parseInt(thisTemp.getMetaDate()['duration'] / this.vars['preview']['scale']);
|
|
if(thisTemp.css(thisTemp.previewDiv, 'display') == 'none') {
|
|
isTween = false;
|
|
}
|
|
thisTemp.css(thisTemp.previewDiv, 'display', 'block');
|
|
var imgWidth = thisTemp.previewDiv.offsetWidth * 0.01 / srcArr.length;
|
|
var left = (imgWidth * nowNum) - obj['x'] + parseInt(imgWidth * 0.5),
|
|
top = obj['y'] - thisTemp.previewDiv.offsetHeight;
|
|
thisTemp.css(thisTemp.previewDiv, 'top', top + 2 + 'px');
|
|
var topLeft = obj['x'] - parseInt(imgWidth * 0.5);
|
|
var timepieces = 0;
|
|
if(topLeft < 0) {
|
|
topLeft = 0;
|
|
timepieces = obj['x'] - topLeft - imgWidth * 0.5;
|
|
}
|
|
if(topLeft > thisTemp.PD.offsetWidth - imgWidth) {
|
|
topLeft = thisTemp.PD.offsetWidth - imgWidth;
|
|
timepieces = obj['x'] - topLeft - imgWidth * 0.5;
|
|
}
|
|
if(left < 0) {
|
|
left = 0;
|
|
}
|
|
if(left > numTotal * imgWidth - thisTemp.PD.offsetWidth) {
|
|
left = numTotal * imgWidth - thisTemp.PD.offsetWidth;
|
|
}
|
|
thisTemp.css(thisTemp.previewTop, {
|
|
left: topLeft + 'px',
|
|
top: top + 2 + 'px',
|
|
display: 'block'
|
|
});
|
|
if(thisTemp.previewTop.offsetHeight > thisTemp.previewDiv.offsetHeight) {
|
|
thisTemp.css(thisTemp.previewTop, {
|
|
height: thisTemp.previewDiv.offsetHeight - (thisTemp.previewTop.offsetHeight - thisTemp.previewDiv.offsetHeight) + 'px'
|
|
});
|
|
}
|
|
if(this.previewTween != null) {
|
|
this.animatePause(this.previewTween);
|
|
this.previewTween = null
|
|
}
|
|
var nowLeft = parseInt(thisTemp.css(thisTemp.previewDiv, 'left'));
|
|
var leftC = nowLeft + left;
|
|
if(nowLeft == -(left + timepieces)) {
|
|
return;
|
|
}
|
|
if(isTween) {
|
|
var obj = {
|
|
element: thisTemp.previewDiv,
|
|
start: null,
|
|
end: -(left + timepieces),
|
|
speed: 0.3
|
|
};
|
|
this.previewTween = this.animate(obj);
|
|
} else {
|
|
thisTemp.css(thisTemp.previewDiv, 'left', -(left + timepieces) + 'px')
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
删除预览图节点
|
|
*/
|
|
deletePreview: function() {
|
|
if(this.previewDiv != null) {
|
|
this.deleteChild(this.previewDiv);
|
|
this.previewDiv = null;
|
|
this.previewStart = 0;
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
修改视频地址，属性
|
|
*/
|
|
changeVideo: function() {
|
|
if(!this.html5Video) {
|
|
this.getVarsObject();
|
|
this.V.newVideo(this.vars);
|
|
return;
|
|
}
|
|
var vArr = this.VA;
|
|
var v = this.vars;
|
|
var i = 0;
|
|
if(vArr.length < 1) {
|
|
return;
|
|
}
|
|
if(this.V != null && this.needSeek == 0) {
|
|
this.needSeek = this.V.currentTime;
|
|
}
|
|
if(v['poster']) {
|
|
this.V.poster = v['poster'];
|
|
} else {
|
|
this.V.removeAttribute('poster');
|
|
}
|
|
if(v['loop']) {
|
|
this.V.loop = 'loop';
|
|
} else {
|
|
this.V.removeAttribute('loop');
|
|
}
|
|
if(v['seek'] > 0) {
|
|
this.needSeek = v['seek'];
|
|
} else {
|
|
this.needSeek = 0;
|
|
}
|
|
if(this.getFileExt(vArr[0][0]) != '.m3u8') {
|
|
this.isM3u8 = false;
|
|
}
|
|
if(!this.isM3u8) {
|
|
if(vArr.length == 1) {
|
|
this.V.innerHTML = '';
|
|
this.V.src = vArr[0][0];
|
|
} else {
|
|
var source = '';
|
|
vArr = this.arrSort(vArr);
|
|
for(i = 0; i < vArr.length; i++) {
|
|
var type = '';
|
|
var va = vArr[i];
|
|
if(va[1]) {
|
|
type = ' type="' + va[1] + '"';
|
|
}
|
|
source += '<source src="' + va[0] + '"' + type + '>';
|
|
}
|
|
this.V.removeAttribute('src');
|
|
this.V.innerHTML = source;
|
|
}
|
|
//分析视频地址结束
|
|
if(v['autoplay']) {
|
|
this.V.autoplay = 'autoplay';
|
|
} else {
|
|
this.V.removeAttribute('autoplay');
|
|
}
|
|
this.V.load();
|
|
} else {
|
|
this.embedHls(vArr[0][0], v['autoplay']);
|
|
}
|
|
if(!this.isUndefined(v['volume'])) {
|
|
this.changeVolume(v['volume']);
|
|
}
|
|
this.resetPlayer(); //重置界面元素
|
|
this.timerErrorFun();
|
|
//如果存在字幕则加载
|
|
if(this.vars['cktrack']) {
|
|
this.loadTrack();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
调整中间暂停按钮,缓冲loading，错误提示文本框的位置
|
|
*/
|
|
elementCoordinate: function() {
|
|
this.pdCoor = this.getXY(this.PD);
|
|
this.css(this.CB['pauseCenter'], {
|
|
left: parseInt((this.PD.offsetWidth - 80) * 0.5) + 'px',
|
|
top: parseInt((this.PD.offsetHeight - 80) * 0.5) + 'px'
|
|
});
|
|
this.css(this.CB['loading'], {
|
|
left: parseInt((this.PD.offsetWidth - 60) * 0.5) + 'px',
|
|
top: parseInt((this.PD.offsetHeight - 60) * 0.5) + 'px'
|
|
});
|
|
this.css(this.CB['errorText'], {
|
|
left: parseInt((this.PD.offsetWidth - 120) * 0.5) + 'px',
|
|
top: parseInt((this.PD.offsetHeight - 30) * 0.5) + 'px'
|
|
});
|
|
this.css(this.CB['logo'], {
|
|
left: parseInt(this.PD.offsetWidth - this.CB['logo'].offsetWidth - 20) + 'px',
|
|
top: '20px'
|
|
});
|
|
this.checkBarWidth();
|
|
},
|
|
/*
|
|
内部函数
|
|
当播放器尺寸变化时，显示和隐藏相关节点
|
|
*/
|
|
checkBarWidth: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var controlBarW = this.CB['controlBar'].offsetWidth;
|
|
var ele = [];
|
|
ele.push([
|
|
[this.CB['full'], this.CB['escFull'], this.CB['fullLine']], this.buttonWidth['full'] + 2, 'full'
|
|
]);
|
|
if(this.vars['front'] != '') {
|
|
ele.push([
|
|
[this.CB['front'], this.CB['frontLine']], this.buttonWidth['front'] + 2
|
|
]);
|
|
}
|
|
if(this.vars['next'] != '') {
|
|
ele.push([
|
|
[this.CB['next'], this.CB['nextLine']], this.buttonWidth['next'] + 2
|
|
]);
|
|
}
|
|
if(this.CB['definition'].innerHTML != '') {
|
|
ele.push([
|
|
[this.CB['definition'], this.CB['definitionLine']], this.buttonWidth['definition'] + 2
|
|
]);
|
|
}
|
|
ele.push([
|
|
[this.CB['volume']], this.buttonWidth['volume']
|
|
]);
|
|
ele.push([
|
|
[this.CB['mute'], this.CB['escMute'], this.CB['muteLine']], this.buttonWidth['mute'] + 2, 'mute'
|
|
]);
|
|
ele.push([
|
|
[this.CB['timeText']], this.buttonWidth['timeText']
|
|
]);
|
|
ele.push([
|
|
[this.CB['play'], this.CB['pause'], this.CB['playLine']], this.buttonWidth['play'] + 2, 'play'
|
|
]);
|
|
|
|
var i = 0;
|
|
var len = 0;
|
|
var isc = true;
|
|
//计算所有要显示的节点的总宽度
|
|
for(var i = 0; i < ele.length; i++) {
|
|
var nlen = ele[i][1];
|
|
if(nlen > 2) {
|
|
len += nlen;
|
|
} else {
|
|
isc = false;
|
|
}
|
|
}
|
|
if(isc) {
|
|
this.buttonLen = len;
|
|
this.buttonArr = ele;
|
|
}
|
|
len = this.buttonLen;
|
|
ele = this.buttonArr;
|
|
for(var i = 0; i < ele.length; i++) {
|
|
if(len > controlBarW) {
|
|
len -= ele[i][1];
|
|
this.css(ele[i][0], 'display', 'none');
|
|
} else {
|
|
this.css(ele[i][0], 'display', 'block');
|
|
if(ele[i].length == 3) {
|
|
var name = ele[i][2];
|
|
switch(name) {
|
|
case 'mute':
|
|
if(this.volume == 0) {
|
|
this.css(this.CB['mute'], 'display', 'none');
|
|
} else {
|
|
this.css(this.CB['escMute'], 'display', 'none');
|
|
}
|
|
break;
|
|
case 'play':
|
|
this.playShow(this.V.paused ? false : true);
|
|
break;
|
|
case 'full':
|
|
if(this.full) {
|
|
this.css(this.CB['full'], 'display', 'none');
|
|
} else {
|
|
this.css(this.CB['escFull'], 'display', 'none');
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
初始化暂停或播放按钮
|
|
*/
|
|
initPlayPause: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
if(this.vars['autoplay']) {
|
|
this.css([this.CB['play'], this.CB['pauseCenter']], 'display', 'none');
|
|
this.css(this.CB['pause'], 'display', 'block');
|
|
} else {
|
|
this.css(this.CB['play'], 'display', 'block');
|
|
if(this.css(this.CB['errorText'], 'display') == 'none') {
|
|
this.css(this.CB['pauseCenter'], 'display', 'block');
|
|
}
|
|
this.css(this.CB['pause'], 'display', 'none');
|
|
}
|
|
},
|
|
|
|
/*
|
|
下面为监听事件
|
|
内部函数
|
|
监听元数据已加载
|
|
*/
|
|
loadedHandler: function() {
|
|
this.loaded = true;
|
|
if(this.vars['loaded'] != '') {
|
|
try {
|
|
eval(this.vars['loaded'] + '()');
|
|
} catch(event) {
|
|
this.log(event);
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听播放
|
|
*/
|
|
playingHandler: function() {
|
|
this.playShow(true);
|
|
if(this.needSeek > 0) {
|
|
this.videoSeek(this.needSeek);
|
|
this.needSeek = 0;
|
|
}
|
|
if(this.animatePauseArray.length > 0) {
|
|
this.animateResume('pause');
|
|
}
|
|
if(this.playerType == 'html5video' && this.V != null && this.config['videoDrawImage']) {
|
|
this.sendVCanvas();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
使用画布附加视频
|
|
*/
|
|
sendVCanvas: function() {
|
|
if(this.timerVCanvas == null) {
|
|
this.css(this.V, 'display', 'none');
|
|
this.css(this.MD, 'display', 'block');
|
|
var thisTemp = this;
|
|
var videoCanvas = function() {
|
|
if(thisTemp.MDCX.width != thisTemp.PD.offsetWidth) {
|
|
thisTemp.MDC.width = thisTemp.PD.offsetWidth;
|
|
}
|
|
if(thisTemp.MDCX.height != thisTemp.PD.offsetHeight) {
|
|
thisTemp.MDC.height = thisTemp.PD.offsetHeight;
|
|
}
|
|
thisTemp.MDCX.clearRect(0, 0, thisTemp.MDCX.width, thisTemp.MDCX.height);
|
|
var coor = thisTemp.getProportionCoor(thisTemp.PD.offsetWidth, thisTemp.PD.offsetHeight, thisTemp.V.videoWidth, thisTemp.V.videoHeight);
|
|
thisTemp.MDCX.drawImage(thisTemp.V, 0, 0, thisTemp.V.videoWidth, thisTemp.V.videoHeight, coor['x'], coor['y'], coor['width'], coor['height']);
|
|
};
|
|
this.timerVCanvas = new this.timer(0, videoCanvas);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听暂停
|
|
*/
|
|
pauseHandler: function() {
|
|
this.playShow(false);
|
|
if(this.animatePauseArray.length > 0) {
|
|
this.animatePause('pause');
|
|
}
|
|
if(this.playerType == 'html5video' && this.V != null && this.config['videoDrawImage']) {
|
|
this.stopVCanvas();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
停止画布
|
|
*/
|
|
stopVCanvas: function() {
|
|
if(this.timerVCanvas != null) {
|
|
this.css(this.V, 'display', 'block');
|
|
this.css(this.MD, 'display', 'none');
|
|
if(this.timerVCanvas.runing) {
|
|
this.timerVCanvas.stop();
|
|
}
|
|
this.timerVCanvas = null;
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
根据当前播放还是暂停确认图标显示
|
|
*/
|
|
playShow: function(b) {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
if(b) {
|
|
this.css(this.CB['play'], 'display', 'none');
|
|
this.css(this.CB['pauseCenter'], 'display', 'none');
|
|
this.css(this.CB['pause'], 'display', 'block');
|
|
} else {
|
|
this.css(this.CB['play'], 'display', 'block');
|
|
if(this.css(this.CB['errorText'], 'display') == 'none') {
|
|
this.css(this.CB['pauseCenter'], 'display', 'block');
|
|
} else {
|
|
this.css(this.CB['pauseCenter'], 'display', 'none');
|
|
}
|
|
this.css(this.CB['pause'], 'display', 'none');
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听seek结束
|
|
*/
|
|
seekedHandler: function() {
|
|
this.resetTrack();
|
|
this.isTimeButtonMove = true;
|
|
if(this.V.paused) {
|
|
this.videoPlay();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听播放结束
|
|
*/
|
|
endedHandler: function() {
|
|
if(!this.vars['loop']) {
|
|
this.videoPause();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听音量改变
|
|
*/
|
|
volumechangeHandler: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
try {
|
|
if(this.V.volume > 0) {
|
|
this.css(this.CB['mute'], 'display', 'block');
|
|
this.css(this.CB['escMute'], 'display', 'none');
|
|
} else {
|
|
this.css(this.CB['mute'], 'display', 'none');
|
|
this.css(this.CB['escMute'], 'display', 'block');
|
|
}
|
|
} catch(event) {}
|
|
},
|
|
|
|
/*
|
|
内部函数
|
|
监听播放时间调节进度条
|
|
*/
|
|
timeUpdateHandler: function() {
|
|
var duration = 0;
|
|
if(this.playerType == 'html5video') {
|
|
try {
|
|
duration = this.V.duration;
|
|
} catch(event) {}
|
|
}
|
|
if(duration > 0) {
|
|
this.time = this.V.currentTime;
|
|
this.timeTextHandler();
|
|
this.trackShowHandler();
|
|
if(this.isTimeButtonMove) {
|
|
this.timeProgress(this.time, duration);
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
按时间改变进度条
|
|
*/
|
|
timeProgress: function(time, duration) {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var timeProgressBgW = this.CB['timeProgressBg'].offsetWidth;
|
|
var timeBOW = parseInt((time * timeProgressBgW / duration) - (this.CB['timeButton'].offsetWidth * 0.5));
|
|
if(timeBOW > timeProgressBgW - this.CB['timeButton'].offsetWidth) {
|
|
timeBOW = timeProgressBgW - this.CB['timeButton'].offsetWidth;
|
|
}
|
|
if(timeBOW < 0) {
|
|
timeBOW = 0;
|
|
}
|
|
this.css(this.CB['timeProgress'], 'width', timeBOW + 'px');
|
|
this.css(this.CB['timeButton'], 'left', parseInt(timeBOW) + 'px');
|
|
},
|
|
/*
|
|
内部函数
|
|
监听播放时间改变时间显示文本框
|
|
*/
|
|
timeTextHandler: function() { //显示时间/总时间
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var duration = this.V.duration;
|
|
var time = this.V.currentTime;
|
|
if(isNaN(duration) || parseInt(duration) < 0.2) {
|
|
duration = this.vars['duration'];
|
|
}
|
|
this.CB['timeText'].innerHTML = this.formatTime(time) + ' / ' + this.formatTime(duration);
|
|
if(this.CB['timeText'].offsetWidth > 0) {
|
|
this.buttonWidth['timeText'] = this.CB['timeText'].offsetWidth;
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
监听是否是缓冲状态
|
|
*/
|
|
bufferEdHandler: function() {
|
|
if(!this.showFace || this.playerType == 'flashplayer') {
|
|
return;
|
|
}
|
|
var thisTemp = this;
|
|
var clearTimerBuffer = function() {
|
|
if(thisTemp.timerBuffer != null) {
|
|
if(thisTemp.timerBuffer.runing) {
|
|
thisTemp.sendJS('buffer', 100);
|
|
thisTemp.timerBuffer.stop();
|
|
}
|
|
thisTemp.timerBuffer = null;
|
|
}
|
|
};
|
|
clearTimerBuffer();
|
|
var bufferFun = function() {
|
|
if(thisTemp.V.buffered.length > 0) {
|
|
var duration = thisTemp.V.duration;
|
|
var len = thisTemp.V.buffered.length;
|
|
var bufferStart = thisTemp.V.buffered.start(len - 1);
|
|
var bufferEnd = thisTemp.V.buffered.end(len - 1);
|
|
var loadTime = bufferStart + bufferEnd;
|
|
var loadProgressBgW = thisTemp.CB['timeProgressBg'].offsetWidth;
|
|
var timeButtonW = thisTemp.CB['timeButton'].offsetWidth;
|
|
var loadW = parseInt((loadTime * loadProgressBgW / duration) + timeButtonW);
|
|
if(loadW >= loadProgressBgW) {
|
|
loadW = loadProgressBgW;
|
|
clearTimerBuffer();
|
|
}
|
|
thisTemp.changeLoad(loadTime);
|
|
}
|
|
};
|
|
this.timerBuffer = new this.timer(200, bufferFun);
|
|
},
|
|
/*
|
|
内部函数
|
|
单独计算加载进度
|
|
*/
|
|
changeLoad: function(loadTime) {
|
|
if(this.V == null) {
|
|
return;
|
|
}
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
var loadProgressBgW = this.CB['timeProgressBg'].offsetWidth;
|
|
var timeButtonW = this.CB['timeButton'].offsetWidth;
|
|
var duration = this.V.duration;
|
|
if(this.isUndefined(loadTime)) {
|
|
loadTime = this.loadTime;
|
|
} else {
|
|
this.loadTime = loadTime;
|
|
}
|
|
var loadW = parseInt((loadTime * loadProgressBgW / duration) + timeButtonW);
|
|
this.css(this.CB['loadProgress'], 'width', loadW + 'px');
|
|
},
|
|
/*
|
|
内部函数
|
|
判断是否是直播
|
|
*/
|
|
judgeIsLive: function() {
|
|
var thisTemp = this;
|
|
if(this.timerError != null) {
|
|
if(this.timerError.runing) {
|
|
this.timerError.stop();
|
|
}
|
|
this.timerError = null;
|
|
}
|
|
this.error = false;
|
|
if(this.showFace) {
|
|
this.css(this.CB['errorText'], 'display', 'none');
|
|
}
|
|
var timeupdate = function(event) {
|
|
thisTemp.timeUpdateHandler();
|
|
};
|
|
if(!this.vars['live']) {
|
|
if(this.V != null && this.playerType == 'html5video') {
|
|
this.addListenerInside('timeupdate', timeupdate);
|
|
thisTemp.timeTextHandler();
|
|
thisTemp.prompt(); //添加提示点
|
|
window.setTimeout(function() {
|
|
thisTemp.bufferEdHandler();
|
|
}, 200);
|
|
}
|
|
} else {
|
|
this.removeListenerInside('timeupdate', timeupdate);
|
|
if(this.timerTime != null) {
|
|
window.clearInterval(this.timerTime);
|
|
timerTime = null;
|
|
}
|
|
if(this.timerTime != null) {
|
|
if(this.timerTime.runing) {
|
|
this.timerTime.stop();
|
|
}
|
|
this.timerTime = null;
|
|
}
|
|
var timeFun = function() {
|
|
if(thisTemp.V != null && !thisTemp.V.paused && thisTemp.showFace) {
|
|
thisTemp.CB['timeText'].innerHTML = thisTemp.getNowDate();
|
|
}
|
|
};
|
|
this.timerTime = new this.timer(1000, timeFun);
|
|
//timerTime.start();
|
|
}
|
|
this.definition();
|
|
},
|
|
/*
|
|
内部函数
|
|
加载字幕
|
|
*/
|
|
loadTrack: function() {
|
|
if(this.playerType == 'flashplayer' || this.vars['flashplayer'] == true) {
|
|
return;
|
|
}
|
|
var thisTemp = this;
|
|
var track = this.vars['cktrack'];
|
|
var obj = {
|
|
method: 'get',
|
|
dataType: 'text',
|
|
url: track,
|
|
charset: 'utf-8',
|
|
success: function(data) {
|
|
thisTemp.track = thisTemp.parseSrtSubtitles(data);
|
|
thisTemp.trackIndex = 0;
|
|
thisTemp.nowTrackShow = {
|
|
sn: ''
|
|
};
|
|
}
|
|
};
|
|
this.ajax(obj);
|
|
},
|
|
/*
|
|
内部函数
|
|
重置字幕
|
|
*/
|
|
resetTrack: function() {
|
|
this.trackIndex = 0;
|
|
this.nowTrackShow = {
|
|
sn: ''
|
|
};
|
|
},
|
|
/*
|
|
内部函数
|
|
根据时间改变读取显示字幕
|
|
*/
|
|
trackShowHandler: function() {
|
|
if(!this.showFace) {
|
|
return;
|
|
}
|
|
if(this.track.length < 1) {
|
|
return;
|
|
}
|
|
if(this.trackIndex >= this.track.length) {
|
|
this.trackIndex = 0;
|
|
}
|
|
var nowTrack = this.track[this.trackIndex]; //当前编号对应的字幕内容
|
|
/*
|
|
this.nowTrackShow=当前显示在界面上的内容
|
|
如果当前时间正好在nowTrack时间内，则需要判断
|
|
*/
|
|
if(this.time >= nowTrack['startTime'] && this.time <= nowTrack['endTime']) {
|
|
/*
|
|
如果当前显示的内容不等于当前需要显示的内容时，则需要显示正确的内容
|
|
*/
|
|
var nowShow = this.nowTrackShow;
|
|
if(nowShow['sn'] != nowTrack['sn']) {
|
|
this.trackHide();
|
|
this.trackShow(nowTrack);
|
|
}
|
|
} else {
|
|
/*
|
|
* 如果当前播放时间不在当前编号字幕内，则需要先清空当前的字幕内容，再显示新的字幕内容
|
|
*/
|
|
this.trackHide();
|
|
this.checkTrack();
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
显示字幕内容
|
|
*/
|
|
trackShow: function(track) {
|
|
this.nowTrackShow = track;
|
|
var arr = track['content'];
|
|
for(var i = 0; i < arr.length; i++) {
|
|
var obj = {
|
|
list: [{
|
|
type: 'text',
|
|
text: arr[i],
|
|
color: '#FFFFFF',
|
|
size: 16,
|
|
font: this.fontFamily,
|
|
lineHeight: 30
|
|
}],
|
|
position: [1, 2, null, -(arr.length - i) * 30 - 50]
|
|
};
|
|
var ele = this.addElement(obj);
|
|
this.trackElement.push(ele);
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
隐藏字字幕内容
|
|
*/
|
|
trackHide: function() {
|
|
for(var i = 0; i < this.trackElement.length; i++) {
|
|
this.deleteElement(this.trackElement[i]);
|
|
}
|
|
this.trackElement = [];
|
|
},
|
|
/*
|
|
内部函数
|
|
重新计算字幕的编号
|
|
*/
|
|
checkTrack: function() {
|
|
var num = this.trackIndex;
|
|
var arr = this.track;
|
|
var i = 0;
|
|
for(i = num; i < arr.length; i++) {
|
|
if(this.time >= arr[i]['startTime'] && this.time <= arr[i]['endTime']) {
|
|
this.trackIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
-----------------------------------------------------------------------------接口函数开始
|
|
接口函数
|
|
在播放和暂停之间切换
|
|
*/
|
|
playOrPause: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.config['videoClick']) {
|
|
if(this.V == null) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.playOrPause();
|
|
return;
|
|
}
|
|
if(this.V.paused) {
|
|
this.videoPlay();
|
|
} else {
|
|
this.videoPause();
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
播放动作
|
|
*/
|
|
videoPlay: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoPlay();
|
|
return;
|
|
}
|
|
this.V.play();
|
|
},
|
|
/*
|
|
接口函数
|
|
暂停动作
|
|
*/
|
|
videoPause: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoPause();
|
|
return;
|
|
}
|
|
this.V.pause();
|
|
},
|
|
/*
|
|
接口函数
|
|
跳转时间动作
|
|
*/
|
|
videoSeek: function(time) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoSeek(time);
|
|
return;
|
|
}
|
|
var meta = this.getMetaDate();
|
|
var duration = meta['duration'];
|
|
if(duration > 0 && time > duration) {
|
|
time = duration;
|
|
}
|
|
if(time >= 0) {
|
|
this.V.currentTime = time;
|
|
this.sendJS('seekTime', time);
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
调节音量/获取音量
|
|
*/
|
|
changeVolume: function(vol, bg, button) {
|
|
if(this.loaded) {
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.changeVolume(time);
|
|
return;
|
|
}
|
|
}
|
|
if(isNaN(vol) || this.isUndefined(vol)) {
|
|
vol = 0;
|
|
}
|
|
if(!this.loaded) {
|
|
this.vars['volume'] = vol;
|
|
}
|
|
if(!this.html5Video) {
|
|
this.V.changeVolume(vol);
|
|
return;
|
|
}
|
|
try {
|
|
if(this.isUndefined(bg)) {
|
|
bg = true;
|
|
}
|
|
} catch(e) {}
|
|
try {
|
|
if(this.isUndefined(button)) {
|
|
button = true;
|
|
}
|
|
} catch(e) {}
|
|
if(!vol) {
|
|
vol = 0;
|
|
}
|
|
if(vol < 0) {
|
|
vol = 0;
|
|
}
|
|
if(vol > 1) {
|
|
vol = 1;
|
|
}
|
|
try {
|
|
this.V.volume = vol;
|
|
} catch(error) {}
|
|
this.volume = vol;
|
|
if(bg && this.showFace) {
|
|
var bgW = vol * this.CB['volumeBg'].offsetWidth;
|
|
if(bgW < 0) {
|
|
bgW = 0;
|
|
}
|
|
if(bgW > this.CB['volumeBg'].offsetWidth) {
|
|
bgW = this.CB['volumeBg'].offsetWidth;
|
|
}
|
|
this.css(this.CB['volumeUp'], 'width', bgW + 'px');
|
|
}
|
|
|
|
if(button && this.showFace) {
|
|
var buLeft = parseInt(this.CB['volumeUp'].offsetWidth - (this.CB['volumeBO'].offsetWidth * 0.5));
|
|
if(buLeft > this.CB['volumeBg'].offsetWidth - this.CB['volumeBO'].offsetWidth) {
|
|
buLeft = this.CB['volumeBg'].offsetWidth - this.CB['volumeBO'].offsetWidth
|
|
}
|
|
if(buLeft < 0) {
|
|
buLeft = 0;
|
|
}
|
|
this.css(this.CB['volumeBO'], 'left', buLeft + 'px');
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
静音
|
|
*/
|
|
videoMute: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoMute();
|
|
return;
|
|
}
|
|
this.volumeTemp = this.V ? (this.V.volume > 0 ? this.V.volume : this.vars['volume']) : this.vars['volume'];
|
|
this.changeVolume(0);
|
|
},
|
|
/*
|
|
接口函数
|
|
取消静音
|
|
*/
|
|
videoEscMute: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoEscMute();
|
|
return;
|
|
}
|
|
this.changeVolume(this.volumeTemp > 0 ? this.volumeTemp : this.vars['volume']);
|
|
},
|
|
/*
|
|
接口函数
|
|
快退
|
|
*/
|
|
fastBack: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.fastBack();
|
|
return;
|
|
}
|
|
var time = this.time - this.ckplayerConfig['config']['timeJump'];
|
|
if(time < 0) {
|
|
time = 0;
|
|
}
|
|
this.videoSeek(time);
|
|
},
|
|
/*
|
|
接口函数
|
|
快进
|
|
*/
|
|
fastNext: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.fastNext();
|
|
return;
|
|
}
|
|
var time = this.time + this.ckplayerConfig['config']['timeJump'];
|
|
if(time > this.V.duration) {
|
|
time = this.V.duration;
|
|
}
|
|
this.videoSeek(time);
|
|
},
|
|
/*
|
|
接口函数
|
|
获取当前播放的地址
|
|
*/
|
|
getCurrentSrc:function(){
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.getCurrentSrc();
|
|
}
|
|
return this.V.currentSrc;
|
|
},
|
|
/*
|
|
内置函数
|
|
全屏/退出全屏动作，该动作只能是用户操作才可以触发，比如用户点击按钮触发该事件
|
|
*/
|
|
switchFull: function() {
|
|
if(this.full) {
|
|
this.quitFullScreen();
|
|
} else {
|
|
this.fullScreen();
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
全屏动作，该动作只能是用户操作才可以触发，比如用户点击按钮触发该事件
|
|
*/
|
|
fullScreen: function() {
|
|
if(this.html5Video && this.playerType == 'html5video') {
|
|
var element = this.PD;
|
|
if(element.requestFullscreen) {
|
|
element.requestFullscreen();
|
|
} else if(element.mozRequestFullScreen) {
|
|
element.mozRequestFullScreen();
|
|
} else if(element.webkitRequestFullscreen) {
|
|
element.webkitRequestFullscreen();
|
|
} else if(element.msRequestFullscreen) {
|
|
element.msRequestFullscreen();
|
|
} else if(element.oRequestFullscreen) {
|
|
element.oRequestFullscreen();
|
|
}
|
|
this.judgeFullScreen();
|
|
} else {
|
|
//this.V.fullScreen();
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
退出全屏动作
|
|
*/
|
|
quitFullScreen: function() {
|
|
if(this.html5Video && this.playerType == 'html5video') {
|
|
if(document.exitFullscreen) {
|
|
document.exitFullscreen();
|
|
} else if(document.msExitFullscreen) {
|
|
document.msExitFullscreen();
|
|
} else if(document.mozCancelFullScreen) {
|
|
document.mozCancelFullScreen();
|
|
} else if(document.oRequestFullscreen) {
|
|
document.oCancelFullScreen();
|
|
} else if(document.requestFullscreen) {
|
|
document.requestFullscreen();
|
|
} else if(document.webkitExitFullscreen) {
|
|
document.webkitExitFullscreen();
|
|
} else {
|
|
this.css(document.documentElement, 'cssText', '');
|
|
this.css(document.document.body, 'cssText', '');
|
|
this.css(this.PD, 'cssText', '');
|
|
}
|
|
this.judgeFullScreen();
|
|
}
|
|
},
|
|
/*
|
|
下面列出只有flashplayer里支持的
|
|
*/
|
|
videoRotation: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoRotation(n);
|
|
return;
|
|
}
|
|
if(this.isUndefined(n)) {
|
|
n = 0;
|
|
}
|
|
var tf = this.css(this.V, 'transform');
|
|
if(this.isUndefined(tf) && !tf) {
|
|
tf = 'rotate(0deg)';
|
|
}
|
|
var reg = tf.match(/rotate\([^)]+\)/);
|
|
reg = reg ? reg[0].replace('rotate(', '').replace('deg)', '') : '';
|
|
if(reg == '') {
|
|
reg = 0;
|
|
} else {
|
|
reg = parseInt(reg);
|
|
}
|
|
if(n == -1) {
|
|
reg -= 90;
|
|
} else if(n == 1) {
|
|
reg += 90;
|
|
} else {
|
|
if(n != 90 && n != 180 && n != 270 && n != -90 && n != -180 && n != -270) {
|
|
reg = 0;
|
|
} else {
|
|
reg = n;
|
|
}
|
|
}
|
|
n = reg;
|
|
tf = tf.replace(/rotate\([^)]+\)/, '') + ' rotate(' + n + 'deg)';
|
|
this.css(this.V, 'transform', tf);
|
|
return;
|
|
},
|
|
videoBrightness: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoBrightness(n);
|
|
return;
|
|
}
|
|
},
|
|
videoContrast: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoContrast(n);
|
|
return;
|
|
}
|
|
},
|
|
videoSaturation: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoSaturation(n);
|
|
return;
|
|
}
|
|
},
|
|
videoHue: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoHue(n);
|
|
return;
|
|
}
|
|
},
|
|
videoZoom: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoZoom(n);
|
|
return;
|
|
}
|
|
if(this.isUndefined(n)) {
|
|
n = 1;
|
|
}
|
|
if(n < 0) {
|
|
n = 0;
|
|
}
|
|
if(n > 2) {
|
|
n = 2;
|
|
}
|
|
var tf = this.css(this.V, 'transform');
|
|
tf = tf.replace(/scale\([^)]+\)/, '') + ' scale(' + n + ')';
|
|
this.css(this.V, 'transform', tf);
|
|
return;
|
|
},
|
|
videoProportion: function(w, h) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoProportion(w, h);
|
|
return;
|
|
}
|
|
},
|
|
adPlay: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.adPlay();
|
|
return;
|
|
}
|
|
},
|
|
adPause: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.adPause();
|
|
return;
|
|
}
|
|
},
|
|
videoError: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoError(n);
|
|
return;
|
|
}
|
|
},
|
|
changeConfig: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.changeConfig(arguments);
|
|
return;
|
|
}
|
|
var obj = this.ckplayerConfig;
|
|
var arg = arguments;
|
|
for(var i = 0; i < arg.length - 1; i++) {
|
|
if(obj.hasOwnProperty(arg[i])) {
|
|
obj = obj[arg[i]];
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
var val = arg[arg.length - 1];
|
|
switch(arg.length) {
|
|
case 2:
|
|
this.ckplayerConfig[arg[0]] = val;
|
|
break;
|
|
case 3:
|
|
this.ckplayerConfig[arg[0]][arg[1]] = val;
|
|
break;
|
|
case 4:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]] = val;
|
|
break;
|
|
case 5:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]][arg[3]] = val;
|
|
break;
|
|
case 6:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]] = val;
|
|
break;
|
|
case 7:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]] = val;
|
|
break;
|
|
case 8:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]][arg[6]] = val;
|
|
break;
|
|
case 9:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]][arg[6]][arg[7]] = val;
|
|
break;
|
|
case 10:
|
|
this.ckplayerConfig[arg[0]][arg[1]][arg[2]][arg[3]][arg[4]][arg[5]][arg[6]][arg[7]][arg[8]] = val;
|
|
break;
|
|
default:
|
|
return;
|
|
break;
|
|
}
|
|
this.sendJS('configChange', this.ckplayerConfig);
|
|
},
|
|
custom: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.custom(arguments);
|
|
return;
|
|
}
|
|
},
|
|
getConfig: function() {
|
|
if(!this.loaded) {
|
|
return null;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.getConfig(arguments);
|
|
}
|
|
},
|
|
openUrl: function(n) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.openUrl(n);
|
|
return;
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
清除视频
|
|
*/
|
|
videoClear: function() {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.videoClear();
|
|
return;
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
向播放器传递新的视频地址
|
|
*/
|
|
newVideo: function(c) {
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.newVideo(c);
|
|
return;
|
|
} else {
|
|
this.embed(c);
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
截图
|
|
*/
|
|
screenshot: function(obj, save, name) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
try {
|
|
this.V.screenshot(obj, save, name);
|
|
} catch(error) {
|
|
this.log(error);
|
|
}
|
|
return;
|
|
}
|
|
if(obj == 'video') {
|
|
var newCanvas = document.createElement('canvas');
|
|
newCanvas.width = this.V.videoWidth;
|
|
newCanvas.height = this.V.videoHeight;
|
|
newCanvas.getContext('2d').drawImage(this.V, 0, 0, this.V.videoWidth, this.V.videoHeight);
|
|
try {
|
|
var base64 = newCanvas.toDataURL('image/jpeg');
|
|
this.sendJS('screenshot', {
|
|
object: obj,
|
|
save: save,
|
|
name: name,
|
|
base64: base64
|
|
});
|
|
} catch(error) {
|
|
this.log(error);
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
改变播放器尺寸
|
|
*/
|
|
changeSize: function(w, h) {
|
|
if(this.isUndefined(w)) {
|
|
w = 0;
|
|
}
|
|
if(this.isUndefined(h)) {
|
|
h = 0;
|
|
}
|
|
if(w > 0) {
|
|
this.css(this.CD, 'width', w + 'px');
|
|
}
|
|
if(h > 0) {
|
|
this.css(this.CD, 'height', h + 'px');
|
|
}
|
|
if(this.html5Video) {
|
|
this.elementCoordinate();
|
|
}
|
|
},
|
|
/*
|
|
接口函数
|
|
改变视频播放速度
|
|
*/
|
|
changePlaybackRate: function(n) {
|
|
if(this.html5Video) {
|
|
var arr = this.playbackRateArr;
|
|
n = parseInt(n);
|
|
if(n < arr.length) {
|
|
this.newPlaybackrate(arr[n][1]);
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部函数
|
|
注册控制控制栏显示与隐藏函数
|
|
*/
|
|
changeControlBarShow: function(show) {
|
|
if(!this.loaded) {
|
|
return;
|
|
}
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.changeControlBarShow(show);
|
|
return;
|
|
}
|
|
if(show) {
|
|
this.controlBarIsShow = true;
|
|
this.controlBarHide(false);
|
|
} else {
|
|
this.controlBarIsShow = false;
|
|
this.controlBarHide(true);
|
|
}
|
|
},
|
|
/*
|
|
-----------------------------------------------------------------------
|
|
调用flashplayer
|
|
*/
|
|
embedSWF: function() {
|
|
var vid = this.randomString();
|
|
var flashvars = this.getFlashVars();
|
|
var param = this.getFlashplayerParam();
|
|
var flashplayerUrl = 'http://www.macromedia.com/go/getflashplayer';
|
|
var html = '',
|
|
src = javascriptPath + 'ckplayer.swf';
|
|
id = 'id="' + vid + '" name="' + vid + '" ';
|
|
html += '<object pluginspage="' + flashplayerUrl + '" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=11,3,0,0" width="100%" height="100%" ' + id + ' align="middle">';
|
|
html += param['v'];
|
|
html += '<param name="movie" value="' + src + '">';
|
|
html += '<param name="flashvars" value="' + flashvars + '">';
|
|
html += '<embed ' + param['w'] + ' src="' + src + '" flashvars="' + flashvars + '" width="100%" height="100%" ' + id + ' align="middle" type="application/x-shockwave-flash" pluginspage="' + flashplayerUrl + '" />';
|
|
html += '</object>';
|
|
this.PD.innerHTML = html;
|
|
this.V = this.getObjectById(vid); //V：定义播放器对象全局变量
|
|
this.playerType = 'flashplayer';
|
|
//this.loaded=true;
|
|
},
|
|
/*
|
|
内置函数
|
|
将vars对象转换成字符
|
|
*/
|
|
getFlashVars: function() {
|
|
this.getVarsObject();
|
|
var v = this.vars;
|
|
var z = '';
|
|
for(k in v) {
|
|
if(k != 'flashplayer' && k != 'container' && v[k] != '') {
|
|
if(z != '') {
|
|
z += '&';
|
|
}
|
|
var vk = v[k];
|
|
if(vk == true) {
|
|
vk = 1;
|
|
}
|
|
if(vk == false) {
|
|
vk = 0;
|
|
}
|
|
z += k + '=' + vk;
|
|
}
|
|
|
|
}
|
|
if(!v.hasOwnProperty('volume') || !v['volume']) {
|
|
if(z != '') {
|
|
z += '&';
|
|
}
|
|
z += 'volume=0';
|
|
}
|
|
return z;
|
|
},
|
|
/*
|
|
内置函数
|
|
将vars格式化成flash能接受的对象。再由getFlashVars函数转化成字符串或由newVideo直接使用
|
|
*/
|
|
getVarsObject: function() {
|
|
var v = this.vars;
|
|
var f = '',
|
|
d = '',
|
|
w = ''; //f=视频地址，d=清晰度地址,w=权重，z=最终地址
|
|
var arr = this.VA;
|
|
var prompt = v['promptSpot'];
|
|
var i = 0;
|
|
var video = this.vars['video'];
|
|
if(typeof(video) == 'object') { //对象或数组
|
|
if(!this.isUndefined(typeof(video.length))) { //说明是数组
|
|
var arr = video;
|
|
for(i = 0; i < arr.length; i++) {
|
|
var arr2 = arr[i];
|
|
if(arr2) {
|
|
if(f != '') {
|
|
f += this.ckplayerConfig['config']['split'];
|
|
d += ',';
|
|
w += ',';
|
|
v['type']+=this.ckplayerConfig['config']['split'];
|
|
}
|
|
f += encodeURIComponent(decodeURIComponent(arr2[0]));
|
|
d += arr2[2];
|
|
w += arr2[3];
|
|
v['type']+=arr2[1].replace('video/','');
|
|
}
|
|
}
|
|
} else {
|
|
f = encodeURIComponent(decodeURIComponent(video['file']));
|
|
if(!this.isUndefined(video['type'])) {
|
|
v['type'] = video['type'];
|
|
}
|
|
d = '';
|
|
w = '';
|
|
}
|
|
} else {
|
|
f = encodeURIComponent(decodeURIComponent(video));
|
|
}
|
|
if(v['preview'] != null) {
|
|
v['previewscale'] = v['preview']['scale'];
|
|
v['preview'] = v['preview']['file'].join(',');
|
|
|
|
}
|
|
if(prompt != null) {
|
|
v['promptspot'] = '';
|
|
v['promptspottime'] = '';
|
|
for(i = 0; i < prompt.length; i++) {
|
|
if(v['promptspot'] != '') {
|
|
v['promptspot'] += ',';
|
|
v['promptspottime'] += ',';
|
|
}
|
|
v['promptspot'] += prompt[i]['words'];
|
|
v['promptspottime'] += prompt[i]['time'];
|
|
}
|
|
|
|
}
|
|
if(f != '') {
|
|
v['video'] = f;
|
|
v['definition'] = d;
|
|
v['weight'] = w;
|
|
}
|
|
if(!v['volume']) {
|
|
v['volume'] = 0;
|
|
}
|
|
var newV = {};
|
|
|
|
for(var k in v) {
|
|
if(v[k] != null) {
|
|
newV[k] = v[k];
|
|
}
|
|
if(k == 'type') {
|
|
newV[k] = v[k].replace('video/m3u8', 'm3u8');
|
|
}
|
|
}
|
|
|
|
this.vars = newV;
|
|
},
|
|
/*
|
|
内置函数
|
|
将embedSWF里的param的对象进行转换
|
|
*/
|
|
getFlashplayerParam: function() {
|
|
var w = '',
|
|
v = '',
|
|
o = {
|
|
allowScriptAccess: 'always',
|
|
allowFullScreen: true,
|
|
quality: 'high',
|
|
bgcolor: '#000'
|
|
};
|
|
for(var e in o) {
|
|
w += e + '="' + o[e] + '" ';
|
|
v += '<param name="' + e + '" value="' + o[e] + '" />';
|
|
}
|
|
w = w.replace('movie=', 'src=');
|
|
return {
|
|
w: w,
|
|
v: v
|
|
};
|
|
},
|
|
|
|
/*
|
|
操作动作结束
|
|
-----------------------------------------------------------------------
|
|
|
|
接口函数
|
|
获取元数据部分
|
|
*/
|
|
getMetaDate: function() {
|
|
if(!this.loaded || this.V == null) {
|
|
return false;
|
|
}
|
|
if(this.playerType == 'html5video') {
|
|
var duration = 0;
|
|
try {
|
|
duration = !isNaN(this.V.duration) ? this.V.duration : 0;
|
|
} catch(event) {this.log(event);}
|
|
var data = {
|
|
duration: duration,
|
|
volume: this.V.volume,
|
|
playbackRate: this.V.playbackRate,
|
|
width: this.PD.offsetWidth || this.V.offsetWidth || this.V.width,
|
|
height: this.PD.offsetHeight || this.V.offsetHeight || this.V.height,
|
|
streamWidth: this.V.videoWidth,
|
|
streamHeight: this.V.videoHeight,
|
|
videoWidth: this.V.offsetWidth,
|
|
videoHeight: this.V.offsetHeight,
|
|
paused: this.V.paused
|
|
};
|
|
return data;
|
|
} else {
|
|
try{
|
|
return this.V.getMetaDate();
|
|
}
|
|
catch(event){
|
|
this.log(event);
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
/*
|
|
接口函数
|
|
取当前提供给播放器播放的视频列表
|
|
*/
|
|
getVideoUrl: function() {
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.getVideoUrl();
|
|
}
|
|
var arr = [];
|
|
if(this.V.src) {
|
|
arr.push(this.V.src);
|
|
} else {
|
|
var uArr = this.V.childNodes;
|
|
for(var i = 0; i < uArr.length; i++) {
|
|
arr.push(uArr[i].src);
|
|
}
|
|
}
|
|
return arr;
|
|
},
|
|
/*
|
|
内置函数
|
|
格式化函数
|
|
*/
|
|
clickEvent: function(call) {
|
|
if(call == 'none' || call == '' || call == null) {
|
|
return {
|
|
type: 'none'
|
|
};
|
|
}
|
|
var callArr = call.split('->');
|
|
var type = '',
|
|
fun = '',
|
|
link = '',
|
|
target = '';
|
|
if(callArr.length == 2) {
|
|
var callM = callArr[0];
|
|
var callE = callArr[1];
|
|
if(!callE) {
|
|
return {
|
|
type: 'none'
|
|
};
|
|
}
|
|
var val = '';
|
|
var eArr = [];
|
|
type = callM;
|
|
switch(callM) {
|
|
case 'actionScript':
|
|
//trace(THIS.hasOwnProperty(callE));
|
|
|
|
if(callE.indexOf('(') > -1) {
|
|
eArr = callE.split('(');
|
|
callE = eArr[0];
|
|
val = eArr[1].replace(')', '');
|
|
}
|
|
if(val == '') {
|
|
fun = 'thisTemp.' + callE + '()';
|
|
} else {
|
|
fun = 'thisTemp.' + callE + '(' + val + ')';
|
|
}
|
|
break;
|
|
case 'javaScript':
|
|
if(callE.substr(0, 11) == '[flashvars]') {
|
|
callE = callE.substr(11);
|
|
if(this.vars.hasOwnProperty(callE)) {
|
|
callE = this.vars[callE];
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
}
|
|
if(callE.indexOf('(') > -1) {
|
|
eArr = callE.split('(');
|
|
callE = eArr[0];
|
|
val = eArr[1].replace(')', '');
|
|
}
|
|
if(val == '') {
|
|
fun = callE + '()';
|
|
} else {
|
|
fun = callE + '(' + val + ')';
|
|
}
|
|
break;
|
|
case "link":
|
|
var callLink = (callE + ',').split(',');
|
|
if(callLink[0].substr(0, 11) == '[flashvars]') {
|
|
var fl = callLink[0].replace('[flashvars]', '');
|
|
if(this.vars.hasOwnProperty(fl)) {
|
|
callLink[0] = this.vars[fl];
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if(!callLink[1]) {
|
|
callLink[1] = '_blank';
|
|
}
|
|
link = callLink[0];
|
|
target = callLink[1];
|
|
break;
|
|
}
|
|
}
|
|
return {
|
|
type: type,
|
|
fun: fun,
|
|
link: link,
|
|
target: target
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
向播放器界面添加一个文本
|
|
*/
|
|
addElement: function(attribute) {
|
|
var thisTemp = this;
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.addElement(attribute);
|
|
}
|
|
var i = 0;
|
|
var obj = {
|
|
list: null,
|
|
x: '100%',
|
|
y: "50%",
|
|
position: null,
|
|
alpha: 1,
|
|
backgroundColor: '',
|
|
backAlpha: 1,
|
|
backRadius: 0,
|
|
clickEvent: ''
|
|
};
|
|
obj = this.standardization(obj, attribute);
|
|
var list = obj['list'];
|
|
if(list == null) {
|
|
return '';
|
|
}
|
|
var id = 'element' + this.randomString(10);
|
|
var ele = document.createElement('div');
|
|
ele.className = id;
|
|
if(obj['x']) {
|
|
ele.setAttribute('data-x', obj['x']);
|
|
}
|
|
if(obj['y']) {
|
|
ele.setAttribute('data-y', obj['y']);
|
|
}
|
|
if(obj['position'] != null) {
|
|
ele.setAttribute('data-position', obj['position'].join(','));
|
|
}
|
|
|
|
this.PD.appendChild(ele);
|
|
var eid = this.getByElement(id);
|
|
this.css(eid, {
|
|
position: 'absolute',
|
|
filter: 'alpha(opacity:' + obj['alpha'] + ')',
|
|
opacity: obj['alpha'].toString(),
|
|
width: '800px',
|
|
zIndex: '20'
|
|
});
|
|
var bgid = 'elementbg' + this.randomString(10);
|
|
var bgAlpha = obj['alpha'].toString();
|
|
var bgColor = obj['backgroundColor'].replace('0x', '#');
|
|
var html = '';
|
|
var idArr = [];
|
|
var clickArr = [];
|
|
if(!this.isUndefined(list) && list.length > 0) {
|
|
var textObj, returnObj, clickEvent;
|
|
for(i = 0; i < list.length; i++) {
|
|
var newEleid = 'elementnew' + this.randomString(10);
|
|
switch(list[i]['type']) {
|
|
case 'image':
|
|
case 'png':
|
|
case 'jpg':
|
|
case 'jpeg':
|
|
case 'gif':
|
|
textObj = {
|
|
type: 'image',
|
|
file: '',
|
|
radius: 0, //圆角弧度
|
|
width: 30, //定义宽，必需要定义
|
|
height: 30, //定义高，必需要定义
|
|
alpha: 1, //透明度
|
|
paddingLeft: 0, //左边距离
|
|
paddingRight: 0, //右边距离
|
|
paddingTop: 0,
|
|
paddingBottom: 0,
|
|
marginLeft: 0,
|
|
marginRight: 0,
|
|
marginTop: 0,
|
|
marginBottom: 0,
|
|
backgroundColor: '',
|
|
clickEvent: ''
|
|
};
|
|
|
|
list[i] = this.standardization(textObj, list[i]);
|
|
clickEvent = this.clickEvent(list[i]['clickEvent']);
|
|
clickArr.push(clickEvent);
|
|
if(clickEvent['type'] == 'link') {
|
|
html += '<div class="' + newEleid + '" data-i="' + i + '"><a href="' + clickEvent['link'] + '" target="' + clickEvent['target'] + '"><img class="' + newEleid + '_image" src="' + list[i]['file'] + '" style="border:0;"></a></div>';
|
|
} else {
|
|
html += '<div class="' + newEleid + '" data-i="' + i + '"><img class="' + newEleid + '_image" src="' + list[i]['file'] + '" style="border:0;"></div>';
|
|
}
|
|
break;
|
|
case 'text':
|
|
textObj = {
|
|
type: 'text', //说明是文本
|
|
text: '', //文本内容
|
|
color: '0xFFFFFF',
|
|
size: 14,
|
|
font: this.fontFamily,
|
|
leading: 0,
|
|
alpha: 1, //透明度
|
|
paddingLeft: 0, //左边距离
|
|
paddingRight: 0, //右边距离
|
|
paddingTop: 0,
|
|
paddingBottom: 0,
|
|
marginLeft: 0,
|
|
marginRight: 0,
|
|
marginTop: 0,
|
|
marginBottom: 0,
|
|
backgroundColor: '',
|
|
backAlpha: 1,
|
|
backRadius: 0, //背景圆角弧度，支持数字统一设置，也支持分开设置[30,20,20,50]，对应上左，上右，下右，下左
|
|
clickEvent: ''
|
|
};
|
|
list[i] = this.standardization(textObj, list[i]);
|
|
clickEvent = this.clickEvent(list[i]['clickEvent']);
|
|
clickArr.push(clickEvent);
|
|
if(clickEvent['type'] == 'link') {
|
|
html += '<div class="' + newEleid + '" data-i="' + i + '"><div class="' + newEleid + '_bg"></div><div class="' + newEleid + '_text"><a href="' + clickEvent['link'] + '" target="' + clickEvent['target'] + '">' + list[i]['text'] + '</a></div></div>';
|
|
} else {
|
|
html += '<div class="' + newEleid + '" data-i="' + i + '"><div class="' + newEleid + '_bg"></div><div class="' + newEleid + '_text">' + list[i]['text'] + '</div></div>';
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
idArr.push(newEleid);
|
|
}
|
|
}
|
|
var objClickEvent = this.clickEvent(obj['clickEvent']);
|
|
/*if(objClickEvent['type']=='link'){
|
|
html = '<a href="'+objClickEvent['link']+'" target="'+objClickEvent['target']+'">' + html + '</a>';
|
|
}*/
|
|
eid.innerHTML = '<div class="' + bgid + '"></div><div class="' + bgid + '_c">' + html + '</div>';
|
|
if(objClickEvent['type'] == 'javaScript' || objClickEvent['type'] == 'actionScript') {
|
|
var objClickHandler = function() {
|
|
eval(objClickEvent['fun']);
|
|
thisTemp.sendJS('clickEvent', clk['type'] + '->' + clk['fun'].replace('thisTemp.', '').replace('()', ''));
|
|
};
|
|
this.addListenerInside('click', objClickHandler, this.getByElement(bgid + '_c'))
|
|
}
|
|
this.css(bgid + '_c', {
|
|
position: 'absolute',
|
|
zIndex: '2'
|
|
});
|
|
for(i = 0; i < idArr.length; i++) {
|
|
var clk = clickArr[i];
|
|
|
|
if(clk['type'] == 'javaScript' || clk['type'] == 'actionScript') {
|
|
var clickHandler = function() {
|
|
clk = clickArr[this.getAttribute('data-i')];
|
|
eval(clk['fun']);
|
|
thisTemp.sendJS('clickEvent', clk['type'] + '->' + clk['fun'].replace('thisTemp.', '').replace('()', ''));
|
|
};
|
|
this.addListenerInside('click', clickHandler, this.getByElement(idArr[i]))
|
|
}
|
|
switch(list[i]['type']) {
|
|
case 'image':
|
|
case 'png':
|
|
case 'jpg':
|
|
case 'jpeg':
|
|
case 'gif':
|
|
this.css(idArr[i], {
|
|
float: 'left',
|
|
width: list[i]['width'] + 'px',
|
|
height: list[i]['height'] + 'px',
|
|
filter: 'alpha(opacity:' + list[i]['alpha'] + ')',
|
|
opacity: list[i]['alpha'].toString(),
|
|
marginLeft: list[i]['marginLeft'] + 'px',
|
|
marginRight: list[i]['marginRight'] + 'px',
|
|
marginTop: list[i]['marginTop'] + 'px',
|
|
marginBottom: list[i]['marginBottom'] + 'px',
|
|
borderRadius: list[i]['radius'] + 'px',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(idArr[i] + '_image', {
|
|
width: list[i]['width'] + 'px',
|
|
height: list[i]['height'] + 'px',
|
|
borderRadius: list[i]['radius'] + 'px'
|
|
});
|
|
break;
|
|
case 'text':
|
|
this.css(idArr[i] + '_text', {
|
|
filter: 'alpha(opacity:' + list[i]['alpha'] + ')',
|
|
opacity: list[i]['alpha'].toString(),
|
|
borderRadius: list[i]['radius'] + 'px',
|
|
fontFamily: list[i]['font'],
|
|
fontSize: list[i]['size'] + 'px',
|
|
color: list[i]['color'].replace('0x', '#'),
|
|
lineHeight: list[i]['leading'] > 0 ? list[i]['leading'] + 'px' : '',
|
|
paddingLeft: list[i]['paddingLeft'] + 'px',
|
|
paddingRight: list[i]['paddingRight'] + 'px',
|
|
paddingTop: list[i]['paddingTop'] + 'px',
|
|
paddingBottom: list[i]['paddingBottom'] + 'px',
|
|
whiteSpace: 'nowrap',
|
|
position: 'absolute',
|
|
zIndex: '3',
|
|
cursor: 'pointer'
|
|
});
|
|
this.css(idArr[i], {
|
|
float: 'left',
|
|
width: this.getByElement(idArr[i] + '_text').offsetWidth + 'px',
|
|
height: this.getByElement(idArr[i] + '_text').offsetHeight + 'px',
|
|
marginLeft: list[i]['marginLeft'] + 'px',
|
|
marginRight: list[i]['marginRight'] + 'px',
|
|
marginTop: list[i]['marginTop'] + 'px',
|
|
marginBottom: list[i]['marginBottom'] + 'px'
|
|
});
|
|
this.css(idArr[i] + '_bg', {
|
|
width: this.getByElement(idArr[i] + '_text').offsetWidth + 'px',
|
|
height: this.getByElement(idArr[i] + '_text').offsetHeight + 'px',
|
|
filter: 'alpha(opacity:' + list[i]['backAlpha'] + ')',
|
|
opacity: list[i]['backAlpha'].toString(),
|
|
borderRadius: list[i]['backRadius'] + 'px',
|
|
backgroundColor: list[i]['backgroundColor'].replace('0x', '#'),
|
|
position: 'absolute',
|
|
zIndex: '2'
|
|
});
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
this.css(bgid, {
|
|
width: this.getByElement(bgid + '_c').offsetWidth + 'px',
|
|
height: this.getByElement(bgid + '_c').offsetHeight + 'px',
|
|
position: 'absolute',
|
|
filter: 'alpha(opacity:' + bgAlpha + ')',
|
|
opacity: bgAlpha,
|
|
backgroundColor: bgColor.replace('0x', '#'),
|
|
borderRadius: obj['backRadius'] + 'px',
|
|
zIndex: '1'
|
|
});
|
|
this.css(eid, {
|
|
width: this.getByElement(bgid).offsetWidth + 'px',
|
|
height: this.getByElement(bgid).offsetHeight + 'px'
|
|
});
|
|
var eidCoor = this.calculationCoor(eid);
|
|
this.css(eid, {
|
|
left: eidCoor['x'] + 'px',
|
|
top: eidCoor['y'] + 'px'
|
|
});
|
|
|
|
this.elementArr.push(eid.className);
|
|
return eid;
|
|
},
|
|
/*
|
|
内置函数
|
|
获取元件的属性，包括x,y,width,height,alpha
|
|
*/
|
|
getElement: function(element) {
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.getElement(element);
|
|
}
|
|
var ele = element;
|
|
if(typeof(element) == 'string') {
|
|
ele = this.getByElement(element);
|
|
}
|
|
var coor = this.getCoor(ele);
|
|
return {
|
|
x: coor['x'],
|
|
y: coor['y'],
|
|
width: ele.offsetWidth,
|
|
height: ele.offsetHeight,
|
|
alpha: !this.isUndefined(this.css(ele, 'opacity')) ? parseFloat(this.css(ele, 'opacity')) : 1
|
|
};
|
|
},
|
|
/*
|
|
内置函数
|
|
根据节点的x,y计算在播放器里的坐标
|
|
*/
|
|
calculationCoor: function(ele) {
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.calculationCoor(ele);
|
|
}
|
|
if(ele == []) {
|
|
return;
|
|
}
|
|
var x, y, position = [];
|
|
var w = this.PD.offsetWidth,
|
|
h = this.PD.offsetHeight;
|
|
var ew = ele.offsetWidth,
|
|
eh = ele.offsetHeight;
|
|
if(!this.isUndefined(this.getDataset(ele, 'x'))) {
|
|
x = this.getDataset(ele, 'x');
|
|
}
|
|
if(!this.isUndefined(this.getDataset(ele, 'y'))) {
|
|
y = this.getDataset(ele, 'y');
|
|
}
|
|
if(!this.isUndefined(this.getDataset(ele, 'position'))) {
|
|
try{
|
|
position = this.getDataset(ele, 'position').toString().split(',');
|
|
}
|
|
catch(event){}
|
|
}
|
|
if(position.length > 0) {
|
|
position.push(null, null, null, null);
|
|
var i = 0;
|
|
for(i = 0; i < position.length; i++) {
|
|
if(this.isUndefined(position[i]) || position[i] == null || position[i] == 'null' || position[i] == '') {
|
|
position[i] = null;
|
|
} else {
|
|
position[i] = parseFloat(position[i]);
|
|
}
|
|
}
|
|
|
|
if(position[2] == null) {
|
|
switch(position[0]) {
|
|
case 0:
|
|
x = 0;
|
|
break;
|
|
case 1:
|
|
x = parseInt((w - ew) * 0.5);
|
|
break;
|
|
default:
|
|
x = w - ew;
|
|
break;
|
|
}
|
|
} else {
|
|
switch(position[0]) {
|
|
case 0:
|
|
x = position[2];
|
|
break;
|
|
case 1:
|
|
x = parseInt(w * 0.5) + position[2];
|
|
break;
|
|
default:
|
|
x = w + position[2];
|
|
break;
|
|
}
|
|
}
|
|
if(position[3] == null) {
|
|
switch(position[1]) {
|
|
case 0:
|
|
y = 0;
|
|
break;
|
|
case 1:
|
|
y = parseInt((h - eh) * 0.5);
|
|
break;
|
|
default:
|
|
y = h - eh;
|
|
break;
|
|
}
|
|
} else {
|
|
switch(position[1]) {
|
|
case 0:
|
|
y = position[3];
|
|
break;
|
|
case 1:
|
|
y = parseInt(h * 0.5) + position[3];
|
|
break;
|
|
default:
|
|
y = h + position[3];
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
if(x.substring(x.length - 1, x.length) == '%') {
|
|
x = Math.floor(parseInt(x.substring(0, x.length - 1)) * w * 0.01);
|
|
}
|
|
if(y.substring(y.length - 1, y.length) == '%') {
|
|
y = Math.floor(parseInt(y.substring(0, y.length - 1)) * h * 0.01);
|
|
}
|
|
}
|
|
return {
|
|
x: x,
|
|
y: y
|
|
}
|
|
|
|
},
|
|
/*
|
|
内置函数
|
|
修改新增元件的坐标
|
|
*/
|
|
changeElementCoor: function() {
|
|
for(var i = 0; i < this.elementArr.length; i++) {
|
|
if(this.getByElement(this.elementArr[i]) != []) {
|
|
var c = this.calculationCoor(this.getByElement(this.elementArr[i]));
|
|
if(c['x'] && c['y']){
|
|
this.css(this.elementArr[i], {
|
|
top: c['y'] + 'px',
|
|
left: c['x'] + 'px'
|
|
});
|
|
}
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
缓动效果集
|
|
*/
|
|
tween: function() {
|
|
var Tween = {
|
|
None: { //均速运动
|
|
easeIn: function(t, b, c, d) {
|
|
return c * t / d + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return c * t / d + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
return c * t / d + b;
|
|
}
|
|
},
|
|
Quadratic: {
|
|
easeIn: function(t, b, c, d) {
|
|
return c * (t /= d) * t + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return -c * (t /= d) * (t - 2) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if((t /= d / 2) < 1) return c / 2 * t * t + b;
|
|
return -c / 2 * ((--t) * (t - 2) - 1) + b;
|
|
}
|
|
},
|
|
Cubic: {
|
|
easeIn: function(t, b, c, d) {
|
|
return c * (t /= d) * t * t + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return c * ((t = t / d - 1) * t * t + 1) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if((t /= d / 2) < 1) return c / 2 * t * t * t + b;
|
|
return c / 2 * ((t -= 2) * t * t + 2) + b;
|
|
}
|
|
},
|
|
Quartic: {
|
|
easeIn: function(t, b, c, d) {
|
|
return c * (t /= d) * t * t * t + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return -c * ((t = t / d - 1) * t * t * t - 1) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if((t /= d / 2) < 1) return c / 2 * t * t * t * t + b;
|
|
return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
|
|
}
|
|
},
|
|
Quintic: {
|
|
easeIn: function(t, b, c, d) {
|
|
return c * (t /= d) * t * t * t * t + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if((t /= d / 2) < 1) return c / 2 * t * t * t * t * t + b;
|
|
return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
|
|
}
|
|
},
|
|
Sine: {
|
|
easeIn: function(t, b, c, d) {
|
|
return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return c * Math.sin(t / d * (Math.PI / 2)) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
|
|
}
|
|
},
|
|
Exponential: {
|
|
easeIn: function(t, b, c, d) {
|
|
return(t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return(t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if(t == 0) return b;
|
|
if(t == d) return b + c;
|
|
if((t /= d / 2) < 1) return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
|
|
return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
|
|
}
|
|
},
|
|
Circular: {
|
|
easeIn: function(t, b, c, d) {
|
|
return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if((t /= d / 2) < 1) return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
|
|
return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
|
|
}
|
|
},
|
|
Elastic: {
|
|
easeIn: function(t, b, c, d, a, p) {
|
|
if(t == 0) return b;
|
|
if((t /= d) == 1) return b + c;
|
|
if(!p) p = d * .3;
|
|
if(!a || a < Math.abs(c)) {
|
|
a = c;
|
|
var s = p / 4;
|
|
} else var s = p / (2 * Math.PI) * Math.asin(c / a);
|
|
return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
|
|
},
|
|
easeOut: function(t, b, c, d, a, p) {
|
|
if(t == 0) return b;
|
|
if((t /= d) == 1) return b + c;
|
|
if(!p) p = d * .3;
|
|
if(!a || a < Math.abs(c)) {
|
|
a = c;
|
|
var s = p / 4;
|
|
} else var s = p / (2 * Math.PI) * Math.asin(c / a);
|
|
return(a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b);
|
|
},
|
|
easeInOut: function(t, b, c, d, a, p) {
|
|
if(t == 0) return b;
|
|
if((t /= d / 2) == 2) return b + c;
|
|
if(!p) p = d * (.3 * 1.5);
|
|
if(!a || a < Math.abs(c)) {
|
|
a = c;
|
|
var s = p / 4;
|
|
} else var s = p / (2 * Math.PI) * Math.asin(c / a);
|
|
if(t < 1) return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
|
|
return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
|
|
}
|
|
},
|
|
Back: {
|
|
easeIn: function(t, b, c, d, s) {
|
|
if(s == undefined) s = 1.70158;
|
|
return c * (t /= d) * t * ((s + 1) * t - s) + b;
|
|
},
|
|
easeOut: function(t, b, c, d, s) {
|
|
if(s == undefined) s = 1.70158;
|
|
return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
|
|
},
|
|
easeInOut: function(t, b, c, d, s) {
|
|
if(s == undefined) s = 1.70158;
|
|
if((t /= d / 2) < 1) return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
|
|
return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
|
|
}
|
|
},
|
|
Bounce: {
|
|
easeIn: function(t, b, c, d) {
|
|
return c - Tween.Bounce.easeOut(d - t, 0, c, d) + b;
|
|
},
|
|
easeOut: function(t, b, c, d) {
|
|
if((t /= d) < (1 / 2.75)) {
|
|
return c * (7.5625 * t * t) + b;
|
|
} else if(t < (2 / 2.75)) {
|
|
return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
|
|
} else if(t < (2.5 / 2.75)) {
|
|
return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
|
|
} else {
|
|
return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
|
|
}
|
|
},
|
|
easeInOut: function(t, b, c, d) {
|
|
if(t < d / 2) return Tween.Bounce.easeIn(t * 2, 0, c, d) * .5 + b;
|
|
else return Tween.Bounce.easeOut(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
|
|
}
|
|
}
|
|
};
|
|
return Tween;
|
|
},
|
|
/*
|
|
接口函数
|
|
缓动效果
|
|
ele:Object=需要缓动的对象,
|
|
parameter:String=需要改变的属性：x,y,width,height,alpha,
|
|
effect:String=效果名称,
|
|
start:Int=起始值,
|
|
end:Int=结束值,
|
|
speed:Number=运动的总秒数，支持小数
|
|
*/
|
|
animate: function(attribute) {
|
|
if(this.playerType == 'flashplayer') {
|
|
return this.V.animate(attribute);
|
|
}
|
|
var thisTemp = this;
|
|
var animateId = 'animate_' + this.randomString();
|
|
var obj = {
|
|
element: null,
|
|
parameter: 'x',
|
|
static: false,
|
|
effect: 'None.easeIn',
|
|
start: null,
|
|
end: null,
|
|
speed: 0,
|
|
overStop: false,
|
|
pauseStop: false, //暂停播放时缓动是否暂停
|
|
callBack: null
|
|
};
|
|
obj = this.standardization(obj, attribute);
|
|
if(obj['element'] == null || obj['speed'] == 0) {
|
|
return false;
|
|
}
|
|
var w = this.PD.offsetWidth,
|
|
h = this.PD.offsetHeight;
|
|
var effArr = (obj['effect'] + '.').split('.');
|
|
var tweenFun = this.tween()[effArr[0]][effArr[1]];
|
|
var eleCoor = {
|
|
x: 0,
|
|
y: 0
|
|
};
|
|
if(this.isUndefined(tweenFun)) {
|
|
return false;
|
|
}
|
|
//先将该元件从元件数组里删除，让其不再跟随播放器的尺寸改变而改变位置
|
|
var def = this.arrIndexOf(this.elementArr, obj['element'].className);
|
|
if(def > -1) {
|
|
this.elementArr.splice(def, 1);
|
|
}
|
|
//var run = true;
|
|
var css = {};
|
|
//对传递的参数进行转化，x和y转化成left,top
|
|
var pm = this.getElement(obj['element']); //包含x,y,width,height,alpha属性
|
|
var t = 0; //当前时间
|
|
var b = 0; //初始值
|
|
var c = 0; //变化量
|
|
var d = obj['speed'] * 1000; //持续时间
|
|
var timerTween = null;
|
|
var tweenObj = null;
|
|
var start = obj['start'] == null ? '' : obj['start'].toString();
|
|
var end = obj['end'] == null ? '' : obj['end'].toString();
|
|
switch(obj['parameter']) {
|
|
case 'x':
|
|
if(obj['start'] == null) {
|
|
b = pm['x'];
|
|
} else {
|
|
if(start.substring(start.length - 1, start.length) == '%') {
|
|
b = parseInt(start) * w * 0.01;
|
|
} else {
|
|
b = parseInt(start);
|
|
}
|
|
|
|
}
|
|
if(obj['end'] == null) {
|
|
c = pm['x'] - b;
|
|
} else {
|
|
if(end.substring(end.length - 1, end.length) == '%') {
|
|
c = parseInt(end) * w * 0.01 - b;
|
|
} else if(end.substring(0, 1) == '-' || end.substring(0, 1) == '+') {
|
|
if(typeof(obj['end']) == 'number') {
|
|
c = parseInt(obj['end']) - b;
|
|
} else {
|
|
c = parseInt(end);
|
|
}
|
|
|
|
} else {
|
|
c = parseInt(end) - b;
|
|
}
|
|
}
|
|
break;
|
|
case 'y':
|
|
if(obj['start'] == null) {
|
|
b = pm['y'];
|
|
} else {
|
|
if(start.substring(start.length - 1, start.length) == '%') {
|
|
b = parseInt(start) * h * 0.01;
|
|
} else {
|
|
b = parseInt(start);
|
|
}
|
|
|
|
}
|
|
if(obj['end'] == null) {
|
|
c = pm['y'] - b;
|
|
} else {
|
|
if(end.substring(end.length - 1, end.length) == '%') {
|
|
c = parseInt(end) * h * 0.01 - b;
|
|
} else if(end.substring(0, 1) == '-' || end.substring(0, 1) == '+') {
|
|
if(typeof(obj['end']) == 'number') {
|
|
c = parseInt(obj['end']) - b;
|
|
} else {
|
|
c = parseInt(end);
|
|
}
|
|
} else {
|
|
c = parseInt(end) - b;
|
|
}
|
|
}
|
|
break;
|
|
case 'alpha':
|
|
if(obj['start'] == null) {
|
|
b = pm['alpha'] * 100;
|
|
} else {
|
|
if(start.substring(start.length - 1, start.length) == '%') {
|
|
b = parseInt(obj['start']);
|
|
} else {
|
|
b = parseInt(obj['start'] * 100);
|
|
}
|
|
|
|
}
|
|
if(obj['end'] == null) {
|
|
c = pm['alpha'] * 100 - b;
|
|
} else {
|
|
if(end.substring(end.length - 1, end.length) == '%') {
|
|
c = parseInt(end) - b;
|
|
} else if(end.substring(0, 1) == '-' || end.substring(0, 1) == '+') {
|
|
if(typeof(obj['end']) == 'number') {
|
|
c = parseInt(obj['end']) * 100 - b;
|
|
} else {
|
|
c = parseInt(obj['end']) * 100;
|
|
}
|
|
} else {
|
|
c = parseInt(obj['end']) * 100 - b;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
var callBack = function() {
|
|
var index = thisTemp.arrIndexOf(thisTemp.animateElementArray, animateId);
|
|
if(index > -1) {
|
|
thisTemp.animateArray.splice(index, 1);
|
|
thisTemp.animateElementArray.splice(index, 1);
|
|
}
|
|
index = thisTemp.arrIndexOf(thisTemp.animatePauseArray, animateId);
|
|
if(index > -1) {
|
|
thisTemp.animatePauseArray.splice(index, 1);
|
|
}
|
|
if(obj['callBack'] != null && obj['element'] && obj['callBack'] != 'callBack' && obj['callBack'] != 'tweenX' && obj['tweenY'] != 'callBack' && obj['callBack'] != 'tweenAlpha') {
|
|
var cb = eval(obj['callBack']);
|
|
cb(obj['element']);
|
|
obj['callBack'] = null;
|
|
}
|
|
};
|
|
var stopTween = function() {
|
|
if(timerTween != null) {
|
|
if(timerTween.runing) {
|
|
timerTween.stop();
|
|
}
|
|
timerTween = null;
|
|
}
|
|
};
|
|
var tweenX = function() {
|
|
if(t < d) {
|
|
t += 10;
|
|
css = {
|
|
left: Math.ceil(tweenFun(t, b, c, d)) + 'px'
|
|
};
|
|
if(obj['static']) {
|
|
eleCoor = thisTemp.calculationCoor(obj['element']);
|
|
css['top'] = eleCoor['y'] + 'px';
|
|
}
|
|
thisTemp.css(obj['element'], css);
|
|
|
|
} else {
|
|
stopTween();
|
|
thisTemp.elementArr.push(obj['element'].className);
|
|
callBack();
|
|
}
|
|
};
|
|
var tweenY = function() {
|
|
if(t < d) {
|
|
t += 10;
|
|
css = {
|
|
top: Math.ceil(tweenFun(t, b, c, d)) + 'px'
|
|
};
|
|
if(obj['static']) {
|
|
eleCoor = thisTemp.calculationCoor(obj['element']);
|
|
css['left'] = eleCoor['x'] + 'px';
|
|
}
|
|
thisTemp.css(obj['element'], css);
|
|
} else {
|
|
stopTween();
|
|
thisTemp.elementArr.push(obj['element'].className);
|
|
callBack();
|
|
}
|
|
};
|
|
var tweenAlpha = function() {
|
|
if(t < d) {
|
|
t += 10;
|
|
eleCoor = thisTemp.calculationCoor(obj['element']);
|
|
var ap = Math.ceil(tweenFun(t, b, c, d)) * 0.01;
|
|
css = {
|
|
filter: 'alpha(opacity:' + ap + ')',
|
|
opacity: ap.toString()
|
|
};
|
|
if(obj['static']) {
|
|
eleCoor = thisTemp.calculationCoor(obj['element']);
|
|
css['top'] = eleCoor['y'] + 'px';
|
|
css['left'] = eleCoor['x'] + 'px';
|
|
}
|
|
thisTemp.css(obj['element'], css);
|
|
} else {
|
|
stopTween();
|
|
thisTemp.elementArr.push(obj['element'].className);
|
|
callBack();
|
|
}
|
|
};
|
|
switch(obj['parameter']) {
|
|
case 'x':
|
|
tweenObj = tweenX;
|
|
break;
|
|
case 'y':
|
|
tweenObj = tweenY;
|
|
break;
|
|
case 'alpha':
|
|
tweenObj = tweenAlpha;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
timerTween = new thisTemp.timer(10, tweenObj);
|
|
timerTween.callBackFunction=callBack;
|
|
if(obj['overStop']) {
|
|
var mouseOver = function() {
|
|
if(timerTween != null && timerTween.runing) {
|
|
timerTween.stop();
|
|
}
|
|
};
|
|
this.addListenerInside('mouseover', mouseOver, obj['element']);
|
|
var mouseOut = function() {
|
|
var start = true;
|
|
if(obj['pauseStop'] && thisTemp.getMetaDate()['paused']) {
|
|
start = false;
|
|
}
|
|
if(timerTween != null && !timerTween.runing && start) {
|
|
timerTween.start();
|
|
}
|
|
};
|
|
this.addListenerInside('mouseout', mouseOut, obj['element']);
|
|
}
|
|
|
|
this.animateArray.push(timerTween);
|
|
this.animateElementArray.push(animateId);
|
|
if(obj['pauseStop']) {
|
|
this.animatePauseArray.push(animateId);
|
|
}
|
|
return animateId;
|
|
},
|
|
/*
|
|
接口函数函数
|
|
继续运行animate
|
|
*/
|
|
animateResume: function(id) {
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.animateResume(this.isUndefined(id) ? '' : id);
|
|
return;
|
|
}
|
|
var arr = [];
|
|
if(id != '' && !this.isUndefined(id) && id != 'pause') {
|
|
arr.push(id);
|
|
} else {
|
|
if(id === 'pause') {
|
|
arr = this.animatePauseArray;
|
|
} else {
|
|
arr = this.animateElementArray;
|
|
}
|
|
}
|
|
for(var i = 0; i < arr.length; i++) {
|
|
var index = this.arrIndexOf(this.animateElementArray, arr[i]);
|
|
if(index > -1) {
|
|
this.animateArray[index].start();
|
|
}
|
|
}
|
|
|
|
},
|
|
/*
|
|
接口函数
|
|
暂停运行animate
|
|
*/
|
|
animatePause: function(id) {
|
|
if(this.playerType == 'flashplayer') {
|
|
this.V.animatePause(this.isUndefined(id) ? '' : id);
|
|
return;
|
|
}
|
|
var arr = [];
|
|
if(id != '' && !this.isUndefined(id) && id != 'pause') {
|
|
arr.push(id);
|
|
} else {
|
|
if(id === 'pause') {
|
|
arr = this.animatePauseArray;
|
|
} else {
|
|
arr = this.animateElementArray;
|
|
}
|
|
}
|
|
for(var i = 0; i < arr.length; i++) {
|
|
var index = this.arrIndexOf(this.animateElementArray, arr[i]);
|
|
if(index > -1) {
|
|
this.animateArray[index].stop();
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
根据ID删除数组里对应的内容
|
|
*/
|
|
deleteAnimate: function(id) {
|
|
if(this.playerType == 'flashplayer' && this.V) {
|
|
try {
|
|
this.V.deleteAnimate(id);
|
|
} catch(event) {this.log(event);}
|
|
return;
|
|
}
|
|
//console.log(this.animateElementArray)
|
|
var index = this.arrIndexOf(this.animateElementArray, id);
|
|
if(index > -1) {
|
|
this.animateArray[index].callBackFunction();
|
|
this.animateArray.splice(index, 1);
|
|
this.animateElementArray.splice(index, 1);
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
删除外部新建的元件
|
|
*/
|
|
deleteElement: function(ele) {
|
|
if(this.playerType == 'flashplayer' && this.V) {
|
|
try {
|
|
this.V.deleteElement(ele);
|
|
} catch(event) {}
|
|
return;
|
|
}
|
|
//先将该元件从元件数组里删除，让其不再跟随播放器的尺寸改变而改变位置
|
|
var def = this.arrIndexOf(this.elementArr, ele.className);
|
|
if(def > -1) {
|
|
this.elementArr.splice(def, 1);
|
|
}
|
|
this.deleteAnimate(ele);
|
|
this.deleteChild(ele);
|
|
|
|
},
|
|
/*
|
|
--------------------------------------------------------------
|
|
共用函数部分
|
|
以下函数并非只能在本程序中使用，也可以在页面其它项目中使用
|
|
根据ID获取元素对象
|
|
*/
|
|
getByElement: function(obj, parent) {
|
|
if(this.isUndefined(parent)) {
|
|
parent = document;
|
|
}
|
|
var num = obj.substr(0, 1);
|
|
var res = [];
|
|
if(num != '#') {
|
|
if(num == '.') {
|
|
obj = obj.substr(1, obj.length);
|
|
}
|
|
if(parent.getElementsByClassName) {
|
|
res = parent.getElementsByClassName(obj);
|
|
} else {
|
|
var reg = new RegExp(' ' + obj + ' ', 'i');
|
|
var ele = parent.getElementsByTagName('*');
|
|
|
|
for(var i = 0; i < ele.length; i++) {
|
|
if(reg.test(' ' + ele[i].className + ' ')) {
|
|
res.push(ele[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(res.length > 0) {
|
|
return res[0];
|
|
} else {
|
|
return res;
|
|
}
|
|
} else {
|
|
if(num == '#') {
|
|
obj = obj.substr(1, obj.length);
|
|
}
|
|
return document.getElementById(obj);
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
功能：修改样式或获取指定样式的值，
|
|
elem：ID对象或ID对应的字符，如果多个对象一起设置，则可以使用数组
|
|
attribute：样式名称或对象，如果是对象，则省略掉value值
|
|
value：attribute为样式名称时，定义的样式值
|
|
示例一：
|
|
this.css(ID,'width','100px');
|
|
示例二：
|
|
this.css('id','width','100px');
|
|
示例三：
|
|
this.css([ID1,ID2,ID3],'width','100px');
|
|
示例四：
|
|
this.css(ID,{
|
|
width:'100px',
|
|
height:'100px'
|
|
});
|
|
示例五(获取宽度)：
|
|
var width=this.css(ID,'width');
|
|
*/
|
|
css: function(elem, attribute, value) {
|
|
var i = 0;
|
|
var k = '';
|
|
if(typeof(elem) == 'object') { //对象或数组
|
|
if(!this.isUndefined(typeof(elem.length))) { //说明是数组
|
|
for(i = 0; i < elem.length; i++) {
|
|
var el;
|
|
if(typeof(elem[i]) == 'string') {
|
|
el = this.getByElement(elem[i])
|
|
} else {
|
|
el = elem[i];
|
|
}
|
|
if(typeof(attribute) != 'object') {
|
|
if(!this.isUndefined(value)) {
|
|
el.style[attribute] = value;
|
|
}
|
|
} else {
|
|
for(k in attribute) {
|
|
if(!this.isUndefined(attribute[k])) {
|
|
el.style[k] = attribute[k];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
}
|
|
if(typeof(elem) == 'string') {
|
|
elem = this.getByElement(elem);
|
|
}
|
|
|
|
if(typeof(attribute) != 'object') {
|
|
if(!this.isUndefined(value)) {
|
|
elem.style[attribute] = value;
|
|
} else {
|
|
if(!this.isUndefined(this.getStyle(elem, attribute))) {
|
|
return this.getStyle(elem, attribute);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
for(k in attribute) {
|
|
if(!this.isUndefined(attribute[k])) {
|
|
elem.style[k] = attribute[k];
|
|
}
|
|
}
|
|
}
|
|
|
|
},
|
|
/*
|
|
内置函数
|
|
兼容型获取style
|
|
*/
|
|
getStyle: function(obj, attr) {
|
|
if(!this.isUndefined(obj.style[attr])) {
|
|
return obj.style[attr];
|
|
} else {
|
|
if(obj.currentStyle) {
|
|
return obj.currentStyle[attr];
|
|
} else {
|
|
return getComputedStyle(obj, false)[attr];
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
判断变量是否存在或值是否为undefined
|
|
*/
|
|
isUndefined: function(value) {
|
|
try {
|
|
if(value == 'undefined' || value == undefined) {
|
|
return true;
|
|
}
|
|
} catch(event) {this.log(event);}
|
|
return false;
|
|
},
|
|
/*
|
|
共用函数
|
|
外部监听函数
|
|
*/
|
|
addListener: function(name, funName) {
|
|
if(name && funName) {
|
|
if(this.playerType == 'flashplayer') {
|
|
var ff = ''; //定义用来向flashplayer传递的函数字符
|
|
if(typeof(funName) == 'function') {
|
|
ff = this.getParameterNames(funName);
|
|
}
|
|
this.V.addListener(name, ff);
|
|
return;
|
|
}
|
|
var have = false;
|
|
for(var i = 0; i < this.listenerJsArr.length; i++) {
|
|
var arr = this.listenerJsArr[i];
|
|
if(arr[0] == name && arr[1] == funName) {
|
|
have = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!have) {
|
|
this.listenerJsArr.push([name, funName]);
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
外部删除监听函数
|
|
*/
|
|
removeListener: function(name, funName) {
|
|
if(name && funName) {
|
|
if(this.playerType == 'flashplayer') {
|
|
var ff = ''; //定义用来向flashplayer传递的函数字符
|
|
if(typeof(funName) == 'function') {
|
|
ff = this.getParameterNames(funName);
|
|
}
|
|
this.V.removeListener(name, ff);
|
|
return;
|
|
}
|
|
for(var i = 0; i < this.listenerJsArr.length; i++) {
|
|
var arr = this.listenerJsArr[i];
|
|
if(arr[0] == name && arr[1] == funName) {
|
|
this.listenerJsArr.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
内部监听函数，调用方式：
|
|
this.addListenerInside('click',function(event){},[ID]);
|
|
d值为空时，则表示监听当前的视频播放器
|
|
*/
|
|
addListenerInside: function(e, f, d, t) {
|
|
if(this.isUndefined(t)) {
|
|
t = false;
|
|
}
|
|
var o = this.V;
|
|
if(!this.isUndefined(d)) {
|
|
o = d;
|
|
}
|
|
if(o.addEventListener) {
|
|
try {
|
|
o.addEventListener(e, f, t);
|
|
} catch(event) {}
|
|
} else if(o.attachEvent) {
|
|
try {
|
|
o.attachEvent('on' + e, f);
|
|
} catch(event) {}
|
|
} else {
|
|
o['on' + e] = f;
|
|
}
|
|
},
|
|
/*
|
|
删除内部监听函数，调用方式：
|
|
this.removeListenerInside('click',function(event){}[,ID]);
|
|
d值为空时，则表示监听当前的视频播放器
|
|
*/
|
|
removeListenerInside: function(e, f, d, t) {
|
|
/*if(this.playerType=='flashplayer' && this.getParameterNames(f) && this.isUndefined(d)) {
|
|
return;
|
|
}*/
|
|
if(this.isUndefined(t)) {
|
|
t = false;
|
|
}
|
|
var o = this.V;
|
|
if(!this.isUndefined(d)) {
|
|
o = d;
|
|
}
|
|
if(o.removeEventListener) {
|
|
try {
|
|
this.addNum--;
|
|
o.removeEventListener(e, f, t);
|
|
} catch(e) {}
|
|
} else if(o.detachEvent) {
|
|
try {
|
|
o.detachEvent('on' + e, f);
|
|
} catch(e) {}
|
|
} else {
|
|
o['on' + e] = null;
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
统一分配监听，以达到跟as3同样效果
|
|
*/
|
|
sendJS: function(name, val) {
|
|
var list = this.listenerJsArr;
|
|
var obj = {
|
|
variable: this.vars['variable']
|
|
};
|
|
if(this.vars['playerID']) {
|
|
obj['playerID'] = this.vars['playerID'];
|
|
}
|
|
for(var i = 0; i < list.length; i++) {
|
|
var arr = list[i];
|
|
if(arr[0] == name) {
|
|
if(val) {
|
|
switch(arr[1].length) {
|
|
case 1:
|
|
arr[1](val);
|
|
break;
|
|
case 2:
|
|
arr[1](val, obj);
|
|
break;
|
|
default:
|
|
arr[1]();
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
switch(arr[1].length) {
|
|
case 1:
|
|
arr[1](obj);
|
|
break;
|
|
default:
|
|
arr[1]();
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
获取函数名称，如 function ckplayer(){} var fun=ckplayer，则getParameterNames(fun)=ckplayer
|
|
*/
|
|
getParameterNames: function(fn) {
|
|
if(typeof(fn) !== 'function') {
|
|
return false;
|
|
}
|
|
var COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
|
|
var code = fn.toString().replace(COMMENTS, '');
|
|
var result = code.slice(code.indexOf(' ') + 1, code.indexOf('('));
|
|
return result === null ? false : result;
|
|
},
|
|
/*
|
|
共用函数
|
|
获取当前本地时间
|
|
*/
|
|
getNowDate: function() {
|
|
var nowDate = new Date();
|
|
var month = nowDate.getMonth() + 1;
|
|
var date = nowDate.getDate();
|
|
var hours = nowDate.getHours();
|
|
var minutes = nowDate.getMinutes();
|
|
var seconds = nowDate.getSeconds();
|
|
var tMonth = '',
|
|
tDate = '',
|
|
tHours = '',
|
|
tMinutes = '',
|
|
tSeconds = '',
|
|
tSeconds = (seconds < 10) ? '0' + seconds : seconds + '',
|
|
tMinutes = (minutes < 10) ? '0' + minutes : minutes + '',
|
|
tHours = (hours < 10) ? '0' + hours : hours + '',
|
|
tDate = (date < 10) ? '0' + date : date + '',
|
|
tMonth = (month < 10) ? '0' + month : month + '';
|
|
return tMonth + '/' + tDate + ' ' + tHours + ':' + tMinutes + ':' + tSeconds;
|
|
},
|
|
/*
|
|
共用函数
|
|
格式化时分秒
|
|
seconds:Int：秒数
|
|
ishours:Boolean：是否显示小时，如果设置成false，则会显示如80:20，表示1小时20分钟20秒
|
|
*/
|
|
formatTime: function(seconds, ishours) {
|
|
var tSeconds = '',
|
|
tMinutes = '',
|
|
tHours = '';
|
|
if(isNaN(seconds)) {
|
|
seconds = 0;
|
|
}
|
|
var s = Math.floor(seconds % 60),
|
|
m = 0,
|
|
h = 0;
|
|
if(ishours) {
|
|
m = Math.floor(seconds / 60) % 60;
|
|
h = Math.floor(seconds / 3600);
|
|
} else {
|
|
m = Math.floor(seconds / 60);
|
|
}
|
|
tSeconds = (s < 10) ? '0' + s : s + '';
|
|
tMinutes = (m > 0) ? ((m < 10) ? '0' + m + ':' : m + ':') : '00:';
|
|
tHours = (h > 0) ? ((h < 10) ? '0' + h + ':' : h + ':') : '';
|
|
if(ishours) {
|
|
return tHours + tMinutes + tSeconds;
|
|
} else {
|
|
return tMinutes + tSeconds;
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
获取一个随机字符
|
|
len：随机字符长度
|
|
*/
|
|
randomString: function(len) {
|
|
len = len || 16;
|
|
var chars = 'abcdefghijklmnopqrstuvwxyz';
|
|
var maxPos = chars.length;
|
|
var val = '';
|
|
for(i = 0; i < len; i++) {
|
|
val += chars.charAt(Math.floor(Math.random() * maxPos));
|
|
}
|
|
return 'ch' + val;
|
|
},
|
|
/*
|
|
共用函数
|
|
获取字符串长度,中文算两,英文数字算1
|
|
*/
|
|
getStringLen: function(str) {
|
|
var len = 0;
|
|
for(var i = 0; i < str.length; i++) {
|
|
if(str.charCodeAt(i) > 127 || str.charCodeAt(i) == 94) {
|
|
len += 2;
|
|
} else {
|
|
len++;
|
|
}
|
|
}
|
|
return len;
|
|
},
|
|
/*
|
|
内部函数
|
|
用来为ajax提供支持
|
|
*/
|
|
createXHR: function() {
|
|
if(window.XMLHttpRequest) {
|
|
//IE7+、Firefox、Opera、Chrome 和Safari
|
|
return new XMLHttpRequest();
|
|
} else if(window.ActiveXObject) {
|
|
//IE6 及以下
|
|
try {
|
|
return new ActiveXObject('Microsoft.XMLHTTP');
|
|
} catch(event) {
|
|
try {
|
|
return new ActiveXObject('Msxml2.XMLHTTP');
|
|
} catch(event) {
|
|
this.eject(this.errorList[7]);
|
|
}
|
|
}
|
|
} else {
|
|
this.eject(this.errorList[8]);
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
ajax调用
|
|
*/
|
|
ajax: function(cObj) {
|
|
var thisTemp = this;
|
|
var callback = null;
|
|
var obj = {
|
|
method: 'get', //请求类型
|
|
dataType: 'json', //请求的数据类型
|
|
charset: 'utf-8',
|
|
async: false, //true表示异步，false表示同步
|
|
url: '',
|
|
data: null,
|
|
success: null
|
|
};
|
|
if(typeof(cObj) != 'object') {
|
|
this.eject(this.errorList[9]);
|
|
return;
|
|
}
|
|
obj = this.standardization(obj, cObj);
|
|
if(obj.dataType === 'json' || obj.dataType === 'text' || obj.dataType === 'html') {
|
|
var xhr = this.createXHR();
|
|
callback = function() {
|
|
//判断http的交互是否成功
|
|
if(xhr.status == 200) {
|
|
if(obj.success == null) {
|
|
return;
|
|
}
|
|
if(obj.dataType === 'json') {
|
|
try {
|
|
obj.success(eval('(' + xhr.responseText + ')')); //回调传递参数
|
|
} catch(event) {
|
|
obj.success(null);
|
|
}
|
|
} else {
|
|
obj.success(xhr.responseText); //回调传递参数
|
|
}
|
|
} else {
|
|
thisTemp.eject(thisTemp.errorList[10], 'Ajax.status:' + xhr.status);
|
|
}
|
|
};
|
|
obj.url = obj.url + '?rand=' + this.randomString(6);
|
|
obj.data = this.formatParams(obj.data); //通过params()将名值对转换成字符串
|
|
if(obj.method === 'get' && !this.isUndefined(obj.data)) {
|
|
obj.url += obj.url.indexOf('?') == -1 ? '?' + obj.data : '&' + obj.data;
|
|
}
|
|
if(obj.async === true) { //true表示异步，false表示同步
|
|
xhr.onreadystatechange = function() {
|
|
if(xhr.readyState == 4) { //判断对象的状态是否交互完成
|
|
callback(); //回调
|
|
}
|
|
};
|
|
}
|
|
xhr.open(obj.method, obj.url, obj.async);
|
|
if(obj.method === 'post') {
|
|
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
|
|
xhr.setRequestHeader('charset', obj['charset']);
|
|
xhr.send(obj.data);
|
|
} else {
|
|
xhr.send(null); //get方式则填null
|
|
}
|
|
if(obj.async === false) { //同步
|
|
callback();
|
|
}
|
|
|
|
} else if(obj.dataType === 'jsonp') {
|
|
var oHead = document.getElementsByTagName('head')[0];
|
|
var oScript = document.createElement('script');
|
|
var callbackName = 'callback' + new Date().getTime();
|
|
var params = this.formatParams(obj.data) + '&callback=' + callbackName; //按时间戳拼接字符串
|
|
callback = obj.success;
|
|
//拼接好src
|
|
oScript.src = obj.url.split('?') + '?' + params;
|
|
//插入script标签
|
|
oHead.insertBefore(oScript, oHead.firstChild);
|
|
//jsonp的回调函数
|
|
window[callbackName] = function(json) {
|
|
callback(json);
|
|
oHead.removeChild(oScript);
|
|
};
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
动态加载js
|
|
*/
|
|
loadJs: function(path, success) {
|
|
var oHead = document.getElementsByTagName('HEAD').item(0);
|
|
var oScript = document.createElement('script');
|
|
oScript.type = 'text/javascript';
|
|
oScript.src = this.getNewUrl(path);
|
|
oHead.appendChild(oScript);
|
|
oScript.onload = function() {
|
|
success();
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
排除IE6-9
|
|
*/
|
|
isMsie: function() {
|
|
var browser = navigator.appName;
|
|
var b_version = navigator.appVersion;
|
|
var version = b_version.split(';');
|
|
var trim_Version = '';
|
|
if(version.length > 1) {
|
|
trim_Version = version[1].replace(/[ ]/g, '');
|
|
}
|
|
if(browser == 'Microsoft Internet Explorer' && (trim_Version == 'MSIE6.0' || trim_Version == 'MSIE7.0' || trim_Version == 'MSIE8.0' || trim_Version == 'MSIE9.0' || trim_Version == 'MSIE10.0')) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
/*
|
|
共用函数
|
|
判断是否安装了flashplayer
|
|
*/
|
|
uploadFlash: function() {
|
|
var swf;
|
|
if(navigator.userAgent.indexOf('MSIE') > 0) {
|
|
try {
|
|
var swf = new ActiveXObject('ShockwaveFlash.ShockwaveFlash');
|
|
return true;
|
|
} catch(e) {
|
|
return false;
|
|
}
|
|
}
|
|
if(navigator.userAgent.indexOf('Firefox') > 0) {
|
|
swf = navigator.plugins['Shockwave Flash'];
|
|
if(swf) {
|
|
return true
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
/*
|
|
共用函数
|
|
检测浏览器是否支持HTML5-Video
|
|
*/
|
|
supportVideo: function() {
|
|
if(!this.isMsie()) {
|
|
return false;
|
|
}
|
|
if(!!document.createElement('video').canPlayType) {
|
|
var vidTest = document.createElement('video');
|
|
var oggTest;
|
|
try {
|
|
oggTest = vidTest.canPlayType('video/ogg; codecs="theora, vorbis"');
|
|
} catch(error) {
|
|
oggTest = false;
|
|
}
|
|
if(!oggTest) {
|
|
var h264Test;
|
|
try {
|
|
h264Test = vidTest.canPlayType('video/mp4; codecs="avc1.42E01E, mp4a.40.2"');
|
|
} catch(error) {
|
|
h264Test = false;
|
|
}
|
|
if(!h264Test) {
|
|
return false;
|
|
} else {
|
|
if(h264Test == "probably") {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
if(oggTest == "probably") {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
获取属性值
|
|
*/
|
|
getDataset: function(ele, z) {
|
|
try {
|
|
return ele.dataset[z];
|
|
} catch(error) {
|
|
try {
|
|
return ele.getAttribute('data-' + z)
|
|
} catch(error) {
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
返回flashplayer的对象
|
|
*/
|
|
getObjectById: function(id) {
|
|
var x = null;
|
|
var y = this.getByElement('#' + id);
|
|
var r = 'embed';
|
|
if(y && y.nodeName == 'OBJECT') {
|
|
if(typeof(y.SetVariable) != 'undefined') {
|
|
x = y;
|
|
} else {
|
|
var z = y.getElementsByTagName(r)[0];
|
|
if(z) {
|
|
x = z;
|
|
}
|
|
}
|
|
}
|
|
return x;
|
|
},
|
|
/*
|
|
共用函数
|
|
对象转地址字符串
|
|
*/
|
|
formatParams: function(data) {
|
|
var arr = [];
|
|
for(var i in data) {
|
|
arr.push(encodeURIComponent(i) + '=' + encodeURIComponent(data[i]));
|
|
}
|
|
return arr.join('&');
|
|
},
|
|
/*
|
|
内置函数
|
|
对地址进行冒泡排序
|
|
*/
|
|
arrSort: function(arr) {
|
|
var temp = [];
|
|
for(var i = 0; i < arr.length; i++) {
|
|
for(var j = 0; j < arr.length - i; j++) {
|
|
if(!this.isUndefined(arr[j + 1]) && arr[j][3] < arr[j + 1][3]) {
|
|
temp = arr[j + 1];
|
|
arr[j + 1] = arr[j];
|
|
arr[j] = temp;
|
|
}
|
|
}
|
|
}
|
|
return arr;
|
|
},
|
|
/*
|
|
内置函数
|
|
判断文件后缀
|
|
*/
|
|
getFileExt: function(filepath) {
|
|
if(filepath != '' && !this.isUndefined(filepath)) {
|
|
if(filepath.indexOf('?') > -1) {
|
|
filepath = filepath.split('?')[0];
|
|
}
|
|
var pos = '.' + filepath.replace(/.+\./, '');
|
|
return pos;
|
|
}
|
|
return '';
|
|
},
|
|
/*
|
|
内置函数
|
|
判断是否是移动端
|
|
*/
|
|
isMobile: function() {
|
|
if(navigator.userAgent.match(/(iPhone|iPad|iPod|Android|ios)/i)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
},
|
|
/*
|
|
内置函数
|
|
搜索字符串str是否包含key
|
|
*/
|
|
isContains: function(str, key) {
|
|
return str.indexOf(key) > -1;
|
|
},
|
|
/*
|
|
内置函数
|
|
给地址添加随机数
|
|
*/
|
|
getNewUrl: function(url) {
|
|
if(this.isContains(url, '?')) {
|
|
return url += '&' + this.randomString(8) + '=' + this.randomString(8);
|
|
} else {
|
|
return url += '?' + this.randomString(8) + '=' + this.randomString(8);
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
获取clientX和clientY
|
|
*/
|
|
client: function(event) {
|
|
var eve = event || window.event;
|
|
if(this.isUndefined(eve)) {
|
|
eve = {
|
|
clientX: 0,
|
|
clientY: 0
|
|
};
|
|
}
|
|
return {
|
|
x: eve.clientX + (document.documentElement.scrollLeft || this.body.scrollLeft) - this.pdCoor['x'],
|
|
y: eve.clientY + (document.documentElement.scrollTop || this.body.scrollTop) - this.pdCoor['y']
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
获取节点的绝对坐标
|
|
*/
|
|
getCoor: function(obj) {
|
|
var coor = this.getXY(obj);
|
|
return {
|
|
x: coor['x'] - this.pdCoor['x'],
|
|
y: coor['y'] - this.pdCoor['y']
|
|
};
|
|
},
|
|
getXY: function(obj) {
|
|
var parObj = obj;
|
|
var left = obj.offsetLeft;
|
|
var top = obj.offsetTop;
|
|
while(parObj = parObj.offsetParent) {
|
|
left += parObj.offsetLeft;
|
|
top += parObj.offsetTop;
|
|
}
|
|
return {
|
|
x: left,
|
|
y: top
|
|
};
|
|
},
|
|
/*
|
|
内置函数
|
|
删除本对象的所有属性
|
|
*/
|
|
removeChild: function() {
|
|
if(this.playerType == 'html5video') {
|
|
//删除计时器
|
|
var i = 0;
|
|
var timerArr = [this.timerError, this.timerFull, this.timerTime, this.timerBuffer, this.timerClick, this.timerLoading, this.timerCBar, this.timerVCanvas];
|
|
for(i = 0; i < timerArr.length; i++) {
|
|
if(timerArr[i] != null) {
|
|
if(timerArr[i].runing) {
|
|
timerArr[i].stop();
|
|
}
|
|
timerArr[i] = null;
|
|
}
|
|
}
|
|
//删除事件监听
|
|
var ltArr = this.listenerJsArr;
|
|
for(i = 0; i < ltArr.length; i++) {
|
|
this.removeListener(ltArr[i][0], ltArr[i][1]);
|
|
}
|
|
}
|
|
this.playerType == '';
|
|
this.V = null;
|
|
if(this.showFace) {
|
|
this.deleteChild(this.CB['menu']);
|
|
}
|
|
this.deleteChild(this.PD);
|
|
this.CD.innerHTML = '';
|
|
},
|
|
/*
|
|
内置函数
|
|
画封闭的图形
|
|
*/
|
|
canvasFill: function(name, path) {
|
|
name.beginPath();
|
|
for(var i = 0; i < path.length; i++) {
|
|
var d = path[i];
|
|
if(i > 0) {
|
|
name.lineTo(d[0], d[1]);
|
|
} else {
|
|
name.moveTo(d[0], d[1]);
|
|
}
|
|
}
|
|
name.closePath();
|
|
name.fill();
|
|
},
|
|
/*
|
|
内置函数
|
|
画矩形
|
|
*/
|
|
canvasFillRect: function(name, path) {
|
|
for(var i = 0; i < path.length; i++) {
|
|
var d = path[i];
|
|
name.fillRect(d[0], d[1], d[2], d[3]);
|
|
}
|
|
},
|
|
/*
|
|
共用函数
|
|
删除容器节点
|
|
*/
|
|
deleteChild: function(f) {
|
|
var def = this.arrIndexOf(this.elementArr, f.className);
|
|
if(def > -1) {
|
|
this.elementArr.splice(def, 1);
|
|
}
|
|
var childs = f.childNodes;
|
|
for(var i = childs.length - 1; i >= 0; i--) {
|
|
f.removeChild(childs[i]);
|
|
}
|
|
|
|
if(f && f != null && f.parentNode) {
|
|
try {
|
|
if(f.parentNode) {
|
|
f.parentNode.removeChild(f);
|
|
|
|
}
|
|
|
|
} catch(event) {}
|
|
}
|
|
},
|
|
/*
|
|
内置函数
|
|
根据容器的宽高,内部节点的宽高计算出内部节点的宽高及坐标
|
|
*/
|
|
getProportionCoor: function(stageW, stageH, vw, vh) {
|
|
var w = 0,
|
|
h = 0,
|
|
x = 0,
|
|
y = 0;
|
|
if(stageW / stageH < vw / vh) {
|
|
w = stageW;
|
|
h = w * vh / vw;
|
|
} else {
|
|
h = stageH;
|
|
w = h * vw / vh;
|
|
}
|
|
x = (stageW - w) * 0.5;
|
|
y = (stageH - h) * 0.5;
|
|
return {
|
|
width: parseInt(w),
|
|
height: parseInt(h),
|
|
x: parseInt(x),
|
|
y: parseInt(y)
|
|
};
|
|
},
|
|
/*
|
|
共用函数
|
|
将字幕文件内容转换成数组
|
|
*/
|
|
parseSrtSubtitles: function(srt) {
|
|
var subtitles = [];
|
|
var textSubtitles = [];
|
|
var i = 0;
|
|
var arrs = srt.split('\n');
|
|
var arr = [];
|
|
var delHtmlTag = function(str) {
|
|
return str.replace(/<[^>]+>/g, ''); //去掉所有的html标记
|
|
};
|
|
for(i = 0; i < arrs.length; i++) {
|
|
if(arrs[i].replace(/\s/g, '').length > 0) {
|
|
arr.push(arrs[i]);
|
|
} else {
|
|
if(arr.length > 0) {
|
|
textSubtitles.push(arr);
|
|
}
|
|
arr = [];
|
|
}
|
|
}
|
|
for(i = 0; i < textSubtitles.length; ++i) {
|
|
var textSubtitle = textSubtitles[i];
|
|
if(textSubtitle.length >= 2) {
|
|
var sn = textSubtitle[0]; // 字幕的序号
|
|
var startTime = this.toSeconds(this.trim(textSubtitle[1].split(' --> ')[0])); // 字幕的开始时间
|
|
var endTime = this.toSeconds(this.trim(textSubtitle[1].split(' --> ')[1])); // 字幕的结束时间
|
|
var content = [delHtmlTag(textSubtitle[2])]; // 字幕的内容
|
|
// 字幕可能有多行
|
|
if(textSubtitle.length > 2) {
|
|
for(var j = 3; j < textSubtitle.length; j++) {
|
|
content.push(delHtmlTag(textSubtitle[j]));
|
|
}
|
|
}
|
|
// 字幕对象
|
|
var subtitle = {
|
|
sn: sn,
|
|
startTime: startTime,
|
|
endTime: endTime,
|
|
content: content
|
|
};
|
|
subtitles.push(subtitle);
|
|
}
|
|
}
|
|
return subtitles;
|
|
},
|
|
/*
|
|
共用函数
|
|
计时器,该函数模拟as3中的timer原理
|
|
time:计时时间,单位:毫秒
|
|
fun:接受函数
|
|
number:运行次数,不设置则无限运行
|
|
*/
|
|
timer: function(time, fun, number) {
|
|
var thisTemp = this;
|
|
this.time = 10; //运行间隔
|
|
this.fun = null; //监听函数
|
|
this.timeObj = null; //setInterval对象
|
|
this.number = 0; //已运行次数
|
|
this.numberTotal = null; //总至需要次数
|
|
this.runing = false; //当前状态
|
|
this.startFun = function() {
|
|
thisTemp.number++;
|
|
thisTemp.fun();
|
|
if(thisTemp.numberTotal != null && thisTemp.number >= thisTemp.numberTotal) {
|
|
thisTemp.stop();
|
|
}
|
|
};
|
|
this.start = function() {
|
|
if(!thisTemp.runing) {
|
|
thisTemp.runing = true;
|
|
thisTemp.timeObj = window.setInterval(thisTemp.startFun, time);
|
|
}
|
|
};
|
|
this.stop = function() {
|
|
if(thisTemp.runing) {
|
|
thisTemp.runing = false;
|
|
window.clearInterval(thisTemp.timeObj);
|
|
thisTemp.timeObj = null;
|
|
}
|
|
};
|
|
if(time) {
|
|
this.time = time;
|
|
}
|
|
if(fun) {
|
|
this.fun = fun;
|
|
}
|
|
if(number) {
|
|
this.numberTotal = number;
|
|
}
|
|
this.start();
|
|
},
|
|
/*
|
|
共用函数
|
|
将时分秒转换成秒
|
|
*/
|
|
toSeconds: function(t) {
|
|
var s = 0.0;
|
|
if(t) {
|
|
var p = t.split(':');
|
|
for(i = 0; i < p.length; i++) {
|
|
s = s * 60 + parseFloat(p[i].replace(',', '.'));
|
|
}
|
|
}
|
|
return s;
|
|
},
|
|
/*
|
|
共用函数
|
|
将对象Object标准化
|
|
*/
|
|
standardization: function(o, n) { //n替换进o
|
|
var h = {};
|
|
var k;
|
|
for(k in o) {
|
|
h[k] = o[k];
|
|
}
|
|
for(k in n) {
|
|
var type = typeof(h[k]);
|
|
switch(type) {
|
|
case 'number':
|
|
h[k] = parseFloat(n[k]);
|
|
break;
|
|
default:
|
|
h[k] = n[k];
|
|
break;
|
|
}
|
|
|
|
}
|
|
return h;
|
|
},
|
|
/*
|
|
共用函数
|
|
搜索数组
|
|
*/
|
|
arrIndexOf: function(arr, key) {
|
|
var re = new RegExp(key, ['']);
|
|
return(arr.toString().replace(re, '┢').replace(/[^,┢]/g, '')).indexOf('┢');
|
|
},
|
|
/*
|
|
共用函数
|
|
去掉空格
|
|
*/
|
|
trim: function(str) {
|
|
if(str!=''){
|
|
return str.replace(/(^\s*)|(\s*$)/g, '');
|
|
}
|
|
return '';
|
|
},
|
|
/*
|
|
共用函数
|
|
输出内容到控制台
|
|
*/
|
|
log: function(val) {
|
|
try {
|
|
console.log(val);
|
|
} catch(e) {}
|
|
},
|
|
/*
|
|
共用函数
|
|
弹出提示
|
|
*/
|
|
eject: function(er, val) {
|
|
if(!this.vars['debug']) {
|
|
return;
|
|
}
|
|
var errorVal = er[1];
|
|
if(!this.isUndefined(val)) {
|
|
errorVal = errorVal.replace('[error]', val);
|
|
}
|
|
var value = 'error ' + er[0] + ':' + errorVal;
|
|
try {
|
|
this.log(value);
|
|
} catch(e) {}
|
|
}
|
|
};
|
|
window.ckplayer = ckplayer;
|
|
})();
|