path: root/src/csview.vala

/*
 * Copyright 2010 Joakim Sindholt <opensource@zhasha.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * on the rights to use, copy, modify, merge, publish, distribute, sub
 * license, and/or sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE. */

using Gtk;
using Emulation;

namespace GUI
{
    /* The fantastic thing about this model is that it doesn't copy the
     * contents of the given CS, and has virtually no creation overhead. This
     * means that we can create as many as we want of them and not really waste
     * any space or CPU time. It makes the code a little cumbersome though. */
    public class CSListModel : GLib.Object, TreeModel
    {
        public enum Columns
        {
            NAME = 0,
            VALUE,
            TARGET,
            COUNT
        }

        public enum RowType
        {
            PACKET = 0,
            HEADER,
            DWORD,
            VARIANT,
            BITFIELD,
            HEADER_BITFIELD
        }

        private static string[] packet_strings = {
            "packet0",
            "packet1",
            "packet2",
            "packet3"
        };

        private static string[] packet0_headers = {
            "BASE_INDEX",
            "ONE_REG_WR",
            "COUNT",
            "TYPE"
        };

        private static string[] packet1_headers = {
            "REG_INDEX1",
            "REG_INDEX2",
            "TYPE"
        };

        private static string[] packet2_headers = {
            "TYPE"
        };

        private static string[] packet3_headers = {
            "IT_OPCODE",
            "COUNT",
            "TYPE"
        };

        private static string[][] packet_headers = {
            packet0_headers,
            packet1_headers,
            packet2_headers,
            packet3_headers
        };

        private static uint[] packet_headers_length = { 4, 3, 1, 3 };

        public class CSIter
        {
            private TreeIter *m_iter;

            public CSIter(TreeIter? iter)
            {
                assert(iter != null);
                m_iter = (TreeIter *)iter;
            }

            /* TreeIters contain 3 void* fields, which means we can partition
             * them into enough space to store our CS stuff. We need:
             *  iter.user_data                   iter.user_data2                  iter.user_data3
             * |--------------------------------|--------------------------------|--------------------------------|
             *  |------------|x|-------------|x| -------------|x|---|
             *  packet (14)   DWORD (15)      Va riant (15)    Bitfield (5)
             * 14 + 1 + 15 + 1 + 15 + 1 + 5 = 52
             * Meaning we need 50 bits (and this will never run on something below 32bit addrs)
             * X denotes a boolean to indicate whether or not a level is reached
             *
             * Packets [0;13]:
             *  We can have a max of 64KB in DWORDs, which equals 16384. We have a min index of 0 and a max of 16383.
             * DWORDs [15;29]:
             *  Same limits as packets. However we have a header DWORD too so we need an extra bit.
             * Variant [31;45]:
             *  Sometimes we need to display variations when we don't know with certainty what the register points to.
             *  We can have a ton of different variations, but we assume 15 bits is enough.
             * Bitfields [47;51]:
             *  Each DWORD has a max of 32 bitfields, and a minimum of 1, so we need 5 bits.
             */

            /* we really never want to handle values larger than 32 bit */
            private inline uint32 get_iter_bits(uint low, uint high)
            {
                /* For now, we utilize assume only 32 bits per pointer and we
                 * need no more. We also don't need more than 64 bits, so ease
                 * up the whole ordeal */
                uint64 num = (uint64)(*((uint32*)(&m_iter->user_data))) |
                            ((uint64)(*((uint32*)(&m_iter->user_data2))) << 32);
                //stdout.printf("get_iter_bits(%u, %u) = %u (%016llX)\n", low, high, (uint32)((num >> low) & (((uint64)1 << (high-low+1))-1)), num);
                return (uint32)((num >> low) & (((uint64)1 << (high-low+1))-1));
            }

            private inline void set_iter_bits(uint low, uint high, uint32 val)
            {
                uint64 num = (uint64)(*((uint32*)(&m_iter->user_data))) |
                            ((uint64)(*((uint32*)(&m_iter->user_data2))) << 32);

                uint64 mask = (((uint64)1 << (high-low+1))-1) << low;
                num &= ~mask;
                num |= ((uint64)val << low) & mask;

                uint32 num32[2];
                num32[0] = (uint32)num;
                num32[1] = (uint32)(num >> 32);
                m_iter->user_data  = *((void**)(&num32[0]));
                m_iter->user_data2 = *((void**)(&num32[1]));
                //stdout.printf("setting [%u;%u] = %u | got %u @ %016llX\n", low, high, val, get_iter_bits(low, high), mask);
            }

