// Copyright (c) 2009, Baidu Inc. All rights reserved.

// 

// Licensed under the BSD License

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

// 

//      http:// tangram.baidu.com/license.html

// 

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS-IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

 /**

 * @namespace T Tangram七巧板

 * @name T

 * @version 1.6.0

*/



/**

 * 声明baidu包

 * @author: allstar, erik, meizz, berg

 */

var T,

    baidu = T = baidu || {version: "1.5.0"};

baidu.guid = "$BAIDU$";

baidu.$$ = window[baidu.guid] = window[baidu.guid] || {global:{}};



/**

 * 使用flash资源封装的一些功能

 * @namespace baidu.flash

 */

baidu.flash = baidu.flash || {};



/**

 * 操作dom的方法

 * @namespace baidu.dom 

 */

baidu.dom = baidu.dom || {};





/**

 * 从文档中获取指定的DOM元素

 * @name baidu.dom.g

 * @function

 * @grammar baidu.dom.g(id)

 * @param {string|HTMLElement} id 元素的id或DOM元素.

 * @shortcut g,T.G

 * @meta standard

 * @see baidu.dom.q

 *

 * @return {HTMLElement|null} 获取的元素，查找不到时返回null,如果参数不合法，直接返回参数.

 */

baidu.dom.g = function(id) {

    if (!id) return null;

    if ('string' == typeof id || id instanceof String) {

        return document.getElementById(id);

    } else if (id.nodeName && (id.nodeType == 1 || id.nodeType == 9)) {

        return id;

    }

    return null;

};

baidu.g = baidu.G = baidu.dom.g;





/**

 * 操作数组的方法

 * @namespace baidu.array

 */



baidu.array = baidu.array || {};





/**

 * 遍历数组中所有元素

 * @name baidu.array.each

 * @function

 * @grammar baidu.array.each(source, iterator[, thisObject])

 * @param {Array} source 需要遍历的数组

 * @param {Function} iterator 对每个数组元素进行调用的函数，该函数有两个参数，第一个为数组元素，第二个为数组索引值，function (item, index)。

 * @param {Object} [thisObject] 函数调用时的this指针，如果没有此参数，默认是当前遍历的数组

 * @remark

 * each方法不支持对Object的遍历,对Object的遍历使用baidu.object.each 。

 * @shortcut each

 * @meta standard

 *             

 * @returns {Array} 遍历的数组

 */

 

baidu.each = baidu.array.forEach = baidu.array.each = function (source, iterator, thisObject) {

    var returnValue, item, i, len = source.length;

    

    if ('function' == typeof iterator) {

        for (i = 0; i < len; i++) {

            item = source[i];

            returnValue = iterator.call(thisObject || source, item, i);

    

            if (returnValue === false) {

                break;

            }

        }

    }

    return source;

};



/**

 * 对语言层面的封装，包括类型判断、模块扩展、继承基类以及对象自定义事件的支持。

 * @namespace baidu.lang

 */

baidu.lang = baidu.lang || {};





/**

 * 判断目标参数是否为function或Function实例

 * @name baidu.lang.isFunction

 * @function

 * @grammar baidu.lang.isFunction(source)

 * @param {Any} source 目标参数

 * @version 1.2

 * @see baidu.lang.isString,baidu.lang.isObject,baidu.lang.isNumber,baidu.lang.isArray,baidu.lang.isElement,baidu.lang.isBoolean,baidu.lang.isDate

 * @meta standard

 * @returns {boolean} 类型判断结果

 */

baidu.lang.isFunction = function (source) {

    return '[object Function]' == Object.prototype.toString.call(source);

};



/**

 * 判断目标参数是否string类型或String对象

 * @name baidu.lang.isString

 * @function

 * @grammar baidu.lang.isString(source)

 * @param {Any} source 目标参数

 * @shortcut isString

 * @meta standard

 * @see baidu.lang.isObject,baidu.lang.isNumber,baidu.lang.isArray,baidu.lang.isElement,baidu.lang.isBoolean,baidu.lang.isDate

 *             

 * @returns {boolean} 类型判断结果

 */

baidu.lang.isString = function (source) {

    return '[object String]' == Object.prototype.toString.call(source);

};

baidu.isString = baidu.lang.isString;





/**

 * 判断浏览器类型和特性的属性

 * @namespace baidu.browser

 */

baidu.browser = baidu.browser || {};





/**

 * 判断是否为opera浏览器

 * @property opera opera版本号

 * @grammar baidu.browser.opera

 * @meta standard

 * @see baidu.browser.ie,baidu.browser.firefox,baidu.browser.safari,baidu.browser.chrome

 * @returns {Number} opera版本号

 */



/**

 * opera 从10开始不是用opera后面的字符串进行版本的判断

 * 在Browser identification最后添加Version + 数字进行版本标识

 * opera后面的数字保持在9.80不变

 */

baidu.browser.opera = /opera(\/| )(\d+(\.\d+)?)(.+?(version\/(\d+(\.\d+)?)))?/i.test(navigator.userAgent) ?  + ( RegExp["\x246"] || RegExp["\x242"] ) : undefined;





/**

 * 在目标元素的指定位置插入HTML代码

 * @name baidu.dom.insertHTML

 * @function

 * @grammar baidu.dom.insertHTML(element, position, html)

 * @param {HTMLElement|string} element 目标元素或目标元素的id

 * @param {string} position 插入html的位置信息，取值为beforeBegin,afterBegin,beforeEnd,afterEnd

 * @param {string} html 要插入的html

 * @remark

 * 

 * 对于position参数，大小写不敏感<br>

 * 参数的意思：beforeBegin&lt;span&gt;afterBegin   this is span! beforeEnd&lt;/span&gt; afterEnd <br />

 * 此外，如果使用本函数插入带有script标签的HTML字符串，script标签对应的脚本将不会被执行。

 * 

 * @shortcut insertHTML

 * @meta standard

 *             

 * @returns {HTMLElement} 目标元素

 */

