NLA SoC: Merge from 2.5 - 21146 to 21178

diff --cc release/ui/buttons_data_modifier.py
index 5635529d90eff5742aea070fab7e5d7aa1e0a8ce,366f2b8a86b10ae9b3d33853df3cc04b23ed2e1b..9d24cd2d5346a80b09e17575981f934e77505fd5
--- 1/release/ui/buttons_data_modifier.py
--- 2/release/ui/buttons_data_modifier.py
+++ b/release/ui/buttons_data_modifier.py
@@@ -19,72 -19,72 +19,72 @@@ class DATA_PT_modifiers(DataButtonsPane
                row.itemL();
  
                for md in ob.modifiers:
 -                      box = layout.template_modifier(md)
 +                      box = layout.template_modifier(context, md)
  
 -                      if box:
 +                      if md.expanded:
                                if md.type == 'ARMATURE':
-                                       self.armature(box, md)
+                                       self.armature(box, ob, md)
                                if md.type == 'ARRAY':
-                                       self.array(box, md)
+                                       self.array(box, ob, md)
                                if md.type == 'BEVEL':
-                                       self.bevel(box, md)
+                                       self.bevel(box, ob, md)
                                if md.type == 'BOOLEAN':
-                                       self.boolean(box, md)
+                                       self.boolean(box, ob, md)
                                if md.type == 'BUILD':
-                                       self.build(box, md)
+                                       self.build(box, ob, md)
                                if md.type == 'CAST':
-                                       self.cast(box, md)
+                                       self.cast(box, ob, md)
                                if md.type == 'CLOTH':
-                                       self.cloth(box, md)
+                                       self.cloth(box, ob, md)
                                if md.type == 'COLLISION':
-                                       self.collision(box, md)
+                                       self.collision(box, ob, md)
                                if md.type == 'CURVE':
-                                       self.curve(box, md)
+                                       self.curve(box, ob, md)
                                if md.type == 'DECIMATE':
-                                       self.decimate(box, md)
+                                       self.decimate(box, ob, md)
                                if md.type == 'DISPLACE':
-                                       self.displace(box, md)
+                                       self.displace(box, ob, md)
                                if md.type == 'EDGE_SPLIT':
-                                       self.edgesplit(box, md)
+                                       self.edgesplit(box, ob, md)
                                if md.type == 'EXPLODE':
-                                       self.explode(box, md)
+                                       self.explode(box, ob, md)
                                if md.type == 'FLUID_SIMULATION':
-                                       self.fluid(box, md)
+                                       self.fluid(box, ob, md)
                                if md.type == 'HOOK':
-                                       self.hook(box, md)
+                                       self.hook(box, ob, md)
                                if md.type == 'LATTICE':
-                                       self.lattice(box, md)
+                                       self.lattice(box, ob, md)
                                if md.type == 'MASK':
-                                       self.mask(box, md)
+                                       self.mask(box, ob, md)
                                if md.type == 'MESH_DEFORM':
-                                       self.mesh_deform(box, md)
+                                       self.mesh_deform(box, ob, md)
                                if md.type == 'MIRROR':
-                                       self.mirror(box, md)
+                                       self.mirror(box, ob, md)
                                if md.type == 'MULTIRES':
-                                       self.multires(box, md)
+                                       self.multires(box, ob, md)
                                if md.type == 'PARTICLE_INSTANCE':
-                                       self.particleinstance(box, md)
+                                       self.particleinstance(box, ob, md)
                                if md.type == 'PARTICLE_SYSTEM':
-                                       self.particlesystem(box, md)
+                                       self.particlesystem(box, ob, md)
                                if md.type == 'SHRINKWRAP':
-                                       self.shrinkwrap(box, md)
+                                       self.shrinkwrap(box, ob, md)
                                if md.type == 'SIMPLE_DEFORM':
-                                       self.simpledeform(box, md)
+                                       self.simpledeform(box, ob, md)
                                if md.type == 'SMOOTH':
-                                       self.smooth(box, md)
+                                       self.smooth(box, ob, md)
                                if md.type == 'SOFTBODY':
-                                       self.softbody(box, md)
+                                       self.softbody(box, ob, md)
                                if md.type == 'SUBSURF':
-                                       self.subsurf(box, md)
+                                       self.subsurf(box, ob, md)
                                if md.type == 'UV_PROJECT':
-                                       self.uvproject(box, md)
+                                       self.uvproject(box, ob, md)
                                if md.type == 'WAVE':
-                                       self.wave(box, md)
+                                       self.wave(box, ob, md)
                                                        
-       def armature(self, layout, md):
+       def armature(self, layout, ob, md):
                layout.itemR(md, "object")
                row = layout.row()
-               row.itemR(md, "vertex_group")
+               row.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                row.itemR(md, "invert")
                flow = layout.column_flow()
                flow.itemR(md, "use_vertex_groups", text="Vertex Groups")
@@@ -184,21 -184,21 +184,21 @@@
                col.itemR(md, "factor")
                col.itemR(md, "radius")
                col.itemR(md, "size")
-               layout.itemR(md, "vertex_group")
+               layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                #Missing: "OB" and "From Radius"
                
-       def cloth(self, layout, md):
+       def cloth(self, layout, ob, md):
                layout.itemL(text="See Cloth panel.")
                
-       def collision(self, layout, md):
+       def collision(self, layout, ob, md):
                layout.itemL(text="See Collision panel.")
                
-       def curve(self, layout, md):
+       def curve(self, layout, ob, md):
 -              layout.itemR(md, "object")
 +              layout.itemR(md, "curve")
-               layout.itemR(md, "vertex_group")
+               layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                layout.itemR(md, "deform_axis")
                
-       def decimate(self, layout, md):
+       def decimate(self, layout, ob, md):
                layout.itemR(md, "ratio")
                layout.itemR(md, "face_count")
                
@@@ -241,24 -241,24 +241,24 @@@
                layout.itemR(md, "falloff")
                layout.itemR(md, "force", slider=True)
                layout.itemR(md, "object")
-               layout.itemR(md, "vertex_group")
+               layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                # Missing: "Reset" and "Recenter"
                
-       def lattice(self, layout, md):
+       def lattice(self, layout, ob, md):
 -              layout.itemR(md, "object")
 +              layout.itemR(md, "lattice")
-               layout.itemR(md, "vertex_group")
+               layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                
-       def mask(self, layout, md):
+       def mask(self, layout, ob, md):
                layout.itemR(md, "mode")
                if md.mode == 'ARMATURE':
                        layout.itemR(md, "armature")
                if md.mode == 'VERTEX_GROUP':
-                       layout.itemR(md, "vertex_group")
+                       layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                layout.itemR(md, "inverse")
                
-       def mesh_deform(self, layout, md):
+       def mesh_deform(self, layout, ob, md):
 -              layout.itemR(md, "object")
 +              layout.itemR(md, "mesh")
-               layout.itemR(md, "vertex_group")
+               layout.item_pointerR(md, "vertex_group", ob, "vertex_groups")
                layout.itemR(md, "invert")
  
                layout.itemS()

diff --cc source/blender/editors/space_view3d/space_view3d.c
Simple merge

diff --cc source/blender/makesrna/intern/makesrna.c
Simple merge

diff --cc source/blender/python/generic/quat.c
Simple merge