303 lines
8.9 KiB
Text
303 lines
8.9 KiB
Text
var assert_m = canvas.assert_m;
|
||
|
||
# --------------------------------
|
||
# From FGDATA/Nasal/canvas/api.nas
|
||
# --------------------------------
|
||
|
||
# Recursively get all children of class specified by first param
|
||
canvas.Group.getChildrenOfType = func(type, array = nil){
|
||
var children = array;
|
||
if(children == nil)
|
||
children = [];
|
||
var my_children = me.getChildren();
|
||
if(typeof(type) != 'vector')
|
||
type = [type];
|
||
foreach(var c; my_children){
|
||
foreach(var t; type){
|
||
if(isa(c, t)){
|
||
append(children, c);
|
||
}
|
||
}
|
||
if(isa(c, canvas.Group)){
|
||
c.getChildrenOfType(type, children);
|
||
}
|
||
}
|
||
return children;
|
||
};
|
||
|
||
# Set color to children of type Path and Text. It is possible to optionally
|
||
# specify which types of children should be affected by passing a vector as
|
||
# the last agrument, ie. my_group.setColor(1,1,1,[Path]);
|
||
canvas.Group.setColor = func(){
|
||
var color = arg;
|
||
var types = [Path, Text];
|
||
var arg_c = size(color);
|
||
if(arg_c > 1 and typeof(color[-1]) == 'vector'){
|
||
types = color[-1];
|
||
color = subvec(color, 0, arg_c - 1);
|
||
}
|
||
var children = me.getChildrenOfType(types);
|
||
if(typeof(color) == 'vector'){
|
||
var first = color[0];
|
||
if(typeof(first) == 'vector')
|
||
color = first;
|
||
}
|
||
foreach(var c; children)
|
||
c.setColor(color);
|
||
};
|
||
|
||
canvas.Map.addLayer = func(factory, type_arg=nil, priority=nil, style=nil, opts=nil, visible=1)
|
||
{
|
||
if(contains(me.layers, type_arg))
|
||
printlog("warn", "addLayer() warning: overwriting existing layer:", type_arg);
|
||
var options = opts;
|
||
# Argument handling
|
||
|
||
if (type_arg != nil) {
|
||
var layer = factory.new(type:type_arg, group:me, map:me, style:style, options:options, visible:visible);
|
||
var type = factory.get(type_arg);
|
||
var key = type_arg;
|
||
} else {
|
||
var layer = factory.new(group:me, map:me, style:style, options:options, visible:visible);
|
||
var type = factory;
|
||
var key = factory.type;
|
||
}
|
||
me.layers[type_arg] = layer;
|
||
|
||
if (priority == nil)
|
||
priority = type.df_priority;
|
||
if (priority != nil)
|
||
layer.group.setInt("z-index", priority);
|
||
|
||
return layer; # return new layer to caller() so that we can directly work with it, i.e. to register event handlers (panning/zooming)
|
||
};
|
||
|
||
# -----------------------------------------
|
||
# From FGDATA/Nasal/canvas/MapStructure.nas
|
||
# -----------------------------------------
|
||
|
||
var opt_member = func(h,k) {
|
||
if (contains(h, k)) return h[k];
|
||
if (contains(h, "parents")) {
|
||
var _=h.parents;
|
||
for (var i=0;i<size(_);i+=1){
|
||
var v = opt_member(_[i], k);
|
||
if (v != nil) return v;
|
||
}
|
||
}
|
||
return nil;
|
||
};
|
||
|
||
# Symbol
|
||
|
||
canvas.Symbol.formattedString = func(frmt, model_props){
|
||
if(me.model == nil) return frmt;
|
||
var args = [];
|
||
foreach(var prop; model_props){
|
||
if(contains(me.model, prop)){
|
||
var val = me.model[prop];
|
||
var tp = typeof(val);
|
||
if(tp != 'scalar'){
|
||
val = '';
|
||
#printlog("warn", "formattedString: invalid type for "~prop~" (" ~ tp ~ ")");
|
||
} else {
|
||
append(args, val);
|
||
}
|
||
}
|
||
}
|
||
return call(sprintf, [frmt] ~ args);
|
||
};
|
||
|
||
canvas.Symbol.getOption = func(name, default = nil){
|
||
var opt = me.options;
|
||
if(opt == nil)
|
||
opt = me.layer.options;
|
||
if(opt == nil) return default;
|
||
var val = opt_member(opt, name);
|
||
if(val == nil) return default;
|
||
return val;
|
||
};
|
||
|
||
canvas.Symbol.getStyle = func(name, default = nil){
|
||
var st = me.style;
|
||
if(st == nil)
|
||
st = me.layer.style;
|
||
if(st == nil) return default;
|
||
var val = opt_member(st, name);
|
||
if(typeof(val) == 'func'){
|
||
val = (call(val,[],me));
|
||
}
|
||
if(val == nil) return default;
|
||
return val;
|
||
};
|
||
|
||
canvas.Symbol.getLabelFromModel = func(default_val = nil){
|
||
if(me.model == nil) return default_val;
|
||
if(default_val == nil and contains(me.model, 'id'))
|
||
default_val = me.model.id;
|
||
var label_content = me.getOption('label_content');
|
||
if(label_content == nil) return default_val;
|
||
if(typeof(label_content) == 'scalar')
|
||
label_content = [label_content];
|
||
var format_s = me.getOption('label_format');
|
||
var label = '';
|
||
if(format_s == nil){
|
||
format_s = "%s";
|
||
}
|
||
return me.formattedString(format_s, label_content);
|
||
};
|
||
|
||
canvas.Symbol.callback = func(name, args...){
|
||
name = name ~'_callback';
|
||
var f = me.getOption(name);
|
||
if(typeof(f) == 'func'){
|
||
return call(f, args, me);
|
||
}
|
||
};
|
||
|
||
# DotSym
|
||
|
||
canvas.DotSym.update = func() {
|
||
if (me.controller != nil) {
|
||
if (!me.controller.update(me, me.model)) return;
|
||
elsif (!me.controller.isVisible(me.model)) {
|
||
me.element.hide();
|
||
return;
|
||
}
|
||
} else
|
||
me.element.show();
|
||
me.draw();
|
||
if(me.getOption('disable_position', 0)) return; # << CHECK FOR OPTION 'disable_position'
|
||
var pos = me.controller.getpos(me.model);
|
||
if (size(pos) == 2)
|
||
pos~=[nil]; # fall through
|
||
if (size(pos) == 3)
|
||
var (lat,lon,rotation) = pos;
|
||
else __die("DotSym.update(): bad position: "~debug.dump(pos));
|
||
# print(me.model.id, ": Position lat/lon: ", lat, "/", lon);
|
||
me.element.setGeoPosition(lat,lon);
|
||
if (rotation != nil)
|
||
me.element.setRotation(rotation);
|
||
};
|
||
|
||
# SVGSymbol
|
||
|
||
canvas.SVGSymbol.init = func() {
|
||
me.callback('init_before');
|
||
var opt_path = me.getStyle('svg_path');
|
||
if(opt_path != nil)
|
||
me.svg_path = opt_path;
|
||
if (!me.cacheable) {
|
||
if(me.svg_path != nil and me.svg_path != '')
|
||
canvas.parsesvg(me.element, me.svg_path);
|
||
# hack:
|
||
if (var scale = me.layer.style['scale_factor'])
|
||
me.element.setScale(scale);
|
||
if ((var transl = me.layer.style['translate']) != nil)
|
||
me.element.setTranslation(transl);
|
||
} else {
|
||
__die("cacheable not implemented yet!");
|
||
}
|
||
me.callback('init_after');
|
||
me.draw();
|
||
};
|
||
|
||
canvas.SVGSymbol.draw = func{
|
||
me.callback('draw');
|
||
};
|
||
|
||
# SymbolLayer
|
||
|
||
canvas.SymbolLayer._new = func(m, style, controller, options) {
|
||
# print("SymbolLayer setup options:", m.options!=nil);
|
||
m.style = default_hash(style, m.df_style);
|
||
m.options = default_hash(options, m.df_options);
|
||
|
||
if (controller == nil)
|
||
controller = m.df_controller;
|
||
assert_m(controller, "parents");
|
||
if (controller.parents[0] == SymbolLayer.Controller)
|
||
controller = controller.new(m);
|
||
assert_m(controller, "parents");
|
||
assert_m(controller.parents[0], "parents");
|
||
if (controller.parents[0].parents[0] != SymbolLayer.Controller)
|
||
__die("MultiSymbolLayer: OOP error");
|
||
if(options != nil){ # << CHECK FOR CONFIGURABLE LISTENERS
|
||
var listeners = opt_member(controller, 'listeners');
|
||
var listen = opt_member(options, 'listen');
|
||
if (listen != nil and listeners != nil){
|
||
var listen_tp = typeof(listen);
|
||
if(listen_tp != 'vector' and listen_tp != 'scalar')
|
||
__die("Options 'listen' cannot be a "~ listen_tp);
|
||
if(typeof(listen) == 'scalar')
|
||
listen = [listen];
|
||
foreach(var node_name; listen){
|
||
var node = opt_member(options, node_name);
|
||
if(node == nil)
|
||
node = node_name;
|
||
append(controller.listeners,
|
||
setlistener(node, func call(m.update,[],m),0,0));
|
||
}
|
||
}
|
||
}
|
||
m.controller = controller;
|
||
};
|
||
|
||
# LineSymbol
|
||
|
||
canvas.LineSymbol.new = func(group, layer, model, controller=nil) {
|
||
if (me == nil) __die("Need me reference for LineSymbol.new()");
|
||
if (typeof(model) != 'vector') {
|
||
if(typeof(model) == 'hash'){
|
||
if(!contains(model, 'path'))
|
||
canvas.__die("LineSymbol.new(): model hash requires path");
|
||
}
|
||
else canvas.__die("LineSymbol.new(): need a vector of points or a hash");
|
||
}
|
||
var m = {
|
||
parents: [me],
|
||
group: group,
|
||
layer: layer,
|
||
model: model,
|
||
controller: controller == nil ? me.df_controller : controller,
|
||
element: group.createChild(
|
||
"path", me.element_id
|
||
),
|
||
};
|
||
append(m.parents, m.element);
|
||
canvas.Symbol._new(m);
|
||
|
||
m.init();
|
||
return m;
|
||
};
|
||
# Non-static:
|
||
canvas.LineSymbol.draw = func() {
|
||
me.callback('draw_before');
|
||
if (!me.needs_update) return;
|
||
#printlog(_MP_dbg_lvl, "redrawing a LineSymbol "~me.layer.type);
|
||
me.element.reset();
|
||
var cmds = [];
|
||
var coords = [];
|
||
var cmd = canvas.Path.VG_MOVE_TO;
|
||
var path = me.model;
|
||
if(typeof(path) == 'hash'){
|
||
path = me.model.path;
|
||
if(path == nil)
|
||
canvas.__die("LineSymbol model requires a 'path' member (vector)");
|
||
}
|
||
foreach (var m; path) {
|
||
if(size(keys(m)) >= 2){
|
||
var (lat,lon) = me.controller.getpos(m);
|
||
append(coords,"N"~lat);
|
||
append(coords,"E"~lon);
|
||
append(cmds,cmd);
|
||
cmd = canvas.Path.VG_LINE_TO;
|
||
} else {
|
||
cmd = canvas.Path.VG_MOVE_TO;
|
||
}
|
||
}
|
||
me.element.setDataGeo(cmds, coords);
|
||
me.element.update(); # this doesn't help with flickering, it seems
|
||
me.callback('draw_after');
|
||
};
|
||
|