baidu.dom.insertHTML = function (element, position, html) {

    element = baidu.dom.g(element);

    var range,begin;

    if (element.insertAdjacentHTML && !baidu.browser.opera) {

        element.insertAdjacentHTML(position, html);

    } else {

        range = element.ownerDocument.createRange();

        position = position.toUpperCase();

        if (position == 'AFTERBEGIN' || position == 'BEFOREEND') {

            range.selectNodeContents(element);

            range.collapse(position == 'AFTERBEGIN');

        } else {

            begin = position == 'BEFOREBEGIN';

            range[begin ? 'setStartBefore' : 'setEndAfter'](element);

            range.collapse(begin);

        }

        range.insertNode(range.createContextualFragment(html));

    }

    return element;

};



baidu.insertHTML = baidu.dom.insertHTML;



/**

 * 操作flash对象的方法，包括创建flash对象、获取flash对象以及判断flash插件的版本号

 * @namespace baidu.swf

 */

baidu.swf = baidu.swf || {};





/**

 * 浏览器支持的flash插件版本

 * @property version 浏览器支持的flash插件版本

 * @grammar baidu.swf.version

 * @return {String} 版本号

 * @meta standard

 */

baidu.swf.version = (function () {

    var n = navigator;

    if (n.plugins && n.mimeTypes.length) {

        var plugin = n.plugins["Shockwave Flash"];

        if (plugin && plugin.description) {

            return plugin.description

                    .replace(/([a-zA-Z]|\s)+/, "")

                    .replace(/(\s)+r/, ".") + ".0";

        }

    } else if (window.ActiveXObject && !window.opera) {

        for (var i = 12; i >= 2; i--) {

            try {

                var c = new ActiveXObject('ShockwaveFlash.ShockwaveFlash.' + i);

                if (c) {

                    var version = c.GetVariable("$version");

                    return version.replace(/WIN/g,'').replace(/,/g,'.');

                }

            } catch(e) {}

        }

    }

})();



/**

 * 操作字符串的方法

 * @namespace baidu.string

 */

baidu.string = baidu.string || {};





/**

 * 对目标字符串进行html编码

 * @name baidu.string.encodeHTML

 * @function

 * @grammar baidu.string.encodeHTML(source)

 * @param {string} source 目标字符串

 * @remark

 * 编码字符有5个：&<>"'

 * @shortcut encodeHTML

 * @meta standard

 * @see baidu.string.decodeHTML

 *             

 * @returns {string} html编码后的字符串

 */

