if (!window.__existCKFrameWork)
        window.__existCKFrameWork = true;
    else
        throw new Error("重複添加了框架");

window.RootType =function(){};    
window.__classes = {};
window.__registeredTypes = {};    
   
RootType.regNameSpace = function(string_namespacePath) {
    var r = window; 
    var p = string_namespacePath.split('.');
    for (var i = 0; i < p.length; i++)
    {
        var c = p[i];
        var ns = r[c];
        if (!ns)
        {
            r[c] = {};
            ns = r[c];
            ns.__namespace = true;
            ns.__typeName = p.slice(0, i + 1).join('.');
            var n = eval(ns.__typeName);
            if (n !== ns)
            {
                delete r[c];
            }
        }
        r = ns;
    }
}

RootType.regClass = function(string_functionName) {
    var fn = string_functionName;
     RootType._checkReg(fn);
    var t = RootType.getFunction(fn);    
    t.prototype.constructor = t;
    t.__typeName = t;
    t.__class = true;
    window.__classes[fn] = t;
    window.__registeredTypes[fn] = true;
    return t;         
}

RootType.regEnum = function(string_functionName) {
    var fn = string_functionName;
    RootType._checkReg(fn);
    var t = RootType.getFunction(fn);
    for (var i in t.prototype)
    {
        t[i] = t.prototype[i];
    }
    window.__registeredTypes[fn] = true;
    t.__enum = true;
}

RootType._checkReg = function(string_functionName) {
    for (var x in window.__registeredTypes)
    {
        if (x === string_functionName)
            throw new Error("[  " + string_functionName + "  ] has already been registered");
    }
}