            public uint32 packet {
                get { return get_iter_bits(0, 13); }
                set { set_iter_bits(0, 13, value); }
            }
            public uint32 dword {
                get { return get_iter_bits(15, 29); }
                set { set_iter_bits(15, 29, value); }
            }
            public uint32 variant {
                get { return get_iter_bits(31, 45); }
                set { set_iter_bits(31, 45, value); }
            }
            public uint32 bitfield {
                get { return get_iter_bits(47, 51); }
                set { set_iter_bits(47, 51, value); }
            }

            public bool in_dwords {
                get { return (get_iter_bits(14, 14) == 1) ? true : false; }
                set { set_iter_bits(14, 14, value ? 1 : 0); }
            }
            public bool in_variants {
                get { return (get_iter_bits(30, 30) == 1) ? true : false; }
                set { set_iter_bits(30, 30, value ? 1 : 0); }
            }
            public bool in_bitfields {
                get { return (get_iter_bits(46, 46) == 1) ? true : false; }
                set { set_iter_bits(46, 46, value ? 1 : 0); }
            }
            public bool is_header {
                get { return dword == 0 && in_dwords; }
            }

            public RowType row_type {
                get {
                    if (in_bitfields) {
                        return is_header ? RowType.HEADER_BITFIELD : RowType.BITFIELD;
                    } else if (in_variants) {
                        return RowType.VARIANT;
                    } else if (in_dwords) {
                        return is_header ? RowType.HEADER : RowType.DWORD;
                    }

                    return RowType.PACKET;
                }
            }

            public void reset()
            {
                set_iter_bits(0, 31, 0);
                set_iter_bits(32, 51, 0);
            }

            public void copy(CSIter it)
            {
                set_iter_bits(0, 31, it.get_iter_bits(0, 31));
                set_iter_bits(32, 51, it.get_iter_bits(32, 51));
            }
        }

        private CS m_cs;
        private Spec m_spec;
        private int m_stamp;

        public CSListModel(CS cs, Spec spec)
        {
            m_cs = cs;
            m_spec = spec;
            m_stamp = 19449216;
        }

        public TreeModelFlags get_flags()
        {
            return TreeModelFlags.ITERS_PERSIST;
        }

        public int get_n_columns()
        {
            return Columns.COUNT;
        }

        public Type get_column_type(int i)
        {
            return typeof(string);
        }

        private uint get_variant_count(uint32 addr)
        {
            var regs = m_spec.translate_addr((uint)addr);
            return regs == null ? 0 : regs.length;
        }
        private uint get_bitfield_count(uint32 addr, uint variant)
        {
            var regs = m_spec.translate_addr((uint)addr);
            assert(regs != null);
            assert(variant < regs.length);
            return (regs[variant].info.length == 0) ? 1 : regs[variant].info.length;
        }

        public bool get_iter(out TreeIter iter, TreePath path)
        {
            var depth = path.get_depth();
            assert(depth <= 4 && depth >= 1);

            CSIter it = new CSIter(iter);
            it.reset();

            int *indices = path.get_indices();
            if (indices[0] >= m_cs.length || indices[0] < 0) { return false; }
            it.packet = indices[0];

            if (depth >= 2) {
                if (indices[1] > m_cs[it.packet].length || indices[1] < 0) { return false; }
                it.dword = indices[1];
                it.in_dwords = true;
            }

            if (depth >= 3) {
                if (indices[2] < 0) { return false; }
                if (it.dword == 0) {
                    /* Header bitfield */
                    if (indices[2] >= packet_headers_length[m_cs[it.packet].type_id]) { return false; }
                    if (depth > 3) { return false; }
                    it.bitfield = indices[2];
                    it.in_bitfields = true;
                } else {
                    /* Variant */
                    uint32 addr = 0;
                    switch (m_cs[it.packet].type_id) {
                        case 0:
                            Packet0 p0 = m_cs[it.packet] as Packet0;
                            addr = p0.addr;
                            break;

                        case 1:
                            Packet1 p1 = m_cs[it.packet] as Packet1;
                            addr = (it.dword == 1) ? p1.addr1 : p1.addr2; // 0 = header
                            break;

                        case 2:
                            return false;

                        case 3: /* TODO */
                            return false;
                    }

                    if (indices[2] < 0) { return false; }
                    if (indices[2] >= get_variant_count(addr)) { return false; }
                    it.variant = indices[2];
                    it.in_variants = true;

                    if (depth == 4) {
                        if (indices[3] < 0) { return false; }
                        if (indices[3] >= get_bitfield_count(addr, it.variant)) { return false; }
                        it.bitfield = indices[3];
                        it.in_bitfields = true;
                    }
                }
            }

            iter.stamp = m_stamp;
            return true;
        }

