mirror of
https://shylinux.com/x/volcanos
synced 2025-04-25 16:58:06 +08:00
379 lines
25 KiB
JavaScript
379 lines
25 KiB
JavaScript
Volcanos(chat.ONIMPORT, {_init: function(can, msg) {
|
|
can.isCmdMode() || can.onmotion.hidden(can, can._action)
|
|
if (can.ConfIndex() == web.WIKI_DRAW) { can.ui = can.onappend.layout(can), can.onexport.title(can, can.Option(nfs.PATH))
|
|
if (can.user.isMobile || !can.isCmdMode()) { can.onmotion.hidden(can, can.ui.project) }
|
|
can.isCmdMode() && can.onmotion.toggle(can, can.ui.profile, true)
|
|
} else { can.ui = {content: can._output} } can.page.Modify(can, can.ui.content, msg.Results()||can.onexport.content(can))
|
|
can.svg = null, can.group = null, can.current = null, can.temp = null, can.points = [], can._display_heights = {}
|
|
can.page.Select(can, can.ui.content, html.SVG, function(target) { can.svg = can.group = can.onimport._block(can, target), can.onimport._group(can, target)
|
|
can.page.Select(can, target, "", function(target) { can.onimport._block(can, target), can.page.tagis(target, svg.G) && target.Value(html.CLASS) && can.onimport._group(can, target) })
|
|
can.isCmdMode() && can.core.ItemCB(can.onaction, function(key, cb) { target[key] = function(event) { can.misc.Event(event, can, function(msg) { cb(event, can) }) } })
|
|
}), can.ondetail._select(can, can.db.hash[1]||can.Option(svg.PID)||can.svg.Value(svg.PID))
|
|
},
|
|
_block: function(can, target) {
|
|
target.Value = function(key, value) { if (can.base.isUndefined(key)) { return } if (can.base.isObject(key)) { return can.core.Item(key, target.Value), key }
|
|
var figure = can.onfigure._get(can, target); key = can.core.Value(figure, [svg.DATA, svg.TRANS, key])||key
|
|
var _cb = can.core.Value(figure, [svg.DATA, key]); if (can.base.isFunc(_cb)) { return _cb(can, value, key, target) }
|
|
if (value == ice.AUTO) { return target.removeAttribute(key) }
|
|
if (key == html.INNER) { return value != undefined && (target.innerHTML = value), target.innerHTML }
|
|
if (key == svg.SHIP) { return value != undefined && target.setAttribute(key, JSON.stringify(value)), can.base.Obj(target.getAttribute(key), []) }
|
|
try { return value != undefined && target.setAttribute(key, value), target.getAttribute(key) || can.core.Value(target[key], "baseVal.value") || can.core.Value(target[key], "baseVal") || undefined } catch(e) { }
|
|
}, target.Val = function(key, value) { return parseInt(target.Value(key, value == undefined? value: parseInt(value)||0))||0 }
|
|
target.Group = function() { for (var node = target; node; node = node.parentNode) { if (can.page.tagis(node, svg.G, html.SVG)) { return node } } return can.svg }
|
|
target.Groups = function() { if (target == can.svg) { return html.SVG } var list = []
|
|
for (var node = target; node && !can.page.tagis(node, html.SVG); node = node.parentNode) { can.page.tagis(node, svg.G) && node.Value(html.CLASS) && list.push(node.Value(html.CLASS)) }
|
|
return list.reverse().join(nfs.PT)
|
|
}; return target
|
|
},
|
|
_group: function(can, target) { var name = target.Groups(); if (!name || !can.ui.project) { return }
|
|
var item = can.onimport.item(can, {name: name}, function(event) { can.group = target, can.Status(svg.GROUP, name), can.onaction.show(event, can)
|
|
can.core.List([svg.FONT_SIZE, svg.STROKE_WIDTH, svg.STROKE, svg.FILL], function(key) { can.Action(key, target.Value(key)||key) })
|
|
}, function(event) { can.user.carteRight(event, can, can.onaction, can.onaction.menu_list) }, can.ui.project)
|
|
name == can.db.hash[0] && can.onmotion.delay(can, function() { item.click() })
|
|
},
|
|
_profile: function(can, target) { if (!can.ui.profile) { return }
|
|
can.misc.SearchHash(can, target.Groups()||"svg", can.Option(svg.PID, can.svg.Value(svg.PID, can.onexport._pid(can, target))))
|
|
var figure = can.onfigure._get(can, target), ui = can.page.Appends(can, can.ui.profile, [html.OUTPUT, html.ACTION])
|
|
can.page.Appends(can, ui.output, [{view: [html.CONTENT, html.TABLE], list: [
|
|
{th: [mdb.KEY, mdb.VALUE]}, {td: [mdb.TYPE, target.tagName]}, {td: [svg.PID, target.Value(svg.PID)]}, {td: [mdb.TEXT, target.Value(mdb.TEXT)]},
|
|
].concat(can.core.List([].concat(can.core.Value(figure, "data.copy"), [svg.X, svg.Y, mdb.INDEX, ctx.ARGS]), function(key) {
|
|
return key = can.core.Value(figure.data, can.core.Keys(svg.TRANS, key))||key, {td: [key, target.Value(key)], ondblclick: function(event) {
|
|
can.onmotion.modify(can, event.target, function(event, value) { target.Value(key, value), can.ondetail._move(can, target)
|
|
if (key == ctx.INDEX || key == ctx.ARGS) { can.onimport._display(can, target) }
|
|
}, {name: key, action: "key"})
|
|
}}
|
|
})) }])
|
|
// can.onappend._action(can, can.ondetail.list, ui.action, {_engine: function(event, can, button) { can.ondetail[button]({target: target}, can, button) }})
|
|
},
|
|
_display: function(can, target) { if (!can.ui.display) { return }
|
|
if (!target.Value(ctx.INDEX)) { return can.onmotion.hidden(can, can.ui.display) } can.onmotion.toggle(can, can.ui.display, true)
|
|
if (can.onmotion.cache(can, function() { return target.Value(svg.PID) }, can.ui.display)) { return }
|
|
can.onappend.plugin(can, {index: target.Value(ctx.INDEX), args: target.Value(ctx.ARGS), height: can.ConfHeight()/2}, function(sub) {
|
|
sub.onexport.output = function() { can.onmotion.delay(can, function() { can.page.style(can, sub._output, html.MAX_HEIGHT, "")
|
|
sub.onimport.size(sub, can._display_heights[target.Value(svg.PID)] = can.base.Max(sub._target.offsetHeight, can.ConfHeight()/2), can.ConfWidth()-can.ui.project.offsetWidth, true)
|
|
can.onimport.layout(can)
|
|
}) }
|
|
sub.onaction._close = function() { can.onmotion.hidden(can, can.ui.display), can.onimport.layout(can) }
|
|
}, can.ui.display)
|
|
},
|
|
block: function(can, type, value, group) { group = group||can.group
|
|
var target = document.createElementNS("http://www.w3.org/2000/svg", type)
|
|
return group.appendChild(can.onimport._block(can, target)), target.Value(value), target
|
|
},
|
|
group: function(can, name, value, group) { var target = can.onimport.block(can, svg.G, value, group||can.svg)
|
|
return target.Value(html.CLASS, name), can.onimport._group(can, target), target
|
|
},
|
|
draw: function(can, value, group) { group = group||can.svg
|
|
var figure = can.onfigure[value.shape], data = figure.draw({}, can, value.points, value.style||{}); can.core.Item(value.style, function(key, value) { data[key] = value })
|
|
var target = can.onimport.block(can, figure.data.name||value.shape, data, group); can.core.ItemCB(value, function(key, cb) { target[key] = cb })
|
|
return value._init && value._init(target), target
|
|
},
|
|
layout: function(can, height, width) {
|
|
can.ui.layout && can.ui.layout(can.ConfHeight(), can.ConfWidth(), 0, function(height, width) { can.page.style(can, can.svg, html.MIN_HEIGHT, height, html.MIN_WIDTH, width) })
|
|
},
|
|
})
|
|
Volcanos(chat.ONACTION, {list: [
|
|
[svg.GRID, svg.GRID, 1, 2, 3, 4, 5, 10, 20],
|
|
[svg.FONT_SIZE, svg.FONT_SIZE, 12, 16, 18, 24, 32],
|
|
[svg.STROKE_WIDTH, svg.STROKE_WIDTH, 1, 2, 3, 4, 5],
|
|
[svg.STROKE, svg.STROKE, cli.RED, cli.YELLOW, cli.GREEN, cli.CYAN, cli.BLUE, cli.PURPLE, cli.BLACK, cli.WHITE],
|
|
[svg.FILL, svg.FILL, cli.RED, cli.YELLOW, cli.GREEN, cli.CYAN, cli.BLUE, cli.PURPLE, cli.BLACK, cli.WHITE],
|
|
// [svg.GO, ice.AUTO, ctx.RUN, ice.AUTO, "manual"],
|
|
[svg.GO, ctx.RUN, ice.AUTO, "manual"],
|
|
[ice.MODE, web.DRAW, web.RESIZE],
|
|
[svg.SHAPE, svg.RECT, svg.TEXT, svg.RECT, svg.LINE, svg.BLOCK, svg.CIRCLE, svg.ELLIPSE],
|
|
], _change: function(can, key, value) {
|
|
value == "" && (value = key), can.Action(key, value)
|
|
key == value && (value = ice.AUTO), can.group.Value(key, value)
|
|
},
|
|
"font-size": function(event, can, key, value) { can.onaction._change(can, key, value) },
|
|
"stroke-width": function(event, can, key, value) { can.onaction._change(can, key, value) },
|
|
stroke: function(event, can, key, value) { can.onaction._change(can, key, value) },
|
|
fill: function(event, can, key, value) { can.onaction._change(can, key, value) },
|
|
|
|
menu_list: [html.HIDE, html.SHOW, mdb.CREATE, web.CLEAR, mdb.REMOVE],
|
|
hide: function(event, can) { can.onmotion.hide(can, {interval: 100, length: 10}, null, can.group) },
|
|
show: function(event, can) { can.onmotion.show(can, {interval: 10, length: 1}, null, can.group) },
|
|
create: function(event, can) { can.user.input(event, can, [svg.GROUP], function(list) { can.onimport.group(can, list[0]) }) },
|
|
clear: function(event, can) { can.onmotion.clear(can, can.group), delete(can.temp), can.points = [] },
|
|
remove: function(event, can) { can.group == can.svg || can.page.Remove(can, can.group) },
|
|
|
|
save: function(event, can, button) { can.runAction(can.request(event, {text: can.onexport.content(can, can.svg)}), button, [can.Option(nfs.PATH)]) },
|
|
edit: function(event, can) { can.Action(svg.GO, can.Action(svg.GO) == ctx.RUN? ice.AUTO: ctx.RUN) },
|
|
|
|
_mode: {
|
|
draw: function(event, can, points) { var shape = can.Action(svg.SHAPE), figure = can.onfigure[shape]
|
|
figure.grid && figure.grid(event, can, points); if (figure.data.points && figure.data.points != points.length) { return }
|
|
var data = figure.draw && figure.draw(event, can, points, {}), target = data && can.onimport.block(can, figure.data.name||shape, data, can.group)
|
|
if (event.type == html.CLICK) { can.points = []; if (target) { var pid = can.onexport._pid(can, target)
|
|
can.core.List(points, function(p, i) { p.target && p.target.Value(svg.SHIP, p.target.Value(svg.SHIP).concat([{pid: pid, which: i+1, anchor: p.anchor}])) })
|
|
return
|
|
} } return target
|
|
},
|
|
resize: function(event, can, points) { var target = event.target
|
|
if (event.type == html.CLICK) { if (points.length > 1) { return can.points = [], delete(can.current) }
|
|
return can.current = {target: target, begin: can.core.List([target], function(target) { if (can.page.tagis(target, svg.G)) { return }
|
|
return {target: target, height: target.Val(html.HEIGHT), width: target.Val(html.WIDTH), x: target.Val(svg.X), y: target.Val(svg.Y),
|
|
ship: can.core.List(target.Value(svg.SHIP), function(ship) { return ship.pid && (ship.target = can.ondetail._select(can, ship.pid)) && ship })
|
|
}
|
|
}), pos: can.onexport.cursor(event, can, target)}
|
|
}
|
|
can.current && can.core.List(can.current.begin, function(item) { var figure = can.onfigure._get(can, item.target)
|
|
can.onexport.resize(item.target, can.current.pos, points[0], points[1], item), can.ondetail._move(can, item.target, item.ship)
|
|
can.ondetail._select(can, item.target.Value(mdb.TEXT), function(text) { text.Value(can.onexport._text(can, item.target, figure, {})) })
|
|
})
|
|
},
|
|
},
|
|
_auto: function(can, target) { if (can.points.length > 0 || can.page.tagis(target, html.TEXT)) { return }
|
|
var pos = can.onexport.cursor(event, can, target); if (target == can.svg) { switch (pos) {
|
|
case 5: can.Action(ice.MODE, web.DRAW), can.Action(svg.SHAPE, html.BLOCK), can.page.style(can, target, {cursor: "crosshair"}); break
|
|
default: can.Action(ice.MODE, web.RESIZE)
|
|
} } else { switch (pos) {
|
|
case 5:
|
|
case 9: can.Action(ice.MODE, web.RESIZE); break
|
|
default: can.Action(ice.MODE, web.DRAW), can.Action(svg.SHAPE, svg.LINE)
|
|
} }
|
|
},
|
|
_figure: function(event, can, points) {
|
|
can._undo && can._undo(), can._undo = function() { can.temp && can.page.Remove(can, can.temp) && delete(can.temp), delete(can._undo) }
|
|
can.temp = can.core.CallFunc([can.onaction._mode, can.Action(ice.MODE)], [event, can, points]), can.points.length == 0 && can._undo && can._undo()
|
|
},
|
|
onmouseover: function(event, can) {
|
|
can.onexport._show(can, event.target)
|
|
},
|
|
onmousemove: function(event, can) {
|
|
var point = can.onexport._point(event, can); can.onexport.cursor(event, can, event.target)
|
|
if (can.Action(svg.GO) == ctx.RUN) { return can.page.style(can, can.svg, "cursor", "pointer") }
|
|
if (can.Action(svg.GO) == ice.AUTO) { can.onaction._auto(can, event.target) }
|
|
can.onaction._figure(event, can, can.points.concat(point))
|
|
can.temp && can.onexport._show(can, can.temp||event.target)
|
|
},
|
|
onclick: function(event, can) { var point = can.onexport._point(event, can)
|
|
if (can.Action(svg.GO) == ctx.RUN) { return can.ondetail._select(can, event.target.Value(svg.PID)) }
|
|
can.onaction._figure(event, can, can.points = can.points.concat(point))
|
|
},
|
|
ondblclick: function(event, can) { can.ondetail.label(event, can) },
|
|
oncontextmenu: function(event, can) { can.page.style(can, can.user.carte(event, can, can.ondetail, null, function(ev, button, meta) { meta[button](event, can, button) })._target, {left: event.clientX, top: event.clientY}) },
|
|
})
|
|
Volcanos(chat.ONDETAIL, {
|
|
list: [cli.START, nfs.COPY, html.LABEL, html.TOIMAGE, mdb.REMOVE],
|
|
_trans: {copy: "复制", label: "标签", toimage: "成图"},
|
|
_select(can, name, cb) { if (!name) { return } var target = can.page.SelectOne(can, can.svg, nfs.PT+name, cb); if (!target) { return }
|
|
can.onimport._profile(can, target), can.onimport._display(can, target), can.onimport.layout(can, can.ConfHeight(), can.ConfWidth())
|
|
return target
|
|
},
|
|
start: function(event, can) {
|
|
event = event._events||event; var target = event.target; if (target == can.svg) { return }
|
|
var list = [target], dict = {}
|
|
for (var i = 0; i < list.length; i++) { var ship = list[i].Value(svg.SHIP)
|
|
for (var j = 0; j < ship.length; j++) { var pid = ship[j].pid
|
|
can.ondetail._select(can, pid, function(target) { var pid = target.Value(svg.SHIP)[1].pid
|
|
can.ondetail._select(can, pid, function(target) { !dict[pid] && list.push(target), dict[pid] = true })
|
|
})
|
|
}
|
|
}
|
|
can.core.Next(list, function(target, next) { can.onmotion.delay(can, function() {
|
|
can.onmotion.show(can, {interval: 300, length: 10}, null, target)
|
|
can.user.toast(can, target.Value(ctx.INDEX))
|
|
can.ondetail.run({target: target}, can), next()
|
|
}) })
|
|
},
|
|
copy: function(event, can) {
|
|
event = event._events||event; var target = event.target; if (target == can.svg) { return }
|
|
var figure = can.onfigure._get(can, target), trans = can.core.Value(figure, [svg.DATA, svg.TRANS])||{}, data = {}
|
|
data[trans.x||svg.X] = target.Val(trans.x||svg.X)+10, data[trans.y||svg.Y] = target.Val(trans.y||svg.Y)+10
|
|
can.core.List(figure.data.copy, function(key) { data[key] = target.Value(key) })
|
|
return can.onimport.block(can, target.tagName, data, can.group)
|
|
},
|
|
label: function(event, can) {
|
|
event = event._events||event; var target = event.target; if (target == can.svg) { return }
|
|
var _target, text = target.Value(mdb.TEXT); can.ondetail._select(can, text, function(target) { _target = target, text = target.Value(html.INNER) })
|
|
can.user.input(event, can, [{name: html.LABEL, value: text}], function(list) {
|
|
if (_target) { _target.Value(html.INNER, list[0]); return } if (can.page.tagis(target, html.TEXT)) { target.innerHTML = list[0]; return }
|
|
target.Value(mdb.TEXT, can.onexport._pid(can, can.onimport.block(can, html.TEXT, can.onexport._text(can, target, can.onfigure._get(can, target), {inner: list[0]}), target.Group()) ))
|
|
})
|
|
},
|
|
toimage: function(event, can) {
|
|
can.user.toimage(can, can.Option(nfs.PATH).split(nfs.PS).pop().split(nfs.PT)[0], can.svg) },
|
|
remove: function(event, can) {
|
|
event = event._events||event; var target = event.target; if (target == can.svg) { return }
|
|
can.core.List(target.Value(svg.SHIP), function(item) { can.ondetail._select(can, item.pid, function(target) { can.page.Remove(can, target) }) })
|
|
can.ondetail._select(can, target.Value(mdb.TEXT), function(target) { can.page.Remove(can, target) }), can.page.Remove(can, target)
|
|
},
|
|
_move: function(can, target, list) {
|
|
can.core.List(list||target.Value(svg.SHIP), function(ship) { var p = can.onexport.anchor(target, ship.anchor, {}); ship.target = can.ondetail._select(can, ship.pid)
|
|
if (ship.which == 1) { ship.target.Val(svg.X1, p.x), ship.target.Val(svg.Y1, p.y) } else if (ship.which == 2) { ship.target.Val(svg.X2, p.x), ship.target.Val(svg.Y2, p.y) }
|
|
})
|
|
},
|
|
})
|
|
Volcanos(chat.ONEXPORT, {list: [svg.GROUP, svg.FIGURE, ctx.INDEX, "pos"],
|
|
_point: function(event, can) { var p = can.svg.getBoundingClientRect(), point = {x: event.clientX-p.x, y: event.clientY-p.y}
|
|
point.x = point.x - point.x % can.onexport.grid(can), point.y = point.y - point.y % can.onexport.grid(can)
|
|
return can.Status("pos", point.x+mdb.FS+point.y), point
|
|
},
|
|
_pid: function(can, target) { if (target.Value(svg.PID)) { return target.Value(svg.PID) }
|
|
var pid = "p"+can.svg.Val(mdb.COUNT, can.svg.Val(mdb.COUNT)+1)
|
|
return target.Value(html.CLASS, [target.Value(html.CLASS), target.Value(svg.PID, pid)].join(lex.SP).trim()), pid
|
|
},
|
|
_text: function(can, target, figure, data) { var trans = can.core.Value(figure.data, svg.TRANS)||{}
|
|
if (figure.text) { return figure.text(can, target, data) }
|
|
return data.x = target.Val(trans[svg.X]||svg.X), data.y = target.Val(trans[svg.Y]||svg.Y), data
|
|
},
|
|
_size: function(can, target, figure) { var trans = can.core.Value(figure.data, svg.TRANS)||{}
|
|
return "<("+target.Val(trans[html.WIDTH]||html.WIDTH)+mdb.FS+target.Val(trans[html.HEIGHT]||html.HEIGHT)+")"
|
|
},
|
|
_position: function(can, target, figure) { var trans = can.core.Value(figure.data, svg.TRANS)||{}
|
|
return "@("+target.Val(trans[svg.X]||svg.X)+mdb.FS+target.Val(trans[svg.Y]||svg.Y)+")"
|
|
},
|
|
_show: function(can, target) { var figure = can.onfigure._get(can, target)
|
|
function show() { return can.onexport._position(can, target, figure)+lex.SP+can.onexport._size(can, target, figure) }
|
|
can.Status(svg.FIGURE, can.core.Keys(target.tagName, target.Value(svg.PID))+lex.SP+(figure? (figure.show||show)(can, target, figure): ""))
|
|
can.Status(svg.GROUP, target.Groups()||can.group.Groups()||html.SVG)
|
|
can.Status(ctx.INDEX, target.Value(ctx.INDEX)||"")
|
|
},
|
|
grid: function(can) { var grid = can.Action(svg.GRID); return grid == svg.GRID || grid == ice.AUTO? 10: grid },
|
|
content: function(can, target) { return ['<svg xmlns="https://www.w3.org/2000/svg" vertion="1.1" text-anchor="middle" dominant-baseline="middle"'].concat(
|
|
target? can.core.List([mdb.COUNT, svg.PID], function(item) { return target.Value(item)? can.base.joinKV([item, target.Value(item)], mdb.EQ): ""}).join(lex.SP): "").concat([">", target? target.innerHTML: "", "</svg>"]).join("")
|
|
},
|
|
cursor: function(event, can, target) {
|
|
var p = target.getBoundingClientRect(), q = {x: event.clientX, y: event.clientY}, pos = 5, margin = 20
|
|
var y = (q.y-p.y)/p.height; if (y < 0.2 && q.y-p.y < margin) { pos -= 3 } else if (y > 0.8 && q.y-p.y-p.height > -margin) { pos += 3 }
|
|
var x = (q.x-p.x)/p.width; if (x < 0.2 && q.x-p.x < margin) { pos -= 1 } else if (x > 0.8 && q.x-p.x- p.width > -margin) { pos += 1 }
|
|
return can.svg.style.cursor = ["nw-resize", "n-resize", "ne-resize", "w-resize", "move", "e-resize", "sw-resize", "s-resize", "se-resize"][pos-1], pos
|
|
},
|
|
anchor: function(target, pos, point) {
|
|
switch (pos) {
|
|
case 1:
|
|
case 2:
|
|
case 3: point.y = target.Val(svg.Y); break
|
|
case 4:
|
|
case 5:
|
|
case 6: point.y = target.Val(svg.Y) + target.Val(html.HEIGHT)/2; break
|
|
case 7:
|
|
case 8:
|
|
case 9: point.y = target.Val(svg.Y) + target.Val(html.HEIGHT); break
|
|
}
|
|
switch (pos) {
|
|
case 1:
|
|
case 4:
|
|
case 7: point.x = target.Val(svg.X); break
|
|
case 2:
|
|
case 5:
|
|
case 8: point.x = target.Val(svg.X) + target.Val(html.WIDTH)/2; break
|
|
case 3:
|
|
case 6:
|
|
case 9: point.x = target.Val(svg.X) + target.Val(html.WIDTH); break
|
|
} return point
|
|
},
|
|
resize: function(target, pos, p0, p1, begin) {
|
|
if (pos == 5) { target.Value(svg.X, begin.x + p1.x - p0.x), target.Value(svg.Y, begin.y + p1.y - p0.y); return }
|
|
switch (pos) {
|
|
case 1:
|
|
case 2:
|
|
case 3: target.Value(svg.Y, begin.y + p1.y - p0.y), target.Value(html.HEIGHT, begin.height - p1.y + p0.y); break
|
|
case 7:
|
|
case 8:
|
|
case 9: target.Value(html.HEIGHT, begin.height + p1.y - p0.y); break
|
|
}
|
|
switch (pos) {
|
|
case 1:
|
|
case 4:
|
|
case 7: target.Value(svg.X, begin.x + p1.x - p0.x), target.Value(html.WIDTH, begin.width - p1.x + p0.x); break
|
|
case 3:
|
|
case 6:
|
|
case 9: target.Value(html.WIDTH, begin.width + p1.x - p0.x); break
|
|
}
|
|
},
|
|
})
|
|
Volcanos(chat.ONFIGURE, {
|
|
_get: function(can, target, name) { return can.onfigure[name]||can.onfigure[target.getAttribute(mdb.NAME)]||can.onfigure[target.tagName] },
|
|
svg: { // <svg count="20" pid="p1"/>
|
|
data: {copy: [html.HEIGHT, html.WIDTH]},
|
|
show: function(can, target, figure) { return can.onexport._size(can, target, figure) }
|
|
},
|
|
rect: { // <rect height="30" width="30" rx="10" ry="10" x="60" y="10"/>
|
|
data: {points: 2, rx: 4, ry: 4, copy: [html.HEIGHT, html.WIDTH, svg.RX, svg.RY]},
|
|
draw: function(event, can, points, style) { var p0 = points[0], p1 = points[1]
|
|
return {height: Math.abs(p0.y-p1.y), width: Math.abs(p0.x-p1.x), x: Math.min(p0.x, p1.x), y: Math.min(p0.y, p1.y), rx: style.rx == undefined? this.data.rx: style.rx, ry: style.ry == undefined? this.data.ry: style.ry}
|
|
},
|
|
text: function(can, target, data) { return data.x = target.Val(svg.X)+target.Val(html.WIDTH)/2, data.y = target.Val(svg.Y)+target.Val(html.HEIGHT)/2, data },
|
|
},
|
|
line: { // "10" y1="50" x2="110" y2="150"/>
|
|
data: {points: 2, trans: {x: svg.X1, y: svg.Y1}, copy: [svg.X1, svg.Y1, svg.X2, svg.Y2]},
|
|
grid: function(event, can, points) { var target = event.target; if (target == can.svg) { return }
|
|
var p = points[points.length-1], pos = can.onexport.cursor(event, can, target); can.onexport.anchor(target, pos, p)
|
|
return p.target = target, p.anchor = pos, points
|
|
},
|
|
draw: function(event, can, points) { var p0 = points[0], p1 = points[1], ship = []
|
|
p0.target && p0.target.Value && ship.push({pid: p0.target.Value(svg.PID)})
|
|
p1.target && p1.target.Value && ship.push({pid: p1.target.Value(svg.PID)})
|
|
return {x1: p0.x, y1: p0.y, x2: p1.x, y2: p1.y, ship: ship.length > 0? ship: undefined}
|
|
},
|
|
text: function(can, target, data) { return data.x = (target.Val(svg.X1)+target.Val(svg.X2))/2, data.y = (target.Val(svg.Y1)+target.Val(svg.Y2))/2, data },
|
|
show: function(can, target, figure) { return "<("+(target.Val(svg.Y2)-target.Val(svg.Y1))+mdb.FS+(target.Val(svg.X2)-target.Val(svg.X1))+")"+can.onexport._position(can, target, figure) },
|
|
},
|
|
|
|
text: { // <text x="60" y="10">hi</text>
|
|
data: {points: 1, copy: [html.INNER]},
|
|
draw: function(event, can, points, style) { if (event.type == "mousemove") { return }
|
|
var p0 = points[0]; return {x: p0.x, y: p0.y, inner: style.inner||can.user.prompt(mdb.TEXT)}
|
|
},
|
|
show: function(can, target, figure) { return can.onexport._position(can, target, figure) }
|
|
},
|
|
block: { // "30" width="30" rx="10" ry="10" x="60" y="10"/>
|
|
data: {points: 2, rx: 4, ry: 4, copy: [html.HEIGHT, html.WIDTH, svg.RX, svg.RY]},
|
|
draw: function(event, can, points, style) {
|
|
can._undo && can._undo(), can._temp = can.onimport.block(can, svg.G, {}, can.group)
|
|
can._undo = function() { can._temp && can.page.Remove(can, can._temp) && delete(can._temp), delete(can._undo) }
|
|
var target = can.onimport.block(can, svg.RECT, can.onfigure.rect.draw(event, can, points, style), can._temp)
|
|
if (event.type == html.CLICK) { can.onexport._pid(can, target), delete(can._temp) }
|
|
},
|
|
text: function(can, target, data) { can.onfigure.rect.text(can, data, target) },
|
|
},
|
|
circle: { // "25" cy="75" r="20"/>
|
|
data: {points: 2, trans: {height: svg.R, width: svg.R, x: svg.CX, y: svg.CY}, copy: [svg.R]},
|
|
draw: function(event, can, points) { var p0 = points[0], p1 = points[1]; return {cx: p0.x, cy: p0.y, r: parseInt(Math.sqrt(Math.pow(p0.x-p1.x, 2)+Math.pow(p0.y-p1.y, 2)))} },
|
|
},
|
|
ellipse: { // "75" cy="75" rx="20" ry="5"/>
|
|
data: {points: 2, trans: {height: svg.RY, width: svg.RX, x: svg.CX, y: svg.CY}, copy: [svg.RY, svg.RX]},
|
|
draw: function(event, can, points) { var p0 = points[0], p1 = points[1]; return {cx: p0.x, cy: p0.y, ry: Math.abs(p0.y - p1.y), rx: Math.abs(p0.x - p1.x)} },
|
|
},
|
|
}, [])
|
|
Volcanos(chat.ONKEYMAP, {
|
|
_mode: {
|
|
normal: {
|
|
Escape: function(event, can) { can._undo && can._undo(), can.points = [] },
|
|
gr: function(event, can) { can.Action(svg.GO, ctx.RUN) },
|
|
ga: function(event, can) { can.Action(svg.GO, ice.AUTO) },
|
|
gm: function(event, can) { can.Action(svg.GO, "manual") },
|
|
|
|
ad: function(event, can) { can.Action(ice.MODE, web.DRAW) },
|
|
ar: function(event, can) { can.Action(ice.MODE, web.RESIZE) },
|
|
|
|
st: function(event, can) { can.Action(svg.SHAPE, svg.TEXT) },
|
|
sr: function(event, can) { can.Action(svg.SHAPE, svg.RECT) },
|
|
sl: function(event, can) { can.Action(svg.SHAPE, svg.LINE) },
|
|
sc: function(event, can) { can.Action(svg.SHAPE, svg.CIRCLE) },
|
|
se: function(event, can) { can.Action(svg.SHAPE, svg.ELLIPSE) },
|
|
|
|
cr: function(event, can) { can.onaction._change(can, svg.STROKE, cli.RED) },
|
|
cb: function(event, can) { can.onaction._change(can, svg.STROKE, cli.BLUE) },
|
|
cg: function(event, can) { can.onaction._change(can, svg.STROKE, cli.GREEN) },
|
|
cy: function(event, can) { can.onaction._change(can, svg.STROKE, cli.YELLOW) },
|
|
cp: function(event, can) { can.onaction._change(can, svg.STROKE, cli.PURPLE) },
|
|
cc: function(event, can) { can.onaction._change(can, svg.STROKE, cli.CYAN) },
|
|
ch: function(event, can) { can.onaction._change(can, svg.STROKE, cli.BLACK) },
|
|
cw: function(event, can) { can.onaction._change(can, svg.STROKE, cli.WHITE) },
|
|
|
|
fr: function(event, can) { can.onaction._change(can, svg.FILL, cli.RED) },
|
|
fb: function(event, can) { can.onaction._change(can, svg.FILL, cli.BLUE) },
|
|
fg: function(event, can) { can.onaction._change(can, svg.FILL, cli.GREEN) },
|
|
fy: function(event, can) { can.onaction._change(can, svg.FILL, cli.YELLOW) },
|
|
fp: function(event, can) { can.onaction._change(can, svg.FILL, cli.PURPLE) },
|
|
fc: function(event, can) { can.onaction._change(can, svg.FILL, cli.CYAN) },
|
|
fh: function(event, can) { can.onaction._change(can, svg.FILL, cli.BLACK) },
|
|
fw: function(event, can) { can.onaction._change(can, svg.FILL, cli.WHITE) },
|
|
},
|
|
}, _engine: {},
|
|
})
|