RootType.getFunction = function(string_functionName) {
    var fn = string_functionName;
    var t = null;
    var n = 'if(typeof(' + fn + ')!="function") throw new Error("' + fn + '   is not function");else t=' + fn + ';';
    eval(n);
    return t;
}

    if (!window.XMLHttpRequest)
    {
        window.XMLHttpRequest = function() {
            var p = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP'];
            for (var i = 0; i < p.length; i++)
            {
                try
                {
                    var x = new ActiveXObject(p[i]);
                    return x;
                }
                catch (ex)
                {
                }
            } return null;
        }
    }
    var __eventNames = 'blur,focus,load,resize,scroll,unload,click,dblclick,mousedown,mouseup,mousemove,mouseover,mouseout,change,select,submit,keydown,keypress,keyup,error,contextmenu,copy,cut,paste,propertychange';    
    $g = function(id) {
        ///<returns type="CodePrompt.$g"></returns>
        ///<summary>此函數功能相當于document.getElementById,但此函數擴展了多個方法</summary>    
        var _el = CK.UI.Dom.getElement(id);
        if (_el)
            CK.UI.Dom.extend(_el);
        return _el;
    }

    RootType.regNameSpace('CK.Enum.Layout');

    CK.Enum.Layout.Align = function() {
        ///<field name="left" static="true"></field>
        ///<field name="center" static="true"></field>
        ///<field name="right" static="true"></field>
    }
    CK.Enum.Layout.Align.prototype = {
        left: 'left',
        center: 'center',
        right: 'right'
    }
    RootType.regEnum('CK.Enum.Layout.Align');

    CK.Enum.Layout.Valign = function() {
        ///<field name="top" static="true"></field>
        ///<field name="middle" static="true"></field>
        ///<field name="bottom" static="true"></field>
    }
    CK.Enum.Layout.Valign.prototype = {
        top: 'top',
        middle: 'middle',
        bottom: 'bottom'
    }
    RootType.regEnum('CK.Enum.Layout.Valign');

    CK.Enum.DisplayMode = function() {
        ///<field name="normal" static="true"></field>
        ///<field name="none" static="true"></field>
        ///<field name="hide" static="true"></field>
        ///<field name="block" static="true"></field>
        ///<field name="inline" static="true"></field>
    }
    CK.Enum.DisplayMode.prototype = {
        none: 'none',
        hide: 'hide',
        block: 'block',
        inline: 'inline',
        normal: ''
    }
    RootType.regEnum('CK.Enum.DisplayMode');

    CK.Enum.Event = function() {
        ///<field name="blur" static="true"></field>
        ///<field name="focus" static="true"></field>
        ///<field name="load" static="true"></field>
        ///<field name="resize" static="true"></field>
        ///<field name="scroll" static="true"></field>
        ///<field name="unload" static="true"></field>
        ///<field name="click" static="true"></field>
        ///<field name="dblclick" static="true"></field>
        ///<field name="mousedown" static="true"></field>
        ///<field name="mouseup" static="true"></field>
        ///<field name="mousemove" static="true"></field>
        ///<field name="mouseover" static="true"></field>
        ///<field name="mouseout" static="true"></field>
        ///<field name="change" static="true"></field>
        ///<field name="select" static="true"></field>
        ///<field name="submit" static="true"></field>
        ///<field name="keydown" static="true"></field>
        ///<field name="keypress" static="true"></field>
        ///<field name="keyup" static="true"></field>
        ///<field name="error" static="true"></field>
        ///<field name="contextmenu" static="true"></field>
        ///<field name="copy" static="true"></field>
        ///<field name="cut" static="true"></field>
        ///<field name="paste" static="true"></field>
        ///<field name="propertychange" static="true"></field>
    }
    var __addEventEnum = function() {
        var i;
        var es = __eventNames.split(',');
        for (i = 0; i < es.length; i++)
            eval('CK.Enum.Event.' + es[i] + '="' + es[i] + '"');
    }
    __addEventEnum();
    RootType.regEnum("CK.Enum.Event");

    CK.Enum.FadeType = function() {
        ///<field name="fadeIn" static="true"></field>
        ///<field name="fadeOut" static="true"></field>
    }
    CK.Enum.FadeType.prototype = { fadeIn: 'in', fadeOut: 'out' };
    RootType.regEnum("CK.Enum.FadeType");


    createXMLHttpRequest = function() {
        ///<returns type="CodePrompt.createXMLHttpRequest"></returns>
        return new XMLHttpRequest();
    }

    CK.Ajax = function() {
        var _self = this;
        this._x =createXMLHttpRequest();
        this._url = null;
        this._verb = null;
        this._completed = null;
        this._headers = null;
        this._data = null;
        this._timeout = 0;
        this._isSucceed = false;
        this._isError = false;
        this._isTimeOut = false;
        this._isAbort = false;
        this._userContext = null;
    }
    CK.Ajax.prototype = {
        get_xmlHttpRequest: function() {
            ///<summary>獲取Ajax請求的原生對象XMLHttpRequest</summary>
            return this._x;
        },
        get_verb: function() {
            ///<summary>獲取Ajax請求的提交方式</summary>
            return this._verb;
        },
        set_verb: function(string_verb) {
            ///<summary>設置Ajax的請求的提交方式,可設置為post或get</summary>        
            this._verb = string_verb.toLowerCase();
        },
        get_url: function() {
            ///<summary>獲取Ajax請求的網絡地址</summary>
            return this._url;
        },
        set_url: function(string_url) {
            ///<summary>設置Ajax請求的網絡地址</summary>
            this._url = string_url;
        },
        abort: function() {
            ///<summary>取消中斷當前Ajax請求</summary>
            this._isAbort = true;
            this._x.abort();
        },
        add_completed: function(function_handler) {
            ///<summary>設置當前Ajax請求的回調函數</summary>                        
            if (!this._completed) this._completed = new CK.ObjectArray();
            this._completed.add(function_handler);
        },
        remove_completed: function(function_handler) {
            ///<summary>設置當前Ajax請求的回調函數</summary>
            if (this._completed) this._completed.remove(function_handler);
        },
        set_data: function(postData) {
            ///<summary>設置當前Ajax請求的post提交的數據</summary>
            this._data = postData;
        },
        get_data: function() {
            ///<summary>獲取當前Ajax請求的post提交的數據</summary>
            return this._data;
        },
        get_userContext: function() {
            ///<summary>獲取當前Ajax請求的用戶上下文</summary>
            return this._userContext;
        },
        set_userContext: function(userContext) {
            ///<summary>設置當前Ajax請求的用戶上下文,可在回調函數的第二個參數中獲取function completed(ajax,userContext){var context = userContext;}</summary>
            this._userContext = userContext;
        },
        set_header: function(string_name, string_value) {
            ///<param name="string_name">設置頭信息的名稱</param>
            ///<param name="string_value">設置頭信息的值</param>
            ///<summary>設置當前Ajax請求的頭信息,可重複設置多嘅頭信息</summary>
            if (!this._headers) this._headers = new CK.ObjectArray();
            this._headers.add(string_name + ',' + string_value);
        },
        get_responseText: function() {
            ///<summary>獲取Ajax回調的數據文本</summary>
            return this._x.responseText;
        },
        get_responseJson: function() {
            ///<summary>獲取Ajax回調的數據對象</summary>
            return this.get_responseText().toJson();
        },
        getResponseHeader: function(string_headerName) {
            ///<param name="string_headerName">鍵入獲取Ajax回調的頭信息的名稱</param>
            ///<summary>獲取Ajax回調的頭信息,功能與get_responseHeader()一樣</summary>

            return this._x.getResponseHeader(string_headerName);
        },
        get_responseHeader: function(string_headerName) {
            ///<param name="string_headerName">鍵入獲取Ajax回調的頭信息的名稱</param>
            ///<summary>獲取Ajax回調的頭信息,功能與getResponseHeader()一樣</summary>
            return this.getResponseHeader(string_headerName);
        },
        getAllResponseHeaders: function() {
            ///<summary>獲取Ajax回調的所有頭信息,功能與get_allResponseHeaders()一樣</summary>
            return this._x.getAllResponseHeaders();
        },
        get_allResponseHeaders: function() {
            ///<summary>獲取Ajax回調的所有頭信息,功能與getAllResponseHeaders()一樣</summary>
            return this.getAllResponseHeaders();
        },

        get_timeOut: function() {
            ///<summary>獲取Ajax請求的超時時間 默認為0，即不會超時 ,以毫秒為單位</summary>
            return this._timeout;
        },
        set_timeOut: function(int_timeout) {
            ///<summary>設置Ajax請求的超時時間 默認為0，即不會超時 ,以毫秒為單位</summary>
            this._timeout = int_timeout;
        },
        get_isSucceed: function() {
            ///<summary>獲取Ajax回調的狀態是否為成功狀態 即get_statusCode()==200,返回true或false</summary>
            return this._isSucceed;
        },
        get_isError: function() {
            ///<summary>獲取Ajax回調的狀態是否為錯誤狀態( 即get_statusCode()!=200,請求沒有被取消,請求沒有超時 ),返回true或false</summary>
            return this._isError;
        },
        get_isAbort: function() {
            ///<summary>獲取Ajax請求是否被用戶取消,返回true或false</summary>

            return this._isAbort;
        },
        get_isTimeOut: function() {
            ///<summary>獲取Ajax請求是否超時,返回true或false</summary>
            return this._isTimeOut;
        },
        get_statusCode: function() {
            ///<summary>獲取Ajax請求狀態碼,即原生對象XMLHttpRequest的status</summary>
            return this._x.status;
        },
        submit: function() {
            ///<summary>提交當前Ajax請求</summary>
            var _self = this;
            var timeoutFun;
            var hasContentType = false;
            this._x.open(this.get_verb(), this.get_url(), true);
            if (this._headers)
            {
                var headers = this._headers;                
                for (var i = 0; i < headers.length; i++)
                {
                    var header = headers[i].split(',');
                    var headerName = header[0];
                    var headerValue = header[1];
                    this._x.setRequestHeader(headerName, headerValue);

                    if (!hasContentType)
                    {
                        if (headerName.toLowerCase() == 'content-type')
                            hasContentType = true;
                    }
                }
            }
            if (this.get_verb() == 'post')
            {
                if (!hasContentType)
                    this._x.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
            }
            this._x.onreadystatechange = function() {
                if (_self._x.readyState == 4)
                {
                    if (timeoutFun)
                    {
                        clearTimeout(timeoutFun);
                        timeoutFun = null;
                    }
                    if (_self._x.status == 200)
                    {
                        _self._isSucceed = true;
                    }
                    else
                    {
                        if (!_self.get_isTimeOut())
                        {
                            if (!_self.get_isAbort())
                                _self._isError = true;
                        }
                    }

                    if (_self._completed)
                    {
                        if (_self._completed.length > 0)
                        {
                            for (var i = _self._completed.length - 1; i >= 0; i--)
                                _self._completed[i](_self, _self.get_userContext(), _self._x);
                        }
                    }
                }
            }
            var data = this.get_data();
            if (data == null) data = '';
            this._x.send(data);
            var timeout = _self.get_timeOut();
            if (timeout > 0) timeoutFun = setTimeout(function() { _self._isTimeOut = true; _self._x.abort(); }, timeout);
        }
    }

    CK.Ajax.submit = function(string_url, bool_useGet, postData, function_onSuccess, function_onError, function_onTimeout, userContext, int_timeOut) {
        ///<returns type="CK.Ajax"></returns>
        var _url = string_url;
        var _isGet = bool_useGet;
        var _verb = _isGet ? 'get' : 'post';
        var _data = postData;
        var _onSucc = function_onSuccess;
        var _onError = function_onError;
        var _onTimeOut = function_onTimeout;
        var _userContext = userContext;
        var _timeOut = int_timeOut;
        var _onCompleted = function(result, context, xmlhttp) {
            var textError = false;
            var text = null;
            try
            {
                result.get_responseText();
            }
            catch (ex)
            {
                textError = true;
            }

            if (!textError)
            {
                text = result.get_responseText();
            }
            if (result.get_isSucceed())
            {
                if (_onSucc)
                {
                    if (text)
                    {
                        if (result.getResponseHeader('Content-Type').toLowerCase() == 'json')
                            text = result.get_responseJson();
                    }
                    _onSucc.apply(xmlhttp, [text, context, xmlhttp]);
                }
            }
            else if (result.get_isError())
            {
                if (_onError)
                    _onError.apply(xmlhttp, [text, context, xmlhttp]);
            }
            else if (result.get_isTimeOut())
            {
                if (_onTimeOut)
                    _onTimeOut.apply(xmlhttp, ['', context, xmlhttp]);
            }
        }
        var x = new CK.Ajax();
        x.set_verb(_verb);
        x.set_url(_url);
        x.set_header('CK', 'CKframework');
        x.set_header('Safe', 'CKSafe');
        x.set_data(_data);
        x.add_completed(_onCompleted);
        x.set_userContext(_userContext);
        x.set_timeOut(_timeOut);
        x.submit();
        return x;

    }
    CK.Ajax.createQuery = function(object) {
        if (!object) throw new Error('must be typeof object');
        var queryBuilder = new CK.Text.StringBuilder();
        for (var x in object)
        {
            if (object[x] != null)
            {
                queryBuilder.append(String.format("{0}={1}", x, object[x]));
                queryBuilder.append("&");
            }
        }
        queryBuilder = queryBuilder.toString();
        return queryBuilder.substr(0, queryBuilder.length - 1);
    }
    RootType.regClass("CK.Ajax");
    CK.Ajax.LoadImage = function() { }
    CK.Ajax.LoadImage.submit = function(string_imageUrl, function_callBack, userContext) {
        var url = string_imageUrl;
        var _fun_complete = function_callBack;
        var _context = userContext;

        var _image = new Image();
        _image.src = url;
        if (!_fun_complete) return;
        var _fun_callback = function() {
            if (_fun_complete.length > 0)
                _fun_complete.apply(_image, [_image, _context]);
            else if (_fun_complete.length == 0)
                _fun_complete.apply(_image);
        }

        if (_image.complete)
            _fun_callback();
        else
            _image.onload = _fun_callback;
    }
    RootType.regClass("CK.Ajax.LoadImage");


    CK.Ajax.AspNet = function() { }
    RootType.regClass("CK.Ajax.AspNet");
    CK.Ajax.AspNet.WebService = function() { }
    CK.Ajax.AspNet.WebService.invoke = function(string_servicePath, string_methodName, bool_useGet, params, function_onsuccess, function_onError, userContext, int_timeout) {
        ///<returns type="CK.Ajax"></returns>
        return CK.Ajax.AspNet.WebService.submit(string_servicePath, string_methodName, bool_useGet, params, function_onsuccess, function_onError, function_onError, userContext, int_timeout);
    }

    CK.Ajax.AspNet.WebService.submit = function(string_servicePath, string_methodName, bool_useGet, params, function_onSuccess, function_onError, function_onTimeout, userContext, int_timeout) {
        ///<returns type="CK.Ajax"></returns>
        var _path = string_servicePath + '/' + string_methodName;
        var _verb = bool_useGet ? 'get' : 'post';
        var _params = params;
        var _onSucc = function_onSuccess
        var _onError = function_onError;
        var _onTimeOut = function_onTimeout;
        var _userContext = userContext;
        var _timeout = int_timeout;
        var _postdata = null;
        var _getdata = '';
        if (_params != null)
        {
            if (_verb == 'post')
            {
                _postdata = CK.Json.decode(_params);
                if (_postdata == '{}') _postdata = '';
            }
            else if (_verb == 'get')
            {
                _getdata = '?';
                var sb = new CK.Text.StringBuilder(_getdata);
                for (var key in _params)
                {
                    sb.append(key);
                    sb.append('=');
                    sb.append(encodeURIComponent(CK.Json.decode(_params[key])));
                    sb.append('&');
                }
                _getdata = sb.toString();
                _getdata = _getdata.substr(0, _getdata.length - 1);
                if (_getdata == '{}') _getdata = '';
            }
        }


        var _onCompleted = function(result, context, xmlhttp) {
            var textError = false;
            var text = null;
            var r = null;
            try
            {
                result.get_responseText();
            }
            catch (ex)
            {
                textError = true;
            }

            if (!textError)
            {
                text = result.get_responseText();
            }

            if (result.get_isSucceed())
            {
                if (_onSucc)
                {
                    if (text != null)
                    {
                        _onSucc.apply(xmlhttp, [text.toJson(), context, xmlhttp]);
                    }
                    else
                    {
                        _onSucc.apply(xmlhttp, [text, context, xmlhttp]);
                    }
                }
            }
            else if (result.get_isError())
            {
                if (_onError)
                {

                    if (text != null)
                    {
                        r = text.toJson();
                        r = new CK.Ajax.AspNet.WebServiceError(r.ExceptionType, r.Message, r.StackTrace, xmlhttp.status, false);
                        _onError.apply(xmlhttp, [r, context, xmlhttp]);
                    }
                    else
                    {
                        _onError.apply(xmlhttp, [text, context, xmlhttp]);
                    }
                }
            }
            else if (result.get_isTimeOut())
            {
                if (_onTimeOut)
                {
                    r = new CK.Ajax.AspNet.WebServiceError('', '', '', xmlhttp.status, true);
                    _onTimeOut.apply(xmlhttp, [r, context, xmlhttp]);
                }
            }
        }
        var z = new CK.Ajax();
        z.set_verb(_verb);
        z.set_url(_path+_getdata);
        z.set_header('Content-Type', 'application/json; charset=utf-8');
        z.set_data(_postdata);
        z.add_completed(_onCompleted);
        z.set_userContext(_userContext);
        z.set_timeOut(_timeout);
        z.submit();
        return z;
    }
    RootType.regClass("CK.Ajax.AspNet.WebService");

    CK.Ajax.AspNet.WebServiceError = function(string_exceptionType, string_message, string_stackTrace, int_statusCode, bool_isTimeOut) {
        this.exceptionType = string_exceptionType;
        this.message = string_message;
        this.stackTrace = string_stackTrace;
        this.statusCode = int_statusCode;
        this.timeOut = bool_isTimeOut;
    }
    CK.Ajax.AspNet.WebServiceError.prototype = {
        get_exceptionType: function() {
            /// <value type="String"></value>
            return this.exceptionType;
        },
        get_message: function() {
            /// <value type="String"></value>
            return this.message;
        },
        get_stackTrace: function() {
            /// <value type="String"></value>
            return this.stackTrace;
        },
        get_statusCode: function() {
            /// <value type="Number"></value>
            return this.statusCode;
        },
        get_timedOut: function() {
            /// <value type="Boolean"></value>
            return this.timeOut;
        },
        toJson: function() {
            return { exceptionType: this.get_exceptionType(), message: this.get_message(), stackTrace: this.get_stackTrace(), statusCode: this.get_statusCode(), timeOut: this.get_timedOut() };
        }
    }
    RootType.regClass("CK.Ajax.AspNet.WebServiceError");

    String.prototype.trim = function() {
     ///<summary>去掉字符串的前後空格</summary>
        return this.replace(/^\s+|\s+$/g, '');
    }
    String.prototype.trimLeft = function() {
    ///<summary>去掉字符串的前空格</summary>
        return this.replace(/^\s+/, '');
    }
    String.prototype.trimRight = function() {
    ///<summary>去掉字符串的后空格</summary>
        return this.replace(/\s+$/, '');
    }
    String.prototype.leftString = function(int_length) {    
        var int_endIndex = int_length;
        return this.substr(0, int_endIndex);
    }
    String.prototype.rightString = function(int_length) {
        var int_statrIndex = int_length;
        return this.substring(this.length - int_statrIndex, this.length);
    }
    String.prototype.toJson = function() {
      ///<summary>將文本轉換成對象</summary>
        return CK.Json.encode(this);
    }
    String.format = function(format,args) {
        if (arguments.length == 0) return '';
        if (arguments.length == 1) return String(format);
        var strOutput = '';
        for (var i = 0; i < format.length - 1; )
        {
            if (format.charAt(i) == '{' && format.charAt(i + 1) != '{')
            {
                var index = 0, indexStart = i + 1;
                for (var j = indexStart; j <= format.length - 2; ++j)
                {
                    var ch = format.charAt(j);
                    if (ch < '0' || ch > '9') break;
                }
                if (j > indexStart)
                {
                    if (format.charAt(j) == '}' && format.charAt(j + 1) != '}')
                    {
                        for (var k = j - 1; k >= indexStart; k--)
                        {
                            index += (format.charCodeAt(k) - 48) * Math.pow(10, j - 1 - k);
                        }
                        var swapArg = arguments[index + 1];
                        strOutput += swapArg;
                        i += j - indexStart + 2;
                        continue;
                    }
                }
                strOutput += format.charAt(i);
                i++;
            }
            else
            {
                if ((format.charAt(i) == '{' && format.charAt(i + 1) == '{')
                || (format.charAt(i) == '}' && format.charAt(i + 1) == '}'))
                {
                    i++
                }
                strOutput += format.charAt(i);
                i++;
            }
        }
        strOutput += format.substr(i);
        return strOutput;
    }

    Number.prototype.toInt = function() {
        return CK.Convert.toInt(this);
    }
    RootType.regNameSpace("CK.Text");


    CK.Text.StringBuilder = function(string_initText) {
        this._text = [];
        if (string_initText != null) this.append(string_initText);
    }
    CK.Text.StringBuilder.prototype.append = function(string_text) {
        this._text[this._text.length] = string_text;
    }
    CK.Text.StringBuilder.prototype.appendLine = function(string_text) {
        string_text != null ? this._text[this._text.length] = string_text + '\r\n' : this._text[this._text.length] = '\r\n';
    }
    CK.Text.StringBuilder.prototype.isEmpty = function() {
        return (this._text.length == 0 || this.toString() === '') ? true : false;
    }
    CK.Text.StringBuilder.prototype.clear = function() {
        this._text = [];
    }
    CK.Text.StringBuilder.prototype.toString = function(string_separtor) {
        return string_separtor != null ? this._text.join(string_separtor) : this._text.join('');
    }
    RootType.regClass("CK.Text.StringBuilder");

    CK.Text.Validate = function() { };
    CK.Text.Validate.isEmail = function(string_emailAddress) {
        var r = /^([a-zA-Z0-9]*[-_.]?[a-zA-Z0-9]+)+@([\w-]+\.)+[a-zA-Z]{2,}$/;
        return r.test(string_emailAddress);
    }

    CK.Text.Validate.isUrl = function(string_url) {
        var u = /^http:\/\/\w+\.\w+\.\w+(\.\w+)?/;
        var v = /^HTTP:\/\/\w+\.\w+\.\w+(\.\w+)?/;
        if (u.test(string_url) || v.test(string_url))
            return true;
        else
            return false;
    }
    CK.Text.Validate.getPasswordStrength = function(string_password) {
        var p = string_password;
        if (p == null) return 0;
        if (typeof (p) !== 'string') throw Error('password must be string');
        var s = 0;
        if (p.length == 0) return 0;
        if (p.match(/[a-z]/)) s += 0.7;
        if (p.match(/[A-Z]/)) s += 0.7;
        if (p.match(/\d+/)) s += 0.7;
        if (p.length >= 12) s += 1.3;
        return s < 1 ? 1 : s.toInt();
    }
    RootType.regClass("CK.Text.Validate");
    CK.ObjectArray = function() {
        /// <field name="length"></field>    
        this.length = 0;
        var args = arguments;
        if (args.length != 0)
        {
            if (args.length == 1)
            {
                if (typeof (args[0]) === "number")
                {
                    var i;
                    for (i = 0; i < args[0]; i++)
                        this.add(undefined);
                }
                else
                {
                    this.add(args[0]);
                }
            }
            else
            {
                for (i = 0; i < args.length; i++)
                    this.add(args[i]);
            }
        }
    }

    CK.ObjectArray.prototype = {
        item: function(int_index) {
            var index = int_index;
            if (index >= this.length || index < 0) throw new Error("Index Out Of RangeException");
            return this[index];
        },
        add: function(object) {
            this[this.length] = object;
            this.length++;
        },
        addAt: function(int_index, object) {
            var index = int_index;
            if (index >= this.length || index < 0) throw new Error("Index Out Of RangeException");
            for (var i = this.length; i > index; i--)
            {
                this[i] = this[i - 1];
            }
            this[index] = object;
            this.length++;
        },
        remove: function(object) {
            for (var i = 0; i < this.length; i++)
            {
                if (this[i] === object)
                {
                    this.removeAt(i);
                    i--;
                }
            }
        },
        removeAt: function(int_index) {
            var index = int_index;
            if (index >= this.length || index < 0) throw new Error("Index Out Of RangeException");
            var cIndex = index;
            if (index == this.length - 1)
            {
                this[index] = null;
                delete this[index];
                this.length--;
            }
            else
            {
                while (true)
                {
                    this[cIndex] = this[cIndex + 1];
                    this[cIndex + 1] = null;
                    if (cIndex + 1 == this.length - 1)
                    {
                        this[cIndex + 1] = null;
                        delete this[cIndex + 1];
                        this.length--;
                        break;
                    }
                    cIndex++;
                }
            }
        }
    }
    RootType.regClass("CK.ObjectArray");

    CK.Browser = {};
    CK.Browser.agent = null;
    CK.Browser.IE = {};
    CK.Browser.Firefox = {};
    CK.Browser.Safari = {};
    CK.Browser.Chrome = {};
    CK.Browser.Opera = {};
    CK.Browser.isIE = false;
    CK.Browser.isFirefox = false;
    CK.Browser.isSafari = false;
    CK.Browser.isChrome = false;
    CK.Browser.isOpera = false;
    CK.Browser.isSupportXHTML = false;
    CK.Browser.isSupportCssPositionFixed = false;
    CK.Browser.name = navigator.appName;
    CK.Browser.version = parseFloat(navigator.appVersion);
    if (navigator.userAgent.indexOf(' MSIE ') > -1)
    {
        CK.Browser.isIE = true;
        CK.Browser.agent = CK.Browser.IE;
        CK.Browser.version = parseFloat(navigator.userAgent.match(/MSIE (\d+\.\d+)/)[1]);
        CK.Browser.name = 'Internet Explorer';
    }
    else if (navigator.userAgent.indexOf(' Firefox/') > -1)
    {
        CK.Browser.isFirefox = true;
        CK.Browser.agent = CK.Browser.Firefox;
        CK.Browser.version = parseFloat(navigator.userAgent.match(/ Firefox\/(\d+\.\d+)/)[1]);
        CK.Browser.name = 'Firefox';
    }
    else if ((navigator.userAgent.indexOf(' Safari/') > -1) && (navigator.userAgent.indexOf('Chrome/') < 0))
    {
        CK.Browser.isSafari = true;
        CK.Browser.isChrome = true;
        CK.Browser.agent = CK.Browser.Safari;
        CK.Browser.version = parseFloat(navigator.userAgent.match(/ Safari\/(\d+\.\d+)/)[1]);
        CK.Browser.name = 'Safari';
    }
    else if (navigator.userAgent.indexOf('Chrome/') > -1)
    {
        CK.Browser.isSafari = true;
        CK.Browser.isChrome = true;
        CK.Browser.agent = CK.Browser.Chrome;
        CK.Browser.version = parseFloat(navigator.userAgent.match(/ Chrome\/(\d+\.\d+)/)[1]);
        CK.Browser.name = 'Google Chrome';
    }
    else if (navigator.userAgent.indexOf('Opera/') > -1)
    {
        CK.Browser.isOpera = true;
        CK.Browser.agent = CK.Browser.Opera;
        CK.Browser.name = 'Opera';
    }

    if (document.compatMode == 'CSS1Compat')
    {
        CK.Browser.isSupportXHTML = true
    }
    if (!(((!CK.Browser.isSupportXHTML) || (Math.floor(CK.Browser.version) <= 6)) && (CK.Browser.isIE)))
    {
        CK.Browser.isSupportCssPositionFixed = true
    }


    RootType.regNameSpace('CK.Convert');
    CK.Convert.toFixed = function(data, int_decimalPlace) {
        ///<returns type="String"><returns>
        if (typeof (data) == 'number')
            return data.toFixed(int_decimalPlace);
        else
            return parseFloat(data).toFixed(int_decimalPlace);
    }
    CK.Convert.toInt = function(number_data) {
        ///<returns type="Number"><returns>
        return Math.floor(number_data);
    }

    RootType.regNameSpace('CK.Json');
    CK.Json.encode = function(string_data) {
        var _data = string_data;
        if (_data.length === 0) throw Error('data is empty');
        try
        {
            var exp = _data.replace(new RegExp('(^|[^\\\\])\\"\\\\/Date\\((-?[0-9]+)\\)\\\\/\\"', 'g'), "$1new Date($2)");
            return eval('(' + exp + ')');
        }
        catch (e)
        {
            throw Error('data can not encode!');
        }
    }

    CK.Json.decode = function(object) {
        var o = object;
        var t = null;
        if (typeof (o) === 'object')
        {
            if (o instanceof Array)
                t = 'array';
            else if (o instanceof Date)
                t = 'date';
            else t = '';
        }
        else
        {
            t = typeof (o);
        }
        switch (t.toLowerCase())
        {
            case 'array':
                var strArray = '[';
                for (var i = 0; i < o.length; ++i)
                {
                    var value = '';
                    if (o && o[i])
                    {
                        var arrType = typeof (o[i]);
                        if (arrType == "object")
                            if (o[i] instanceof Array) arrType = "array";
                        value = CK.Json.decode(o[i]);
                    }
                    strArray += value + ',';
                }
                if (strArray.charAt(strArray.length - 1) == ',') strArray = strArray.substr(0, strArray.length - 1);
                strArray += ']';
                return strArray;
                break;
            case 'date':
                return 'new Date(' + o.getTime() + ')';
                break;
            case 'boolean':
            case 'function':
            case 'number':
                return o;
                break;
            case 'string':
                return '"' + o.toString() + '"';
                break;
            default:
                var serialize = '{';
                for (var key in o)
                {
                    if (key == 'Serialize') continue;
                    var subserialize = '';
                    if (o[key] != undefined)
                    {
                        var _t = typeof (o[key]);
                        if (_t == "object")
                        {
                            if (o[key] instanceof Array)
                                _t = "array";
                        }
                        subserialize = CK.Json.decode(o[key]);
                    }
                    serialize += key + ' : ' + subserialize + ',';
                }
                if (serialize.charAt(serialize.length - 1) == ',') serialize = serialize.substr(0, serialize.length - 1);
                serialize += '}';
                return serialize;
        }
    }

    CK.Json.JsonTable = function() { }
    CK.Json.JsonTable.desc = function(JsonTable, string_columnName) {
    ///<summary>Json形式的数据表排序，降序排列</summary>      
        return CK.Json.JsonTable._sort(JsonTable, string_columnName, 'desc');
    }
    CK.Json.JsonTable.asc = function(JsonTable, string_columnName) {
    ///<summary>Json形式的数据表排序，升序排列</summary>
        return CK.Json.JsonTable._sort(JsonTable, string_columnName, 'asc');
    }
    CK.Json.JsonTable._sort = function(data, string_columnName, string_sortType) {
        var array = data;
        var col = string_columnName;
        var type = string_sortType.trim().toLowerCase();
        var flag = false;
        var len = array.length;
        var i, j, temp;
        switch (type)
        {
            case 'asc':
                for (i = 0; i <= len - 2; i++)
                {
                    flag = false;
                    for (j = len - 1; j >= 1; j--)
                    {
                        if (array[j][col] < array[j - 1][col])
                        {
                            temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                            flag = true;
                        }
                    }
                    if (!flag) break;
                }
                break;
            case 'desc':
                for (i = 0; i <= len - 2; i++)
                {
                    flag = false;
                    for (j = len - 1; j >= 1; j--)
                    {
                        if (array[j][col] > array[j - 1][col])
                        {
                            temp = array[j];
                            array[j] = array[j - 1];
                            array[j - 1] = temp;
                            flag = true;
                        }
                    }
                    if (!flag) break;
                }
                break;
            default:
                throw new Error('unkown sortType, Please enter "asc" or "desc" ');
        }
        return array;
    }
    RootType.regClass("CK.Json.JsonTable");



    RootType.regNameSpace("CK.UI");
    CK.UI.Size = function(int_width, int_height) {
        /// <field name="width"></field>
        /// <field name="height"></field>
        this.width = parseInt(int_width);
        this.height = parseInt(int_height);
    }
    RootType.regClass("CK.UI.Size");

    CK.UI.XY = function(int_x, int_y) {
        /// <field name="x"></field>
        /// <field name="y"></field>
        this.x = parseInt(int_x);
        this.y = parseInt(int_y);
    }
    RootType.regClass("CK.UI.XY");

    CK.UI.Infomation = function(int_x, int_y, int_width, int_height) {
        /// <field name="x"></field>
        /// <field name="y"></field>
        /// <field name="width"></field>
        /// <field name="height"></field>
        this.x = parseInt(int_x);
        this.y = parseInt(int_y);
        this.width = parseInt(int_width);
        this.height = parseInt(int_height);
    }
    RootType.regClass("CK.UI.Infomation");

    CK.UI.Control = function() { }
    CK.UI.Control.findControl = function(string_controlId) {
        var _id = string_controlId;
        var _controls = __cachecontrolArray;
        var i;
        for (i = 0; i < _controls.length; i++)
        {
            if (_controls.item(i)._controlId == _id)
                return _controls.item(i)._control;
        }
        return null;
    }
    var $findControl = CK.UI.Control.findControl;
    RootType.regClass("CK.UI.Control");

    CK.UI.Control.cacheControl = function(string_controlId, control) {
        var i;
        for (i = 0; i < __cachecontrolArray.length; i++)
        {
            if (__cachecontrolArray.item(i)._controlId == string_controlId) throw new Error('Control Id [ ' + string_controlId + ' ] exists');
        }
        var _controlJson = { _controlId: string_controlId, _control: control };
        __cachecontrolArray.add(_controlJson);
    }
    CK.UI.Control.MaskScreen = function(string_controlId, string_bgColor, float_opacity, int_zIndex) {
        if (!string_controlId) throw new Error(" [ string_controlId ] param is null");
        if ((float_opacity < 0) || (float_opacity > 1)) throw new Error(" [ float_opacity ] param  must  between 0 and 1");
        if ($findControl(string_controlId)) throw new Error(" [ " + string_controlId + " ] Control Id exists!");

        this._controlId = string_controlId;
        this._el = document.createElement("div");

        if (!CK.Browser.isSupportCssPositionFixed)
        {
            this._el.style.position = "absolute";
            this._el.style.setExpression("left", "eval( CK.UI.Dom.Scroll.getInfo().x)");
            this._el.style.setExpression("top", "eval( CK.UI.Dom.Scroll.getInfo().y)");
            this._el.style.setExpression("width", "eval( CK.UI.Dom.getBodyInfo().width)");
            this._el.style.setExpression("height", "eval(CK.UI.Dom.getBodyInfo().height)");
        }
        else
        {
            this._el.style.position = "fixed";
            this._el.style.top = "0px";
            this._el.style.left = "0px";
            this._el.style.bottom = "0px";
            this._el.style.right = "0px";
        }

        this._bgColor = string_bgColor;
        var _opacity = float_opacity;
        this._isShow = true;
        this._zIndex = 0;
        CK.UI.Control.cacheControl(this._controlId, this);
        this.set_bgColor(this.get_bgColor());
        this.set_opacity(_opacity);

        if (!this._zIndex != null)
            this.set_zIndex(int_zIndex);
        else
            this._zIndex = 0;

        this.set_zIndex(this.get_zIndex());
        document.body.appendChild(this._el);
    }

    CK.UI.Control.MaskScreen.prototype = {
        get_controlId: function() {
            return this._controlId;
        },
        show: function() {
            CK.UI.Dom.setDisplay(this._el, '');
            this._isShow = true;
        },
        hide: function() {
            CK.UI.Dom.setDisplay(this._el, 'none');
            this._isShow = false;
        },
        get_isShow: function() {
            return this._isShow;
        },
        get_zIndex: function() {
            return this._zIndex;
        },
        set_zIndex: function(int_zIndex) {
            this._zIndex = int_zIndex;
            this._el.style.zIndex = this.get_zIndex();
        },
        get_bgColor: function() {
            return this._bgColor;
        },
        set_bgColor: function(string_bgColor) {
            this._bgColor = string_bgColor;
            this._el.style.backgroundColor = this.get_bgColor();
        },
        get_opacity: function() {
            return CK.UI.Dom.getOpacity(this._el);
        },
        set_opacity: function(float_opacity) {
            CK.UI.Dom.setOpacity(this._el, parseFloat(float_opacity));
        },
        get_srcDiv: function() {
            return this._el;
        }
    }
    RootType.regClass("CK.UI.Control.MaskScreen");

    CK.UI.Control.AlwaysVisibleDiv = function(string_controlId, div_element, int_zIndex, CK_Enum_Layout_Align, CK_Enum_Layout_Valign, int_margin, int_vmargin) {
        div_element = CK.UI.Dom.getElement(div_element);
        if ((!div_element) || (div_element.tagName != "DIV")) throw new Error("Element must be DIV");

        this._isSupportNewCode = true;
        if (!CK.Browser.isSupportCssPositionFixed)
            this._isSupportNewCode = false;

        this._controlId = string_controlId;
        this._el = div_element;
        if (this._isSupportNewCode)
            this._el.style.position = 'fixed';
        else
            this._el.style.position = 'absolute';

        this._zIndex = 0;
        this._align = CK.Enum.Layout.Align.left;
        this._valign = CK.Enum.Layout.Valign.top;
        this._margin = 0;
        this._vmargin = 0;
        this._isShow = true;
        this._x;
        this._y;
        this._isInit = true;
        var _self = this;
        CK.UI.Control.cacheControl(this._controlId, this);

        if (int_zIndex != null)
            this.set_zIndex(int_zIndex);

        if (CK_Enum_Layout_Align)
            this.set_align(CK_Enum_Layout_Align);

        if (CK_Enum_Layout_Valign)
            this.set_valign(CK_Enum_Layout_Valign);


        if (int_margin != null)
            this.set_margin(parseInt(int_margin));

        if (int_vmargin != null)
            this.set_vmargin(parseInt(int_vmargin));


        this.___selfSetFloat = function() {
            var _elX;
            var _elY;
            var _elWidth;
            var _elHeight;
            var _docHeight;
            var _docWidth;
            var _scrollX;
            var _scrollY;

            if (_self.get_isShow() == true)
                CK.UI.Dom.setDisplay(_self._el, 'inline');

            if (_self._isSupportNewCode)
            {
                _elX = _self._el.offsetLeft;
                _elY = _self._el.offsetTop;
                _elWidth = _self._el.offsetWidth;
                _elHeight = _self._el.offsetHeight;
                _self._el.style.left = "";
                _self._el.style.right = "";
                _self._el.style.top = "";
                _self._el.style.bottom = "";
                _self._el.style.marginLeft = "";
                _self._el.style.marginTop = "";
            }
            else
            {
                _elX = "this.offsetLeft";
                _elY = "this.offsetTop";
                _elWidth = "this.offsetWidth";
                _elHeight = "this.offsetHeight";
                _docHeight = "CK.UI.Dom.getBodyInfo().height";
                _docWidth = "CK.UI.Dom.getBodyInfo().width";
                _scrollX = "CK.UI.Dom.Scroll.getInfo().x";
                _scrollY = "CK.UI.Dom.Scroll.getInfo().y";
            }
            switch (_self.get_align())
            {
                case CK.Enum.Layout.Align.left: default:
                    if (_self._isSupportNewCode)
                        _self._el.style.left = (0 + _self.get_margin()) + "px";
                    else
                        _self._x = String.format("eval({0}+{1})", _scrollX, _self.get_margin());
                    break;

                case CK.Enum.Layout.Align.center:
                    if (_self._isSupportNewCode)
                    {
                        _self._el.style.left = "50%";
                        _self._el.style.marginLeft = "-" + (_elWidth / 2) + "px";
                    }
                    else
                    {
                        _self._x = String.format("eval( ({0}/2)-({1}/2) +{2})", _docWidth, _elWidth, _scrollX);
                    }
                    break;

                case CK.Enum.Layout.Align.right:
                    if (_self._isSupportNewCode)
                        this._el.style.right = (0 + _self.get_margin()) + "px";
                    else
                        _self._x = String.format("eval({0}+{1}-{2}-{3})", _scrollX, _docWidth, _elWidth, _self.get_margin());
                    break;
            }
            switch (_self.get_valign())
            {
                case CK.Enum.Layout.Valign.top: default:
                    if (_self._isSupportNewCode)
                        _self._el.style.top = (0 + _self.get_vmargin()) + "px";
                    else
                        _self._y = String.format("eval({0}+{1})", _scrollY, _self.get_vmargin());
                    break;
                case CK.Enum.Layout.Valign.middle:
                    if (_self._isSupportNewCode)
                    {
                        _self._el.style.top = "50%";
                        _self._el.style.marginTop = "-" + (_elHeight / 2) + "px";
                    }
                    else
                    {
                        _self._y = String.format("eval(({0}/2)-({1}/2)+{2})", _docHeight, _elHeight, _scrollY);
                    }
                    break;
                case CK.Enum.Layout.Valign.bottom:
                    if (_self._isSupportNewCode)
                        _self._el.style.bottom = (0 + _self.get_vmargin()) + "px";
                    else
                        _self._y = String.format("eval({0}+{1}-{2}-{3})", _scrollY, _docHeight, _elHeight, _self.get_vmargin());
                    break;
            }

            if (!this._isSupportNewCode)
            {
                this._el.style.setExpression("left", this._x);
                this._el.style.setExpression("top", this._y);
            }
        }
        this._isInit = false;
        this.___selfSetFloat();
    }

    CK.UI.Control.AlwaysVisibleDiv.prototype = {
        get_controlId: function() {
            return this._controlId;
        },
        get_isShow: function() {
            return this._isShow;
        },
        get_zIndex: function() {
            return this._zIndex;
        },
        set_zIndex: function(int_zIndex) {
            this._zIndex = int_zIndex;
            this._el.style.zIndex = this.get_zIndex();
        },
        get_align: function() {
            return this._align;
        },
        set_align: function(CK_Enum_Layout_Align) {
            this._align = CK_Enum_Layout_Align;
            if (!this._isInit)
                this.___selfSetFloat();
        },
        get_valign: function() {
            return this._valign;
        },
        set_valign: function(CK_Enum_Layout_Valign) {
            this._valign = CK_Enum_Layout_Valign;
            if (!this._isInit)
                this.___selfSetFloat();
        },
        get_margin: function() {
            return this._margin;
        },
        set_margin: function(int_margin) {
            this._margin = parseInt(int_margin);
            if (!this._isInit)
                this.___selfSetFloat();
        },
        get_vmargin: function() {
            return this._vmargin;
        },
        set_vmargin: function(int_vmargin) {
            this._vmargin = parseInt(int_vmargin);
            if (!this._isInit)
                this.___selfSetFloat();
        },
        get_srcDiv: function() {
            return this._el;
        },
        show: function() {
            CK.UI.Dom.setDisplay(this._el, 'inline');
            this._isShow = true;
        },
        hide: function() {
            CK.UI.Dom.setDisplay(this._el, 'none');
            this._isShow = false;
        }
    }
    RootType.regClass("CK.UI.Control.AlwaysVisibleDiv");

    CK.UI.Control.MaskAlwaysVisibleDiv = function(string_controlId, div_element, string_bgColor, float_opacity, int_zIndex) {
        div_element = CK.UI.Dom.getElement(div_element);
        if ((!div_element) || (div_element.tagName != "DIV")) throw new Error("Element must be DIV");

        this._controlId = string_controlId;
        this._el = div_element;
        var _bgColor = string_bgColor;
        var _opacity = float_opacity;
        this._zIndex = int_zIndex;
        var _maskId = string_controlId + "_MaskScreen";
        var _floatId = string_controlId + "_AlwaysVisibleDiv";
        this._maskControl = new CK.UI.Control.MaskScreen(_maskId, _bgColor, _opacity, this._zIndex);
        this._floatControl = new CK.UI.Control.AlwaysVisibleDiv(_floatId, this._el, this._zIndex + 1, CK.Enum.Layout.Align.center, CK.Enum.Layout.Valign.middle, 0, 0);
        CK.UI.Control.cacheControl(this._controlId, this);
    }
    CK.UI.Control.MaskAlwaysVisibleDiv.prototype = {
        get_controlId: function() {
            return this._controlId;
        },
        show: function() {
            this.get_srcMaskScreen().show();
            this.get_srcAlwaysVisibleDiv().show();
            this._isShow = true;
        },
        hide: function() {
            this.get_srcMaskScreen().hide();
            this.get_srcAlwaysVisibleDiv().hide();
            this._isShow = false;
        },
        get_isShow: function() {
            return this._isShow;
        },
        get_zIndex: function() {
            return this._zIndex;
        },
        set_zIndex: function(int_zIndex) {
            this._zIndex = int_zIndex;
            this.get_srcMaskScreen().set_zIndex(this.get_zIndex());
            this.get_srcAlwaysVisibleDiv().set_zIndex(this.get_zIndex() + 1);
        },
        get_bgColor: function() {
            return this.get_srcMaskScreen().get_bgColor();
        },
        set_bgColor: function(string_bgColor) {
            this.get_srcMaskScreen().set_bgColor(string_bgColor);
        },
        get_opacity: function() {
            return this.get_srcMaskScreen().get_opacity();
        },
        set_opacity: function(float_opacity) {
            this.get_srcMaskScreen().set_opacity(float_opacity);
        },
        get_srcMaskScreen: function() {
        ///<returns type="CK.UI.Control.MaskScreen"></returns>
            return this._maskControl;
        },

        get_srcAlwaysVisibleDiv: function() {
         ///<returns type="CK.UI.Control.AlwaysVisibleDiv"></returns>
            return this._floatControl;
        }
    }
    RootType.regClass("CK.UI.Control.MaskAlwaysVisibleDiv");
    CK.UI.Control.DragDiv = function(string_controlId, div_element, int_zIndex) {
        if (string_controlId == null) throw new Error('Please enter control id');
        if (typeof (string_controlId) != 'string') throw new Error('Control id must be typeof string');
        var _self = this;
        this._controlId = string_controlId;
        CK.UI.Control.cacheControl(this._controlId, this);
        this._el = CK.UI.Dom.getElement(div_element);
        this._titleEl = null;
        if (int_zIndex != null) this._el.style.zIndex = int_zIndex;
        this._dragStartHandlers = null;
        this._dragingHandlers = null;
        this._dragEndHandlers = null;
        this._isDragStart = false;
        this._isDraging = false;
        this._isDragEnd = true;
        this._canNotDragElements = null;
        this._canDrag = true;
        this._isUseTitle = false;
        this._isFirstSetTitle = true;
        this._isShow = true;
        this._targetElement = null;
        var _isMouseOnTitle = false;
        this._alwaysVisibleDragDivDragEndHander = null;
        this._isDragingDiv = false;
        var _downX;
        var _downY;
        var _removeDragingElement = function() {
            if (_self._eventEl)
            {
                document.body.removeChild(_self._eventEl);
                _self._eventEl = null;
            }
        }
        this._getDragingElement = function() {

            if (!_self._eventEl)
            {
                _self._eventEl = document.createElement("div");
                document.body.appendChild(_self._eventEl);
                _self._eventEl.style.borderStyle = 'solid';
                _self._eventEl.style.borderWidth = '1px';
                _self._eventEl.style.zIndex = "9999";
                var _size = CK.UI.Dom.getSize(_self._el);
                var xy = CK.UI.Dom.getXY(_self._el);
                CK.UI.Dom.setSize(_self._eventEl, _size.width, _size.height);
                CK.UI.Dom.setXY(_self._eventEl, xy.x, xy.y);
                _self._eventEl.style.display = 'block';
                _self._eventEl.style.position = 'absolute';
            }
            return _self._eventEl;
        }
        var _dragStart = function(e) {
            if (e) CK.UI.DomEventArg.blockEvent(e);
            if (!_self.get_canDrag()) return;
            var _src = CK.UI.DomEventArg.getSrcElement(e);
            var _cs = _self._canNotDragElements;
            if (_cs != null)
            {
                for (var i = 0; i < _cs.length; i++)
                    if (_src == _cs[i]) return;
            }

            var _setDragInitInfo = function() {
                _self._isDragingDiv = true;
                var elXy = CK.UI.Dom.getXY(_self._el);
                _downX = e.clientX - elXy.x;
                _downY = e.clientY - elXy.y;
                _self._getDragingElement();
                CK.UI.Dom.setOpacity(_self._el, 0.3);
                _self._isDragStart = true;
                _self._isDraging = false;
                _self._isDragEnd = false;
                if (_self._dragStartHandlers != null)
                {
                    for (var ii = _self._dragStartHandlers.length - 1; ii >= 0; ii--)
                        _self._dragStartHandlers[ii](e);
                }
            }

            if (_self.get_useTitle())
            {
                if (_isMouseOnTitle)
                    _setDragInitInfo();
            }
            else
            {
                _setDragInitInfo();
            }


        }

        var _draging = function(e) {

            if (e) CK.UI.DomEventArg.blockEvent(e);

            var _setDragingXY = function() {
                if (_self._isDragingDiv)
                {
                    var x = e.clientX - _downX;
                    var y = e.clientY - _downY;
                    CK.UI.Dom.setXY(_self._getDragingElement(), x, y);

                    _self._isDragStart = false;
                    _self._isDraging = true;
                    _self._isDragEnd = false;
                    if (_self._dragingHandlers != null)
                    {
                        for (var jj = _self._dragingHandlers.length - 1; jj >= 0; jj--)
                            _self._dragingHandlers[jj](e);
                    }
                }

            }
            if (_self.get_useTitle())
            {
                if (_isMouseOnTitle)
                    _setDragingXY();
            }
            else
            {
                _setDragingXY();
            }
        }

        var _dragsEnd = function(e) {

            if (_self._isDragingDiv)
            {
                CK.UI.Dom.setOpacity(_self._el, 1.0);
                var fxy = _self.get_xy();
                CK.UI.Dom.setXY(_self._el, fxy.x, fxy.y);
                _removeDragingElement();
                _self._isDragStart = false;
                _self._isDraging = false;
                _self._isDragEnd = true;
                _self._isDragingDiv = false;

                if (_self._dragEndHandlers != null)
                {
                    for (var kk = _self._dragEndHandlers.length - 1; kk >= 0; kk--)
                        _self._dragEndHandlers[kk](e);
                }
            }
        }


        var _titleOver = function() {

            _isMouseOnTitle = true;
        }
        var _titleOut = function() {
            if (!(_self.get_isDragStart() || _self.get_isDraging()))
                _isMouseOnTitle = false;
        }

        var _updateAlwayVisibleDragDivStaticXY = function(e) {
            CK.UI.DomEventArg.blockEvent(e);
            if (_self._alwaysVisibleDragDivDragEndHander)
                _self._alwaysVisibleDragDivDragEndHander(e);
        }

        this._setTitle = function(el) {
            var oldTitle = _self.get_title();
            var newTitle = el;
            if (oldTitle != null)
            {
                $removeEventHandler(oldTitle, 'mouseover', _titleOver);
                $removeEventHandler(oldTitle, 'mouseout', _titleOut);
            }

            _self._titleEl = newTitle;
            _self._setMoveCursor(oldTitle, newTitle);
            $addEventHandler(newTitle, 'mouseover', _titleOver);
            $addEventHandler(newTitle, 'mouseout', _titleOut);
        }

        this._setMoveCursor = function(oldTitle) {
            if (oldTitle) oldTitle.style.cursor = '';
            var _title = _self.get_title();
            var cursor = 'move';
            if (!_self.get_canDrag())
            {
                _self._el.style.cursor = '';
                if (_title) _title.style.cursor = '';
            }
            else if (_self.get_useTitle())
            {
                _self._el.style.cursor = '';
                if (_title) _title.style.cursor = cursor;
            }
            else
            {
                if (_title) _title.style.cursor = '';
                _self._el.style.cursor = cursor;
            }
        }


        $addEventHandler(_self._el, 'mousedown', _dragStart);
        $addEventHandler(document, 'mousemove', _draging);
        $addEventHandler(document, 'mouseup', _dragsEnd);
        $addEventHandler(document, 'mouseup', function() { _isMouseOnTitle = false });
        $addEventHandler(document, 'mouseup', _updateAlwayVisibleDragDivStaticXY);
    }

    CK.UI.Control.DragDiv.prototype = {
        get_controlId: function() {
            return this._controlId;
        },
        get_title: function() {
            return this._titleEl;
        },
        set_title: function(element) {
            element = CK.UI.Dom.getElement(element);
            this._setTitle(element);
            if (this._isFirstSetTitle)
            {
                if (element != null)
                    this.set_useTitle(true);
                else
                    this.set_useTitle(false);
                this._isFirstSetTitle = false;
            }
        },
        get_useTitle: function() {
            return this._isUseTitle;
        },
        set_useTitle: function(bool_isUseTitle) {
            if ((this._titleEl == null) && (bool_isUseTitle == true)) throw new Error('can not find title element!');
            this._isUseTitle = bool_isUseTitle;
            this._setMoveCursor();
        },


        get_target: function() {
            return this._targetElement;
        },
        set_target: function(element) {
            this._targetElement = element;
        },



        set_canNotDragElements: function(array_elements) {
            var args = arguments;
            if (args.length > 0)
            {
                if (args[0] instanceof Array)
                {
                    this._canNotDragElements = args[0];
                }
                else
                {
                    this._canNotDragElements = [];
                    for (var i = 0; i < args.length; i++)
                        this._canNotDragElements[this._canNotDragElements.length] = args[i];
                }
            }
        },

        get_zIndex: function() {
            return this._el.style.zIndex;
        },
        set_zIndex: function(int_zIndex) {
            this._el.style.zIndex = int_zIndex;
        },
        get_size: function() {
            ///<returns type="CK.UI.Size"></returns>
            return CK.UI.Dom.getSize(this._el);
        },
        get_xy: function() {
            if (this._isDragingDiv)
                return CK.UI.Dom.getXY(this._getDragingElement());
            else
                return CK.UI.Dom.getXY(this._el);
        },
        set_xy: function(int_x, int_y) {
            CK.UI.Dom.setXY(this._el, int_x, int_y);
        },
        get_canDrag: function() {
            return this._canDrag;
        },
        set_canDrag: function(bool_canDrag) {
            this._canDrag = bool_canDrag;
            this._setMoveCursor();
        },
        get_isShow: function() {
            return this._isShow;
        },
        show: function() {
            CK.UI.Dom.setDisplay(this._el, '');
            if (this._alwaysVisibleDragDivDragEndHander) this._alwaysVisibleDragDivDragEndHander();
            this._isShow = true;
        },
        hide: function() {
            CK.UI.Dom.setDisplay(this._el, 'none');
            this._isShow = false;
        },
        add_dragStart: function(function_handler) {
            if (!this._dragStartHandlers) this._dragStartHandlers = new CK.ObjectArray();
            this._dragStartHandlers.add(function_handler);
        },
        remove_dragStart: function(function_handler) {
            if (this._dragStartHandlers)
                this._dragStartHandlers.remove(function_handler);
        },
        add_draging: function(function_handler) {
            if (!this._dragingHandlers) this._dragingHandlers = new CK.ObjectArray();
            this._dragingHandlers.add(function_handler);
        },
        remove_draging: function(function_handler) {
            if (this._dragingHandlers) this._dragingHandlers.remove(function_handler);

        },
        add_dragEnd: function(function_handler) {
            if (!this._dragEndHandlers) this._dragEndHandlers = new CK.ObjectArray();
            this._dragEndHandlers.add(function_handler);
        },
        remove_dragEnd: function(function_handler) {
            if (this._dragEndHandlers)
                this._dragEndHandlers.remove(function_handler);
        },
        get_isDragStart: function() {
            return this._isDragStart;
        },
        get_isDraging: function() {
            return this._isDraging;
        },
        get_isDragEnd: function() {
            return this._isDragEnd;
        },
        get_isOverTarget: function() {
            var t = this.get_target();
            if (!t) return false;
            var tInfo = CK.UI.Dom.getElementInfo(t);
            if (tInfo.width == 0 || tInfo.height == 0)
            {
                return false;
            }
            else
            {
                var xy = this.get_xy();
                var wh = this.get_size();
                var eInfo = new CK.UI.Infomation(xy.x, xy.y, wh.width, wh.height);
                var eStartX = eInfo.x;
                var eStartY = eInfo.y;
                var eEndX = eStartX + eInfo.width;
                var eEndY = eStartY + eInfo.height;

                var tStartX = tInfo.x;
                var tStartY = tInfo.y;
                var tEndX = tStartX + tInfo.width;
                var tEndY = tStartY + tInfo.height;
                var startLPoint = false;
                var startRPoint = false;
                var endLPoint = false;
                var endRPoint = false;
                if ((eStartX >= tStartX && eStartX <= tEndX) && (eStartY >= tStartY && eStartY <= tEndY))
                    startLPoint = true;
                else if ((eEndX >= tStartX && eEndX <= tEndX) && (eStartY >= tStartY && eStartY <= tEndY))
                    startRPoint = true;
                else if ((eStartX >= tStartX && eStartX <= tEndX) && (eEndY >= tStartY && eEndY <= tEndY))
                    endLPoint = true;
                else if ((eEndX >= tStartX && eEndX <= tEndX) && (eEndY >= tStartY && eEndY <= tEndY))
                    endRPoint = true;

                if (startLPoint || startRPoint || endLPoint || endRPoint)
                    return true;
                else
                    return false;
            }
        },
        appendToTarget: function() {
            var t = this.get_target();
            if (t)
            {
                t.appendChild(this._el);
                this._el.style.position = '';
            }
        }
    }
    RootType.regClass('CK.UI.Control.DragDiv');

    CK.UI.Control.AlwaysVisibleDragDiv = function(string_controlId, div_element, int_zIndex) {
        var _self = this;
        this._controlId = string_controlId;
        this._el = div_element;
        var _zIndex = int_zIndex;
        this._isAlwaysVisible = true;
        this._dragDiv = new CK.UI.Control.DragDiv(this._controlId + "_DragDiv", this._el, _zIndex);
        CK.UI.Control.cacheControl(this._controlId, this);
        var dxy;
        this._updateStaticXY = function() {
            dxy = _self._dragDiv.get_xy();
            var scrollxy = CK.UI.Dom.Scroll.getInfo();
            dxy.x = dxy.x - scrollxy.x;
            dxy.y = dxy.y - scrollxy.y;
        }
        this._updateStaticXY();
        this._dragDiv._alwaysVisibleDragDivDragEndHander = this._updateStaticXY;

        this._scrollXY = function() {
            if (_self.get_isAlwaysVisible())
            {
                if (!_self.get_isShow()) return;
                var sxy = CK.UI.Dom.Scroll.getInfo();
                var bxy = CK.UI.Dom.getBodyInfo();
                var fx = dxy.x + sxy.x;
                var fy = dxy.y + sxy.y;
                var size = _self.get_size();

                var allowX = sxy.x + bxy.width - size.width;
                var allowY = sxy.y + bxy.height - size.height;
                if (fx > allowX) fx = allowX;
                else if (fx <= sxy.x) fx = sxy.x;
                if (fy > allowY) fy = allowY;
                else if (fy <= sxy.y) fy = sxy.y;
                _self._dragDiv.set_xy(fx, fy);
            }
        }
        $addEventHandler(window, 'scroll', this._scrollXY);
        $addEventHandler(window, 'resize', this._scrollXY);
    }

    CK.UI.Control.AlwaysVisibleDragDiv.prototype = {
        get_controlId: function() {
            return this._controlId;
        },
        get_title: function() {
            return this._dragDiv.get_title();
        },
        set_title: function(element) {
            this._dragDiv.set_title(element);
        },
        get_isAlwaysVisible: function() {
            return this._isAlwaysVisible;
        },
        set_isAlwaysVisible: function(bool_isAlwaysVisible) {
            this._isAlwaysVisible = bool_isAlwaysVisible;
        },
        set_canNotDragElements: function(elements) {
            this._dragDiv.set_canNotDragElements(elements);
        },
        get_useTitle: function() {
            return this._dragDiv.get_useTitle();
        },
        set_useTitle: function(bool_isUseTitle) {
            this._dragDiv.set_useTitle(bool_isUseTitle);
        },

        get_zIndex: function() {
            return this._dragDiv.get_zIndex();
        },
        set_zIndex: function(int_zIndex) {
            this._dragDiv.set_zIndex(int_zIndex);
        },
        get_size: function() {
            ///<returns type="CK.UI.Size"></returns>
            return this._dragDiv.get_size();
        },
        get_xy: function() {
            ///<returns type="CK.UI.XY"></returns>
            return this._dragDiv.get_xy();
        },
        set_xy: function(int_x, int_y) {
            this._dragDiv.set_xy(int_x, int_y);
            this._updateStaticXY();
        },
        get_canDrag: function() {
            return this._dragDiv.get_canDrag();
        },
        set_canDrag: function(bool_canDrag) {
            return this._dragDiv.set_canDrag(bool_canDrag);
        },
        get_isShow: function() {
            return this._dragDiv.get_isShow();
        },
        show: function() {
            this._dragDiv.show();
            this._scrollXY();
        },
        hide: function() {
            this._dragDiv.hide();
        },
        add_dragStart: function(function_handler) {
            this._dragDiv.add_dragStart(function_handler);
        },
        remove_dragStart: function() {
            this._dragDiv.remove_dragStart();
        },
        add_draging: function(function_handler) {
            this._dragDiv.add_draging(function_handler);
        },
        remove_draging: function() {
            this._dragDiv.remove_draging();
        },
        add_dragEnd: function(function_handler) {
            this._dragDiv.add_dragEnd(function_handler);
        },
        remove_dragEnd: function() {
            this._dragDiv.remove_dragEnd();
        }
    }
    RootType.regClass('CK.UI.Control.AlwaysVisibleDragDiv');


    CK.UI.Dom = function() { };
    CK.UI.Dom.getBodyInfo = function() {
        /// <returns type="CK.UI.Size"></returns>
        var _width = document.documentElement.clientWidth;
        var _height = document.documentElement.clientHeight;
        if (!CK.Browser.isSupportXHTML)
        {
            _width = document.body.clientWidth;
            _height = document.body.clientHeight;
        }
        return new CK.UI.Size(_width, _height);
    }

    CK.UI.Dom.getElementById = function(id) {
        var _id = id;
        var _el = document.getElementById(_id);
        if (!_el)
        {
            return null;
        }
        else
        {
            if (_el.id != _id)
                _el = null;
        }
        return _el;
    }
    
    CK.UI.Dom.getElementsByType = function(element, string_elementTypeName) {
    ///<returns type="CK.ObjectArray"></returns>
        var elements = element.getElementsByTagName("input");
        var selectorElements = new CK.ObjectArray();
        for (var i = 0; i < elements.length; i++)
        {
            if (elements[i].type == string_elementTypeName.toLowerCase())
            {
                selectorElements.add(elements[i]);
            }
        }
        return selectorElements;
    }
    
    
    CK.UI.Dom.getElement = function(idOrElement) {
        var el = null;
        if (typeof (idOrElement) == 'string')
            el = CK.UI.Dom.getElementById(idOrElement);
        else
            el = idOrElement;
        return el;
    }

    CK.UI.Dom.getXY = function(element) {
        ///<returns type="CK.UI.XY"></returns>
        // not opera spoof      
        var el = CK.UI.Dom.getElement(element);
        if (el.parentNode === null || el.style.display == 'none')
        { return false; }
        var parent = null;
        var pos = [];
        var box;
        if (el.getBoundingClientRect)
        {//IE  firefox  opera  
            box = el.getBoundingClientRect();
            var _scroll = CK.UI.Dom.Scroll.getInfo();
            var x = box.left + _scroll.x;
            var y = box.top + _scroll.y;
            if (CK.Browser.isIE)
                return new CK.UI.XY(x - 2, y - 2);
            else
                return new CK.UI.XY(x, y);
        }
        else if (document.getBoxObjectFor)
        {// firefox        
            box = document.getBoxObjectFor(el);
            var borderLeft = (el.style.borderLeftWidth) ? parseInt(el.style.borderLeftWidth) : 0;
            var borderTop = (el.style.borderTopWidth) ? parseInt(el.style.borderTopWidth) : 0;
            pos = [box.x - borderLeft, box.y - borderTop];
        }
        else
        {// safari & Chrome
            pos = [el.offsetLeft, el.offsetTop]; parent = el.offsetParent; if (parent != el) { while (parent) { pos[0] += parent.offsetLeft; pos[1] += parent.offsetTop; parent = parent.offsetParent; } }
            if (CK.Browser.isOpera || ((CK.Browser.isSafari || CK.Browser.isChrome) && el.style.position == 'absolute'))
            {
                pos[0] -= document.body.offsetLeft;
                pos[1] -= document.body.offsetTop;
            }
        } if (el.parentNode) { parent = el.parentNode; } else { parent = null; } while (parent && parent.tagName != 'BODY' && parent.tagName != 'HTML')
        {//other
            pos[0] -= parent.scrollLeft;
            pos[1] -= parent.scrollTop;
            if (parent.parentNode) { parent = parent.parentNode; }
            else { parent = null; }
        }
        return new CK.UI.XY(pos[0], pos[1]);
    }

    CK.UI.Dom.setXY = function(element, int_x, int_y) {
        var _el = CK.UI.Dom.getElement(element);
        
        if(int_x==null&&int_y==null) return;
        if (_el.style.position != 'absolute')        
            _el.style.position = 'absolute';

        if (int_x != null)
            _el.style.left = int_x + "px";

        if (int_y != null)
            _el.style.top = int_y + "px";
    }
    CK.UI.Dom.getFloatXY = function(element) {
        var xy = CK.UI.Dom.getXY(element);
        var scrollXY = CK.UI.Dom.Scroll.getInfo();
        var x = xy.x - scrollXY.x;
        var y = xy.y - scrollXY.y;
        return new CK.UI.XY(x, y);
    }
    CK.UI.Dom.setFloatXY = function(element, int_x, int_y) {
        var el = CK.UI.Dom.getElement(element);
        var fix = true;
        if (el.style.position != 'fixed') fix = false;

        if (fix)
        {
            if (int_x != null)
                el.style.left = int_x + "px";
            if (int_y != null)
                el.style.top = int_y + "px";
        }
        else
        {
            var scrollXY = CK.UI.Dom.Scroll.getInfo();
            if (int_x != null)
                int_x = scrollXY.x + parseInt(int_x);

            if (int_y != null)
                int_y = scrollXY.y + parseInt(int_y);

            CK.UI.Dom.setXY(el, int_x, int_y);
        }
    }



    CK.UI.Dom.setSize = function(element, int_width, int_height) {
        var _el = CK.UI.Dom.getElement(element);
        if (int_width != null)
        {
            if (typeof (int_width) === 'string' && int_width.rightString(1) == '%')
                _el.style.width = int_width;
            else
                _el.style.width = int_width + "px";
        }

        if (int_height != null)
        {
            if (typeof (int_height) === 'string' && int_height.rightString(1) == '%')
                _el.style.height = int_height;
            else
                _el.style.height = int_height + "px";
        }
    }

    CK.UI.Dom.getSize = function(element) {
        ///<returns type="CK.UI.Size"></returns>
        var _el = CK.UI.Dom.getElement(element);
        return new CK.UI.Size(_el.offsetWidth, _el.offsetHeight);
    }

    CK.UI.Dom.getElementInfo = function(element) {
        ///<returns type="CK.UI.Infomation"></returns>
        var _el = CK.UI.Dom.getElement(element);
        var p = CK.UI.Dom.getXY(_el);
        var s = CK.UI.Dom.getSize(_el);
        return new CK.UI.Infomation(p.x, p.y, s.width, s.height);
    }

    CK.UI.Dom.isApplyCss = function(element, string_cssName) {
        var _el = CK.UI.Dom.getElement(element);
        var _cn = string_cssName;
        if (!_cn) throw new Error("[  string_cssName  ] param is null");

        var _cl = _el.className.split(' ');
        var i;
        for (i = 0; i < _cl.length; i++)
        {
            if (_cl[i] == _cn)
                return true;
        }
        return false;
    }


    CK.UI.Dom.addCss = function(element, string_cssName) {
        var __el = CK.UI.Dom.getElement(element);
        var __cn = string_cssName;
        if (!__cn) throw new Error("[  string_cssName  ] param is null");

        if (!CK.UI.Dom.isApplyCss(__el, __cn))
            element.className += ' ' + __cn;
    }
    CK.UI.Dom.removeCss = function(element, string_cssName) {
        var _el = CK.UI.Dom.getElement(element);
        var _cn = string_cssName;

        if (!_cn) throw new Error("[  string_cssName  ] param is null");
        if (!CK.UI.Dom.isApplyCss(_el, _cn)) return;

        var _cln = ' ' + _el.className + ' ';
        var _index = _cln.indexOf(' ' + _cn + ' ');
        if (_index >= 0)
        {
            var _eln = _cln.substr(0, _index) + ' ' + _cln.substring(_index + _cn.length + 1, _cln.length);
            _el.className = _eln.trim();
        }
    }

    CK.UI.Dom.toggleCss = function(element, string_cssName) {
        var _el = CK.UI.Dom.getElement(element);
        var _cn = string_cssName;
        if (CK.UI.Dom.isApplyCss(_el, _cn))
            CK.UI.Dom.removeCss(_el, _cn);
        else
            CK.UI.Dom.addCss(_el, _cn);
    }

    CK.UI.Dom.clearCss = function(element) {
        var _el = CK.UI.Dom.getElement(element);
        _el.className = '';
    }


    CK.UI.Dom.setOpacity = function(element, float_opacity) {
        var _el = CK.UI.Dom.getElement(element);
        var _init_o = float_opacity;
        var _o = _init_o;
        if ((typeof (_o) != 'number') || ((_o < 0) || (_o > 1))) throw new Error(" [ float_opacity ] param  must  between 0 and 1");

        if (CK.Browser.isIE)
        {
            _o = float_opacity * 100;


            if (_o >= 100)
            {
                _el.style.filter = '';
            }
            else
            {
                try
                {
                    if (_el.filters.alpha == null)
                        _el.style.filter = "alpha(opacity=" + _o + ")";
                    else
                        _el.filters.alpha.opacity = _o;
                }
                catch (e)
                {
                    _el.style.filter = "alpha(opacity=" + _o + ")";
                }
            }

        }
        else
        {
            _el.style.opacity = _o;
        }
        _el._opacityValue = _init_o;
    }

    CK.UI.Dom.getOpacity = function(element) {
        var _el = CK.UI.Dom.getElement(element);
        return _el._opacityValue != null ? parseFloat(_el._opacityValue) : 1;
    }


    CK.UI.Dom.setDisplay = function(element, CK_Enum_DisplayMode) {
        var _els = element.style;
        var _dm = CK_Enum_DisplayMode;
        switch (_dm.toLowerCase())
        {
            case CK.Enum.DisplayMode.normal:
            case '':
                _els.visibility = 'visible';
                _els.display = '';
                break;
            case CK.Enum.DisplayMode.block:
                _els.visibility = 'visible';
                _els.display = 'block';
                break;

            case CK.Enum.DisplayMode.inline:
                _els.visibility = 'visible';
                _els.display = 'inline';
                break;

            case CK.Enum.DisplayMode.hide:
                _els.visibility = 'hidden';
                _els.display = '';
                break;
            case CK.Enum.DisplayMode.none:
                _els.display = 'none';
                break;
            default:
                throw new Error("unkown DisplayMode");
        }
    }

    CK.UI.Dom.extend = function(element) {
        ///<returns type="CodePrompt.$g"></returns>
        var l = CK.UI.Dom.getElement(element);
        if (l.__isExtend == true || l == null) return l;
        l.getElementsByType = function(string_elementTypeName) {
            return CK.UI.Dom.getElementsByType(l, string_elementTypeName);
        }

        l.attr = function(string_attributeName, string_attributeValue) {
            if (string_attributeValue != null) l.setAttribute(string_attributeName, string_attributeValue);
            return l.getAttribute(string_attributeName)
        }
        l.parent = function() {
            return l.parentNode;
        }
        l.html = function(text) {
            if (text != null) l.innerHTML = text;
            return l.innerHTML;
        }
        l.opacity = function(p) {
            if (p != null) CK.UI.Dom.setOpacity(l, p);
            return CK.UI.Dom.getOpacity(l);
        }
        l.css = function(css) {
            if (css) l.className = css;
            return l.className;
        }
        l.addCss = function(css) {
            CK.UI.Dom.addCss(l, css);
        }
        l.removeCss = function(css) {
            CK.UI.Dom.removeCss(l, css);
        }
        l.clearCss = function() {
            CK.UI.Dom.clearCss(l);
        }
        l.toggleCss = function(css) {
            CK.UI.Dom.toggleCss(l, css);
        }
        l.offset = function() {
            return CK.UI.Dom.getSize(l);
        }
        l.xy = function(x, y) {
            CK.UI.Dom.setXY(l, x, y);
            return CK.UI.Dom.getXY(l);
        }
        l.show = function() {
            CK.UI.Dom.setDisplay(l, '');
        }
        l.hide = function(isUseSpace) {
            isUseSpace ? CK.UI.Dom.setDisplay(l, 'hide') : CK.UI.Dom.setDisplay(l, 'none');
        }

        l.fadeIn = function(speed, callBack) {
            CK.UI.Dom.fade('in', l, speed, callBack);
        }
        l.fadeOut = function(speed, callBack, isUseSpace) {
            CK.UI.Dom.fade('out', l, speed, callBack, isUseSpace);
        }
        var _addHandler = function(l, event, handler) {
            CK.UI.DomEvent.__gRemovegEventHandler(l, event);
            if (handler)
                CK.UI.DomEvent.__gAddgEventHandler(l, event, handler);
        }

        var eS = __eventNames.split(',');
        var i;
        for (i = 0; i < eS.length; i++)
        {
            var x = 'l._' + eS[i] + '= l.' + eS[i] + ';l.' + eS[i] + ' = function(handler) {if(typeof(handler)=="function"||handler===null){_addHandler(l,"' + eS[i] + '",handler);} else if ((l._' + eS[i] + ')&&(typeof(handler)==="undefined")) l._' + eS[i] + '();return l}';
            eval(x);
        }
        l.__isExtend = true;
        return l;
    }
    CK.UI.Dom.fade = function(CK_Enum_FadeType, element, int_speed, function_callBack, bool_isUseSpace) {
        var _t = CK_Enum_FadeType;
        var _el = CK.UI.Dom.getElement(element);
        var _fps = 25;
        var _isUseSpace = false;
        if (bool_isUseSpace == true) _isUseSpace = true;
        var _isFinish = false;
        var _execTime = int_speed / _fps;
        var _avgOpacity = 1 / _fps;
        var _opacity = CK.UI.Dom.getOpacity(element);
        var _callBack = function(isChanged) {
            if (function_callBack)
                function_callBack(isChanged);
        }
        var _clearExec = function() {
            if (_el._execIn)
            {
                clearInterval(_el._execIn);
                _el._execIn = null;
            }
            if (_el._execOut)
            {
                clearInterval(_el._execOut);
                _el._execOut = null;
            }
        }
        _clearExec();
        switch (_t.toLowerCase().replace('fade', '').trim())
        {
            case 'in':
                if (_opacity == 1)
                {
                    _callBack(false);
                    return;
                }
                CK.UI.Dom.setDisplay(_el, '');
                _el._execIn = setInterval(
              function() {
                  _opacity += _avgOpacity;
                  if (_opacity >= 1)
                  {
                      _opacity = 1;
                      _clearExec();
                      _isFinish = true;
                  }
                  CK.UI.Dom.setOpacity(_el, _opacity);
                  if (_isFinish)
                  {
                      _callBack(true);
                  }
              }
            , _execTime);
                break;

            case 'out':
                if (_opacity == 0)
                {
                    if (_isUseSpace == true)
                        CK.UI.Dom.setDisplay(_el, 'hide');
                    else
                        CK.UI.Dom.setDisplay(_el, 'none');
                    _callBack(false);
                    return;
                }

                _el._execOut = setInterval(
              function() {
                  _opacity -= _avgOpacity;
                  if (_opacity <= 0)
                  {
                      _opacity = 0;
                      _clearExec();
                      _isFinish = true;

                  }
                  CK.UI.Dom.setOpacity(_el, _opacity);
                  if (_isFinish)
                  {
                      if (_isUseSpace)
                          CK.UI.Dom.setDisplay(_el, 'hide');
                      else
                          CK.UI.Dom.setDisplay(_el, 'none');

                      _callBack(true);
                  }
              }
            , _execTime);
                break;
            default: ;
        }
    }
    RootType.regClass("CK.UI.Dom");

    CK.UI.Dom.Scroll = function() { }
    CK.UI.Dom.Scroll.getInfo = function() {
        ///<returns type="CK.UI.Infomation"></returns>  
        var _body = document.documentElement;
        if ((CK.Browser.isSafari) || (CK.Browser.isChrome) || (!CK.Browser.isSupportXHTML))
            _body = document.body;
        return new CK.UI.Infomation(_body.scrollLeft, _body.scrollTop, _body.scrollWidth, _body.scrollHeight);
    }
    RootType.regClass("CK.UI.Dom.Scroll");
    CK.UI.DomEvent = function() { }
    CK.UI.DomEvent.__addEventHandler = function(element, eventName, handler) {
        if (element.attachEvent)
            element.attachEvent("on" + eventName, handler);
        else
            element.addEventListener(eventName, handler, false);
    }
    CK.UI.DomEvent.__removeEventHandler = function(element, eventName, handler) {
        if (element.detachEvent)
            element.detachEvent("on" + eventName, handler);
        else
            element.removeEventListener(eventName, handler, false);
    }
    CK.UI.DomEvent.__gAddCachegEventHandler = function(element, eventName, handler) {
        var _el = element;
        var _eN = eventName;
        if (!_el.gEventHandlers) _el._gEventHandlers = new CK.ObjectArray();
        _el._gEventHandlers.add({ gEvent: _eN, gHandler: handler });
    }
    CK.UI.DomEvent.__gRemoveCachegEventHandler = function(element, eventName) {
        var _el = element;
        var _eN = eventName;
        var _handler = null;
        if (_el._gEventHandlers)
        {
            var i;
            for (i = 0; i < _el._gEventHandlers.length; i++)
            {
                if (_el._gEventHandlers.item(i).gEvent == _eN)
                {
                    _handler = _el._gEventHandlers.item(i).gHandler;
                    _el._gEventHandlers.removeAt(i);
                    return _handler;
                }
            }
        }
    }

    CK.UI.DomEvent.__gAddgEventHandler = function(element, eventName, handler) {
        var _el = element;
        var _eN = eventName;
        var _h = handler;
        CK.UI.DomEvent.__addEventHandler(_el, _eN, _h);
        CK.UI.DomEvent.__gAddCachegEventHandler(_el, _eN, _h);
    }
    CK.UI.DomEvent.__gRemovegEventHandler = function(element, eventName) {
        var _el = element;
        var _eN = eventName;
        var _handler = CK.UI.DomEvent.__gRemoveCachegEventHandler(_el, _eN);
        if (_handler)
            CK.UI.DomEvent.__removeEventHandler(_el, _eN, _handler);
    }

    CK.UI.DomEvent.addEventHandler = function(element, CK_Enum_Event, function_handler) {
        var _el = CK.UI.Dom.getElement(element);
        var _eN = CK_Enum_Event.toLowerCase().trim();
        var _handler = function_handler;
        if (_eN.substr(0, 2) == 'on') _eN = _eN.substr(2, _eN.length - 2);
        CK.UI.DomEvent.__addEventHandler(_el, _eN, _handler);
        if (!_el._eventHandlerlist)
            _el._eventHandlerlist = new CK.UI.DomEvent.EventHandlerList(_el);

        _el._eventHandlerlist.add({ eventName: _eN, eventhandler: _handler });
    }

    CK.UI.DomEvent.removeEventHandler = function(element, CK_Enum_Event, function_handler) {
        var _el = CK.UI.Dom.getElement(element);
        var _eN = CK_Enum_Event.toLowerCase();
        var _handler = function_handler;
        if (_eN.substr(0, 2) == 'on') _eN = _eN.substr(2, _eN.length - 2);
        CK.UI.DomEvent.__removeEventHandler(_el, _eN, _handler);
        if (_el._eventHandlerlist)
        {
            if (_el._eventHandlerlist.get_length() == 0)
                _el._eventHandlerlist = undefined;
        }
        if (arguments.length == 5) return;
        if (_el._eventHandlerlist)
            _el._eventHandlerlist.remove({ eventName: _eN, eventhandler: _handler });
    }
    var $addEventHandler = CK.UI.DomEvent.addEventHandler;
    var $removeEventHandler = CK.UI.DomEvent.removeEventHandler;
    RootType.regClass("CK.UI.DomEvent");


    CK.UI.DomEventArg = function() { }
    CK.UI.DomEventArg.blockEvent = function(e) {
        if (CK.Browser.isIE)
            e.returnValue = false;
        else
            e.preventDefault();
    }
    CK.UI.DomEventArg.getSrcElement = function(e) {
        var _el = e.srcElement ? e.srcElement : e.target;
        return _el;
    }
    RootType.regClass('CK.UI.DomEventArg');
    CK.UI.DomEvent.EventHandlerList = function(element) {
        this._el = CK.UI.Dom.getElement(element);
        this.__o = new CK.ObjectArray();
    }
    CK.UI.DomEvent.EventHandlerList.prototype = {
        add: function(eventJson) {
            //{eventName:_eN,eventhandler:_handler}                                
            this.__o.add(eventJson);
        },
        remove: function(eventJson) {
            //{eventName:_eN,eventhandler:_handler}       
            var _ej = eventJson;
            if (this.__o)
            {
                var _eventlist = this.__o;
                var i;
                var _len = _eventlist.length;
                var _hasdel = true;
                while (_hasdel)
                {
                    _hasdel = false;
                    _len = _eventlist.length;
                    for (i = 0; i < _len; i++)
                    {
                        var _evn = _eventlist.item(i).eventName;
                        var _evh = _eventlist.item(i).eventhandler;
                        var _evjn = _ej.eventName;
                        var _evjh = _ej.eventhandler;
                        if ((_evn == _evjn) && (_evh == _evjh))
                        {
                            _eventlist.removeAt(i);
                            _hasdel = true;
                            break;
                        }
                    }
                    if (_hasdel)
                        $removeEventHandler(this._el, _evn, _evh, null, null);
                }
            }
        },
        removeAt: function(index) {
            this.__o.removeAt(index);
        },
        get_length: function() {
            return this.__o.length;
        }
    }
    RootType.regClass("CK.UI.DomEvent.EventHandlerList");

    RootType.regNameSpace("CK.Web");
    CK.Web.Cookie = function() { }
    CK.Web.Cookie.getValue = function(string_cookieName) {
        ///<returns type="String"></returns>
        var _cookieName = string_cookieName;
        var _cookies = document.cookie.split(';');
        var i;
        for (i = 0; i < _cookies.length; i++)
        {
            if (_cookies[i].indexOf(_cookieName + "=") > -1)
                return _cookies[i].replace(_cookieName + "=", "");
        }
        return null;
    }

    CK.Web.Cookie.setValue = function(string_cookieName, string_cookieValue) {
        document.cookie = string_cookieName + "=" + string_cookieValue;
    }
    RootType.regClass("CK.Web.Cookie");

    ___pageInit = function() {
        if (window.docLoad) window.docLoad();
    }
    ___CKWorkFrameWorkInit = function() {
        window.__cachecontrolArray = new CK.ObjectArray();
        $addEventHandler(window, 'load', ___pageInit);
    }
    ___CKWorkFrameWorkInit();

    RootType.regNameSpace('CodePrompt');
    CodePrompt.createXMLHttpRequest = function() { }
    CodePrompt.createXMLHttpRequest.prototype = {
        open: function(string_httpVerb, string_url, bool_isAsync) {
            ///<param name="string_httpVerb">設置Ajax請求的請求方式,可以設置為POST或GET</param>
            ///<param name="string_url">設置Ajax請求的網絡Url地址,可以是絕對地址，也可以是相對地址</param>
            ///<param name="bool_isAsync">設置Ajax請求是否為異步,一般建議設為true</param>
        },
        setRequestHeader: function(string_HeaderName, string_HeaderValue) {
            ///<param name="string_HeaderName">設置頭信息的名稱</param>
            ///<param name="string_HeaderValue">設置頭信息的值</param>
            ///<summary>設置數據请求的头信息</summary>    
        },
        send: function(string_data) {
            ///<param name="string_data">設置數據請求方式,可以設置為POST或GET</param>
            ///<summary>提交數據</summary>
        },
        abort: function() {
            ///<summary>取消Ajax請求</summary>
        },
        getResponseHeader: function(string_headerName) {

        },
        getAllResponseHeaders: function() {
            ///<summary>獲取服務器返回的所有頭信息</summary>
        },
        status: null,
        responseXML: null,
        responseBody: null,
        onreadystatechange: null,
        readyState: null,
        responseText: null,
        statusText: null
    }

    CodePrompt.$g = function() { }
    CodePrompt.$g.prototype = {


        getElementsByType: function(string_elementTypeName) {
            ///<param name="string_attributeName">输入要设置的属性名称</param>
            ///<summary>獲取該元素中 type屬性符合條件的子元素列表</summary>
            ///<returns type="CK.ObjectArray"></returns>
        },
        attr: function(string_attributeName, string_attributeValue) {
            ///<param name="string_attributeName">输入要设置的属性名称</param>
            ///<param name="string_attributeValue">输入要设置的属性值,如果获取属性的值，此参数可以不输入</param>
            ///<summary>設置或獲取該元素的属性,功能相當于setAttribute  getAttribute, 参数string_attributeValue可以不输入</summary>
        },
        parent: function() {
            ///<summary>獲取該元素的父元素</summary>        
        },

        html: function(string_text) {
            ///<returns type="String"></returns>
            ///<summary>設置或獲取該元素的HTML代碼,功能相當于innerHTML, 参数string_text可以不输入</summary>
        },
        opacity: function(float_opacity) {
            ///<returns type="Number"></returns>
            ///<summary>獲取或設置該元素的透明度，從0到1之間, 數值越小就越透明,0透明,1不透明,0到1之間則是半透明狀態,參數float_opacity可以不輸入</summary>
        },
        css: function(string_cssName) {
            ///<summary>設置或獲取該元素的css class</summary>
        },
        addCss: function(string_cssName) {
            ///<summary>添加該元素css Class ,可以添加多個</summary>
        },
        removeCss: function(string_cssName) {
            ///<summary>刪除該元素css Class</summary>
        },
        clearCss: function() {
            ///<summary>清空該元素的css Class</summary>
        },
        toggleCss: function(string_cssName) {
            ///<summary>切換該元素的css Class, 當Class 已經應用時, 該功能變為添加Class,否則,該功能變為刪除Class</summary>
        },
        offset: function() {
            ///<summary>獲取該元素的寬度width和高度height,以px(像素)為單位</summary>
            ///<returns type="CK.UI.Size"></returns>
        },
        xy: function(int_x, int_y) {
            ///<param name="int_width">設置元素的x坐標</param>
            ///<param name="int_height">設置元素的y坐標</param>   
            ///<summary>獲取或設置該元素的 坐標位置x和y坐標,以px(像素)为單位,參數int_x,int_y可以不輸入</summary>
            ///<returns type="CK.UI.XY"></returns>
        },
        fadeIn: function(int_speed, function_callBack) {
            ///<param name="int_speed">元素淡入所用的時間,以毫秒為單位</param>
            ///<param name="function_callBack">元素淡入完成后執行的函數,此函數可以不輸入</param> 
        },
        fadeOut: function(int_speed, function_callBack, bool_isUseSpace) {
            ///<param name="int_speed">元素淡出所用的時間,以毫秒為單位</param>
            ///<param name="function_callBack">元素淡出完成后執行的函數,此函數可以不輸入或輸入null</param>
            ///<param name="bool_isUseSpace">元素淡出完成后是否占網頁空間,true為占空間,false為不占空間,默認是false</param>
            ///<summary>元素淡出(即漸漸地消失)</summary>
        },
        show: function() {
            ///<summary>顯示元素,功能相當于css的 visibility:visible</summary>     
        },
        hide: function(bool_isUseSpace) {
            ///<param name="bool_isUseSpace">元素隱藏后是否占網頁空間,true為占空間,false為不占空間,默認是false,為false功能相當于display:none,為true功能相當于visibility:hidden</param>
            ///<summary>隱藏元素</summary>
        },
        blur: function(function_handler) {
            ///<summary>綁定元素的blur事件函數,當此元素失去焦點時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        focus: function(function_handler) {
            ///<summary>綁定元素的focus事件函數,當此元素獲取焦點時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        load: function(function_handler) {
            ///<summary>綁定元素的load事件函數,當此元素加載完成時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        resize: function(function_handler) {
            ///<summary>綁定元素的resize事件函數,當元素大小改變時觸發次事件,如window放大或縮小,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        scroll: function(function_handler) {
            ///<summary>綁定元素的scroll事件函數,當此元素滾動條滾動時觸發此事件,只有有滾動條的元素(如:window,div,textarea....)才有scroll事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        unload: function(function_handler) {
            ///<summary>綁定元素的unload事件函數,當此元素卸載時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        click: function(function_handler) {
            ///<summary>綁定元素的click事件函數,當在此元素上鼠標左鍵單擊時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        dblclick: function(function_handler) {
            ///<summary>綁定元素的dblclick事件函數,當在此元素上鼠標左鍵雙擊時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        mousedown: function(function_handler) {
            ///<summary>綁定元素的mousedown事件函數,當在此元素上鼠標按鍵按下時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        mouseup: function(function_handler) {
            ///<summary>綁定元素的mouseup事件函數,當在此元素上鼠標按鍵放手時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        mousemove: function(function_handler) {
            ///<summary>綁定元素的mousemove事件函數,當在此元素上鼠標移動時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        mouseover: function(function_handler) {
            ///<summary>綁定元素的mouseover事件函數,當在此元素上鼠標滑過時(鼠標在元素上)觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        mouseout: function(function_handler) {
            ///<summary>綁定元素的mouseout事件函數,當鼠標離開此元素時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        change: function(function_handler) {
            ///<summary>綁定元素的change事件函數,當此元素內容改變時觸發次事件(如在text中輸入文字),若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        select: function(function_handler) {
            ///<summary>綁定元素的select事件函數,當在此元素上選中內容時觸發次事件(如選中文本文字),若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        submit: function(function_handler) {
            ///<summary>綁定元素的submit事件函數,表單(form)提交時執行此函數,只有表單(form)才有submit事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        keydown: function(function_handler) {
            ///<summary>綁定元素的keydown事件函數,當在此元素上鍵盤按鍵按下時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        keypress: function(function_handler) {
            ///<summary>綁定元素的keypress事件函數,當在此元素上按鍵盤按鍵時觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        keyup: function(function_handler) {
            ///<summary>綁定元素的keyup事件函數,當在此元素上按鍵盤按鍵時鬆開觸發此事件,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        error: function(function_handler) {
            ///<summary>綁定元素的error事件函數,當元素加載發生異常時觸發此函數(如加載圖片失敗),若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        contextmenu: function(function_handler) {
            ///<summary>綁定元素的contextmenu事件函數,當在此元素上鼠標右鍵單擊時觸發此事件,此事件Opera核心瀏覽器暫不支持,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        copy: function(function_handler) {
            ///<summary>綁定元素的copy事件函數,當在此元素上執行複製時觸發此事件,此事件只有IE核心瀏覽器支持,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        cut: function(function_handler) {
            ///<summary>綁定元素的cut事件函數,當在此元素上執行剪切時觸發此事件,此事件只有IE核心瀏覽器支持,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        paste: function(function_handler) {
            ///<summary>綁定元素的paste事件函數,當在此元素上執行粘貼時觸發此事件,此事件只有IE核心瀏覽器支持,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        },
        propertychange: function(function_handler) {
            ///<summary>綁定元素的propertychange事件函數,當此元素的屬性改變時觸發此事件,此事件只有IE核心瀏覽器支持,若想元素支持更多事件,請使用$addEventHandler函數綁定更多的事件</summary>
        }
    }