        public TreePath get_path(TreeIter iter)
        {
            var path = new TreePath();
            CSIter it = new CSIter(iter);

            path.append_index((int)it.packet);
            if (it.in_dwords) { path.append_index((int)it.dword); }
            if (it.in_bitfields) {
                if (it.in_variants) { path.append_index((int)it.variant); }
                path.append_index((int)it.bitfield);
            }

            return path;
        }

        private string translate_addr(uint32 addr)
        {
            if (addr == 0) { return ""; }

            var regs = m_spec.translate_addr((uint)addr);
            if (regs == null) {
                return addr.to_string("0x%04X");
            } else if (regs.length > 1) {
                return "Multiple";
            } else if (regs[0].info.count <= 1) {
                return regs[0].info.name;
            }

            return regs[0].info.name + "[" + regs[0].num.to_string() + "]";
        }

        private weak string variant_name(uint32 addr, uint variant)
        {
            var regs = m_spec.translate_addr((uint)addr);
            assert(regs != null);
            assert(variant < regs.length);
            return regs[variant].info.name;
        }

        private weak string bitfield_name(uint32 addr, uint variant, uint bitfield)
        {
            var regs = m_spec.translate_addr((uint)addr);
            assert(regs != null);
            assert(variant < regs.length);
            if (regs[variant].info.length > 0) {
                assert(bitfield < regs[variant].info.length);
                return regs[variant].info[bitfield].name;
            }
            return "DATA_REGISTER";
        }

        private uint32 bitfield_value(uint32 addr, uint variant, uint bitfield, uint32 dword)
        {
            var regs = m_spec.translate_addr((uint)addr);
            assert(regs != null);
            assert(variant < regs.length);
            uint high = 31, low = 0;
            if (regs[variant].info.length > 0) {
                assert(bitfield < regs[variant].info.length);
                high = regs[variant].info[bitfield].high;
                low = regs[variant].info[bitfield].low;
            }
            return (dword >> low) & ((1 << (high-low+1))-1);
        }

        public void get_value(TreeIter iter, int column, out Value val)
        {
            if (iter.stamp != m_stamp) { return; }
            CSIter it = new CSIter(iter);
            Packet p = m_cs[it.packet];
            val.init(typeof(string));

            switch (it.row_type) {
                case RowType.PACKET:
                    switch (column) {
                        case Columns.NAME: val.set_static_string(packet_strings[p.type_id]); break;
                        case Columns.VALUE: val.set_string(p.header.to_string("0x%08X")); break;
                        case Columns.TARGET:
                            switch (p.type_id) {
                                case 0: val.set_string(translate_addr(p.target_addr(0))); break;
                                case 1: val.set_string(translate_addr(p.target_addr(0)) + " | " + translate_addr(p.target_addr(1))); break;
                                case 2: val.set_static_string(""); break;
                                case 3: val.set_string((p as Packet3).opcode_name); break;
                            }
                            break;
                    }
                    break;

                case RowType.DWORD:
                    switch (column) {
                        case Columns.NAME: val.set_string((it.dword-1).to_string("DWORD%u")); break;
                        case Columns.VALUE: val.set_string(p[it.dword-1].to_string("0x%08X")); break;
                        case Columns.TARGET: val.set_string(translate_addr(p.target_addr(it.dword-1))); break;
                    }
                    break;

                case RowType.HEADER:
                    switch (column) {
                        case Columns.NAME: val.set_static_string("HEADER"); break;
                        case Columns.VALUE: val.set_string(p.header.to_string("0x%08X")); break;
                        case Columns.TARGET: val.set_static_string(""); break;
                    }
                    break;

                case RowType.VARIANT:
                    switch (column) {
                        case Columns.NAME: val.set_static_string(variant_name(p.target_addr(it.dword-1), it.variant)); break;
                        case Columns.VALUE: val.set_static_string(""); break;
                        case Columns.TARGET: val.set_static_string(""); break;
                    }
                    break;

                case RowType.BITFIELD:
                    switch (column) {
                        case Columns.NAME: val.set_static_string(bitfield_name(p.target_addr(it.dword-1), it.variant, it.bitfield)); break;
                        case Columns.VALUE: val.set_string(bitfield_value(p.target_addr(it.dword-1), it.variant, it.bitfield, p[it.dword-1]).to_string()); break;
                        case Columns.TARGET: val.set_static_string(""); break;
                    }
                    break;

                case RowType.HEADER_BITFIELD:
                    switch (column) {
                        case Columns.NAME: val.set_static_string(packet_headers[p.type_id][it.bitfield]); break;
                        case Columns.TARGET: val.set_static_string(""); break;
                        case Columns.VALUE:
                            switch (p.type_id) {
                                case 0:
                                    Packet0 p0 = p as Packet0;
                                    switch (it.bitfield) {
                                        case 0: val.set_string(p0._ADDR.to_string("%04X")); break;
                                        case 1: val.set_string(p0._ONE_REG_WR.to_string()); break;
                                        case 2: val.set_string(p0._COUNT.to_string()); break;
                                        case 3: val.set_string(p.type_id.to_string()); break;
                                    }
                                    break;
                                case 1:
                                    Packet1 p1 = p as Packet1;
                                    switch (it.bitfield) {
                                        case 0: val.set_string(p1._ADDR1.to_string("%04X")); break;
                                        case 1: val.set_string(p1._ADDR2.to_string("%04X")); break;
                                        case 2: val.set_string(p.type_id.to_string()); break;
                                    }
                                    break;
                                case 2:
                                    switch (it.bitfield) {
                                        case 0: val.set_string(p.type_id.to_string()); break;
                                    }
                                    break;
                                case 3:
                                    Packet3 p3 = p as Packet3;
                                    switch (it.bitfield) {
                                        case 0: val.set_string(p3._IT_OPCODE.to_string("0x%02X")); break;
                                        case 1: val.set_string(p3._COUNT.to_string()); break;
                                        case 2: val.set_string(p.type_id.to_string()); break;
                                    }
                                    break;
                            }
                            break;
                    }
                    break;
            }
        }

