# vim: set foldmethod=marker foldmarker={{{,}}} :

var TcasItemClass = {

# get data from AI and multiplayers {{{

    new : func(canvasGroup, index) {

        var m = {parents : [TcasItemClass]};

        m._group = canvasGroup.createChild("group", "TcasItem_" ~ index);

        canvas.parsesvg(m._group, data.zkv1000_reldir ~ "Models/tcas.svg");

        m._can = {

            Alt : m._group.getElementById("Alt_above").setVisible(0),

            Arrow : [

                m._group.getElementById("Arrow_climb").setVisible(0),

                m._group.getElementById("Arrow_descent").setVisible(0)

            ],

            Callsign: m._group.getElementById("Callsign").setVisible(0),

            ThreadLevel: [],

        };

        for (var i=0; i<4; i+=1)

            append(m._can.ThreadLevel,

                    m._group.getElementById("Thread_Level_" ~ i).setVisible(0));

        m._colors = [ '#00ffff', '#00ffff', '#ff7f2a', '#ff0000' ];

        return m;

    },

    setData : func(lat, lon, alt, vs, level, callsign, orientation) {

        me._group.setVisible(1);

        me._group.setGeoPosition(lat, lon);

        if (alt and level)

            me._can.Alt

                .setText(sprintf("%+i", alt))

                .set('fill', me._colors[level])

                .setRotation(orientation)

                .setVisible(1);

        else

            me._can.Alt.setVisible(0);

        if (abs(vs) > 50 and level > 1) {

            me._can.Arrow[vs < 0]

                .set('fill', me._colors[level])

                .set('stroke', me._colors[level])

                .setRotation(orientation)

                .setVisible(1);

            me._can.Arrow[vs > 0].setVisible(0);

        }

        else {

            me._can.Arrow[0].setVisible(0);

            me._can.Arrow[1].setVisible(0);

        }

        for (var i = 0; i < 4; i += 1)

            me._can.ThreadLevel[i]

                .setRotation(orientation)

                .setVisible(level == i);

        me._can.Callsign

            .setText(callsign)

            .set('fill', me._colors[level])

            .setRotation(orientation)

            .setVisible(1);

    },

};

# }}} 

var MapTcas = {

# init TCAS layer and update {{{

    new : func(device, group) {

        var m = {parents:[MapTcas]}; 

        m.device = device;

        m.visibility = 0;

        m.group = group.createChild('map', 'tcas')

            .setTranslation(

                m.device.role == 'MFD' ? (m.device.data.mapview[0] + m.device.data.mapclip.left)/2 : 120,

                m.device.role == 'MFD' ? 400 : 600)

            .setVisible(m.visibility);

        m._item      = [];

        m._itemIndex = 0;

        m._itemCount = 0;

        return m;

    },

    off: func {

        me.setVisible(0);

    },

    update : func() {

        if (me.group.getVisible() == 0)

            return;

        me.group._node.getNode('ref-lat', 1).setDoubleValue(data.lat);

        me.group._node.getNode('ref-lon', 1).setDoubleValue(data.lon);

        me.group.setRange(me.device.data['range-nm']/2);

        me._itemIndex = 0;

        var normOrientation = -me.device.data.orientation.map * D2R;

        foreach (var ac; data.tcas) {

            if (me._itemIndex >= me._itemCount) {

                append(me._item, TcasItemClass.new(me.group, me._itemIndex));

                me._itemCount += 1;

            }

            me._item[me._itemIndex].setData(ac.lat, ac.lon, ac.alt, ac.vs, ac.level, ac.callsign, normOrientation);

            me._itemIndex += 1;

        }

        for (; me._itemIndex < me._itemCount; me._itemIndex += 1) {

            me._item[me._itemIndex]._group.setVisible(0);

        }

    },

    setVisible : func (v) {

        me.group.setVisible(v);

    },

};

# }}}