精华内容
下载资源
问答
  • Atitit 模板引擎总结 v4 saa 目录 1. 模板引擎 1 1.1. 构成渲染引擎+指令系统 1 1.2. 模板语法mustache语法 es6 el语法 1 2. 常见模板步骤 1 2.1. 1)定义模板字符串 1 2.2. 2) 构造模板引擎 预编译...

    Atitit 模板引擎总结 v4 saa

    目录

    1. 模板引擎 1

    1.1. 构成渲染引擎+指令系统 1

    1.2. 模板语法mustache语法   es6 el语法 1

    2. 常见模板步骤 1

    2.1. 1)定义模板字符串  1

    2.2. 2)   构造模板引擎 预编译模板 2

    2.3. //构造上下文(Model) 2

    2.4. 渲染模板  2

    3. 流程渲染 if else  foreach 3

     

    1. 模板引擎

    Jsp+jstl    freemarker等

     

      1. 构成渲染引擎+指令系统
      2. 模板语法mustache语法   es6 el语法

    Mybatis模板  #{}   ${}

    1. 常见模板步骤

    mustache的使用非常简单,先通过script标签引入它的js文件,然后按下面的步骤操作: 

      1. 1)定义模板字符串 


    定义模板有2种方式,方式一就是在前面部分中看到的,直接用[...].join('')的方式在js代码中定义,方式二直接把模板内容用script定义在html中:

    - Hide code

    <script id="tpl" type="text/html">

        Hello {{name}}!</script>

    然后在编译模板之前,通过获取tpl的innerHTML定义原始模板串:

    - Hide code

    var tpl = document.getElementById('tpl').innerHTML.trim();

    具体要用哪种方式来定义模板,可以参考下面的建议: 
    如果这个模板要用于多个页面,推荐把模板定义在js代码中;如果这个模板只用于当前页面,推荐直接定义到script标签中,管理更方便。 

      1. 2)   构造模板引擎 预编译模板

     


    假设原始模板串已经定义好,并用tpl变量来引用,就可以通过下面的代码来预编译模板:

    - Hide code

    Mustache.parse(tpl);

    要注意的是,经过预编译之后的tpl已经不再是原来的模板串了,连数据类型都变成数组类型了,这都是预编译的结果。 
     

      1.    //构造上下文(Model)

     

      1. 渲染模板 


    渲染方式很简单:

    - Hide code

    var htmlAfterRendered = Mustache.render(tpl1, obj);

    obj引用的是一个数据源对象,mustache会把模板中那些属性标签,根据约定的规则,替换成对象的内容。htmlAfterRendered就是替换之后的字符串,你可以用它完成你需要的DOM操作。

    1. 流程渲染 if else  foreach
    1. if-else渲染2)for-each渲染

    3) 动态渲染

    当prop属性所引用的是一个函数,并且这个函数的返回值还是一个函数的话,mustache会再次调用这个返回的函数,并给它传递2个参数:text表示原来的模板内容,render表示mustache内部的执行渲染的对象,以便在这个函数内部可以通过这render对象,结合原来的模板内容,自定义渲染的逻辑,并把函数的返回值作为渲染结果(这个返回值渲染的逻辑跟{{prop}}标签完全一样):

     

    Javascript模板引擎mustache.js详解 - 流云诸葛 - 博客园.html

     

    Atitit freemarker模板总结.docx

    展开全文
  • -与2016年的v4修订版17相同。尚未更改。 -有关详细信息,请参见下面的“到目前为止的进展”部分。 错误,安全问题,功能请求 对于所有错误,安全问题和功能请求,请。 您的反馈意见对于帮助我确定要进行的工作至关...
  • 基于Advanced Locomotion System的最新市场版本(V4) 完全在C ++中实现 完全复制支持,带宽使用率低 插件结构 高度优化的生产 实现和调试功能作为单独的插件/插件类型actor组件实现,以减少基本字符类的总开销 市场...
  • 包含Bootstrap V4后,您将无法在运行Internet Explorer 9或更早版本的客户端上运行此引擎。 它建议Android上的用户使用与默认浏览器不同的浏览器,除非他们运行的是Android 5.0或更高版本。 现场游戏 是否
  • 设备树之V4L2实例

    2018-03-30 13:27:30
    一 概述 V4L2(全称Video For Linux Two)是Linux下...SoC视频模块主要功能:采集并且处理视频信号,通过DMA引擎传输数据到DDR 外部Decoder主要功能:转换视频信号,比如将HDMI信号转换为BT1120信号 注意:外部Deco...

    一 概述

    V4L2(全称Video For Linux Two)是Linux下的视频驱动框架,为Linux视频驱动和应用程序提供统一的编程规范。

    V4L2硬件系统包含两部分:SoC视频模块和外部Decoder

    SoC视频模块主要功能:采集并且处理视频信号,通过DMA引擎传输数据到DDR

    外部Decoder主要功能:转换视频信号,比如将HDMI信号转换为BT1120信号

    注意:外部Decoder通常挂载到主芯片I2C总线或者SPI总线上。

    二 V4L2实例重要属性

    slave-mode 设置device工作模式为从模式,通常将SoC视频模块设置为slave-mode,外部Decoder设置为master-mode,由外部Decoder输出同步信号给SoC视频模块

    bus-width 数字信号位宽,常用值:8,16,24

    注意:bus-width属性只适用于并行数字信号

    hsync-active 行同步信号有效电平,0表示低电平有效,1表示高电平有效

    vsync-active 帧同步信号有效电平,0表示低电平有效,1表示高电平有效

    field-even-active 表示传输偶场数据时,FID信号电平

    0表示传输偶场数据时,FID信号为低电平

    1表示传输偶场数据时,FID信号为高电平

    data-active 数据使能信号有效电平,1表示数据使能信号高电平有效,0表示数据使能信号低电平有效

    pclk-sample 表示像素时钟下降沿采样数据还是上升沿采样数据

    0表示下降沿采样数据,1表示上升沿采样数据

    channels 输入端口视频流ID

    注意:

    1使用分离同步信号采集视频,需要指定hsync-active、vsync-active、field-even-active中任意一个属性

    2使用内嵌同步信号采集视频,需要指定channels属性

    三 具体实例详解

    V4L2典型实例1:使用分离同步信号采集视频

                     图1
    

                     图2
    

    上图1为SoC视频模块设备树结点信息,工作模式为从模式

    上图2为外部Decoder设备树结点信息,工作模式为主模式

    即由adv7842芯片输出分离同步信号给vin5a。

    由于外部Decoder通常挂载到主芯片I2C总线或者SPI总线上,因此adv7842结点是I2C结点的子结点。

    hsync-active = <1>; 表示行同步信号高电平有效

    vsync-active = <1>; 表示帧同步信号高电平有效

    data-active = <1>; 表示数据使能信号高电平有效

    pclk-sample = <0>; 表示像素时钟下降沿采样数据

    V4L2典型实例2:使用内嵌同步信号采集视频

                    图3
    

                    图4
    

    上图3为SoC视频模块设备树结点信息,工作模式为从模式

    上图4为外部Decoder设备树结点信息,工作模式为主模式

    即由tvp5158芯片输出内嵌同步信号给vin6a。

    channels属性表示输入端口视频流ID,从上图4可知vin6a端口包含4个视频流,ID为0、2、4、6。

    那么问题来了,如果vin6a端口只包含1个视频流,如何配置channels属性?

    答:

    channels = <0>;

    详细实例如下图所示:

                     图5
    
    展开全文
  • SocketTool V4.exe

    2019-05-02 19:12:18
    .综述 SocketTool V4.0版本支持JavaScript编程方式,从而增加了灵活性。...它的解释器被称为 JavaScript 引擎,广泛用于客户端的脚本语言,最早是在 HTML 网 页上使用,用来给HTML 网页增加动态功能
  • 海多外链资源V4

    2012-01-05 23:00:16
    是不是先有内容,大家觉得不错,都帮你宣传,就有了外链,然后搜索引擎就给了你一个好排名?如果只有外链没有内容,或者只有内容没有外链,排名都是不长久的。所以我们做SEO第一步就是先做内容。在这里,我发现有很...
  • 所述分支存储库应包含Music Blocks v4应用程序的核心(引擎)。应在此处建立一个捆绑包,该捆绑包应作为本申请的核心;该存储库应包含用户端客户端,该客户端将通过代理模块与所述核心进行通信。 所述存储库已在此处...
  • sous-app-v4-源码

    2021-03-13 04:48:51
    自述文件 该自述文件通常会记录启动和运行应用程序所需的所有步骤。 您可能要讲的内容: Ruby版本 系统依赖 配置 数据库创建 数据库初始化 ...服务(作业队列,缓存服务器,搜索引擎等) 部署说明 ...
  • 阿赛树形论坛系统 v4

    2019-10-18 05:28:43
    03、优化各大搜索引擎的收录,全站默认全伪静态(后缀名.html)访问;04、全新原创的树形论坛架构理念,速度更快、外形更加美观,帖子之间的关系一目了然;05、集成管理员功能,提供编辑、删除、一键清理过期帖子,...
  • mass Framework fx模块 v4

    2012-11-12 18:06:00
    mass Framework第四代动画引擎,支持CSS3的变形动画,全新的中央列队,与jQuery API完全兼容。 //========================================= // 动画模块v4 //========================================== ...

    mass Framework第四代动画引擎,支持CSS3的变形动画,全新的中央列队,与jQuery API完全兼容。

    //=========================================
    // 动画模块v4
    //==========================================
    define("fx", ["$css"],function(){
        var types = {
            color:/color/i,
            scroll:/scroll/i,
            transform: /transform/i
        },
        rfxnum = /^([+\-/*]=)?([\d+.\-]+)([a-z%]*)$/i;
        function isHidden( elem ) {
            return elem.sourceIndex === 0 || $.css( elem, "display" ) === "none" || !$.contains( elem.ownerDocument.documentElement, elem );
        }
        $.mix({//缓动公式
            easing : {
                linear: function( pos ) {
                    return pos;
                },
                swing: function( pos ) {
                    return (-Math.cos(pos*Math.PI)/2) + 0.5;
                }
            },
            "@queue": [],//主列队
            tick: function(fx){//用于向主列队或元素的子列队插入动画实例,并会让停走了的定时器再次动起来
                var gotoQueue = true;
                for(var i = 0, el; el = $["@queue"][i++];){
                    if(el.symbol == fx.symbol){//★★★第一步
                        el.positive.push(fx);//子列队
                        gotoQueue = false
                        break;
                    }
                }
                if(gotoQueue){//★★★第二步
                    fx.positive = fx.positive || [];
                    $["@queue"].unshift( fx );
                }
                if ($.tick.id === null) {
                    $.tick.id = setInterval( nextTick, 1000/ fx.fps );//原始的setInterval id并执行动画
                }
            },
            //由于构建更高级的基于元素节点的复合动画
            fx: function ( nodes, duration, hash, effects ){
                nodes = nodes.mass ? nodes : $(nodes);
                var props =  hash || duration ;
                props = typeof props === "object" ? props : {}
    
                if(typeof duration === "function"){// fx(obj fn)
                    hash = duration;               // fx(obj, 500, fn)
                    duration = 500;
                }
                if(typeof hash === "function"){   //  fx(obj, num, fn)
                    props.after = hash;           //  fx(obj, num, {after: fn})
                }
                if( effects ){
                    for(var i in effects){
                        if(typeof effects[i] === "function"){
                            var old = props[i];
                            props[i] = function(node, fx ){
                                effects[i].call(node, node, fx);
                                if(typeof old === "function"){
                                    old.call(node, node, fx);
                                }
                            }
                        }else{
                            props[i] = effects[i]
                        }
                    }
                }
                return nodes.fx(duration || 500, props);
            },
            //show 开始时计算其width1 height1 保存原来的width height display改为inline-block或block overflow处理 赋值(width1,height1)
            //hide 保存原来的width height 赋值为(0,0) overflow处理 结束时display改为none;
            //toggle 开始时判定其是否隐藏,使用再决定使用何种策略
            show: function(node, fx){
                if(node.nodeType == 1 && isHidden(node)) {
                    var display =  $._data(node, "olddisplay");
                    if(!display || display == "none"){
                        display = parseDisplay(node.nodeName)
                        $._data(node, "olddisplay", display);
                    }
                    node.style.display = display;
                    if(fx && ("width" in fx || "height" in fx)){//如果是缩放操作
                        //修正内联元素的display为inline-block,以让其可以进行width/height的动画渐变
                        if ( display === "inline" && $.css( node, "float" ) === "none" ) {
                            if ( !$.support.inlineBlockNeedsLayout ) {//w3c
                                node.style.display = "inline-block";
                            } else {//IE
                                if ( display === "inline" ) {
                                    node.style.display = "inline-block";
                                }else {
                                    node.style.display = "inline";
                                    node.style.zoom = 1;
                                }
                            }
                        }
                    }
                }
            },
            hide: function(node, fx){
                if(node.nodeType == 1 && !isHidden(node)){
                    var display = $.css( node, "display" );
                    if ( display !== "none" && !$._data( node, "olddisplay" ) ) {
                        $._data( node, "olddisplay", display );
                    }
                    if( fx ){//缩小
                        if("width" in fx || "height" in fx){//如果是缩放操作
                            //确保内容不会溢出,记录原来的overflow属性,因为IE在改变overflowX与overflowY时,overflow不会发生改变
                            fx.overflow = [ node.style.overflow, node.style.overflowX, node.style.overflowY ];
                            node.style.overflow = "hidden";
                        }
                        var after = fx.after;
                        fx.after = function( node, fx ){
                            node.style.display = "none";
                            if ( fx.overflow != null && !$.support.keepSize  ) {
                                [ "", "X", "Y" ].forEach(function (postfix,index) {
                                    node.style[ "overflow" + postfix ] = fx.overflow[index]
                                });
                            }
                            if(typeof after == "function"){
                                after.call( node, node, fx );
                            }
                        };
                    }else{
                        node.style.display = "none";
                    }
                }
            },
            toggle: function( node ){
                $[ isHidden(node) ? "show" : "hide" ]( node );
            }
        })
        //用于从主列队中剔除已经完成或被强制完成的动画实例,一旦主列队被清空,还负责中止定时器,节省内存
        function nextTick() {
            var fxs = $["@queue"], i = fxs.length;
            while(--i >= 0){
                if ( !(fxs[i].symbol && animate(fxs[i], i)) ) {
                    fxs.splice(i, 1);
                }
            }
            fxs.length || (clearInterval($.tick.id), $.tick.id = null);
        }
        $.tick.id = null;
        $.fn.fx = function( duration, hash, /*internal*/ p  ){
            if(typeof duration === "number" ){
                hash = hash || {};
                for( var name in hash){
                    p = $.cssName(name) || name;
                    if( name != p ){
                        hash[ p ] = hash[ name ];//收集用于渐变的属性
                        delete hash[ name ];
                    }
                }
                if(typeof hash.easing !== "function"){//转换easing属性为缓动公式
                    var easing = (hash.easing || "swing").toLowerCase() ;
                    hash.easing = $.easing[ easing ] || $.easing.swing;
                }
                for(var i = 0, node; node = this[i++];){
                    var fx = new Fx;
                    $.mix(fx, hash)
                    fx.method = "noop"
                    fx.duration = duration
                    fx.symbol = node;
                    $.tick( fx );
                }
                return this;
            }else{
                throw "First argument must be number "
            }
        }
    
        var cssTransform = $.support.transform
        $.mix($.fx, {
            fps: 30,
            "@debug": 1,
            type: function (attr){//  用于取得适配器的类型
                for(var i in types){
                    if(types[i].test(attr)){
                        return i;
                    }
                }
                return "_default";
            },
            update: {
                scroll: function(node, per, end, obj){
                    node[obj.name] = (end ? obj.to :  obj.from + (obj.to - obj.from ) * obj.easing(per) ) + obj.unit
                },
                color: function(node, per, end, obj){
                    var pos = obj.easing( per ),
                    rgb = end ? obj.to : obj.from.map(function(from, i){
                        return Math.max(Math.min( parseInt( from + (obj.to[i] - from) * pos, 10), 255), 0);
                    });
                    node.style[obj.name] = "rgb(" + rgb + ")";
                },
                transform: function(node, per, end, obj){
                    if(!obj.parsed){
                        var t = new $.Matrix2D
                        t.set.apply(t, obj.from)
                        obj.from = t.decompose();
                        t.set.apply(t, obj.to)
                        obj.to = t.decompose();
                        obj.parsed = 1;
                    }
                    var pos = obj.easing(per), transform = "", unit, startVal, endVal, i = obj.from.length;
                    while ( i-- ) {
                        startVal = obj.from[i];
                        endVal = obj.to[i];
                        unit = +false;
                        switch ( startVal[0] ) {
                            case "translate":
                                unit = "px";
                            case "scale":
                                unit || ( unit = "");
                                transform = startVal[0] + "(" +
                                (end ? endVal[1][0]: (startVal[1][0] + (endVal[1][0] - startVal[1][0]) * pos).toFixed(7) ) + unit +","+
                                (end ? endVal[1][1]: (startVal[1][1] + (endVal[1][1] - startVal[1][1]) * pos).toFixed(7) ) + unit + ") "+
                                transform;
                                break;
                            case "skewX":
                            case "rotate":
                                transform = startVal[0] + "(" +
                                (end ? endVal[1]:  (startVal[1] + (endVal[1] - startVal[1]) * pos).toFixed(7) ) +"rad) "+
                                transform;
                                break;
                        }
                    }
                    if(cssTransform){
                        node.style[ obj.name ] = transform;
                    }else{
                        $(node).css("transform",transform );
                    }
                }
            },
            parse: {
                color:function(node, from, to){
                    return [ color2array(from), color2array(to) ]
                },
                transform: function(node, from, to){
                    var zero = "matrix(1,0,0,1,0,0)"
                    from = from == "none" ? zero  : from;
                    if(to.indexOf("matrix") == -1 ){
                        var neo = node.cloneNode(true);
                        //webkit与opera如果display为none,无法取得其变形属性
                        neo.style.position = "relative";
                        neo.style.opacity = "0";
                        node.parentNode.appendChild(neo)
                        neo = $(neo).css("transform", to);
                        to = neo.css("transform");
                        neo.remove();
                    }
                    to = (from +" "+ to).match(/[-+.e\d]+/g).map(function(el){
                        return el * 1
                    });
                    from = to.splice(0,6);
                    return [from, to]
                }
            },
            _default: $.css,
            scroll: function(el, prop){
                return el[ prop ];
            }
        });
    
        if(window.WebKitCSSMatrix){
            $.fx.parse.transform = function(node, from, to){
                var first = new WebKitCSSMatrix(from), second = new WebKitCSSMatrix(to)
                from = [], to = [];
                "a,b,c,d,e,f".replace($.rword, function(p){
                    from.push( first[ p ] )
                    to.push( second[ p ] )
                });
                return [from, to]
            }
        }
        if(!$.support.cssOpacity){
            $.fx.update.opacity = function(node, per, end, obj){
                $.css(node,"opacity", (end ? obj.to :  obj.from + obj.easing(per) * (obj.to - obj.from) ))
            }
            types.opacity = /opacity/i;
        }
        var Fx = function(){}
        Fx.prototype.update = function(per, end){
            var node = this.symbol;
            for(var i = 0, obj; obj = this.props[i++];){
                var fn = $.fx.update[obj.type]
                if(fn){
                    fn(node, per, end, obj)
                }else{
                    node.style[obj.name] = (end ? obj.to :  obj.from + obj.easing(per) * (obj.to - obj.from)  ) + obj.unit
                }
            }
        }
    
        var keyworks = $.oneObject("orig,overflow,before,frame,after,easing,revert,record");
        //用于生成动画实例的关键帧(第一帧与最后一帧)所需要的计算数值与单位,并将回放用的动画放到negative子列队中去
        function fxBuilder(node, fx, index ){
            var to, parts, unit, op, props = [], revertProps = [],orig = {}, hidden = isHidden(node);
            for(var name in fx){
                if(!fx.hasOwnProperty(name) && keyworks[name]){
                    continue
                }
                var val = fx[name] //取得结束值
                var easing = fx.easing;//公共缓动公式
                var type = $.fx.type(name);
                var from = ($.fx[ type ] || $.fx._default)(node, name);//取得起始值
                //用于分解属性包中的样式或属性,变成可以计算的因子
                if( val === "show" || (val === "toggle" && hidden)){
                    val = $._data(node,"old"+name) || from;
                    fx.method = "show";
                    from = 0;
                    $.css(node, name, 0 );
                }else if(val === "hide" || val === "toggle" ){//hide
                    orig[name] = $._data(node,"old"+name, from );
                    fx.method = "hide";
                    val = 0;
                }else if($.isArray( val )){// array
                    parts = val;
                    val = parts[0];//取得第一个值
                    easing = typeof parts[1] == "function" ? parts[1]: easing;//取得第二个值或默认值
                }
    
                if($.fx.parse[ type ]){
                    parts = $.fx.parse[ type ](node, from, val );
                }else{
                    from = from == "auto" ? 0 : parseFloat(from)//确保from为数字
                    if( (parts = rfxnum.exec( val )) ){
                        to = parseFloat( parts[2] ),//确保to为数字
                        unit = $.cssNumber[ name ] ? "" : (parts[3] || "px");
                        if(parts[1]){
                            op = parts[1].charAt(0);//操作符
                            if (unit && unit !== "px" && (op == "+" || op == "-")  ) {
                                $.css(node, name, (to || 1) + unit);
                                from = ((to || 1) / parseFloat( $.css(node,name) )) * from;
                                $.css( node, name, from + unit);
                            }
                            if(op){//处理+=,-= \= *=
                                to = eval(from+op+to);
                            }
                        }
                        parts = [from, to]
                    }else{
                        parts = [0, 0]
                    }
                }
    
                from = parts[0];
                to = parts[1];
                if( from +"" === to +"" ){//不处理初止值都一样的样式与属性
                    continue
                }
                var prop = {
                    name: name,
                    from: from ,
                    to: to,
                    type: type,
                    easing: easing,
                    unit: unit
                }
                props.push( prop );
                revertProps.push($.mix({}, prop,{
                    to: from,
                    from: to
                }))
            }
            fx.props = props;
            fx.orig = orig;
            if ( fx.record || fx.revert ) {
                var fx2 = new Fx;//回滚到最初状态
                for( name in fx ){
                    fx2[ name ] = fx[ name ];
                }
                fx2.record = fx2.revert = void 0
                fx2.props = revertProps;
                var el = $["@queue"][ index ];
                el.negative = el.negative || [];
                el.negative.push(fx2);//添加已存负向列队中
            }
        }
        //驱动主列队的动画实例进行补间动画(update),执行各种回调(before, frame, after),
        //并在动画结束后,从子列队选取下一个动画实例取替自身
        function animate( fx, index ) {
            var node = fx.symbol, now =  +new Date, mix;
            if(!fx.startTime){//第一帧
                mix = fx.before;//位于动画的最前面
                mix && ( mix.call( node, node, fx ), fx.before = 0 );
                if(!fx.props){//from这个值必须在此个时间点才能侦察正确
                    fxBuilder( fx.symbol, fx, index ); //添加props属性与设置负向列队
                }
                $[ fx.method ].call(node, node, fx );//这里用于设置node.style.display
                fx.startTime = now;
            }else{
                var per = (now - fx.startTime) / fx.duration;
                var end = fx.gotoEnd || per >= 1;
                fx.update( per, end ); // 处理渐变
                if( (mix = fx.frame ) && !end ){
                    mix.call(node, node, fx ) ;
                }
                if ( end ) {//最后一帧
                    if(fx.method == "hide"){
                        for(var i in fx.orig){//还原为初始状态
                            $.css( node, i, fx.orig[i] );
                        }
                    }
                    mix = fx.after;//执行动画完成后的回调
                    mix && mix.call( node, node, fx ) ;
                    if( fx.revert && fx.negative.length){
                        Array.prototype.unshift.apply( fx.positive, fx.negative.reverse());
                        fx.negative = []; // 清空负向列队
                    }
                    var neo = fx.positive.shift();
                    if ( !neo ) {
                        return false;
                    }
                    $["@queue"][ index ] = neo;
                    neo.positive = fx.positive;
                    neo.negative = fx.negative;
                }
            }
            return true;
        }
        $.fn.delay = function( ms ){
            return this.fx( ms );
        }
        //如果clearQueue为true,是否清空列队
        //如果gotoEnd 为true,是否跳到此动画最后一帧
        $.fn.stop = function( clearQueue, gotoEnd  ){
            clearQueue = clearQueue ? "1" : ""
            gotoEnd  = gotoEnd  ? "1" : "0"
            var stopCode = parseInt( clearQueue+gotoEnd ,2 );//返回0 1 2 3
            var array = $["@queue"];
            return this.each(function(node){
                for(var i = 0, fx ; fx = array[i];i++){
                    if(fx.symbol === node){
                        switch(stopCode){//如果此时调用了stop方法
                            case 0:  //中断当前动画,继续下一个动画
                                fx.update = fx.after = fx.frame = $.noop
                                fx.revert && fx.negative.shift();
                                fx.gotoEnd = true;
                                break;
                            case 1://立即跳到最后一帧,继续下一个动画
                                fx.gotoEnd = true;
                                break;
                            case 2://清空该元素的所有动画
                                delete fx.symbol
                                break;
                            case 3:
                                Array.prototype.unshift.apply( fx.positive,fx.negative.reverse());
                                fx.negative = []; // 清空负向列队
                                for(var j =0; fx = fx.positive[j++]; ){
                                    fx.before = fx.after = fx.frame = $.noop
                                    fx.gotoEnd = true;//立即完成该元素的所有动画
                                }
                                break;
                        }
                    }
                }
            });
        }
    
        var fxAttrs = [ [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
        [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ], ["opacity"]]
        function genFx( type, num ) {//生成属性包
            var obj = {};
            fxAttrs.concat.apply([], fxAttrs.slice(0,num)).forEach(function(name) {
                obj[ name ] = type;
                if(~name.indexOf("margin")){
                    $.fx.update[name] = function(node, per, end, obj){
                        var val = (end ? obj.to :  obj.from + ( obj.from - obj.to) * obj.easing(per) ) ;
                        node.style[name] = Math.max(val,0) + obj.unit;
                    }
                }
            });
            return obj;
        }
    
        var effects = {
            slideDown: genFx( "show", 1 ),
            slideUp: genFx( "hide", 1 ),
            slideToggle: genFx( "toggle", 1 ),
            fadeIn: {
                opacity: "show"
            },
            fadeOut: {
                opacity: "hide"
            },
            fadeToggle: {
                opacity: "toggle"
            }
        }
    
        Object.keys(effects).forEach(function( method ){
            $.fn[ method ] = function( duration, hash ){
                return $.fx( this, duration, hash, effects[method] );
            }
        });
    
        [ "toggle", "show", "hide" ].forEach(function(  name, i ) {
            var toggle = $.fn[ name ];
            $.fn[ name ] = function( duration, hash ) {
                if(!arguments.length ){
                    return this.each(function(node) {
                        $.toggle( node );
                    });
                }else if(!i && typeof duration === "function" && typeof duration === "function" ){
                    return toggle.apply(this,arguments)
                }else{
                    return $.fx( this, duration, hash, genFx( name , 3) );
                }
            };
        });
        
        function beforePuff( node, fx ) {
            var position = $.css(node,"position"),
            width = $.css(node,"width"),
            height = $.css(node,"height"),
            left = $.css(node,"left"),
            top = $.css(node,"top");
            node.style.position = "relative";
            $.mix(fx, {
                width: "*=1.5",
                height: "*=1.5",
                opacity: "hide",
                left: "-=" + parseInt(width) * 0.25,
                top: "-=" + parseInt(height) * 0.25
            });
            var after = fx.after;
            fx.after = function( node, fx ){
                node.style.position = position;
                node.style.width = width;
                node.style.height = height;
                node.style.left = left;
                node.style.top = top;
                if(typeof after === "function"){
                    after.call( node, node, fx );
                }
            }
        }
        //扩大1.5倍并淡去
        $.fn.puff = function(duration, hash) {
            return $.fx( this, duration, hash, {
                before: beforePuff
            });
        }
    
        var colorMap = {
            "black":[0,0,0],
            "gray":[128,128,128],
            "white":[255,255,255],
            "orange":[255, 165, 0],
            "red":[255,0,0],
            "green":[0,128,0],
            "yellow":[255,255,0],
            "blue":[0,0,255]
        };
        var sandbox,sandboxDoc;
        function callSandbox(parent,callback){
            if ( !sandbox ) {
                sandbox = document.createElement( "iframe" );
                sandbox.frameBorder = sandbox.width = sandbox.height = 0;
            }
            parent.appendChild(sandbox);
            if ( !sandboxDoc || !sandbox.createElement ) {
                sandboxDoc = ( sandbox.contentWindow || sandbox.contentDocument ).document;
                sandboxDoc.write( ( $.support.boxModel  ? "<!doctype html>" : "" ) + "<html><body>" );
                sandboxDoc.close();
            }
            callback(sandboxDoc);
            parent.removeChild(sandbox);
        }
        function parseColor(color) {
            var value;
            callSandbox( $.html, function(doc){
                var range = doc.body.createTextRange();
                doc.body.style.color = color;
                value = range.queryCommandValue("ForeColor");
            });
            return [value & 0xff, (value & 0xff00) >> 8,  (value & 0xff0000) >> 16];
        }
        function color2array(val) {//将字符串变成数组
            var color = val.toLowerCase(),ret = [];
            if (colorMap[color]) {
                return colorMap[color];
            }
            if (color.indexOf("rgb") == 0) {
                var match = color.match(/(\d+%?)/g),
                factor = match[0].indexOf("%") !== -1 ? 2.55 : 1
                return (colorMap[color] = [ parseInt(match[0]) * factor , parseInt(match[1]) * factor, parseInt(match[2]) * factor ]);
            } else if (color.charAt(0) == '#') {
                if (color.length == 4)
                    color = color.replace(/([^#])/g, '$1$1');
                color.replace(/\w{2}/g,function(a){
                    ret.push( parseInt(a, 16))
                });
                return (colorMap[color] = ret);
            }
            if(window.VBArray){
                return (colorMap[color] = parseColor(color));
            }
            return colorMap.white;
        }
        $.parseColor = color2array
        var cacheDisplay = $.oneObject("a,abbr,b,span,strong,em,font,i,img,kbd","inline");
        var blocks = $.oneObject("div,h1,h2,h3,h4,h5,h6,section,p","block");
        $.mix(cacheDisplay ,blocks);
        function parseDisplay( nodeName ) {
            if ( !cacheDisplay[ nodeName ] ) {
                var body = document.body, elem = document.createElement(nodeName);
                body.appendChild(elem)
                var display = $.css( elem, "display" );
                body.removeChild(elem);
                // 先尝试连结到当前DOM树去取,但如果此元素的默认样式被污染了,就使用iframe去取
                if ( display === "none" || display === "" ) {
                    callSandbox(body, function(doc){
                        elem = doc.createElement( nodeName );
                        doc.body.appendChild( elem );
                        display = $.css( elem, "display" );
                    });
                }
                cacheDisplay[ nodeName ] = display;
            }
            return cacheDisplay[ nodeName ];
        }
    })
    /**
    2011.10.10 改进$.fn.stop
    2011.10.20 改进所有特效函数,让传参更加灵活
    2011.10.21 改进内部的normalizer函数
    2012.2.19 normalizer暴露为$.fx 改进绑定回调的机制
    2012.5.17 升级到  v4
    2012.5.19 $.fx.parse.transform FIX BUG
    2012.6.1 优化show hide toggle方法
    
    展开全文
  • 一、前端路由和后端路由 1)后端路由 ... 多页应用中,每次页面切换都需要向服务器发送一次请求,页面使用到的静态资源也需要重新加载,存在一定的浪费。而且,页面的整体刷新对...目前,国内的搜索引擎大多对单页应用的
  • WeedCMS V4 正式版01.[修复]后台删除横幅出现代码问题。02.[优化]让详细页面也显示菜单选中状态。03.[优化]当前位置根据程序判断04.[优化]讨论组详细页面优化。05.[新增]增加内容顶和踩功能。06.[新增]首页增加...
  • 03、优化各大搜索引擎的收录,全站默认全伪静态(后缀名.html)访问; 04、全新原创的树形论坛架构理念,速度更快、外形更加美观,帖子之间的关系一目了然; 05、集成管理员功能,提供编辑、删除、一键清理过期帖子,...
  • TQ210V4原理图开源了

    2019-09-12 15:42:18
    广州天嵌计算机科技有限公司出品的TQ210使用SamsungCortex-A8S5PV210芯片,CPU采用45nm工艺制程,运行最大频率可达1GHz,处理器内部为64/32位总线结构,32/32KB一级...自带3D图形加速引擎(SGX540),2D图形加速,...

        广州天嵌计算机科技有限公司出品的TQ210使用Samsung Cortex-A8 S5PV210芯片,CPU采用45nm工艺制程,运行最大频率可达1GHz,处理器内部为64/32位总线结构,32/32KB一级缓存,512KB二级缓存。自带3D图形加速引擎(SGX540),2D图形加速,最大支持8192×8192分辨率。视频编码支持MPEG-4/H.263/H.264达到1080p@30fps,解码MPEG2/VC1/Xvid视频达到1080p@30fps。支持高清HDMI TV输出。

     

            S5PV210芯片性能高功耗低,适于做手持电子设备,通讯设备或者医疗应用设备,上网本,学习机,监控视频设备和各种人机界面,可以应用于高清游戏,无线GPS导航,移动视频播放,智能控制,仪器仪表,导航设备,PDA设备,远程监控,游戏开发等开发。

     

     

     

    TQ210V4技术规格及配置:

     

     

    一、 TQ210 CoreB核心板参数及电气特性:

     

    1、核心板大小尺寸:63x53x7mm;

    2、核心板层数:10层板沉金工艺、布局、布线充分考虑EMC、EMI;

    3、 核心板引脚数:280pin,采用B2B接口;

    4、 CPU:Samsung  S5PV210  Cortex  A8;

    5、 主频:1GHz;

    6、 DDR2:1G DDR2  128Mx8pcs;

    7、 Nandflash:1G,SLC(K9K8G08)可以扩展至2G;

    8、 PMU:采用TI专为210设计的电源管理芯片TPS659101;

    9、 核心板功率:1.5W (5V-300mA);

     

     

     

    二、TQ210v4底板功能特性说明:

     

    1、底板尺寸:183x131x18mm(不含接口尺寸);

    2、底板层数:2层;

    3、输入电压:12伏;电源输入(>=1A);

    4、底板功率:1.2W (12V-100mA);

    5、底板+核心板功耗(12V-250mA):3W;

    6、底板+核心板+7寸屏(12V-550mA):6.6W;

    7、Usb OTG:1路USB_OTG 2.0下载接口;

    8、Usb Host        :4路USB_HOST 2.0输出;

    9、SPK功放输出:支持左右声道各1W输出功率(8欧负载);

    10、TV out:1路;

    11、HDMI:HDMI v1.3,1080p@30fps 高清数字输出;

    12、Audio:MIC、PHONE、LINE、功放接口,板载驻极体话筒;

    13、Ethernet:10/100M  DM9000AEP;

    14、COM(232、485、TTL):2路5线RS232,4路TTL,1路RS485(复用);

    15、Bus接口:支持总线扩展;

    16、Keypad:6x6矩阵键盘;

    17、RTC备用电池:支持;

    18、SD卡座:1个;

    19、T-flash卡座:1个;

    20、WIFI:支持 SDIO WIFI,USB WIFI(可选配);

    21、User key:8个;

    22、Beep(Buzzer):1路蜂鸣器,PWM输出;

    23、GPRS:支持USB接口

    24、GPRS模块:支持USB接口;

    25、ADC:支持,8路12位AD,1路电位器模拟ADC输入;

    26、PWM:3路,一路蜂鸣器,PWM输出;

    27、SPI:2路SPI接口,支持加速度传感器模块;

    28、IIC:支持3路;

    29、EEPROM:板载E2PROM芯片AT24C02;

    30、JTAG:10pin(2x5,2.0间距);

    31、PMU管理按键:1个;

    32、RST复位:1路复位按键;

    33、Camera:2路,支持CMOS、AV摄像头(流媒体格式)双CMOS摄像头模块接口,支持自动识别(部分系统),支持1080 高清;

    34、AV in:支持;

    35、Bat电池接口:板载充电电路及电池供电功能,支持7.4V电池(可选配);

    36、User Led:2个;

    37、红外IrDA:1路,支持红外遥控(遥控器可选配);

    38、温度传感器:1个,温度传感器采集功能;

    39、POW_OUT接口:1个(3.3V)为遥控器等供电;

    40、用户按键:8个;

    41、MIPI接口:硬件支持12M Camera IF/MIPI CSI-2;

    42、LCD类型选择:底板支持电容屏/电阻屏自由切换,可接VGA模块,跳线在LCD接口右边;

     

     

     

     

     

     

    三、配套显示屏

    1、显示屏:7寸屏;

    2、LCD驱动板自带40pin0.5间距和50pin2.0间距接口;

    3、液晶屏尺寸:7.0英寸(对角线);

    4、分辨率:800 x3(RGB)x480;

    5、驱动因素:斯特TFT有源矩阵;

    6、显示模式:通常白色,递送的;

    7、点距:0.0642(W)x0.1790(H)毫米;

    8、活动区域:154.08(W)x85.92(H)毫米;

    9、模块尺寸:164.9(W)x100.0(H)x5.7(D)毫米;

    10、表面处理:防眩光;

    11、颜色排列:RGB-stripe;

    12、接口:数字;

    13、背光功耗:TBD;

    14、面板功耗:TBD;

    15、重量:160克;

    16、电源电压:3.3 v DVdd(典型的) 10.4 v AVdd(典型的);

     

     

    附件下载地址:http://www.armbbs.net/forum.php?mod=viewthread&tid=21235&extra=page%3D1 ;


    转载于:https://my.oschina.net/embedsky/blog/496178

    展开全文
  • musicblocks-v4的核心(引擎) 新应用程序的核心。 科技栈 Music Blocks v4的此核心使用TypeScript 4 。另外,应使用Jest进行测试。 Webpack已配置为转换和捆绑源代码,以便在Web浏览器上进行部署。 贡献 程序员,请...
  • 其他引擎的使用限制请参见:SQL Server使用限制 PostgreSQL使用限制 PPAS使用限制 MariaDB使用限制 RDS MySQL的使用限制详情如下表所示。约束项 使用约束 实例参数 大部分实例参数可以使用控制台或API进行修改,同时...
  • 1. 更新云端默认搜索引擎 2. 更新云端搜索引擎链接 3. 更新十二月节日温馨提示 文字说明: 在线搜盟云搜索全天候关注各搜索引擎动态, 在第一时间修复死链; 提供全球十多万网站的中文直达服务, 用户不再担心...
  • 搜集最全搜索引擎登录入口搜索引擎登录入口 二百多个网赚论坛 525个中文博客 400个可以发外链的网站 二百多个外链大收集 权重高博客排行 刚总结好的84个pr值高的可以发外链网址的论坛 93个高权重论坛(PR8到PR2) ...
  • 今天我们来了解一下google 的Open Images Dataset V4,它的网址是这个:https://storage.googleapis.com/openimages/web/index.html我推荐的其它深度学习相关文章:利用搜索引擎和ffmpeg生成深度学习图片数据集深度...
  • Atiti attilax主要成果与解决方案与案例rsm版 v4 版本历史记录1 1. ##----------主要成果与解决方案与参与项目1 ###开发流程与培训系列1 #-----组织运营与文化建设系列1 ###编程语言系列与架构系列(au2 ...
  • 一. 设计器 IDE 集成: a. 放置加载需要用到的 jar 包 jar 包源路径:esProc\lib 下 ...dm.jar 集算器计算引擎及 JDBC 驱动包 icu4j_3_4_5.jar 处理国际化 dom4j-1.6.1.jar 解析配置文件 注...
  • 搜索引擎优化。做了基础的seo优化。对搜索引擎更友好 系统功能 关于我们: 介绍企业介绍类信息,可自由添加多个介绍栏目! 资讯中心: 公司或行业资讯类内容展示。可自由添加多个资讯内容! 产品展示: 支持...
  • js模板引擎v5

    2012-08-07 11:47:00
    上次的js模板引擎v4基本已经可以满足大部分需求了,期间也碰到过一些问题,当模板里需要一些函数来处理数据时,必须得定一个全局函数,或者在一个全局变量上挂着一个属性,这种用法还是感觉蛮不爽的, 没必要为了一...
  • smarty 模板引擎

    2015-04-20 16:20:00
    http://wenku.baidu.com/link?url=-UHlSnTXOOAjFG1KjX6T9sEG6V4hNAMfRDpMuRRnc_FKbFAxiE5Ntk4lzxSm-7Z531uWdfvgYx81sdC61SgTZm7q8FdUt3gSs7ZlC0JR1...
  • Jbpm,他是jboss下的一个开源项目,是个基于petri net理论为基础的工作流引擎。JBPM把工作流程分离出来,比如一个请假流程,从员工申请-> 经理批准-> 提交人事部备案,这个流程就可以用xml来描述,其中每一步都...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

v4引擎