        public bool iter_next(ref TreeIter iter)
        {
            if (iter.stamp != m_stamp) { return false; }
            iter.stamp = 0;

            CSIter it = new CSIter(iter);
            var p = it.packet;
            switch (it.row_type) {
                case RowType.PACKET:
                    p++;
                    if (p >= m_cs.length) { return false; }
                    it.packet = p;
                    break;

                case RowType.HEADER:
                case RowType.DWORD:
                    var d = it.dword+1;
                    if (d >= m_cs[p].length+1) { return false; }
                    it.dword = d;
                    break;

                case RowType.VARIANT:
                    var v = it.variant+1;
                    if (v >= get_variant_count(m_cs[p].target_addr(it.dword-1))) { return false; }
                    it.variant = v;
                    break;

                case RowType.BITFIELD:
                    var b = it.bitfield+1;
                    if (b >= get_bitfield_count(m_cs[p].target_addr(it.dword-1), it.variant)) { return false; }
                    it.bitfield = b;
                    break;

                case RowType.HEADER_BITFIELD:
                    var b = it.bitfield+1;
                    if (b >= packet_headers_length[m_cs[p].type_id]) { return false; }
                    it.bitfield = b;
                    break;
            }

            iter.stamp = m_stamp;
            return true;
        }

        public bool iter_children(out TreeIter iter, TreeIter? parent)
        {
            CSIter it = new CSIter(iter);
            iter.stamp = 0;

            if (parent == null) {
                if (m_cs.length == 0) {
                    return false;
                }
                it.reset();
                iter.stamp = m_stamp;
                return true;
            }
            if (parent.stamp != m_stamp) { return false; }

            CSIter pa = new CSIter(parent);
            it.copy(pa);
            switch (pa.row_type) {
                case RowType.PACKET:
                    it.dword = 0;
                    it.in_dwords = true;
                    break;

                case RowType.VARIANT:
                case RowType.HEADER:
                    it.bitfield = 0;
                    it.in_bitfields = true;
                    break;

                case RowType.DWORD:
                    if (get_variant_count(m_cs[pa.packet].target_addr(pa.dword-1)) == 0) { return false; }
                    it.variant = 0;
                    it.in_variants = true;
                    break;

                case RowType.BITFIELD:
                case RowType.HEADER_BITFIELD:
                default:
                    return false;
            }

            iter.stamp = m_stamp;
            return true;
        }