baidu.string.encodeHTML = function (source) {

    return String(source)

                .replace(/&/g,'&amp;')

                .replace(/</g,'&lt;')

                .replace(/>/g,'&gt;')

                .replace(/"/g, "&quot;")

                .replace(/'/g, "&#39;");

};



baidu.encodeHTML = baidu.string.encodeHTML;



/**

 * 创建flash对象的html字符串

 * @name baidu.swf.createHTML

 * @function

 * @grammar baidu.swf.createHTML(options)

 * 

 * @param {Object} 	options 					创建flash的选项参数

 * @param {string} 	options.id 					要创建的flash的标识

 * @param {string} 	options.url 				flash文件的url

 * @param {String} 	options.errorMessage 		未安装flash player或flash player版本号过低时的提示

 * @param {string} 	options.ver 				最低需要的flash player版本号

 * @param {string} 	options.width 				flash的宽度

 * @param {string} 	options.height 				flash的高度

 * @param {string} 	options.align 				flash的对齐方式，允许值：middle/left/right/top/bottom

 * @param {string} 	options.base 				设置用于解析swf文件中的所有相对路径语句的基本目录或URL

 * @param {string} 	options.bgcolor 			swf文件的背景色

 * @param {string} 	options.salign 				设置缩放的swf文件在由width和height设置定义的区域内的位置。允许值：l/r/t/b/tl/tr/bl/br

 * @param {boolean} options.menu 				是否显示右键菜单，允许值：true/false

 * @param {boolean} options.loop 				播放到最后一帧时是否重新播放，允许值： true/false

 * @param {boolean} options.play 				flash是否在浏览器加载时就开始播放。允许值：true/false

 * @param {string} 	options.quality 			设置flash播放的画质，允许值：low/medium/high/autolow/autohigh/best

 * @param {string} 	options.scale 				设置flash内容如何缩放来适应设置的宽高。允许值：showall/noborder/exactfit

 * @param {string} 	options.wmode 				设置flash的显示模式。允许值：window/opaque/transparent

 * @param {string} 	options.allowscriptaccess 	设置flash与页面的通信权限。允许值：always/never/sameDomain

 * @param {string} 	options.allownetworking 	设置swf文件中允许使用的网络API。允许值：all/internal/none

 * @param {boolean} options.allowfullscreen 	是否允许flash全屏。允许值：true/false

 * @param {boolean} options.seamlesstabbing 	允许设置执行无缝跳格，从而使用户能跳出flash应用程序。该参数只能在安装Flash7及更高版本的Windows中使用。允许值：true/false

 * @param {boolean} options.devicefont 			设置静态文本对象是否以设备字体呈现。允许值：true/false

 * @param {boolean} options.swliveconnect 		第一次加载flash时浏览器是否应启动Java。允许值：true/false

 * @param {Object} 	options.vars 				要传递给flash的参数，支持JSON或string类型。

 * 

 * @see baidu.swf.create

 * @meta standard

 * @returns {string} flash对象的html字符串

 */

baidu.swf.createHTML = function (options) {

    options = options || {};

    var version = baidu.swf.version, 

        needVersion = options['ver'] || '6.0.0', 

        vUnit1, vUnit2, i, k, len, item, tmpOpt = {},

        encodeHTML = baidu.string.encodeHTML;

    for (k in options) {

        tmpOpt[k] = options[k];

    }

    options = tmpOpt;

    if (version) {

        version = version.split('.');

        needVersion = needVersion.split('.');

        for (i = 0; i < 3; i++) {

            vUnit1 = parseInt(version[i], 10);

            vUnit2 = parseInt(needVersion[i], 10);

            if (vUnit2 < vUnit1) {

                break;

            } else if (vUnit2 > vUnit1) {

                return '';

            }

        }

    } else {

        return '';

    }

    

    var vars = options['vars'],

        objProperties = ['classid', 'codebase', 'id', 'width', 'height', 'align'];

    options['align'] = options['align'] || 'middle';

    options['classid'] = 'clsid:d27cdb6e-ae6d-11cf-96b8-444553540000';

    options['codebase'] = 'http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,0,0';

    options['movie'] = options['url'] || '';

    delete options['vars'];

    delete options['url'];

    if ('string' == typeof vars) {

        options['flashvars'] = vars;

    } else {

        var fvars = [];

        for (k in vars) {

            item = vars[k];

            fvars.push(k + "=" + encodeURIComponent(item));

        }

        options['flashvars'] = fvars.join('&');

    }

    var str = ['<object '];

    for (i = 0, len = objProperties.length; i < len; i++) {

        item = objProperties[i];

        str.push(' ', item, '="', encodeHTML(options[item]), '"');

    }

    str.push('>');

    var params = {

        'wmode'             : 1,

        'scale'             : 1,

        'quality'           : 1,

        'play'              : 1,

        'loop'              : 1,

        'menu'              : 1,

        'salign'            : 1,

        'bgcolor'           : 1,

        'base'              : 1,

        'allowscriptaccess' : 1,

        'allownetworking'   : 1,

        'allowfullscreen'   : 1,

        'seamlesstabbing'   : 1,

        'devicefont'        : 1,

        'swliveconnect'     : 1,

        'flashvars'         : 1,

        'movie'             : 1

    };

    

    for (k in options) {

        item = options[k];

        k = k.toLowerCase();

        if (params[k] && (item || item === false || item === 0)) {

            str.push('<param name="' + k + '" value="' + encodeHTML(item) + '" />');

        }

    }

    options['src']  = options['movie'];

    options['name'] = options['id'];

    delete options['id'];

    delete options['movie'];

    delete options['classid'];

    delete options['codebase'];

    options['type'] = 'application/x-shockwave-flash';

    options['pluginspage'] = 'http://www.macromedia.com/go/getflashplayer';

    str.push('<embed');

    var salign;

    for (k in options) {

        item = options[k];

        if (item || item === false || item === 0) {

            if ((new RegExp("^salign\x24", "i")).test(k)) {

                salign = item;

                continue;

            }

            

            str.push(' ', k, '="', encodeHTML(item), '"');

        }

    }

    

    if (salign) {

        str.push(' salign="', encodeHTML(salign), '"');

    }

    str.push('></embed></object>');

    

    return str.join('');

};





/**

 * 在页面中创建一个flash对象

 * @name baidu.swf.create

 * @function

 * @grammar baidu.swf.create(options[, container])

 * 

 * @param {Object} 	options 					创建flash的选项参数

 * @param {string} 	options.id 					要创建的flash的标识

 * @param {string} 	options.url 				flash文件的url

 * @param {String} 	options.errorMessage 		未安装flash player或flash player版本号过低时的提示

 * @param {string} 	options.ver 				最低需要的flash player版本号

 * @param {string} 	options.width 				flash的宽度

 * @param {string} 	options.height 				flash的高度

 * @param {string} 	options.align 				flash的对齐方式，允许值：middle/left/right/top/bottom

 * @param {string} 	options.base 				设置用于解析swf文件中的所有相对路径语句的基本目录或URL

 * @param {string} 	options.bgcolor 			swf文件的背景色

 * @param {string} 	options.salign 				设置缩放的swf文件在由width和height设置定义的区域内的位置。允许值：l/r/t/b/tl/tr/bl/br

 * @param {boolean} options.menu 				是否显示右键菜单，允许值：true/false

 * @param {boolean} options.loop 				播放到最后一帧时是否重新播放，允许值： true/false

 * @param {boolean} options.play 				flash是否在浏览器加载时就开始播放。允许值：true/false

 * @param {string} 	options.quality 			设置flash播放的画质，允许值：low/medium/high/autolow/autohigh/best

 * @param {string} 	options.scale 				设置flash内容如何缩放来适应设置的宽高。允许值：showall/noborder/exactfit

 * @param {string} 	options.wmode 				设置flash的显示模式。允许值：window/opaque/transparent

 * @param {string} 	options.allowscriptaccess 	设置flash与页面的通信权限。允许值：always/never/sameDomain

 * @param {string} 	options.allownetworking 	设置swf文件中允许使用的网络API。允许值：all/internal/none

 * @param {boolean} options.allowfullscreen 	是否允许flash全屏。允许值：true/false

 * @param {boolean} options.seamlesstabbing 	允许设置执行无缝跳格，从而使用户能跳出flash应用程序。该参数只能在安装Flash7及更高版本的Windows中使用。允许值：true/false

 * @param {boolean} options.devicefont 			设置静态文本对象是否以设备字体呈现。允许值：true/false

 * @param {boolean} options.swliveconnect 		第一次加载flash时浏览器是否应启动Java。允许值：true/false

 * @param {Object} 	options.vars 				要传递给flash的参数，支持JSON或string类型。

 * 

 * @param {HTMLElement|string} [container] 		flash对象的父容器元素，不传递该参数时在当前代码位置创建flash对象。

 * @meta standard

 * @see baidu.swf.createHTML,baidu.swf.getMovie

 */

baidu.swf.create = function (options, target) {

    options = options || {};

    var html = baidu.swf.createHTML(options) 

               || options['errorMessage'] 

               || '';

                

    if (target && 'string' == typeof target) {

        target = document.getElementById(target);

    }

    baidu.dom.insertHTML( target || document.body ,'beforeEnd',html );

};

/**

 * 判断是否为ie浏览器

 * @name baidu.browser.ie

 * @field

 * @grammar baidu.browser.ie

 * @returns {Number} IE版本号

 */

baidu.browser.ie = baidu.ie = /msie (\d+\.\d+)/i.test(navigator.userAgent) ? (document.documentMode || + RegExp['\x241']) : undefined;



/**

 * 移除数组中的项

 * @name baidu.array.remove

 * @function

 * @grammar baidu.array.remove(source, match)

 * @param {Array} source 需要移除项的数组

 * @param {Any} match 要移除的项

 * @meta standard

 * @see baidu.array.removeAt

 *             

 * @returns {Array} 移除后的数组

 */

baidu.array.remove = function (source, match) {

    var len = source.length;

        

    while (len--) {

        if (len in source && source[len] === match) {

            source.splice(len, 1);

        }

    }

    return source;

};



/**

 * 判断目标参数是否Array对象

 * @name baidu.lang.isArray

 * @function

 * @grammar baidu.lang.isArray(source)

 * @param {Any} source 目标参数

 * @meta standard

 * @see baidu.lang.isString,baidu.lang.isObject,baidu.lang.isNumber,baidu.lang.isElement,baidu.lang.isBoolean,baidu.lang.isDate

 *             

 * @returns {boolean} 类型判断结果

 */

baidu.lang.isArray = function (source) {

    return '[object Array]' == Object.prototype.toString.call(source);

};







/**

 * 将一个变量转换成array

 * @name baidu.lang.toArray

 * @function

 * @grammar baidu.lang.toArray(source)

 * @param {mix} source 需要转换成array的变量

 * @version 1.3

 * @meta standard

 * @returns {array} 转换后的array

 */

baidu.lang.toArray = function (source) {

    if (source === null || source === undefined)

        return [];

    if (baidu.lang.isArray(source))

        return source;

    if (typeof source.length !== 'number' || typeof source === 'string' || baidu.lang.isFunction(source)) {

        return [source];

    }

    if (source.item) {

        var l = source.length, array = new Array(l);

        while (l--)

            array[l] = source[l];

        return array;

    }



    return [].slice.call(source);

};



/**

 * 获得flash对象的实例

 * @name baidu.swf.getMovie

 * @function

 * @grammar baidu.swf.getMovie(name)

 * @param {string} name flash对象的名称

 * @see baidu.swf.create

 * @meta standard

 * @returns {HTMLElement} flash对象的实例

 */

baidu.swf.getMovie = function (name) {

	var movie = document[name], ret;

    return baidu.browser.ie == 9 ?

    	movie && movie.length ? 

    		(ret = baidu.array.remove(baidu.lang.toArray(movie),function(item){

    			return item.tagName.toLowerCase() != "embed";

    		})).length == 1 ? ret[0] : ret

    		: movie

    	: movie || window[name];

};





baidu.flash._Base = (function(){

   

    var prefix = 'bd__flash__';



    /**

     * 创建一个随机的字符串

     * @private

     * @return {String}

     */

    function _createString(){

        return  prefix + Math.floor(Math.random() * 2147483648).toString(36);

    };

   

    /**

     * 检查flash状态

     * @private

     * @param {Object} target flash对象

     * @return {Boolean}

     */

    function _checkReady(target){

        if(typeof target !== 'undefined' && typeof target.flashInit !== 'undefined' && target.flashInit()){

            return true;

        }else{

            return false;

        }

    };



    /**

     * 调用之前进行压栈的函数

     * @private

     * @param {Array} callQueue 调用队列

     * @param {Object} target flash对象

     * @return {Null}

     */

    function _callFn(callQueue, target){

        var result = null;

        

        callQueue = callQueue.reverse();

        baidu.each(callQueue, function(item){

            result = target.call(item.fnName, item.params);

            item.callBack(result);

        });

    };



    /**

     * 为传入的匿名函数创建函数名

     * @private

     * @param {String|Function} fun 传入的匿名函数或者函数名

     * @return {String}

     */

    function _createFunName(fun){

        var name = '';



        if(baidu.lang.isFunction(fun)){

            name = _createString();

            window[name] = function(){

                fun.apply(window, arguments);

            };



            return name;

        }else if(baidu.lang.isString){

            return fun;

        }

    };



    /**

     * 绘制flash

     * @private

     * @param {Object} options 创建参数

     * @return {Object} 

     */

    function _render(options){

        if(!options.id){

            options.id = _createString();

        }

        

        var container = options.container || '';

        delete(options.container);

        

        baidu.swf.create(options, container);

        

        return baidu.swf.getMovie(options.id);

    };



    return function(options, callBack){

        var me = this,

            autoRender = (typeof options.autoRender !== 'undefined' ? options.autoRender : true),

            createOptions = options.createOptions || {},

            target = null,

            isReady = false,

            callQueue = [],

            timeHandle = null,

            callBack = callBack || [];



        /**

         * 将flash文件绘制到页面上

         * @public

         * @return {Null}

         */

        me.render = function(){

            target = _render(createOptions);

            

            if(callBack.length > 0){

                baidu.each(callBack, function(funName, index){

                    callBack[index] = _createFunName(options[funName] || new Function());

                });    

            }

            me.call('setJSFuncName', [callBack]);

        };



        /**

         * 返回flash状态

         * @return {Boolean}

         */

        me.isReady = function(){

            return isReady;

        };



        /**

         * 调用flash接口的统一入口

         * @param {String} fnName 调用的函数名

         * @param {Array} params 传入的参数组成的数组,若不许要参数，需传入空数组

         * @param {Function} [callBack] 异步调用后将返回值作为参数的调用回调函数，如无返回值，可以不传入此参数

         * @return {Null}

        */

        me.call = function(fnName, params, callBack){

            if(!fnName) return null;

            callBack = callBack || new Function();



            var result = null;

    

            if(isReady){

                result = target.call(fnName, params);

                callBack(result);

            }else{

                callQueue.push({

                    fnName: fnName,

                    params: params,

                    callBack: callBack

                });

    

                (!timeHandle) && (timeHandle = setInterval(_check, 200));

            }

        };

    

        /**

         * 为传入的匿名函数创建函数名

         * @public

         * @param {String|Function} fun 传入的匿名函数或者函数名

         * @return {String}

         */

        me.createFunName = function(fun){

            return _createFunName(fun);    

        };



        /**

         * 检查flash是否ready， 并进行调用

         * @private

         * @return {Null}

         */

        function _check(){

            if(_checkReady(target)){

                clearInterval(timeHandle);

                timeHandle = null;

                _call();



                isReady = true;

            }               

        };



        /**

         * 调用之前进行压栈的函数

         * @private

         * @return {Null}

         */

        function _call(){

            _callFn(callQueue, target);

            callQueue = [];

        }



        autoRender && me.render(); 

    };

})();







/**

 * 创建flash based imageUploader

 * @class

 * @grammar baidu.flash.imageUploader(options)

 * @param {Object} createOptions 创建flash时需要的参数，请参照baidu.swf.create文档

 * @config {Object} vars 创建imageUploader时所需要的参数

 * @config {Number} vars.gridWidth 每一个预览图片所占的宽度，应该为flash寛的整除

 * @config {Number} vars.gridHeight 每一个预览图片所占的高度，应该为flash高的整除

 * @config {Number} vars.picWidth 单张预览图片的宽度

 * @config {Number} vars.picHeight 单张预览图片的高度

 * @config {String} vars.uploadDataFieldName POST请求中图片数据的key,默认值'picdata'

 * @config {String} vars.picDescFieldName POST请求中图片描述的key,默认值'picDesc'

 * @config {Number} vars.maxSize 文件的最大体积,单位'MB'

 * @config {Number} vars.compressSize 上传前如果图片体积超过该值，会先压缩

 * @config {Number} vars.maxNum:32 最大上传多少个文件

 * @config {Number} vars.compressLength 能接受的最大边长，超过该值会等比压缩

 * @config {String} vars.url 上传的url地址

 * @config {Number} vars.mode mode == 0时，是使用滚动条，mode == 1时，拉伸flash, 默认值为0

 * @see baidu.swf.createHTML

 * @param {String} backgroundUrl 背景图片路径

 * @param {String} listBacgroundkUrl 布局控件背景

 * @param {String} buttonUrl 按钮图片不背景

 * @param {String|Function} selectFileCallback 选择文件的回调

 * @param {String|Function} exceedFileCallback文件超出限制的最大体积时的回调

 * @param {String|Function} deleteFileCallback 删除文件的回调

 * @param {String|Function} startUploadCallback 开始上传某个文件时的回调

 * @param {String|Function} uploadCompleteCallback 某个文件上传完成的回调

 * @param {String|Function} uploadErrorCallback 某个文件上传失败的回调

 * @param {String|Function} allCompleteCallback 全部上传完成时的回调

 * @param {String|Function} changeFlashHeight 改变Flash的高度，mode==1的时候才有用

 */ 

baidu.flash.imageUploader = baidu.flash.imageUploader || function(options){

   

    var me = this,

        options = options || {},

        _flash = new baidu.flash._Base(options, [

            'selectFileCallback', 

            'exceedFileCallback', 

            'deleteFileCallback', 

            'startUploadCallback',

            'uploadCompleteCallback',

            'uploadErrorCallback',

            'allCompleteCallback',

            'changeFlashHeight'

        ]);

    /**

     * 开始或回复上传图片

     * @public

     * @return {Null}

     */

    me.upload = function(){

        _flash.call('upload');

    };



    /**

     * 暂停上传图片

     * @public

     * @return {Null}

     */

    me.pause = function(){

        _flash.call('pause');

    };

    me.addCustomizedParams = function(index,obj){

        _flash.call('addCustomizedParams',[index,obj]);

    }

};



/**

 * 操作原生对象的方法

 * @namespace baidu.object

 */

baidu.object = baidu.object || {};





/**

 * 将源对象的所有属性拷贝到目标对象中

 * @author erik

 * @name baidu.object.extend

 * @function

 * @grammar baidu.object.extend(target, source)

 * @param {Object} target 目标对象

 * @param {Object} source 源对象

 * @see baidu.array.merge

 * @remark

 * 

1.目标对象中，与源对象key相同的成员将会被覆盖。<br>

2.源对象的prototype成员不会拷贝。

		

 * @shortcut extend

 * @meta standard

 *             

 * @returns {Object} 目标对象

 */

baidu.extend =

baidu.object.extend = function (target, source) {

    for (var p in source) {

        if (source.hasOwnProperty(p)) {

            target[p] = source[p];

        }

    }

    

    return target;

};











/**

 * 创建flash based fileUploader

 * @class

 * @grammar baidu.flash.fileUploader(options)

 * @param {Object} options

 * @config {Object} createOptions 创建flash时需要的参数，请参照baidu.swf.create文档

 * @config {String} createOptions.width

 * @config {String} createOptions.height

 * @config {Number} maxNum 最大可选文件数

 * @config {Function|String} selectFile

 * @config {Function|String} exceedMaxSize

 * @config {Function|String} deleteFile

 * @config {Function|String} uploadStart

 * @config {Function|String} uploadComplete

 * @config {Function|String} uploadError

 * @config {Function|String} uploadProgress

 */

baidu.flash.fileUploader = baidu.flash.fileUploader || function(options){

    var me = this,

        options = options || {};

    

    options.createOptions = baidu.extend({

        wmod: 'transparent'

    },options.createOptions || {});

    

    var _flash = new baidu.flash._Base(options, [

        'selectFile',

        'exceedMaxSize',

        'deleteFile',

        'uploadStart',

        'uploadComplete',

        'uploadError', 

        'uploadProgress'

    ]);



    _flash.call('setMaxNum', options.maxNum ? [options.maxNum] : [1]);



    /**

     * 设置当鼠标移动到flash上时，是否变成手型

     * @public

     * @param {Boolean} isCursor

     * @return {Null}

     */

    me.setHandCursor = function(isCursor){

        _flash.call('setHandCursor', [isCursor || false]);

    };



    /**

     * 设置鼠标相应函数名

     * @param {String|Function} fun

     */

    me.setMSFunName = function(fun){

        _flash.call('setMSFunName',[_flash.createFunName(fun)]);

    }; 



    /**

     * 执行上传操作

     * @param {String} url 上传的url

     * @param {String} fieldName 上传的表单字段名

     * @param {Object} postData 键值对，上传的POST数据

     * @param {Number|Array|null|-1} [index]上传的文件序列

     *                            Int值上传该文件

     *                            Array一次串行上传该序列文件

     *                            -1/null上传所有文件

     * @return {Null}

     */

    me.upload = function(url, fieldName, postData, index){



        if(typeof url !== 'string' || typeof fieldName !== 'string') return null;

        if(typeof index === 'undefined') index = -1;



        _flash.call('upload', [url, fieldName, postData, index]);

    };



    /**

     * 取消上传操作

     * @public

     * @param {Number|-1} index

     */

    me.cancel = function(index){

        if(typeof index === 'undefined') index = -1;

        _flash.call('cancel', [index]);

    };



    /**

     * 删除文件

     * @public

     * @param {Number|Array} [index] 要删除的index，不传则全部删除

     * @param {Function} callBack

     * */

    me.deleteFile = function(index, callBack){



        var callBackAll = function(list){

                callBack && callBack(list);

            };



        if(typeof index === 'undefined'){

            _flash.call('deleteFilesAll', [], callBackAll);

            return;

        };

        

        if(typeof index === 'Number') index = [index];

        index.sort(function(a,b){

            return b-a;

        });

        baidu.each(index, function(item){

            _flash.call('deleteFileBy', item, callBackAll);

        });

    };



    /**

     * 添加文件类型，支持macType

     * @public

     * @param {Object|Array[Object]} type {description:String, extention:String}

     * @return {Null};

     */

    me.addFileType = function(type){

        var type = type || [[]];

        

        if(type instanceof Array) type = [type];

        else type = [[type]];

        _flash.call('addFileTypes', type);

    };

    

    /**

     * 设置文件类型，支持macType

     * @public

     * @param {Object|Array[Object]} type {description:String, extention:String}

     * @return {Null};

     */

    me.setFileType = function(type){

        var type = type || [[]];

        

        if(type instanceof Array) type = [type];

        else type = [[type]];

        _flash.call('setFileTypes', type);

    };



    /**

     * 设置可选文件的数量限制

     * @public

     * @param {Number} num

     * @return {Null}

     */

    me.setMaxNum = function(num){

        _flash.call('setMaxNum', [num]);

    };



    /**

     * 设置可选文件大小限制，以兆M为单位

     * @public

     * @param {Number} num,0为无限制

     * @return {Null}

     */

    me.setMaxSize = function(num){

        _flash.call('setMaxSize', [num]);

    };



    /**

     * @public

     */

    me.getFileAll = function(callBack){

        _flash.call('getFileAll', [], callBack);

    };



    /**

     * @public

     * @param {Number} index

     * @param {Function} [callBack]

     */

    me.getFileByIndex = function(index, callBack){

        _flash.call('getFileByIndex', [], callBack);

    };



    /**

     * @public

     * @param {Number} index

     * @param {function} [callBack]

     */

    me.getStatusByIndex = function(index, callBack){

        _flash.call('getStatusByIndex', [], callBack);

    };

};



/**

 * 使用动态script标签请求服务器资源，包括由服务器端的回调和浏览器端的回调

 * @namespace baidu.sio

 */

baidu.sio = baidu.sio || {};



/**

 * 

 * @param {HTMLElement} src script节点

 * @param {String} url script节点的地址

 * @param {String} [charset] 编码

 */

baidu.sio._createScriptTag = function(scr, url, charset){

    scr.setAttribute('type', 'text/javascript');

    charset && scr.setAttribute('charset', charset);

    scr.setAttribute('src', url);

    document.getElementsByTagName('head')[0].appendChild(scr);

};



/**

 * 删除script的属性，再删除script标签，以解决修复内存泄漏的问题

 * 

 * @param {HTMLElement} src script节点

 */

baidu.sio._removeScriptTag = function(scr){

    if (scr.clearAttributes) {

        scr.clearAttributes();

    } else {

        for (var attr in scr) {

            if (scr.hasOwnProperty(attr)) {

                delete scr[attr];

            }

        }

    }

    if(scr && scr.parentNode){

        scr.parentNode.removeChild(scr);

    }

    scr = null;

};





/**

 * 通过script标签加载数据，加载完成由浏览器端触发回调

 * @name baidu.sio.callByBrowser

 * @function

 * @grammar baidu.sio.callByBrowser(url, opt_callback, opt_options)

 * @param {string} url 加载数据的url

 * @param {Function|string} opt_callback 数据加载结束时调用的函数或函数名

 * @param {Object} opt_options 其他可选项

 * @config {String} [charset] script的字符集

 * @config {Integer} [timeOut] 超时时间，超过这个时间将不再响应本请求，并触发onfailure函数

 * @config {Function} [onfailure] timeOut设定后才生效，到达超时时间时触发本函数

 * @remark

 * 1、与callByServer不同，callback参数只支持Function类型，不支持string。

 * 2、如果请求了一个不存在的页面，callback函数在IE/opera下也会被调用，因此使用者需要在onsuccess函数中判断数据是否正确加载。

 * @meta standard

 * @see baidu.sio.callByServer

 */

baidu.sio.callByBrowser = function (url, opt_callback, opt_options) {

    var scr = document.createElement("SCRIPT"),

        scriptLoaded = 0,

        options = opt_options || {},

        charset = options['charset'],

        callback = opt_callback || function(){},

        timeOut = options['timeOut'] || 0,

        timer;

    scr.onload = scr.onreadystatechange = function () {

        if (scriptLoaded) {

            return;

        }

        

        var readyState = scr.readyState;

        if ('undefined' == typeof readyState

            || readyState == "loaded"

            || readyState == "complete") {

            scriptLoaded = 1;

            try {

                callback();

                clearTimeout(timer);

            } finally {

                scr.onload = scr.onreadystatechange = null;

                baidu.sio._removeScriptTag(scr);

            }

        }

    };



    if( timeOut ){

        timer = setTimeout(function(){

            scr.onload = scr.onreadystatechange = null;

            baidu.sio._removeScriptTag(scr);

            options.onfailure && options.onfailure();

        }, timeOut);

    }

    

    baidu.sio._createScriptTag(scr, url, charset);

};



/**

 * 通过script标签加载数据，加载完成由服务器端触发回调

 * @name baidu.sio.callByServer

 * @function

 * @grammar baidu.sio.callByServer(url, callback[, opt_options])

 * @param {string} url 加载数据的url.

 * @param {Function|string} callback 服务器端调用的函数或函数名。如果没有指定本参数，将在URL中寻找options['queryField']做为callback的方法名.

 * @param {Object} opt_options 加载数据时的选项.

 * @config {string} [charset] script的字符集

 * @config {string} [queryField] 服务器端callback请求字段名，默认为callback

 * @config {Integer} [timeOut] 超时时间(单位：ms)，超过这个时间将不再响应本请求，并触发onfailure函数

 * @config {Function} [onfailure] timeOut设定后才生效，到达超时时间时触发本函数

 * @remark

 * 如果url中已经包含key为“options['queryField']”的query项，将会被替换成callback中参数传递或自动生成的函数名。

 * @meta standard

 * @see baidu.sio.callByBrowser

 */

baidu.sio.callByServer = /**@function*/function(url, callback, opt_options) {

    var scr = document.createElement('SCRIPT'),

        prefix = 'bd__cbs__',

        callbackName,

        callbackImpl,

        options = opt_options || {},

        charset = options['charset'],

        queryField = options['queryField'] || 'callback',

        timeOut = options['timeOut'] || 0,

        timer,

        reg = new RegExp('(\\?|&)' + queryField + '=([^&]*)'),

        matches;



    if (baidu.lang.isFunction(callback)) {

        callbackName = prefix + Math.floor(Math.random() * 2147483648).toString(36);

        window[callbackName] = getCallBack(0);

    } else if(baidu.lang.isString(callback)){

        callbackName = callback;

    } else {

        if (matches = reg.exec(url)) {

            callbackName = matches[2];

        }

    }



    if( timeOut ){

        timer = setTimeout(getCallBack(1), timeOut);

    }

    url = url.replace(reg, '\x241' + queryField + '=' + callbackName);

    

    if (url.search(reg) < 0) {

        url += (url.indexOf('?') < 0 ? '?' : '&') + queryField + '=' + callbackName;

    }

    baidu.sio._createScriptTag(scr, url, charset);



    /*

     * 返回一个函数，用于立即（挂在window上）或者超时（挂在setTimeout中）时执行

     */

    function getCallBack(onTimeOut){

        /*global callbackName, callback, scr, options;*/

        return function(){

            try {

                if( onTimeOut ){

                    options.onfailure && options.onfailure();

                }else{

                    callback.apply(window, arguments);

                    clearTimeout(timer);

                }

                window[callbackName] = null;

                delete window[callbackName];

            } catch (exception) {

            } finally {

                baidu.sio._removeScriptTag(scr);

            }

        }

    }

};



/**

 * 通过请求一个图片的方式令服务器存储一条日志

 * @function

 * @grammar baidu.sio.log(url)

 * @param {string} url 要发送的地址.

 * @author: int08h,leeight

 */

baidu.sio.log = function(url) {

  var img = new Image(),

      key = 'tangram_sio_log_' + Math.floor(Math.random() *

            2147483648).toString(36);

  window[key] = img;



  img.onload = img.onerror = img.onabort = function() {

    img.onload = img.onerror = img.onabort = null;



    window[key] = null;

    img = null;

  };

  img.src = url;

};







/*

 * Tangram

 * Copyright 2009 Baidu Inc. All rights reserved.

 * 

 * path: baidu/json.js

 * author: erik

 * version: 1.1.0

 * date: 2009/12/02

 */





/**

 * 操作json对象的方法

 * @namespace baidu.json

 */

baidu.json = baidu.json || {};

/*

 * Tangram

 * Copyright 2009 Baidu Inc. All rights reserved.

 * 

 * path: baidu/json/parse.js

 * author: erik, berg

 * version: 1.2

 * date: 2009/11/23

 */







/**

 * 将字符串解析成json对象。注：不会自动祛除空格

 * @name baidu.json.parse

 * @function

 * @grammar baidu.json.parse(data)

 * @param {string} source 需要解析的字符串

 * @remark

 * 该方法的实现与ecma-262第五版中规定的JSON.parse不同，暂时只支持传入一个参数。后续会进行功能丰富。

 * @meta standard

 * @see baidu.json.stringify,baidu.json.decode

 *             

 * @returns {JSON} 解析结果json对象

 */

baidu.json.parse = function (data) {

    //2010/12/09：更新至不使用原生parse，不检测用户输入是否正确

    return (new Function("return (" + data + ")"))();

};

/*

 * Tangram

 * Copyright 2009 Baidu Inc. All rights reserved.

 * 

 * path: baidu/json/decode.js

 * author: erik, cat

 * version: 1.3.4

 * date: 2010/12/23

 */







/**

 * 将字符串解析成json对象，为过时接口，今后会被baidu.json.parse代替

 * @name baidu.json.decode

 * @function

 * @grammar baidu.json.decode(source)

 * @param {string} source 需要解析的字符串

 * @meta out

 * @see baidu.json.encode,baidu.json.parse

 *             

 * @returns {JSON} 解析结果json对象

 */

baidu.json.decode = baidu.json.parse;

/*

 * Tangram

 * Copyright 2009 Baidu Inc. All rights reserved.

 * 

 * path: baidu/json/stringify.js

 * author: erik

 * version: 1.1.0

 * date: 2010/01/11

 */







/**

 * 将json对象序列化

 * @name baidu.json.stringify

 * @function

 * @grammar baidu.json.stringify(value)

 * @param {JSON} value 需要序列化的json对象

 * @remark

 * 该方法的实现与ecma-262第五版中规定的JSON.stringify不同，暂时只支持传入一个参数。后续会进行功能丰富。

 * @meta standard

 * @see baidu.json.parse,baidu.json.encode

 *             

 * @returns {string} 序列化后的字符串

 */

baidu.json.stringify = (function () {

    /**

     * 字符串处理时需要转义的字符表

     * @private

     */

    var escapeMap = {

        "\b": '\\b',

        "\t": '\\t',

        "\n": '\\n',

        "\f": '\\f',

        "\r": '\\r',

        '"' : '\\"',

        "\\": '\\\\'

    };

    

    /**

     * 字符串序列化

     * @private

     */

    function encodeString(source) {

        if (/["\\\x00-\x1f]/.test(source)) {

            source = source.replace(

                /["\\\x00-\x1f]/g, 

                function (match) {

                    var c = escapeMap[match];

                    if (c) {

                        return c;

                    }

                    c = match.charCodeAt();

                    return "\\u00" 

                            + Math.floor(c / 16).toString(16) 

                            + (c % 16).toString(16);

                });

        }

        return '"' + source + '"';

    }

    

    /**

     * 数组序列化

     * @private

     */

    function encodeArray(source) {

        var result = ["["], 

            l = source.length,

            preComma, i, item;

            

        for (i = 0; i < l; i++) {

            item = source[i];

            

            switch (typeof item) {

            case "undefined":

            case "function":

            case "unknown":

                break;

            default:

                if(preComma) {

                    result.push(',');

                }

                result.push(baidu.json.stringify(item));

                preComma = 1;

            }

        }

        result.push("]");

        return result.join("");

    }

    

    /**

     * 处理日期序列化时的补零

     * @private

     */

    function pad(source) {

        return source < 10 ? '0' + source : source;

    }

    

    /**

     * 日期序列化

     * @private

     */

    function encodeDate(source){

        return '"' + source.getFullYear() + "-" 

                + pad(source.getMonth() + 1) + "-" 

                + pad(source.getDate()) + "T" 

                + pad(source.getHours()) + ":" 

                + pad(source.getMinutes()) + ":" 

                + pad(source.getSeconds()) + '"';

    }

    

    return function (value) {

        switch (typeof value) {

        case 'undefined':

            return 'undefined';

            

        case 'number':

            return isFinite(value) ? String(value) : "null";

            

        case 'string':

            return encodeString(value);

            

        case 'boolean':

            return String(value);

            

        default:

            if (value === null) {

                return 'null';

            } else if (value instanceof Array) {

                return encodeArray(value);

            } else if (value instanceof Date) {

                return encodeDate(value);

            } else {

                var result = ['{'],

                    encode = baidu.json.stringify,

                    preComma,

                    item;

                    

                for (var key in value) {

                    if (Object.prototype.hasOwnProperty.call(value, key)) {

                        item = value[key];

                        switch (typeof item) {

                        case 'undefined':

                        case 'unknown':

                        case 'function':

                            break;

                        default:

                            if (preComma) {

                                result.push(',');

                            }

                            preComma = 1;

                            result.push(encode(key) + ':' + encode(item));

                        }

                    }

                }

                result.push('}');

                return result.join('');

            }

        }

    };

})();

/*

 * Tangram

 * Copyright 2009 Baidu Inc. All rights reserved.

 * 

 * path: baidu/json/encode.js

 * author: erik, cat

 * version: 1.3.4

 * date: 2010/12/23

 */







/**

 * 将json对象序列化，为过时接口，今后会被baidu.json.stringify代替

 * @name baidu.json.encode

 * @function

 * @grammar baidu.json.encode(value)

 * @param {JSON} value 需要序列化的json对象

 * @meta out

 * @see baidu.json.decode,baidu.json.stringify

 *             

 * @returns {string} 序列化后的字符串

 */

baidu.json.encode = baidu.json.stringify;

