It's something tricky what you need. Here is an example that should solve your problem. It's developed in old Odoo API style. Enjoy it, maybe it's not exactly what you need or need a minor tweaks or validation but it's pretty complete

The models for the example:

from openerp.osv import fields, osv
import json

from openerp import api
from openerp.models import onchange_v7


class xform(osv.osv):
    _name = 'xform'
    _columns = {
        'name': fields.char('Name', size=64),
        'xstate': fields.text('XState'),
        'xmany_ids': fields.one2many('xmany', 'xform_id', string='Xmany'),
    }
    _defaults = {
        'xstate': '{}'
    }

    def update_state(self, xform):
        xstate = {}
        for line in xform.xmany_ids:
            xstate[line.id] = line.xvalue
        osv.osv.write(xform, {'xstate': json.dumps(xstate)})
        
    @api.model
    @api.returns('self', lambda value:value.id)
    def create(self, vals):
        xform = osv.osv.create(self, vals)
        self.update_state(xform)
        return xform
    
    @api.multi
    def write(self, vals):
        res = osv.osv.write(self, vals)
        self.update_state(self)
        return res
    
    def onchange_many_lines(self, cr, uid, ids, xmany_ids, xstate, **kwargs):
        #to save the state of modified fields to latter could detect new changes
        xstate = json.loads(xstate)
        lines = []
        xlast = False
        #for identify non saved lines
        index = 0
        
        for xline in xmany_ids:
            if not xlast:
                #detecting the actual modified line
                if xline[0] in (0,1) and xline[2].get('xvalue', False):
                    if (xline[0] == 0 and xstate.get('new-%s'%index,False) != xline[2].get('xvalue')) or \
                            (xline[0] == 1 and xstate.get(str(xline[1]),False) != xline[2].get('xvalue')):
                        xlast = xline[2].get('xvalue')
                    if xline[0] == 0:
                        xstate['new-%s'%index] = xline[2]['xvalue']
                    if xline[0] == 1:
                        xstate[str(xline[1])] = xline[2]['xvalue']
                lines.append(xline)
            else:
                #not a deleted line
                if xline[0] != 2:
                    xlast+=1
                else:
                    lines.append(xline)
                #new line not saved yet
                if xline[0] == 0:
                    data = {'xvalue': xlast}
                    if xline[2].get('name', False):
                        data.update({'name': xline[2]['name']})
                    lines.append((0, 0, data))
                    xstate['new-%s'%index] = xlast
                #existing lines, 1: modified line and 4: linked line to an existing record
                elif xline[0] in (1,4):
                    data = {'xvalue': xlast}
                    if xline[0] == 1 and xline[2].get('name', False):
                        data.update({'name': xline[2]['name']})
                    lines.append((1, xline[1], data))
                    xstate[str(xline[1])] = xlast
            index+=1
        if not xlast:
            return {}
        return {'value': {'xstate': json.dumps(xstate), 'xmany_ids': lines}}
    
    @api.multi
    def onchange(self, values, field_name, field_onchange):
        match = onchange_v7.match(field_onchange[field_name])
        if match:
            method, params = match.groups()

            # evaluate params -> tuple
            global_vars = {'context': self._context, 'uid': self._uid}
            if self._context.get('field_parent'):
                class RawRecord(object):
                    def __init__(self, record):
                        self._record = record
                    def __getattr__(self, name):
                        field = self._record._fields[name]
                        value = self._record[name]
                        return field.convert_to_onchange(value)
                record = self[self._context['field_parent']]
                global_vars['parent'] = RawRecord(record)
            params = eval("[%s]" % params, global_vars, values)

            # call onchange method with context when possible
            args = (self._cr, self._uid, self._ids) + tuple(params)
            
            try:
                method_res = getattr(self._model, method)(*args, context=self._context)
            except TypeError:
                method_res = getattr(self._model, method)(*args)
            
            return method_res
        super(xform,self).onchange(values, field_name, field_onchange)
    
xform()

class xmany(osv.osv):
    _name = 'xmany'
    _columns = {
        'name': fields.char('Name', size=64),
        'xvalue': fields.integer('XValue'),
        'xform_id': fields.many2one('xform', string='XForm'),
    }
xmany()

in the view for the model xform:

        <record model="ir.ui.view" id="solt_xform_form_view">
            <field name="name">xform</field>
            <field name="model">xform</field>
            <field name="arch" type="xml">
                <form string="XFORM">
                    <field name="name"/>
                    <field name="xstate" invisible="1"/>
                    <field name="xmany_ids" on_change="onchange_many_lines(xmany_ids, xstate)">
                        <tree editable="bottom">
                            <field name="xvalue"/>
                            <field name="name"/>
                        </tree>
                    </field>
                </form>
            </field>
        </record>

        <record id="solt_xform_action" model="ir.actions.act_window">
            <field name="name">XFORM</field>
            <field name="res_model">xform</field>
            <field name="view_type">form</field>
            <field name="view_mode">tree,form</field>
        </record>
        
        <menuitem name="Many Tests" id="solt_many_menu" parent="base.menu_administration" sequence="5"/>
        <menuitem name="XFORM" id="solt_xform_submenu" parent="solt_many_menu" action="solt_xform_action" sequence="3"/>