        public bool iter_has_child(TreeIter iter)
        {
            if (iter.stamp != m_stamp) { return false; }
            CSIter it = new CSIter(iter);
            switch (it.row_type) {
                case RowType.PACKET: return true;
                case RowType.HEADER: return true;
                case RowType.DWORD: return (get_variant_count(m_cs[it.packet].target_addr(it.dword-1)) == 0) ? false : true;
                case RowType.VARIANT: return true;
                case RowType.BITFIELD: return false;
                case RowType.HEADER_BITFIELD: return false;
            }

            return false;
        }

        public int iter_n_children(TreeIter? iter)
        {
            if (iter == null) { return (int)m_cs.length; }

            if (iter.stamp != m_stamp) { return 0; }
            CSIter it = new CSIter(iter);
            switch (it.row_type) {
                case RowType.PACKET: return (int)m_cs[it.packet].length+1;
                case RowType.HEADER: return (int)packet_headers_length[m_cs[it.packet].type_id];
                case RowType.DWORD: return (int)get_variant_count(m_cs[it.packet].target_addr(it.dword-1));
                case RowType.VARIANT: return (int)get_bitfield_count(m_cs[it.packet].target_addr(it.dword-1), it.variant);
                case RowType.BITFIELD: return 0;
                case RowType.HEADER_BITFIELD: return 0;
            }

            return 0;
        }

        public bool iter_nth_child(out TreeIter iter, TreeIter? parent, int n)
        {
            CSIter it = new CSIter(iter);
            iter.stamp = 0;

            if (parent == null) {
                if (n >= m_cs.length || n < 0) {
                    return false;
                }
                iter.stamp = m_stamp;
                it.reset();
                it.packet = n;
                return true;
            }
            if (parent.stamp != m_stamp) { return false; }
            if (n < 0) { return false; }

            CSIter pa = new CSIter(parent);
            it.copy(pa);
            switch (pa.row_type) {
                case RowType.PACKET:
                    if (n > m_cs[pa.packet].length) { return false; }
                    it.in_dwords = true;
                    it.dword = n;
                    break;

                case RowType.HEADER:
                    if (n >= packet_headers_length[m_cs[pa.packet].type_id]) { return false; }
                    it.in_bitfields = true;
                    it.bitfield = n;
                    break;

                case RowType.DWORD:
                    if (n >= get_variant_count(m_cs[pa.packet].target_addr(pa.dword-1))) { return false; }
                    it.in_variants = true;
                    it.variant = n;
                    break;

                case RowType.VARIANT:
                    if (n >= get_bitfield_count(m_cs[pa.packet].target_addr(pa.dword-1), pa.variant)) { return false; }
                    it.in_bitfields = true;
                    it.bitfield = n;
                    break;

                case RowType.BITFIELD:
                case RowType.HEADER_BITFIELD:
                default:
                    return false;
            }

            iter.stamp = m_stamp;
            return true;
        }

        public bool iter_parent(out TreeIter iter, TreeIter child)
        {
            iter.stamp = 0;
            if (child.stamp != m_stamp) { return false; }

            CSIter it = new CSIter(iter);
            CSIter ch = new CSIter(child);
            it.copy(ch);
            if (ch.in_bitfields) {
                it.in_bitfields = false;
            } else if (ch.in_variants) {
                it.in_variants = false;
            } else if (ch.in_dwords) {
                it.in_dwords = false;
            } else {
                return false;
            }

            iter.stamp = m_stamp;
            return true;
        }

        public void ref_node(TreeIter iter) { return; }
        public void unref_node(TreeIter iter) { return; }
    }

