_can_name = "/frame.js"
Volcanos("onengine", {help: "搜索引擎", list: [], _init: function(can, meta, list, cb, target) {
        can.run = function(event, cmds, cb) { var msg = can.request(event); cmds = cmds||[]
            return (can.onengine[cmds[0]]||can.onengine._remote)(event, can, msg, can, cmds, cb)
        }, can.river = can.Conf(chat.RIVER)||{}

        can.core.Next(list, function(item, next) { item.type = chat.PANEL
            can.onappend._init(can, item, item.list, function(panel) {
                panel.run = function(event, cmds, cb) { var msg = panel.request(event); cmds = cmds||[]
                    return (can.onengine[cmds[0]]||can.onengine._remote)(event, can, msg, panel, cmds, cb)
                }, can[item.name] = panel, panel._root = can, panel._trans = panel.onaction._trans

                can.core.Item(panel.onaction, function(key, cb) { if (key.indexOf("on") == 0) {
                    can.onengine.listen(can, key, function(msg) { can.core.CallFunc(cb, {can: panel, msg: msg}) })
                } }), panel.onaction._init(panel, item, item.list, next, panel._target)

                can.onmotion.float.auto(can, panel._output)
            }, target)
        }, function() { can.misc.Log(can.user.title(), cli.RUN, can)
            can.ondaemon._init(can), can.onmotion._init(can, target), can.onkeypop._init(can, target)
            can.onlayout.topic(can), can.onengine.signal(can, chat.ONMAIN, can.request())
            can.base.isFunc(cb) && cb()
        })
    },
    _search: function(event, can, msg, panel, cmds, cb) {
        var sub, mod = can, fun = can, key = ""; can.core.List(cmds[1].split(ice.PT), function(value) {
            fun && (sub = mod, mod = fun, fun = mod[value], key = value)
        }); if (!sub || !mod || !fun) { can.misc.Warn("not found", cmds)
            return can.base.isFunc(cb) && cb(msg.Echo("warn: ", "not found: ", cmds))
        }

        return can.core.CallFunc(fun, {
            "event": event, "can": sub, "msg": msg,
            "button": key, "cmd": key, "cmds": cmds.slice(2),
            "list": cmds.slice(2), "cb": cb, "target": sub._target,
        }, mod)
    },
    _engine: function(event, can, msg, panel, cmds, cb) { return false },
    _remote: function(event, can, msg, panel, cmds, cb) {
        if (panel.onengine._engine(event, can, msg, panel, cmds, cb)) { return }
        can.search({follow: panel._follow, msg, cmds}, ["Footer.onimport.ncmd"])

        var key = can.core.Keys(panel._name, cmds.join(","))
        if (can.user.isLocalFile) { var msg = can.request(event); msg.Clear(ice.MSG_APPEND)
            var res = Volcanos.meta.pack[key]; res? msg.Copy(res): can.user.toast(can, "缺失数据")
            return can.base.isFunc(cb) && cb(msg)
        }

        var names = msg.Option("_names")||panel._names||((can.Conf("iceberg")||"/chat/")+panel._name)
        can.misc.Run(event, can, {names: names, daemon: can.core.Keys(can.ondaemon._list[0], msg._daemon)}, cmds, function(msg) {
            Volcanos.meta.pack[key] = msg, delete(msg._handle), delete(msg._toast)
            if (msg.result && msg.result[0] == "warn: ") { can.user.toast(can, msg.Result(), "", 10000); return }
            can.base.isFunc(cb) && cb(msg)
        })
    },

    listen: shy("监听事件", {}, [], function(can, name, cb) {
        arguments.callee.meta[name] = (arguments.callee.meta[name]||[]).concat(cb)
    }),
    signal: shy("触发事件", function(can, name, msg) { msg = msg||can.request()
        can.misc.Log("signal", name, msg)
        can.core.List(can.onengine.listen.meta[name], function(cb) {
            can.core.CallFunc(cb, {msg: msg})
        })
    }),
})
Volcanos("ondaemon", {help: "推荐引擎", list: [], _init: function(can, name) { if (can.user.isLocalFile) { return }
        can.misc.WSS(can, {type: "chrome", name: can.user.Search(can, "daemon")||name||""}, function(event, msg, cmd, arg) { if (!msg) { return }
            can.base.isFunc(can.ondaemon[cmd])? can.core.CallFunc(can.ondaemon[cmd], {
                "can": can, "msg": msg, "cmd": cmd, "arg": arg, "cb": function() { msg.Reply() },
            }): can.onengine._search({}, can, msg, can, ["_search", cmd].concat(arg), function() {
                msg.Reply()
            })
        })
    }, _list: [""],
    pwd: function(can, msg, arg) { 
        can.ondaemon._list[0] = arg[0]
    },
    grow: function(can, msg, arg) {
        var sub = can.ondaemon._list[msg.Option(ice.MSG_TARGET)]
        sub.onimport._grow(sub, can.page.Color(arg.join("")))
    },
    toast: function(can, msg, arg) {
        can.onmotion.float.add(can, chat.FLOAT, can.core.CallFunc(can.user.toast, {can: can, msg: msg, cmds: arg}))
    },
})
Volcanos("onappend", {help: "渲染引擎", list: [], _init: function(can, meta, list, cb, target, field) {
        meta.name = meta.name||"", meta.name = meta.name.split(ice.SP)[0].split(ice.PT).pop()
        field = field||can.onappend.field(can, meta.type, meta, target).first
        var legend = can.page.Select(can, field, ice.PT+html.LEGEND)[0]||can.page.Select(can, field, html.LEGEND)[0]
        var option = can.page.Select(can, field, html.FORM_OPTION)[0]
        var action = can.page.Select(can, field, html.DIV_ACTION)[0]
        var output = can.page.Select(can, field, html.DIV_OUTPUT)[0]
        var status = can.page.Select(can, field, html.DIV_STATUS)[0]

        var sub = Volcanos(meta.name, {_follow: can.core.Keys(can._follow, meta.name), _target: field,
            _legend: legend, _option: option, _action: action, _output: output, _status: status,
            _inputs: {}, _outputs: [], _history: [],

            Status: function(key, value) {
                if (sub.base.isObject(key)) { return sub.core.Item(key, sub.Status), key }

                sub.page.Select(sub, status, "div."+key+">span", function(item) {
                    return value == undefined? (value = item.innerHTML): (item.innerHTML = value)
                }); return value
            },
            Action: function(key, value) { return sub.page.SelectArgs(sub, action, key, value)[0] },
            Option: function(key, value) { return sub.page.SelectArgs(sub, option, key, value)[0] },
            Update: function(event, cmds, cb, silent) { sub.onappend._output(sub, sub.Conf(), event||{}, cmds||sub.Input(), cb, silent) },
            Input: function(cmds, silent) {
                cmds = cmds && cmds.length > 0? cmds: sub.page.SelectArgs(sub, option, ""), cmds = can.base.trim(cmds)
                silent || cmds[0] == ctx.ACTION || sub.base.Eq(sub._history[sub._history.length-1], cmds) || sub._history.push(cmds)
                return cmds
            },
            Clone: function() {
                meta.args = sub.page.SelectArgs(sub, option, "")
                can.onappend._init(can, meta, list, function(sub) {
                    can.core.Timer(10, function() { for (var k in sub._inputs) { sub._inputs[k]._target.focus(); break } })
                    can.base.isFunc(cb) && cb(sub)
                }, target)
            },
        }, list, function(sub) { sub.Conf(meta)
            meta.feature = sub.base.Obj(meta.feature, {})
            sub.page.ClassList.add(sub, field, meta.style||meta.feature.style||"")
            sub.page.ClassList.add(sub, field, meta.index? meta.index.split(ice.PT).pop(): meta.name)

            sub.page.Modify(sub, sub._legend, {onmouseenter: function(event) {
                sub.user.carte(event, sub, sub.onaction, sub.onaction.list.concat([["所有 ->"].concat(can.core.Item(meta.feature._trans))]))
            }})

            meta.inputs && sub.onappend._option(sub, meta, sub._option)
            can.base.isFunc(cb) && cb(sub)
        }); return sub
    },
    _option: function(can, meta, option) { var index = -1, args = can.base.Obj(meta.args||meta.arg, []), opts = can.base.Obj(meta.opts, {})
        function add(item, next) { item._input != html.BUTTON && item.type != html.BUTTON && index++
            Volcanos(item.name, {_follow: can.core.Keys(can._follow, item.name),
                _target: can.onappend.input(can, item, args[index]||opts[item.name], option),
                _option: can._option, _action: can._action, _output: can._output, _status: can._status,
                Option: can.Option, Action: can.Action, Status: can.Status,
                CloneInput: function() { add(item)._target.focus() }, CloneField: function() { can.Clone() },
            }, [item.display||"/plugin/input.js"], function(input) { input.Conf(item)
                input.run = function(event, cmds, cb, silent) { var msg = can.request(event)
                    if (msg.RunAction(event, input, cmds)) { return }
                    if (msg.RunAction(event, can.core.Value(can, "_outputs.-1"), cmds)) { return }
                    return can.Update(event, can.Input(cmds, silent), cb, silent)
                }, can._inputs[item.name] = input, input.sup = can

                can.core.Item(input.onaction, function(key, cb) { if(key.indexOf("on") == 0)  {
                    input._target[key] = function(event) { cb(event, input) }
                } }), can.core.CallFunc([input.onaction, "_init"], [input, item, [], next, input._target])

                can.onappend.figure(input, item, input._target)
            })
        }; can.core.Next(can.base.Obj(meta.inputs, []), add)
    },
    _action: function(can, list, action, meta) { action = action||can._action, meta = meta||can.onaction
        can.core.List(list||can.onaction.list, function(item) { can.onappend.input(can, item == ""? /*空白*/ {type: html.SPACE}:
            can.base.isString(item)? /*按键*/ {type: html.BUTTON, value: item, onclick: function(event) {
                var cb = meta[item]||meta["_engine"]
                cb? can.core.CallFunc(cb, {event: event, can: can, button: item}): can.run(event, [ctx.ACTION, item].concat(can.sup.Input()))

            }}: item.length > 0? /*列表*/ {type: html.SELECT, name: item[0], values: item.slice(1), onchange: function(event) {
                var which = item[event.target.selectedIndex+1]
                can.core.CallFunc(meta[which], [event, can, which])
                can.core.CallFunc(meta[item[0]], [event, can, item[0], which])

            }}: /*其它*/ item
        , "", action)})
        return meta
    },
    _output: function(can, meta, event, cmds, cb, silent) { var msg = can.request(event)
        if (msg.RunAction(event, can, cmds)) { return }

        if (msg.Option(ice.MSG_HANDLE) != ice.TRUE && cmds && cmds[0] == ctx.ACTION && meta.feature[cmds[1]]) {
            return can.user.input(event, can, meta.feature[cmds[1]], function(ev, button, data, list, args) { var msg = can.request(event, {_handle: ice.TRUE}, can.Option())
                can.Update(event, cmds.slice(0, 2).concat(args), function(msg) { can.Update({}, can.Input(), cb) }, true)
            })
        }

        can.base.isUndefined(can._daemon) && (can._daemon = can.ondaemon._list.push(can)-1), msg._daemon = msg._daemon||can._daemon

        return can.run(event, cmds, function(msg) { var sub = can.core.Value(can, "_outputs.-1")||{}; can._msg = msg, sub._msg = msg
            var process = msg._can == can || msg._can == sub
            if (process && can.core.CallFunc([sub, "onimport._process"], [sub, msg, cmds, cb])) { return }
            if (process && can.core.CallFunc([can, "onimport._process"], [can, msg, cmds, cb])) { return }
            if (can.base.isFunc(cb) && can.core.CallFunc(cb, {can: can, msg: msg})) { return }
            if (silent) { return }

            var display = msg.Option(ice.MSG_DISPLAY)||meta.display||meta.feature.display||"/plugin/table.js"

            Volcanos(display, {_follow: can.core.Keys(can._follow, display), _display: display, _target: can._output, _fields: can._target,
                _option: can._option, _action: can._action, _output: can._output, _status: can._status,
                Option: can.Option, Action: can.Action, Status: can.Status,
            }, [display], function(table) { table.Conf(can.Conf())
                table.run = function(event, cmds, cb, silent) { var msg = can.request(event)
                    if (msg.RunAction(event, table, cmds)) { return }
                    return can.Update(event, can.Input(cmds, silent), cb, silent)
                }, can._outputs.push(table), table.sup = can, table._msg = msg

                table.onimport && table.onimport._init && table.onimport._init(table, msg, msg.result||[], function(msg) {
                    can.page.Modify(can, can._action, ""), can.page.Modify(can, can._status, "")
                    table.onaction && table.onappend._action(table, can.base.Obj(msg.Option(ice.MSG_ACTION), table.onaction.list))
                    table.onexport && table.onappend._status(table, can.base.Obj(msg.Option(ice.MSG_STATUS), table.onexport.list))
                }, can._output)
            })
        })
    },
    _status: function(can, list, status) { status = status||can._status
        can.core.List(list, function(item) { item = can.base.isObject(item)? item: {name: item}
            can.page.Append(can, status, [{view: can.base.join(["item", item.name]), title: item.name, list: [
                {text: [item.name, html.LABEL]}, {text: [": ", html.LABEL]}, {text: [(item.value||"")+"", html.SPAN, item.name]},
            ], }])
        })
    },

    list: function(can, root, cb, target) {
        can.core.List(root.list, function(item) {
            var ui = can.page.Append(can, target, [{view: ["item", "div", item.meta.name], onclick: function(event) {
                can.base.isFunc(cb) && cb(event, item) || can.onmotion.toggle(can, ui.list)
            }}, {view: "list"}]); can.onappend.list(can, item, cb, ui.list)
        })
    },
    item: function(can, type, item, cb, cbs, target) { target = target||can._output
        var ui = can.page.Append(can, target, [{view: [type, html.DIV, item.nick||item.name],
            onclick: function(event) { cb(event, ui.first)
                can.onmotion.select(can, target, "div."+type, ui.first)
            }, oncontextmenu: function(event) { cbs(event, ui.first) },
        }]); return ui.first
    },
    tree: function(can, list, field, split, cb, target, node) {
        node = node || {"": target}; can.core.List(list, function(item) {
            item[field] && can.core.List(item[field].split(split), function(value, index, array) { if (!value) { return }
                var last = array.slice(0, index).join(split), name = array.slice(0, index+1).join(split)

                node[name] || (node[name] = can.page.Append(can, node[last], [{view: ["item", html.DIV, value+(index==array.length-1?"":split)], onclick: function(event) {
                    index < array.length - 1? can.onmotion.toggle(can, node[name]): can.base.isFunc(cb) && cb(event, item)
                }}, {view: "list", style: {display: "none"}}]).last)
            })
        }); return node
    },
    field: function(can, type, item, target) { type = type||html.INPUT, item = item||{}
        var name = (item.nick||item.name||"").split(ice.SP)[0]
        var title = !item.help || can.user.language(can) == "en"? name: name+"("+item.help.split(ice.SP)[0]+")"
        return can.page.Append(can, target||can._output, [{view: [can.base.join([type||"", item.name||"", item.pos||""]), html.FIELDSET], list: [
            name && {text: [title, html.LEGEND]},
            can.user.mod.isCmd && type == chat.PLUGIN && {view: [html.LEGEND, html.DIV, title]},
            {view: [html.OPTION, html.FORM]}, {view: [html.ACTION]}, {view: [html.OUTPUT]}, {view: [html.STATUS]},
        ]}])
    },
    input: function(can, item, value, target) {
        switch (item.type) {
            case "": return can.page.Append(can, target, [item])
            case "space": return can.page.Append(can, target, [{view: "item space"}])
        }

        var input = can.page.input(can, item, value)
        var br = input.type == html.TEXTAREA? [{type: html.BR}]: []
        var title = can.Conf(["feature", chat.TITLE, item.name].join(ice.PT))||""; title && (input.title = title)
        return can.page.Append(can, target, ([{view: ["item "+item.type], list: [input]}]).concat(br))[item.name]
    },
    table: function(can, msg, cb, target, sort) {
        var table = can.page.AppendTable(can, msg, target||can._output, msg.append, cb||function(value, key, index, line, array) {
            if (msg.append.length == 2 && msg.append[0] == kit.MDB_KEY && msg.append[1] == kit.MDB_VALUE) {
                if (key == kit.MDB_VALUE) { key = line.key }
                line = {}, can.core.List(array, function(item) { line[item.key] = item.value })
            }


            if (key == "extra.cmd") {
                can.onappend.plugin(can, {ctx: line["extra.ctx"], cmd: line["extra.cmd"], arg: line["extra.arg"]}, function(sub) {
                    sub.run = function(event, cmds, cb) { var msg = can.request(event, line, can.Option())
                        can.run(event, can.misc.Concat([ctx.ACTION, cli.RUN], cmds), cb, true)
                    }
                }, target)
            }

            return {text: [value, html.TD], onclick: function(event) { var target = event.target
                if (target.tagName == "INPUT" && target.type == html.BUTTON) { var msg = can.sup.request(event, line, can.Option())
                    return can.run(event, [ctx.ACTION, target.name], function(msg) { can.run() }, true)
                }

                can.sup.onaction.change(event, can.sup, key, value)
            }, ondblclick: function(event) { if ([kit.MDB_KEY].indexOf(key) > -1) { return }
                var item = can.core.List(can.Conf("feature.insert"), function(item) {
                    if (item.name == key) { return item }
                })[0]||{name: key, value: value}

                item.run = function(event, cmds, cb) { can.run(can.request(event, line)._event, cmds, cb, true) }

                can.onmotion.modifys(can, event.target, function(event, value, old) { var msg = can.sup.request(event, line, can.Option())
                    can.run(event, [ctx.ACTION, mdb.MODIFY, key, value], function(msg) { can.run() }, true)
                }, item)
            }}
        }); table && can.page.Modify(can, table, {className: "content"})

        return sort && can.page.RangeTable(can, table, sort), table
    },
    board: function(can, text, target) { text && text.Result && (text = text.Result()); if (!text) { return }
        var code = can.page.Append(can, target||can._output, [{text: [can.page.Color(text), html.DIV, html.CODE]}]).code
        can.page.Select(can, code, "input[type=button]", function(target) {
            target.onclick = function(event) { var msg = can.sup.request(event, can.Option())
                return can.run(event, [ctx.ACTION, target.name], function(msg) { can.run() }, true)
            }
        })
        return code.scrollBy(0, 10000), code
    },

    figure: function(can, meta, target, cb) { if ([html.BUTTON, html.SELECT].indexOf(meta.type) > -1) { return }
        var input = meta.action||"key"; input != "auto" && can.require(["/plugin/input/"+input+".js"], function(can) {
            can.core.Item(can.onfigure[input], function(key, on) { if (key.indexOf("on") != 0) { return }
                target[key] = function(event) {
                    can.onappend._init(can, {type: html.INPUT, name: input, pos: html.FLOAT}, [], function(sub) { sub.Conf(meta)
                        sub.run = function(event, cmds, cb) { var msg = sub.request(event, can.Option());
                            (meta.run||can.run)(event, cmds, cb, true)
                        }

                        meta.style && sub.page.Modify(sub, sub._target, {style: meta.style})
                        can.onmotion.float.add(can, "input", sub)
                        on(event, sub, meta, cb, target)
                    }, document.body)
                }
            })
        })
    },
    _plugin: function(can, value, meta, cb, target) {
        meta.feature = can.base.Obj(value.meta, meta.feature||{})
        meta.inputs = can.base.Obj(value.list,  meta.inputs||[])

        meta.height = meta.height||can.Conf(html.HEIGHT)
        meta.width = meta.width||can.Conf(html.WIDTH)

        meta.name = value.name||meta.name||html.STORY
        meta.help = value.help||meta.help||html.STORY
        meta.type = meta.type||html.STORY

        can.onappend._init(can, meta, ["/plugin/state.js"], function(sub) {
            sub.base.isFunc(cb) && cb(sub, meta)
        }, target||can._output)
    },
    plugin: function(can, meta, cb, target) { meta = meta||{}
        meta.inputs && meta.inputs.length > 0? can.onappend._plugin(can, {meta: meta.meta, list: meta.list}, meta, cb, target):
            can.run({}, [ctx.ACTION, ctx.COMMAND, meta.index||can.core.Keys(meta.ctx, meta.cmd)], function(msg) { msg.Table(function(value) {
                can.onappend._plugin(can, value, meta, cb, target)
            }) }, true)
    },

    float: function(can, msg, cb) {
        var ui = can.onappend.field(can, "story toast float", {}, document.body)
        ui.close = function() { can.page.Remove(can, ui.first), can.onengine.signal(can, "keymap.focus") }
        can.onmotion.float.auto(can, ui.output, "carte", "input")

        can.search({}, ["Action.onexport.size"], function(msg, top, left, width, height) {
            can.page.Modify(can, ui.output, {style: {"max-width": width, "max-height": height-28}})
            can.page.Modify(can, ui.first, {style: {top: top, left: left}})
        })

        can.onappend._action(can, ["close", "refresh", {input: "text", placeholder: "filter", style: {position: ""}, _init: function(input) {
            can.onengine.signal(can, "keymap.focus", can.request({}, {cb: function(event) {
                if (event.target.tagName == "INPUT") { return }
                if (event.key == "Escape") { ui.close(); return }
                if (event.key == " ") { input.focus(), event.stopPropagation(), event.preventDefault() }
            }}))
        }, onkeydown: function(event) {
            can.onkeypop.input(event, can)
            if (event.key != "Enter") { return }
            event.target.setSelectionRange(0, -1)

            can.page.Select(can, ui.output, "tr", function(tr, index) { if (index == 0) { return }
                can.page.Modify(can, tr, {style: {display: "none"}})
                can.page.Select(can, tr, "td", function(td) {
                    if (td.innerText.indexOf(event.target.value) > -1) {
                        can.page.Modify(can, tr, {style: {display: ""}})
                    }
                })
            })
        }}], ui.action, { "close": ui.close,
            "refresh": function(event) { ui.close(), can.toast.click() },
        })
        can.onappend.table(can, msg, function(value, key, index, line, list) {
            return {text: [value, html.TD], onclick: function(event) {
                can.base.isFunc(cb) && cb(value, key, index, line, list)
            }}
        }, ui.output)
        can.onappend.board(can, msg.Result(), ui.output)
        return ui
    },
}, [], function(can) {})
Volcanos("onlayout", {help: "页面布局", list: [], _init: function(can, target) { target = target||document.body
        var list = []; document.body.onresize = function() {
            can.core.Delay(list, 1000, function() { can.onlayout._init(can, target) })
        }

        var width = window.innerWidth, height = window.innerHeight
        can.page.Select(can, target, ["fieldset.head", "fieldset.foot"], function(field) {
            height -= field.offsetHeight
        })

        can.page.Select(can, target, "fieldset.left", function(field, index) {
            can.user.isMobile || (width -= field.offsetWidth)

            can.page.Modify(can, field, {style: {height: height}})
            can.page.Select(can, target, "fieldset.left>div.output", function(output) {
                can.page.Modify(can, output, {style: {height: height-32}})
            })
        })

        can.page.Select(can, target, "fieldset.main", function(field, index) {
            if (can.user.isMobile) {
                can.page.Modify(can, field, {style: {"padding-top": can.user.isLandscape? "0px": ""}})
            } else {
                height -= can.page.Select(can, field, "div.action")[0].offsetHeight

                can.page.Modify(can, field, {style: {height: height}})
                can.page.Select(can, target, "fieldset.main>div.output", function(output) {
                    can.page.Modify(can, output, {style: {height: height}})
                })
            }
        })

        can.onengine.signal(can, "onresize", can.request({}, {width: width, height: height}))
    },
    topic: function(can, topic) { topic && (can._topic = topic)
        can.user.topic(can, can._topic || can.user.Search(can, "topic") || ((can.user.Search(can, cli.POD)||can.base.isNight())? "black": "white"))
        can.page.ClassList.add(can, document.body, can.user.language(can))
    },
    figure: function(event, can, target, right) { target = target||can._target; if (!event || !event.target) { return }
        var left = event.clientX-event.offsetX, top = event.clientY-event.offsetY+event.target.offsetHeight; if (right) {
            var left = event.clientX-event.offsetX+event.target.offsetWidth, top = event.clientY-event.offsetY
        }

        if (left+target.offsetWidth>window.innerWidth) { left = window.innerWidth - target.offsetWidth }
        if (top+target.offsetHeight>window.innerHeight-100) { top = window.innerHeight - target.offsetHeight - 100 }

        var layout = {left: left, top: top}
        can.page.Modify(can, target, {style: layout})
        can.onmotion.move(can, target, layout)
    },
    resize: function(can, name, cb) {
        var list = []; can.onengine.listen(can, name, function(width, height) {
            can.Conf({width: width, height: height}), can.core.Delay(list, 100, function() {
                can.base.isFunc(cb) && cb(event)
            })
        })
    },
    background: function(can, url, target) { target = target || document.body
        can.page.Modify(can, target, {style: {background: url == "" || url == "void"? "": 'url("'+url+'")'}})
    },

    profile: function(can, target) { target = target || can._output
        return can.page.Append(can, target, [{view: ["layout", "table"], list: [
            {view: ["project", "td"], list: [{view: ["project"]}]},
            {type: "td", list: [
                {type: "tr", list: [{type: "tr", list: [
                    {view: ["content", "td"], list: [{view: ["content"]}]},
                    {view: ["profile", "td"], list: [{view: ["profile"], style: {display: "none"}}]},
                ]}]},
                {view: ["display", "tr"], list: [{view: ["display"], style: {display: "none"}}]}
            ]}
        ] }])
    },
    project: function(can, target) { target = target || can._target
        return can.page.Append(can, target, [{view: ["layout", "table"], list: [{type: "tr", list: [
            {type: "td", list: [{view: "project", style: {display: "none"}}]}, {type: "td", list: [
                {view: ["layout", "table"], list: [
                    {type: "tr", list: [{view: "content"}]},
                    {type: "tr", list: [{view: "display"}]},
                ]}
            ]}
        ]}] }])
    },
    display: function(can, target) { target = target || can._target
        return can.page.Appends(can, target, [{view: ["layout", "table"], list: [
            {type: "tr", list: [{view: "content"}]},
            {type: "tr", list: [{view: "display"}]},
        ]}])
    },
})
Volcanos("onmotion", {help: "动态特效", list: [], _init: function(can, target) {
        if ((can.user.Search(can, "topic")||"").indexOf("print") > -1) { return }
        return

        var count = 0, add = true
        can.user.isMobile || can.user.Search(can, "share") || can.core.Timer({interval: 100}, function() {
            if (target.className.indexOf("print") > -1) { return }

            add? count++: count--
            count < 0 && (add = true)
            count > 50 && (add = false)

            can.page.Select(can, target, "fieldset.story", function(item) {
                can.page.Modify(can, item, {style: {
                    "box-shadow": "40px 10px 10px "+(count/10+1)+"px #626bd0",
                }})
            })
        })
    },
    clear: function(can, target) {
        can.page.Modify(can, target||can._output, "")
        return true
    },
    focus: function(can, target) {
        target.setSelectionRange(0, -1), target.focus()
    },
    float: {
        _hash: {},
        del: function(can, key) {
            if (key == "carte") {
                can.page.Select(can, document.body, "div.carte", function(item) {
                    can.page.Remove(can, item)
                })
            }
            this._hash[key] && can.page.Remove(can, this._hash[key]._target)
        },
        add: function(can, key, value) {
            this.del(can, key), this._hash[key] = value
        },

        auto: function(can, target, key) { var that = this
            var list = can.core.List(arguments).slice(2)
            if (list.length == 0) { list = [chat.CARTE, chat.INPUT] }
            can.page.Modify(can, target, {onmouseover: function(event) { 
                if (event.target.tagName == "IMG") { return }
                can.core.List(list, function(key, index) { that.del(can, key) })
            }})
        },
    },
    story: {
        _hash: {
            spark: function(can, meta, target) {
                if (meta[kit.MDB_NAME] == "inner") {
                    target.title = "点击复制", target.onclick = function(event) {
                        can.user.copy(event, can, target.innerText)
                    }
                } else {
                    can.page.Select(can, target, html.SPAN, function(item) {
                        item.title = "点击复制", item.onclick = function(event) {
                            can.user.copy(event, can, item.innerText)
                        }
                    })
                }
            },
        },
        auto: function(can, target) { var that = this
            can.page.Select(can, target||can._output, ".story", function(item) { var meta = item.dataset
                can.page.Modify(can, item, {style: can.base.Obj(meta.style)})
                can.core.CallFunc(that._hash[meta.type], [can, meta, target||can._output])
            })
        },
    },

    hidden: function(can, target, show) {
        can.page.Modify(can, target||can._target, {style: {display: show? "": "none"}})
    },
    toggle: function(can, target) {
        return can.onmotion.Toggle(can, target||can._target)
    },
    select: function(can, target, name, which) {
        can.page.Select(can, target, name, function(item, index) {
            if (item == which || which == index) {
                can.page.ClassList.add(can, item, html.SELECT)
            } else {
                can.page.ClassList.del(can, item, html.SELECT)
            }
        })
    },
    modify: function(can, target, cb, item) { var back = target.innerHTML, text = target.innerText
        if (back.length > 120 || back.indexOf("\n") > -1) {
            return can.onmotion.modifys(can, target, cb)
        }
        var ui = can.page.Appends(can, target, [{type: html.INPUT, value: target.innerText, style: {
            width: target.offsetWidth > 400? 400: target.offsetWidth-20,
        }, onkeydown: function(event) {
            switch (event.key) {
                case "Enter":
                    target.innerHTML = event.target.value
                    if (event.target.value != back) {
                        cb(event, event.target.value, back)
                    }
                    break
                case "Escape":
                    target.innerHTML = back
                    break
                default:
                    can.onkeypop.input(event, can)
            }
        }, _init: function(target) {
            item && can.onappend.figure(can, item, target), target.value = text
        }}]); ui.first.focus(), ui.first.setSelectionRange(0, -1)
    },
    modifys: function(can, target, cb, item) { var back = target.innerHTML
        var ui = can.page.Appends(can, target, [{type: html.TEXTAREA, value: target.innerText, style: {
            width: target.offsetWidth > 400? 400: target.offsetWidth-20, height: target.offsetHeight < 60? 60: target.offsetHeight-20,
        }, onkeydown: function(event) {
            switch (event.key) {
                case "Enter":
                    if (event.ctrlKey) {
                        target.innerHTML = event.target.value
                        if (event.target.value != back) {
                            cb(event, event.target.value, back)
                        }
                    }
                    break
                case "Escape":
                    target.innerHTML = back
                    break
                default:
                    can.onkeypop.input(event, can)
            }
        }}]); ui.first.focus(), ui.first.setSelectionRange(0, -1)
        can.onappend.figure(can, item, ui.first)
    },

    autosize: function(can, target, max, min) {
        can.page.Modify(can, target, {
            onfocus: function(event) {
                can.onmotion.resize(can, target, max, 10)
            }, onmouseenter: function(event) {
                can.onmotion.resize(can, target, max, 10)
            }, onmouseleave: function(event) {
                can.onmotion.resize(can, target, min, 5)
            }, onblur: function(event) {
                can.onmotion.resize(can, target, min, 5)
            },
        })
    },
    resize: function(can, target, width, speed) {
        var begin = target.offsetWidth
        var space = (width - begin) / 30
        can.core.Timer({interval: speed||10, length: 30}, function() {
            can.page.Modify(can, target, {style: {width: begin+=space}})
        })
    },
    move: function(can, target, layout) { var begin
        target.onmousedown = function(event) {
            layout.width = target.offsetWidth
            layout.height = target.offsetHeight
            layout.left = target.offsetLeft
            layout.top = target.offsetTop
            begin = {x: event.x, y: event.y, left: layout.left, top: layout.top, width: layout.width, height: layout.height}
        }, target.onmouseup = function(event) { begin = null }

        target.onmousemove = function(event) { if (!begin || !event.ctrlKey) { return }
            if (event.shiftKey) {
                layout.width = layout.width + event.x - begin.x 
                layout.height = layout.height + event.y - begin.y
                can.page.Modify(can, target, {style: {width: layout.width, height: layout.height}})
            } else {
                layout.top = begin.top + event.y - begin.y
                layout.left = begin.left + event.x - begin.x 
                can.page.Modify(can, target, {style: {left: layout.left, top: layout.top}})
            }
            event.stopPropagation(), event.preventDefault()
        }
    },
    show: function(can, time, cb, target) { target = target || can._target
        time = typeof time == "object"? time: {value: 10, length: time||20}

        can.page.Modify(can, target, {style: {opacity: 0, display: "block"}})
        can.core.Timer(time, function(event, value, index) {
            can.page.Modify(can, target, {style: {opacity: (index+1)/time.length}})
        }, cb)
    },
    hide: function(can, time, cb, target) { target = target || can._target
        time = typeof time == "object"? time: {value: 10, length: time||20}

        can.page.Modify(can, target, {style: {opacity: 1}})
        can.core.Timer(time, function(event, value, index) {
            can.page.Modify(can, target, {style: {opacity: 1-(index+1)/time.length}})
        }, function() {
            can.page.Modify(can, target, {style: {display: "none"}})
            can.base.isFunc(cb) && cb()
        })
    },

    EnableDrop: function(can, parent, search, target) {
        return can.page.Modify(can, target, { draggable: true,
            ondragstart: function(event) { var target = event.target; can.drop = function(event, tab) {
                parent.insertBefore(target, tab)
                can.page.Select(can, parent, search, function(item) {
                    can.page.ClassList.del(can, item, "over")
                })
            } },
            ondragover: function(event) { event.preventDefault()
                can.page.Select(can, parent, search, function(item) {
                    can.page.ClassList.del(can, item, "over")
                }), can.page.ClassList.add(can, event.target, "over")
            },
            ondrop: function(event) { event.preventDefault()
                can.drop(event, event.target)
            },
        })
    },
    Resizes: function(event, item, begin, p0, p1, pos) {
        switch (pos) {
            case 5:
                item.Value("x", begin.x + p1.x - p0.x)
                item.Value("y", begin.y + p1.y - p0.y)
                return
        }

        switch (pos) {
            case 1:
            case 2:
            case 3:
                item.Value("y", begin.y + p1.y - p0.y)
                item.Value("height", begin.height - p1.y + p0.y)
                break
        }
        switch (pos) {
            case 1:
            case 4:
            case 7:
                item.Value("x", begin.x + p1.x - p0.x)
                item.Value("width", begin.width - p1.x + p0.x)
                break
        }
        switch (pos) {
            case 3:
            case 6:
            case 9:
                item.Value("width", begin.width + p1.x - p0.x)
                break
        }
        switch (pos) {
            case 7:
            case 8:
            case 9:
                item.Value("height", begin.height + p1.y - p0.y)
                break
        }
    },
    Resize: function(event, item, begin, pos) {
        switch (pos) {
            case 5:
                item.style.left = begin.left + event.clientX - begin.x + "px"
                item.style.top = begin.top + event.clientY - begin.y + "px"
                return
        }

        switch (pos) {
            case 1:
            case 2:
            case 3:
                item.style.top = begin.top + event.clientY - begin.y + "px"
                item.style.height = begin.height - event.clientY + begin.y + "px"
                break
        }
        switch (pos) {
            case 1:
            case 4:
            case 7:
                item.style.left = begin.left + event.clientX - begin.x + "px"
                item.style.width = begin.width - event.clientX + begin.x + "px"
                break
        }
        switch (pos) {
            case 3:
            case 6:
            case 9:
                item.style.width = begin.width + event.clientX - begin.x + "px"
                break
        }
        switch (pos) {
            case 7:
            case 8:
            case 9:
                item.style.height = begin.height + event.clientY - begin.y + "px"
                break
        }
    },
    Anchor: function(event, target, pos, point) {
        switch (pos) {
            case 1:
            case 2:
            case 3:
                point.y = target.Val("y")
                break
            case 4:
            case 5:
            case 6:
                point.y = target.Val("y") + target.Val("height") / 2
                break
            case 7:
            case 8:
            case 9:
                point.y = target.Val("y") + target.Val("height")
                break
        }

        switch (pos) {
            case 1:
            case 4:
            case 7:
                point.x = target.Val("x")
                break
            case 2:
            case 5:
            case 8:
                point.x = target.Val("x") + target.Val("width") / 2
                break
            case 3:
            case 6:
            case 9:
                point.x = target.Val("x") + target.Val("width")
                break
        }
        return point
    },
    Prepos: function(event, item, p, q) {
        var max = 20
        p = p || item.getBoundingClientRect()
        q = q || {x: event.clientX, y: event.clientY}

        var pos = 5
        var y = (q.y - p.y) / p.height
        if (y < 0.2 && q.y - p.y < max) {
            pos -= 3
        } else if (y > 0.8 && q.y - p.y - p.height > -max) {
            pos += 3
        }
        var x = (q.x - p.x) / p.width
        if (x < 0.2 && q.x - p.x < max) {
            pos -= 1
        } else if (x > 0.8 && q.x - p.x - p.width > -max) {
            pos += 1
        }

        var cursor = [
            "nw-resize", "n-resize", "ne-resize",
            "w-resize", "move", "e-resize",
            "sw-resize", "s-resize", "se-resize",
        ]
        item.style.cursor = cursor[pos-1]
        return pos
    },
    Toggle: function(can, target, show, hide) { var status = target.style.display == "none"
        can.page.Modify(can, target, {style: {display: status? "": "none"}})
        status? typeof show == "function" && show(): typeof hide == "function" && hide()
        return status
    },
})
Volcanos("onkeypop", {help: "键盘交互", list: [], _focus: [], _init: function(can, target) {
        var focus = can.onkeypop._focus
        // can.onengine.listen(can, "keymap.focus", function(cb) { cb? focus.push(cb): focus.pop() })
        can.onengine.listen(can, "keymap.focus", function(cb) { cb? focus.push(cb): can.onkeypop._focus.length = 0 })
        can.onkeypop._build(can)
        target.onkeydown = function(event) { if (focus.length > 0) { return focus[focus.length-1](event) }
            event.target == target && can.page.Select(can, target, "fieldset.Action>div.output", function(item) {
                target._keys = can.onkeypop._parse(event, can, "normal", target._keys||[], item)
            })
        }
    },
    _build: function(can) {
        can.core.Item(can.onkeypop._mode, function(item, value) { var engine = {}
            can.core.Item(value, function(key, cb) { var map = engine
                for (var i = key.length-1; i > -1; i--) {
                    map = map[key[i]] = i == 0? cb: (map[key[i]]||{})
                }
            }), can.onkeypop._engine[item] = engine
        })
    },
    _parse: function(event, can, mode, list, target) { list = list||[], list.push(event.key)
        for (var pre = 0; pre < list.length; pre++) {
            if ("0" <= list[pre] && list[pre] <= "9") { continue } break
        }; var count = parseInt(list.slice(0, pre).join(""))||1

        function repeat(cb, count) { list = []
            for (var i = 1; i <= count; i++) { if (cb(event, can, target, count)) { break } }
            event.stopPropagation(), event.preventDefault()
        }

        var map = can.onkeypop._mode[mode]
        var cb = map && map[event.key]; if (can.base.isFunc(cb) && event.key.length > 1) {
            repeat(cb, count); return list
        }
        var cb = map && map[event.key.toLowerCase()]; if (can.base.isFunc(cb) && event.key.length > 1) {
            repeat(cb, count); return list
        }

        var map = can.onkeypop._engine[mode]; for (var i = list.length-1; i > pre-1; i--) {
            var cb = map[list[i]]; switch (typeof cb) {
                case "function": repeat(cb, count); return list
                case "object": map = cb; continue
                case "string": 
                default: return list
            }
        }
        return list
    },
    _mode: {
        normal: {
            j: function(event, can, target) { target.scrollBy(0, event.ctrlKey? 300: 30) },
            k: function(event, can, target) { target.scrollBy(0, event.ctrlKey? -300: -30) },

            b: function(event, can, target) { can.search(event, ["Header.onaction.black"]) },
            w: function(event, can, target) { can.search(event, ["Header.onaction.white"]) },

            s: function(event, can, target) { can.search(event, ["River.ondetail.添加应用"]) },
            t: function(event, can, target) { can.search(event, ["River.ondetail.添加工具"]) },

            ":": function(event, can, target) {
                can.page.Select(can, document.body, "fieldset.panel.Footer input.cmd", function(target) {
                    target.focus()
                })
            },
            " ": function(event, can, target) {
                can.page.Select(can, document.body, "fieldset.panel.Header div.search input", function(target) {
                    target.focus()
                })
            },
            enter: function(event, can, target) { can.misc.Log("enter") },
            escape: function(event, can, target) {
                can.page.Select(can, document.body, "fieldset.float", function(item) {
                    can.page.Remove(can, item)
                })
                can.page.Select(can, document.body, "fieldset.auto", function(item) {
                    can.onmotion.hidden(can, item)
                })
                can.search(event, ["Search.onaction.hide"])
                can.misc.Log("enter")
            },
        },
        insert: {
            escape: function(event, can, target) {
                target.blur()
            },
            jk: function(event, can, target) {
                can.onkeypop.DelText(target, target.selectionStart-1, target.selectionStart)
                target.blur()
            },
            enter: function(event, can, target) {
                var his = target._history || []
                his.push(target.value)

                target.setSelectionRange(0, -1)
                target._current = his.length
                target._history = his
            },
        },
        insert_ctrl: {
            p: function(event, can, target) {
                var his = target._history||[]
                var pos = target._current||0

                pos = --pos % (his.length+1)
                if (pos < 0) { pos = his.length}
                target.value = his[pos]||""
                can.misc.Log(pos, his)

                target._current = pos
            },
            n: function(event, can, target) {
                var his = target._history||[]
                var pos = target._current||0

                pos = ++pos % (his.length+1)
                target.value = his[pos]||""
                can.misc.Log(pos, his)

                target._current = pos
            },

            u: function(event, can, target) {
                can.onkeypop.DelText(target, 0, target.selectionEnd)
            },
            k: function(event, can, target) {
                can.onkeypop.DelText(target, target.selectionStart)
            },
            h: function(event, can, target) {
                can.onkeypop.DelText(target, target.selectionStart-1, target.selectionStart)
            },
            d: function(event, can, target) {
                can.onkeypop.DelText(target, 0, target.selectionStart)
            },
            w: function(event, can, target) {
                var start = target.selectionStart-2
                var end = target.selectionEnd-1
                for (var i = start; i >= 0; i--) {
                    if (target.value[end] == " " && target.value[i] != " ") {
                        break
                    }
                    if (target.value[end] != " " && target.value[i] == " ") {
                        break
                    }
                }
                can.onkeypop.DelText(target, i+1, end-i)
            },
        },
    }, _engine: {},

    DelText: function(target, start, count) {
        target.value = target.value.substring(0, start)+target.value.substring(start+(count||target.value.length), target.value.length)
        target.setSelectionRange(start, start)
    },
    input: function(event, can) { var target = event.target
        target._keys = can.onkeypop._parse(event, can, event.ctrlKey? "insert_ctrl": mdb.INSERT, target._keys||[], target)
        if (target._keys.length == 0)  { event.stopPropagation(), event.preventDefault() }
    },
})
_can_name = ""