    public class CSView : Window
    {
        private static string xml_ui = """
        <?xml version="1.0"?>
        <interface>
          <requires lib="gtk+" version="2.16"/>
          <!-- interface-naming-policy project-wide -->
          <object class="GtkVBox" id="mainbox">
            <property name="visible">True</property>
            <property name="orientation">vertical</property>
            <property name="spacing">4</property>
            <child>
              <object class="GtkHBox" id="chips_box">
                <property name="visible">True</property>
                <property name="spacing">4</property>
                <child>
                  <object class="GtkLabel" id="label1">
                    <property name="visible">True</property>
                    <property name="label" translatable="yes">&lt;b&gt;Chip&lt;/b&gt;</property>
                    <property name="use_markup">True</property>
                  </object>
                  <packing>
                    <property name="expand">False</property>
                    <property name="position">0</property>
                  </packing>
                </child>
              </object>
              <packing>
                <property name="expand">False</property>
                <property name="position">0</property>
              </packing>
            </child>
            <child>
              <object class="GtkHBox" id="hbox2">
                <property name="visible">True</property>
                <property name="spacing">4</property>
                <child>
                  <object class="GtkScrolledWindow" id="scrolledwindow1">
                    <property name="visible">True</property>
                    <property name="can_focus">True</property>
                    <property name="hscrollbar_policy">automatic</property>
                    <property name="vscrollbar_policy">automatic</property>
                    <property name="shadow_type">etched-in</property>
                    <child>
                      <object class="GtkTreeView" id="packet_tree">
                        <property name="visible">True</property>
                        <property name="can_focus">True</property>
                      </object>
                    </child>
                  </object>
                  <packing>
                    <property name="position">0</property>
                  </packing>
                </child>
                <child>
                  <object class="GtkVBox" id="vbox2">
                    <property name="visible">True</property>
                    <property name="orientation">vertical</property>
                    <child>
                      <object class="GtkButton" id="up_button">
                        <property name="visible">True</property>
                        <property name="can_focus">True</property>
                        <property name="receives_default">True</property>
                        <child>
                          <object class="GtkImage" id="image2">
                            <property name="visible">True</property>
                            <property name="stock">gtk-go-up</property>
                          </object>
                        </child>
                      </object>
                      <packing>
                        <property name="expand">False</property>
                        <property name="position">0</property>
                      </packing>
                    </child>
                    <child>
                      <object class="GtkButton" id="down_button">
                        <property name="visible">True</property>
                        <property name="can_focus">True</property>
                        <property name="receives_default">True</property>
                        <child>
                          <object class="GtkImage" id="image1">
                            <property name="visible">True</property>
                            <property name="stock">gtk-go-down</property>
                          </object>
                        </child>
                      </object>
                      <packing>
                        <property name="expand">False</property>
                        <property name="pack_type">end</property>
                        <property name="position">1</property>
                      </packing>
                    </child>
                  </object>
                  <packing>
                    <property name="expand">False</property>
                    <property name="position">1</property>
                  </packing>
                </child>
              </object>
              <packing>
                <property name="position">1</property>
              </packing>
            </child>
          </object>
        </interface>
        """;

        //private CS m_cs;
        private Button up_btn;
        private Button down_btn;
        private CSListModel[] models;
        private TreeView cs_view;
        //private uint m_pos;

        public CSView(CS cs)
        {
            //m_cs = cs;
            //m_pos = 0;

            var builder = new Builder();
            try {
                builder.add_from_string(xml_ui, xml_ui.length);
            } catch (Error e) {
                stderr.printf("Unable to construct cs viewer: %s\n", e.message);
                return;
            }
            title = "Viewing CS";
            border_width = 10;
            set_default_size(640, 480);

            /* can't make a ComboBox.text with GtkBuilder to my knowledge */
            models = new CSListModel[specs.length];
            var chips = new ComboBox.text();
            for (uint i = 0; i < specs.length; i++) {
                chips.append_text(specs[i].name);
                models[i] = new CSListModel(cs, specs[i].spec);
            }
            chips.set_active((int)spec_default);
            chips.changed.connect((combo) => { cs_view.set_model(models[combo.get_active()]); });

            var chips_box = builder.get_object("chips_box") as HBox;
            chips_box.pack_start(chips, false, false, 0);

            /* populate tree view */
            cs_view = builder.get_object("packet_tree") as TreeView;
            cs_view.set_model(models[spec_default]);
            //cs_view.insert_column_with_data_func(-1, "", new CellRendererPixbuf(), current_dword_renderer);
            cs_view.insert_column(new TreeViewColumn.with_attributes("Name", new CellRendererText(), "text", CSListModel.Columns.NAME, null), -1);
            cs_view.insert_column(new TreeViewColumn.with_attributes("Value", new CellRendererText(), "text", CSListModel.Columns.VALUE, null), -1);
            cs_view.insert_column(new TreeViewColumn.with_attributes("Target", new CellRendererText(), "text", CSListModel.Columns.TARGET, null), -1);

            up_btn = builder.get_object("up_button") as Button;
            down_btn = builder.get_object("down_button") as Button;

            add(builder.get_object("mainbox") as Widget);
        }

        /*private void current_dword_renderer(TreeViewColumn tree_column, CellRenderer cell, TreeModel model, TreeIter iter)
        {
            if (m_pos == (model as CSListModel).get_packet_num(iter)) {
                (cell as Gtk.CellRendererPixbuf).stock_id = "gtk-media-record";
            } else {
                (cell as Gtk.CellRendererPixbuf).stock_id = "";
            }
        }*/
    }
}