rna attribute consistency edits, use common prefix for booleans.
authorCampbell Barton <ideasman42@gmail.com>
Tue, 23 Apr 2013 07:06:29 +0000 (07:06 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 23 Apr 2013 07:06:29 +0000 (07:06 +0000)
29 files changed:
release/scripts/freestyle/style_modules/parameter_editor.py
release/scripts/startup/bl_operators/rigidbody.py
release/scripts/startup/bl_ui/properties_data_modifier.py
release/scripts/startup/bl_ui/properties_freestyle.py
release/scripts/startup/bl_ui/properties_game.py
release/scripts/startup/bl_ui/properties_object.py
release/scripts/startup/bl_ui/properties_particle.py
release/scripts/startup/bl_ui/properties_physics_fluid.py
release/scripts/startup/bl_ui/properties_physics_rigidbody.py
release/scripts/startup/bl_ui/properties_physics_rigidbody_constraint.py
release/scripts/startup/bl_ui/properties_physics_smoke.py
release/scripts/startup/bl_ui/properties_scene.py
release/scripts/startup/bl_ui/space_image.py
release/scripts/startup/bl_ui/space_node.py
release/scripts/startup/bl_ui/space_sequencer.py
release/scripts/startup/bl_ui/space_view3d_toolbar.py
source/blender/editors/space_image/image_buttons.c
source/blender/makesrna/intern/rna_brush.c
source/blender/makesrna/intern/rna_fluidsim.c
source/blender/makesrna/intern/rna_image.c
source/blender/makesrna/intern/rna_linestyle.c
source/blender/makesrna/intern/rna_modifier.c
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_particle.c
source/blender/makesrna/intern/rna_rigidbody.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_sequencer.c
source/blender/makesrna/intern/rna_smoke.c

index 11398ef2ad80224f5742fdbf0e8db0674f7a2286..e267b513ba4b6684c8085afa886479e32e26854b 100644 (file)
@@ -59,24 +59,24 @@ class ScalarBlendModifier(StrokeShader):
     def blend(self, v1, v2):
         fac = self.__influence
         facm = 1.0 - fac
-        if self.__blend == "MIX":
+        if self.__blend == 'MIX':
             v1 = facm * v1 + fac * v2
-        elif self.__blend == "ADD":
+        elif self.__blend == 'ADD':
             v1 += fac * v2
-        elif self.__blend == "MULTIPLY":
+        elif self.__blend == 'MULTIPLY':
             v1 *= facm + fac * v2;
-        elif self.__blend == "SUBTRACT":
+        elif self.__blend == 'SUBTRACT':
             v1 -= fac * v2
-        elif self.__blend == "DIVIDE":
+        elif self.__blend == 'DIVIDE':
             if v2 != 0.0:
                 v1 = facm * v1 + fac * v1 / v2
-        elif self.__blend == "DIFFERENCE":
+        elif self.__blend == 'DIFFERENCE':
             v1 = facm * v1 + fac * abs(v1 - v2)
-        elif self.__blend == "MININUM":
+        elif self.__blend == 'MININUM':
             tmp = fac * v1
             if v1 > tmp:
                 v1 = tmp
-        elif self.__blend == "MAXIMUM":
+        elif self.__blend == 'MAXIMUM':
             tmp = fac * v1
             if v1 < tmp:
                 v1 = tmp
@@ -87,7 +87,7 @@ class ScalarBlendModifier(StrokeShader):
 class CurveMappingModifier(ScalarBlendModifier):
     def __init__(self, blend, influence, mapping, invert, curve):
         ScalarBlendModifier.__init__(self, blend, influence)
-        assert mapping in ("LINEAR", "CURVE")
+        assert mapping in {'LINEAR', 'CURVE'}
         self.__mapping = getattr(self, mapping)
         self.__invert = invert
         self.__curve = curve
@@ -103,7 +103,7 @@ class CurveMappingModifier(ScalarBlendModifier):
 class ThicknessModifierMixIn:
     def __init__(self):
         scene = freestyle.getCurrentScene()
-        self.__persp_camera = (scene.camera.data.type == "PERSP")
+        self.__persp_camera = (scene.camera.data.type == 'PERSP')
     def set_thickness(self, sv, outer, inner):
         fe = sv.first_svertex.get_fedge(sv.second_svertex)
         nature = fe.nature
@@ -129,16 +129,16 @@ class ThicknessBlenderMixIn(ThicknessModifierMixIn):
         self.__position = position
         self.__ratio = ratio
     def blend_thickness(self, outer, inner, v):
-        if self.__position == "CENTER":
+        if self.__position == 'CENTER':
             outer = self.blend(outer, v / 2)
             inner = self.blend(inner, v / 2)
-        elif self.__position == "INSIDE":
+        elif self.__position == 'INSIDE':
             outer = self.blend(outer, 0)
             inner = self.blend(inner, v)
-        elif self.__position == "OUTSIDE":
+        elif self.__position == 'OUTSIDE':
             outer = self.blend(outer, v)
             inner = self.blend(inner, 0)
-        elif self.__position == "RELATIVE":
+        elif self.__position == 'RELATIVE':
             outer = self.blend(outer, v * self.__ratio)
             inner = self.blend(inner, v * (1 - self.__ratio))
         else:
@@ -152,16 +152,16 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
     def __init__(self, thickness, position, ratio):
         StrokeShader.__init__(self)
         ThicknessModifierMixIn.__init__(self)
-        if position == "CENTER":
+        if position == 'CENTER':
             self.__outer = thickness / 2
             self.__inner = thickness / 2
-        elif position == "INSIDE":
+        elif position == 'INSIDE':
             self.__outer = 0
             self.__inner = thickness
-        elif position == "OUTSIDE":
+        elif position == 'OUTSIDE':
             self.__outer = thickness
             self.__inner = 0
-        elif position == "RELATIVE":
+        elif position == 'RELATIVE':
             self.__outer = thickness * ratio
             self.__inner = thickness * (1 - ratio)
         else:
@@ -350,84 +350,76 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
 
 # Material modifiers
 
-def iter_material_color(stroke, material_attr):
+def iter_material_color(stroke, material_attribute):
     func = CurveMaterialF0D()
     it = stroke.stroke_vertices_begin()
     while not it.is_end:
         material = func(Interface0DIterator(it))
-        if material_attr == "DIFF":
-            color = (material.diffuse[0],
-                     material.diffuse[1],
-                     material.diffuse[2])
-        elif material_attr == "SPEC":
-            color = (material.specular[0],
-                     material.specular[1],
-                     material.specular[2])
+        if material_attribute == 'DIFF':
+            color = material.diffuse[:]
+        elif material_attribute == 'SPEC':
+            color = material.specular[:]
         else:
-            raise ValueError("unexpected material attribute: " + material_attr)
+            raise ValueError("unexpected material attribute: " + material_attribute)
         yield it, color
         it.increment()
 
-def iter_material_value(stroke, material_attr):
+def iter_material_value(stroke, material_attribute):
     func = CurveMaterialF0D()
     it = stroke.stroke_vertices_begin()
     while not it.is_end:
         material = func(Interface0DIterator(it))
-        if material_attr == "DIFF":
-            r = material.diffuse[0]
-            g = material.diffuse[1]
-            b = material.diffuse[2]
+        if material_attribute == 'DIFF':
+            r, g, b = material.diffuse
             t = 0.35 * r + 0.45 * r + 0.2 * b
-        elif material_attr == "DIFF_R":
+        elif material_attribute == 'DIFF_R':
             t = material.diffuse[0]
-        elif material_attr == "DIFF_G":
+        elif material_attribute == 'DIFF_G':
             t = material.diffuse[1]
-        elif material_attr == "DIFF_B":
+        elif material_attribute == 'DIFF_B':
             t = material.diffuse[2]
-        elif material_attr == "SPEC":
-            r = material.specular[0]
-            g = material.specular[1]
-            b = material.specular[2]
+        elif material_attribute == 'SPEC':
+            r, g, b = material.specular
             t = 0.35 * r + 0.45 * r + 0.2 * b
-        elif material_attr == "SPEC_R":
+        elif material_attribute == 'SPEC_R':
             t = material.specular[0]
-        elif material_attr == "SPEC_G":
+        elif material_attribute == 'SPEC_G':
             t = material.specular[1]
-        elif material_attr == "SPEC_B":
+        elif material_attribute == 'SPEC_B':
             t = material.specular[2]
-        elif material_attr == "SPEC_HARDNESS":
+        elif material_attribute == 'SPEC_HARDNESS':
             t = material.shininess
-        elif material_attr == "ALPHA":
+        elif material_attribute == 'ALPHA':
             t = material.diffuse[3]
         else:
-            raise ValueError("unexpected material attribute: " + material_attr)
+            raise ValueError("unexpected material attribute: " + material_attribute)
         yield it, t
         it.increment()
 
 class ColorMaterialShader(ColorRampModifier):
-    def __init__(self, blend, influence, ramp, material_attr, use_ramp):
+    def __init__(self, blend, influence, ramp, material_attribute, use_ramp):
         ColorRampModifier.__init__(self, blend, influence, ramp)
-        self.__material_attr = material_attr
+        self.__material_attribute = material_attribute
         self.__use_ramp = use_ramp
     def shade(self, stroke):
-        if self.__material_attr in ["DIFF", "SPEC"] and not self.__use_ramp:
-            for it, b in iter_material_color(stroke, self.__material_attr):
+        if self.__material_attribute in {'DIFF', 'SPEC'} and not self.__use_ramp:
+            for it, b in iter_material_color(stroke, self.__material_attribute):
                 sv = it.object
                 a = sv.attribute.color
                 sv.attribute.color = self.blend_ramp(a, b)
         else:
-            for it, t in iter_material_value(stroke, self.__material_attr):
+            for it, t in iter_material_value(stroke, self.__material_attribute):
                 sv = it.object
                 a = sv.attribute.color
                 b = self.evaluate(t)
                 sv.attribute.color = self.blend_ramp(a, b)
 
 class AlphaMaterialShader(CurveMappingModifier):
-    def __init__(self, blend, influence, mapping, invert, curve, material_attr):
+    def __init__(self, blend, influence, mapping, invert, curve, material_attribute):
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__material_attr = material_attr
+        self.__material_attribute = material_attribute
     def shade(self, stroke):
-        for it, t in iter_material_value(stroke, self.__material_attr):
+        for it, t in iter_material_value(stroke, self.__material_attribute):
             sv = it.object
             a = sv.attribute.alpha
             b = self.evaluate(t)
@@ -435,14 +427,14 @@ class AlphaMaterialShader(CurveMappingModifier):
 
 class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
     def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, mapping, invert, curve, material_attr, value_min, value_max):
+                 blend, influence, mapping, invert, curve, material_attribute, value_min, value_max):
         ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
         CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
-        self.__material_attr = material_attr
+        self.__material_attribute = material_attribute
         self.__value_min = value_min
         self.__value_max = value_max
     def shade(self, stroke):
-        for it, t in iter_material_value(stroke, self.__material_attr):
+        for it, t in iter_material_value(stroke, self.__material_attribute):
             sv = it.object
             a = sv.attribute.thickness
             b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
@@ -453,12 +445,12 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
 
 class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
     def __init__(self, thickness_position, thickness_ratio,
-                 blend, influence, orientation, min_thickness, max_thickness):
+                 blend, influence, orientation, thickness_min, thickness_max):
         ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
         ScalarBlendModifier.__init__(self, blend, influence)
         self.__orientation = mathutils.Vector((math.cos(orientation), math.sin(orientation)))
-        self.__min_thickness = min_thickness
-        self.__max_thickness = max_thickness
+        self.__thickness_min = thickness_min
+        self.__thickness_max = thickness_max
     def shade(self, stroke):
         func = VertexOrientation2DF0D()
         it = stroke.stroke_vertices_begin()
@@ -469,7 +461,7 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
             fac = abs(orthDir * self.__orientation)
             sv = it.object
             a = sv.attribute.thickness
-            b = self.__min_thickness + fac * (self.__max_thickness - self.__min_thickness)
+            b = self.__thickness_min + fac * (self.__thickness_max - self.__thickness_min)
             b = max(b, 0.0)
             c = self.blend_thickness(a[0], a[1], b)
             self.set_thickness(sv, c[0], c[1])
@@ -570,14 +562,14 @@ class Transform2DShader(StrokeShader):
         self.__pivot_y = pivot_y
     def shade(self, stroke):
         # determine the pivot of scaling and rotation operations
-        if self.__pivot == "START":
+        if self.__pivot == 'START':
             it = stroke.stroke_vertices_begin()
             pivot = it.object.point
-        elif self.__pivot == "END":
+        elif self.__pivot == 'END':
             it = stroke.stroke_vertices_end()
             it.decrement()
             pivot = it.object.point
-        elif self.__pivot == "PARAM":
+        elif self.__pivot == 'PARAM':
             p = None
             it = stroke.stroke_vertices_begin()
             while not it.is_end:
@@ -593,7 +585,7 @@ class Transform2DShader(StrokeShader):
             else:
                 delta = u - self.__pivot_u
                 pivot = p + delta * (prev - p)
-        elif self.__pivot == "CENTER":
+        elif self.__pivot == 'CENTER':
             pivot = mathutils.Vector([0.0, 0.0])
             n = 0
             it = stroke.stroke_vertices_begin()
@@ -604,7 +596,7 @@ class Transform2DShader(StrokeShader):
                 it.increment()
             pivot.x = pivot.x / n
             pivot.y = pivot.y / n
-        elif self.__pivot == "ABSOLUTE":
+        elif self.__pivot == 'ABSOLUTE':
             pivot = mathutils.Vector([self.__pivot_x, self.__pivot_y])
         # apply scaling and rotation operations
         cos_theta = math.cos(self.__angle)
@@ -874,15 +866,15 @@ class AndBP1D(BinaryPredicate1D):
 # predicates for selection
 
 class LengthThresholdUP1D(UnaryPredicate1D):
-    def __init__(self, min_length=None, max_length=None):
+    def __init__(self, length_min=None, length_max=None):
         UnaryPredicate1D.__init__(self)
-        self._min_length = min_length
-        self._max_length = max_length
+        self._length_min = length_min
+        self._length_max = length_max
     def __call__(self, inter):
         length = inter.length_2d
-        if self._min_length is not None and length < self._min_length:
+        if self._length_min is not None and length < self._length_min:
             return False
-        if self._max_length is not None and length > self._max_length:
+        if self._length_max is not None and length > self._length_max:
             return False
         return True
 
@@ -931,16 +923,16 @@ class MaterialBoundaryUP0D(UnaryPredicate0D):
         return idx1 != idx2
 
 class Curvature2DAngleThresholdUP0D(UnaryPredicate0D):
-    def __init__(self, min_angle=None, max_angle=None):
+    def __init__(self, angle_min=None, angle_max=None):
         UnaryPredicate0D.__init__(self)
-        self._min_angle = min_angle
-        self._max_angle = max_angle
+        self._angle_min = angle_min
+        self._angle_max = angle_max
         self._func = Curvature2DAngleF0D()
     def __call__(self, inter):
         angle = math.pi - self._func(inter)
-        if self._min_angle is not None and angle < self._min_angle:
+        if self._angle_min is not None and angle < self._angle_min:
             return True
-        if self._max_angle is not None and angle > self._max_angle:
+        if self._angle_max is not None and angle > self._angle_max:
             return True
         return False
 
@@ -984,13 +976,13 @@ def process(layer_name, lineset_name):
     selection_criteria = []
     # prepare selection criteria by visibility
     if lineset.select_by_visibility:
-        if lineset.visibility == "VISIBLE":
+        if lineset.visibility == 'VISIBLE':
             selection_criteria.append(
                 QuantitativeInvisibilityUP1D(0))
-        elif lineset.visibility == "HIDDEN":
+        elif lineset.visibility == 'HIDDEN':
             selection_criteria.append(
                 NotUP1D(QuantitativeInvisibilityUP1D(0)))
-        elif lineset.visibility == "RANGE":
+        elif lineset.visibility == 'RANGE':
             selection_criteria.append(
                 QuantitativeInvisibilityRangeUP1D(lineset.qi_start, lineset.qi_end))
     # prepare selection criteria by edge types
@@ -1023,21 +1015,21 @@ def process(layer_name, lineset_name):
         if lineset.select_external_contour:
             upred = ExternalContourUP1D()
             edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_external_contour else upred)
-        if lineset.edge_type_combination == "OR":
+        if lineset.edge_type_combination == 'OR':
             upred = join_unary_predicates(edge_type_criteria, OrUP1D)
         else:
             upred = join_unary_predicates(edge_type_criteria, AndUP1D)
         if upred is not None:
-            if lineset.edge_type_negation == "EXCLUSIVE":
+            if lineset.edge_type_negation == 'EXCLUSIVE':
                 upred = NotUP1D(upred)
             selection_criteria.append(upred)
     # prepare selection criteria by face marks
     if lineset.select_by_face_marks:
-        if lineset.face_mark_condition == "BOTH":
+        if lineset.face_mark_condition == 'BOTH':
             upred = FaceMarkBothUP1D()
         else:
             upred = FaceMarkOneUP1D()
-        if lineset.face_mark_negation == "EXCLUSIVE":
+        if lineset.face_mark_negation == 'EXCLUSIVE':
             upred = NotUP1D(upred)
         selection_criteria.append(upred)
     # prepare selection criteria by group of objects
@@ -1068,13 +1060,13 @@ def process(layer_name, lineset_name):
     Operators.select(upred)
     # join feature edges to form chains
     if linestyle.use_chaining:
-        if linestyle.chaining == "PLAIN":
-            if linestyle.same_object:
+        if linestyle.chaining == 'PLAIN':
+            if linestyle.use_same_object:
                 Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
             else:
                 Operators.bidirectional_chain(ChainPredicateIterator(upred, TrueBP1D()), NotUP1D(upred))
-        elif linestyle.chaining == "SKETCHY":
-            if linestyle.same_object:
+        elif linestyle.chaining == 'SKETCHY':
+            if linestyle.use_same_object:
                 Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(linestyle.rounds))
             else:
                 Operators.bidirectional_chain(pySketchyChainingIterator(linestyle.rounds))
@@ -1083,10 +1075,10 @@ def process(layer_name, lineset_name):
     # split chains
     if linestyle.material_boundary:
         Operators.sequential_split(MaterialBoundaryUP0D())
-    if linestyle.use_min_angle or linestyle.use_max_angle:
-        min_angle = linestyle.min_angle if linestyle.use_min_angle else None
-        max_angle = linestyle.max_angle if linestyle.use_max_angle else None
-        Operators.sequential_split(Curvature2DAngleThresholdUP0D(min_angle, max_angle))
+    if linestyle.use_angle_min or linestyle.use_angle_max:
+        angle_min = linestyle.angle_min if linestyle.use_angle_min else None
+        angle_max = linestyle.angle_max if linestyle.use_angle_max else None
+        Operators.sequential_split(Curvature2DAngleThresholdUP0D(angle_min, angle_max))
     if linestyle.use_split_length:
         Operators.sequential_split(Length2DThresholdUP0D(linestyle.split_length), 1.0)
     if linestyle.use_split_pattern:
@@ -1107,140 +1099,140 @@ def process(layer_name, lineset_name):
                                        SplitPatternStoppingUP0D(controller),
                                        sampling)
     # select chains
-    if linestyle.use_min_length or linestyle.use_max_length:
-        min_length = linestyle.min_length if linestyle.use_min_length else None
-        max_length = linestyle.max_length if linestyle.use_max_length else None
-        Operators.select(LengthThresholdUP1D(min_length, max_length))
+    if linestyle.use_length_min or linestyle.use_length_max:
+        length_min = linestyle.length_min if linestyle.use_length_min else None
+        length_max = linestyle.length_max if linestyle.use_length_max else None
+        Operators.select(LengthThresholdUP1D(length_min, length_max))
     # prepare a list of stroke shaders
     shaders_list = []
     for m in linestyle.geometry_modifiers:
         if not m.use:
             continue
-        if m.type == "SAMPLING":
+        if m.type == 'SAMPLING':
             shaders_list.append(SamplingShader(
                 m.sampling))
-        elif m.type == "BEZIER_CURVE":
+        elif m.type == 'BEZIER_CURVE':
             shaders_list.append(BezierCurveShader(
                 m.error))
-        elif m.type == "SINUS_DISPLACEMENT":
+        elif m.type == 'SINUS_DISPLACEMENT':
             shaders_list.append(SinusDisplacementShader(
                 m.wavelength, m.amplitude, m.phase))
-        elif m.type == "SPATIAL_NOISE":
+        elif m.type == 'SPATIAL_NOISE':
             shaders_list.append(SpatialNoiseShader(
-                m.amplitude, m.scale, m.octaves, m.smooth, m.pure_random))
-        elif m.type == "PERLIN_NOISE_1D":
+                m.amplitude, m.scale, m.octaves, m.smooth, m.use_pure_random))
+        elif m.type == 'PERLIN_NOISE_1D':
             shaders_list.append(PerlinNoise1DShader(
                 m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed)))
-        elif m.type == "PERLIN_NOISE_2D":
+        elif m.type == 'PERLIN_NOISE_2D':
             shaders_list.append(PerlinNoise2DShader(
                 m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed)))
-        elif m.type == "BACKBONE_STRETCHER":
+        elif m.type == 'BACKBONE_STRETCHER':
             shaders_list.append(BackboneStretcherShader(
                 m.backbone_length))
-        elif m.type == "TIP_REMOVER":
+        elif m.type == 'TIP_REMOVER':
             shaders_list.append(TipRemoverShader(
                 m.tip_length))
-        elif m.type == "POLYGONIZATION":
+        elif m.type == 'POLYGONIZATION':
             shaders_list.append(PolygonalizationShader(
                 m.error))
-        elif m.type == "GUIDING_LINES":
+        elif m.type == 'GUIDING_LINES':
             shaders_list.append(GuidingLinesShader(
                 m.offset))
-        elif m.type == "BLUEPRINT":
-            if m.shape == "CIRCLES":
+        elif m.type == 'BLUEPRINT':
+            if m.shape == 'CIRCLES':
                 shaders_list.append(pyBluePrintCirclesShader(
                     m.rounds, m.random_radius, m.random_center))
-            elif m.shape == "ELLIPSES":
+            elif m.shape == 'ELLIPSES':
                 shaders_list.append(pyBluePrintEllipsesShader(
                     m.rounds, m.random_radius, m.random_center))
-            elif m.shape == "SQUARES":
+            elif m.shape == 'SQUARES':
                 shaders_list.append(pyBluePrintSquaresShader(
                     m.rounds, m.backbone_length, m.random_backbone))
-        elif m.type == "2D_OFFSET":
+        elif m.type == '2D_OFFSET':
             shaders_list.append(Offset2DShader(
                 m.start, m.end, m.x, m.y))
-        elif m.type == "2D_TRANSFORM":
+        elif m.type == '2D_TRANSFORM':
             shaders_list.append(Transform2DShader(
                 m.pivot, m.scale_x, m.scale_y, m.angle, m.pivot_u, m.pivot_x, m.pivot_y))
     color = linestyle.color
-    if (not linestyle.use_chaining) or (linestyle.chaining == "PLAIN" and linestyle.same_object):
+    if (not linestyle.use_chaining) or (linestyle.chaining == 'PLAIN' and linestyle.use_same_object):
         thickness_position = linestyle.thickness_position
     else:
-        thickness_position = "CENTER"
+        thickness_position = 'CENTER'
         import bpy
         if bpy.app.debug_freestyle:
-            print("Warning: Thickness position options are applied when chaining is disabled")
-            print("         or the Plain chaining is used with the Same Object option enabled.")
+            print("Warning: Thickness position options are applied when chaining is disabled\n"
+                  "         or the Plain chaining is used with the Same Object option enabled.")
     shaders_list.append(BaseColorShader(color.r, color.g, color.b, linestyle.alpha))
     shaders_list.append(BaseThicknessShader(linestyle.thickness, thickness_position,
                                             linestyle.thickness_ratio))
     for m in linestyle.color_modifiers:
         if not m.use:
             continue
-        if m.type == "ALONG_STROKE":
+        if m.type == 'ALONG_STROKE':
             shaders_list.append(ColorAlongStrokeShader(
                 m.blend, m.influence, m.color_ramp))
-        elif m.type == "DISTANCE_FROM_CAMERA":
+        elif m.type == 'DISTANCE_FROM_CAMERA':
             shaders_list.append(ColorDistanceFromCameraShader(
                 m.blend, m.influence, m.color_ramp,
                 m.range_min, m.range_max))
-        elif m.type == "DISTANCE_FROM_OBJECT":
+        elif m.type == 'DISTANCE_FROM_OBJECT':
             shaders_list.append(ColorDistanceFromObjectShader(
                 m.blend, m.influence, m.color_ramp, m.target,
                 m.range_min, m.range_max))
-        elif m.type == "MATERIAL":
+        elif m.type == 'MATERIAL':
             shaders_list.append(ColorMaterialShader(
-                m.blend, m.influence, m.color_ramp, m.material_attr,
+                m.blend, m.influence, m.color_ramp, m.material_attribute,
                 m.use_ramp))
     for m in linestyle.alpha_modifiers:
         if not m.use:
             continue
-        if m.type == "ALONG_STROKE":
+        if m.type == 'ALONG_STROKE':
             shaders_list.append(AlphaAlongStrokeShader(
                 m.blend, m.influence, m.mapping, m.invert, m.curve))
-        elif m.type == "DISTANCE_FROM_CAMERA":
+        elif m.type == 'DISTANCE_FROM_CAMERA':
             shaders_list.append(AlphaDistanceFromCameraShader(
                 m.blend, m.influence, m.mapping, m.invert, m.curve,
                 m.range_min, m.range_max))
-        elif m.type == "DISTANCE_FROM_OBJECT":
+        elif m.type == 'DISTANCE_FROM_OBJECT':
             shaders_list.append(AlphaDistanceFromObjectShader(
                 m.blend, m.influence, m.mapping, m.invert, m.curve, m.target,
                 m.range_min, m.range_max))
-        elif m.type == "MATERIAL":
+        elif m.type == 'MATERIAL':
             shaders_list.append(AlphaMaterialShader(
                 m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.material_attr))
+                m.material_attribute))
     for m in linestyle.thickness_modifiers:
         if not m.use:
             continue
-        if m.type == "ALONG_STROKE":
+        if m.type == 'ALONG_STROKE':
             shaders_list.append(ThicknessAlongStrokeShader(
                 thickness_position, linestyle.thickness_ratio,
                 m.blend, m.influence, m.mapping, m.invert, m.curve,
                 m.value_min, m.value_max))
-        elif m.type == "DISTANCE_FROM_CAMERA":
+        elif m.type == 'DISTANCE_FROM_CAMERA':
             shaders_list.append(ThicknessDistanceFromCameraShader(
                 thickness_position, linestyle.thickness_ratio,
                 m.blend, m.influence, m.mapping, m.invert, m.curve,
                 m.range_min, m.range_max, m.value_min, m.value_max))
-        elif m.type == "DISTANCE_FROM_OBJECT":
+        elif m.type == 'DISTANCE_FROM_OBJECT':
             shaders_list.append(ThicknessDistanceFromObjectShader(
                 thickness_position, linestyle.thickness_ratio,
                 m.blend, m.influence, m.mapping, m.invert, m.curve, m.target,
                 m.range_min, m.range_max, m.value_min, m.value_max))
-        elif m.type == "MATERIAL":
+        elif m.type == 'MATERIAL':
             shaders_list.append(ThicknessMaterialShader(
                 thickness_position, linestyle.thickness_ratio,
                 m.blend, m.influence, m.mapping, m.invert, m.curve,
-                m.material_attr, m.value_min, m.value_max))
-        elif m.type == "CALLIGRAPHY":
+                m.material_attribute, m.value_min, m.value_max))
+        elif m.type == 'CALLIGRAPHY':
             shaders_list.append(CalligraphicThicknessShader(
                 thickness_position, linestyle.thickness_ratio,
                 m.blend, m.influence,
-                m.orientation, m.min_thickness, m.max_thickness))
-    if linestyle.caps == "ROUND":
+                m.orientation, m.thickness_min, m.thickness_max))
+    if linestyle.caps == 'ROUND':
         shaders_list.append(RoundCapShader())
-    elif linestyle.caps == "SQUARE":
+    elif linestyle.caps == 'SQUARE':
         shaders_list.append(SquareCapShader())
     if linestyle.use_dashed_line:
         pattern = []
index ba1215c8a13e0af0a4718241496e1e311541847c..979cc01c0add047cd8ba59d958f39e694745cefe 100644 (file)
@@ -40,7 +40,7 @@ class CopyRigidbodySettings(Operator):
         "friction",
         "restitution",
         "use_deactivation",
-        "start_deactivated",
+        "use_start_deactivated",
         "deactivate_linear_velocity",
         "deactivate_angular_velocity",
         "linear_damping",
index 71178e6afac3f0347a1905e5d6e43d7f9b6d0c9f..a99919f68ad30dee8cf1e227b895126e6211c7d0 100644 (file)
@@ -936,9 +936,9 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
             layout.prop(md, "sharpness")
 
         layout.prop(md, "use_smooth_shade")
-        layout.prop(md, "remove_disconnected_pieces")
+        layout.prop(md, "use_remove_disconnected")
         row = layout.row()
-        row.active = md.remove_disconnected_pieces
+        row.active = md.use_remove_disconnected
         row.prop(md, "threshold")
 
     @staticmethod
index fb97dffefb9118df83f3c9a7c53d4496f2539f98..b4ab1a733f204ab5cc837e0d708e516f373c8876 100644 (file)
@@ -409,14 +409,14 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
                 prop.name = modifier.name
 
             elif modifier.type == 'MATERIAL':
-                box.prop(modifier, "material_attr", text="")
+                box.prop(modifier, "material_attribute", text="")
                 self.draw_modifier_curve_common(box, modifier, False, True)
 
             elif modifier.type == 'CALLIGRAPHY':
                 box.prop(modifier, "orientation")
                 row = box.row(align=True)
-                row.prop(modifier, "min_thickness")
-                row.prop(modifier, "max_thickness")
+                row.prop(modifier, "thickness_min")
+                row.prop(modifier, "thickness_max")
 
     def draw_geometry_modifier(self, context, modifier):
         layout = self.layout
@@ -448,7 +448,7 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
                 col.prop(modifier, "octaves")
                 col = split.column()
                 col.prop(modifier, "smooth")
-                col.prop(modifier, "pure_random")
+                col.prop(modifier, "use_pure_random")
 
             elif modifier.type == 'PERLIN_NOISE_1D':
                 split = box.split()
@@ -540,7 +540,7 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
             col.prop(linestyle, "use_chaining", text="Enable Chaining")
             sub = col.row()
             sub.active = linestyle.use_chaining
-            sub.prop(linestyle, "same_object")
+            sub.prop(linestyle, "use_same_object")
             # Second column
             col = split.column()
             col.active = linestyle.use_chaining
@@ -554,15 +554,15 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
             # First column
             col = split.column()
             row = col.row(align=True)
-            row.prop(linestyle, "use_min_angle", text="")
+            row.prop(linestyle, "use_angle_min", text="")
             sub = row.row()
-            sub.active = linestyle.use_min_angle
-            sub.prop(linestyle, "min_angle")
+            sub.active = linestyle.use_angle_min
+            sub.prop(linestyle, "angle_min")
             row = col.row(align=True)
-            row.prop(linestyle, "use_max_angle", text="")
+            row.prop(linestyle, "use_angle_max", text="")
             sub = row.row()
-            sub.active = linestyle.use_max_angle
-            sub.prop(linestyle, "max_angle")
+            sub.active = linestyle.use_angle_max
+            sub.prop(linestyle, "angle_max")
             # Second column
             col = split.column()
             row = col.row(align=True)
@@ -590,17 +590,17 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
             # First column
             col = split.column()
             row = col.row(align=True)
-            row.prop(linestyle, "use_min_length", text="")
+            row.prop(linestyle, "use_length_min", text="")
             sub = row.row()
-            sub.active = linestyle.use_min_length
-            sub.prop(linestyle, "min_length")
+            sub.active = linestyle.use_length_min
+            sub.prop(linestyle, "length_min")
             # Second column
             col = split.column()
             row = col.row(align=True)
-            row.prop(linestyle, "use_max_length", text="")
+            row.prop(linestyle, "use_length_max", text="")
             sub = row.row()
-            sub.active = linestyle.use_max_length
-            sub.prop(linestyle, "max_length")
+            sub.active = linestyle.use_length_max
+            sub.prop(linestyle, "length_max")
 
             ## Caps
             layout.label(text="Caps:")
index 1f05c8eea5aac98af7b463d55b2c1f56c8572270..fcafc7c816a8a4a42ddf05cdb0af44033c260345 100644 (file)
@@ -407,7 +407,7 @@ class RENDER_PT_game_system(RenderButtonsPanel, Panel):
         row = col.row()
         col = row.column()
         col.prop(gs, "use_frame_rate")
-        col.prop(gs, "restrict_animation_updates")
+        col.prop(gs, "use_restrict_animation_updates")
         col.prop(gs, "use_material_caching")
         col = row.column()
         col.prop(gs, "use_display_lists")
index ff8cf6ee1970e0654dcb935640b3ee379ddaba12..31023d49340fd7dd8124360b36be88bea226b7c8 100644 (file)
@@ -297,8 +297,8 @@ class OBJECT_PT_relations_extras(ObjectButtonsPanel, Panel):
         row.active = ((ob.parent is not None) and (ob.use_slow_parent))
         row.prop(ob, "slow_parent_offset", text="Offset")
 
-        layout.prop(ob, "extra_recalc_object")
-        layout.prop(ob, "extra_recalc_data")
+        layout.prop(ob, "use_extra_recalc_object")
+        layout.prop(ob, "use_extra_recalc_data")
 
 
 from bl_ui.properties_animviz import (MotionPathButtonsPanel,
index d4a16b56b43593244cfca9812bec9bbed92269e2..dc73d5981d782d16b008c0f839324b0a7fa4806c 100644 (file)
@@ -496,8 +496,8 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             supports_courant = part.physics_type == 'FLUID'
             subsub = sub.row()
             subsub.enabled = supports_courant
-            subsub.prop(part, "adaptive_subframes", text="")
-            if supports_courant and part.adaptive_subframes:
+            subsub.prop(part, "use_adaptive_subframes", text="")
+            if supports_courant and part.use_adaptive_subframes:
                 col.prop(part, "courant_target", text="Threshold")
 
             row = layout.row()
@@ -524,20 +524,20 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
 
                 if fluid.solver == 'DDR':
                     sub = col.row()
-                    sub.prop(fluid, "repulsion", slider=fluid.factor_repulsion)
-                    sub.prop(fluid, "factor_repulsion", text="")
+                    sub.prop(fluid, "repulsion", slider=fluid.use_factor_repulsion)
+                    sub.prop(fluid, "use_factor_repulsion", text="")
 
                     sub = col.row()
-                    sub.prop(fluid, "stiff_viscosity", slider=fluid.factor_stiff_viscosity)
-                    sub.prop(fluid, "factor_stiff_viscosity", text="")
+                    sub.prop(fluid, "stiff_viscosity", slider=fluid.use_factor_stiff_viscosity)
+                    sub.prop(fluid, "use_factor_stiff_viscosity", text="")
 
                 sub = col.row()
-                sub.prop(fluid, "fluid_radius", slider=fluid.factor_radius)
-                sub.prop(fluid, "factor_radius", text="")
+                sub.prop(fluid, "fluid_radius", slider=fluid.use_factor_radius)
+                sub.prop(fluid, "use_factor_radius", text="")
 
                 sub = col.row()
-                sub.prop(fluid, "rest_density", slider=fluid.factor_density)
-                sub.prop(fluid, "factor_density", text="")
+                sub.prop(fluid, "rest_density", slider=fluid.use_factor_density)
+                sub.prop(fluid, "use_factor_density", text="")
 
                 if fluid.solver == 'CLASSICAL':
                     # With the classical solver, it is possible to calculate the
@@ -563,8 +563,8 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     col = split.column()
                     col.label(text="Advanced:")
                     sub = col.row()
-                    sub.prop(fluid, "rest_length", slider=fluid.factor_rest_length)
-                    sub.prop(fluid, "factor_rest_length", text="")
+                    sub.prop(fluid, "rest_length", slider=fluid.use_factor_rest_length)
+                    sub.prop(fluid, "use_factor_rest_length", text="")
                     col.label(text="")
                     sub = col.column()
                     sub.active = fluid.use_viscoelastic_springs
index 78bb21e76a566fbc78c65fecfabab118c2216cd2..0935f9336e1140f6a88d7d4b26efbac41484278b 100644 (file)
@@ -274,7 +274,7 @@ class PHYSICS_PT_domain_boundary(PhysicButtonsPanel, Panel):
         col.prop(fluid, "slip_type", text="")
         if fluid.slip_type == 'PARTIALSLIP':
             col.prop(fluid, "partial_slip_factor", slider=True, text="Amount")
-        col.prop(fluid, "surface_noobs")
+        col.prop(fluid, "use_surface_noobs")
 
         col = split.column()
         col.label(text="Surface:")
index 77ea5a9034467e05985d4931d6aedbd38458578e..cd701178976c985b3e69e19525731484678a79c9 100644 (file)
@@ -118,7 +118,7 @@ class PHYSICS_PT_rigid_body_dynamics(PHYSICS_PT_rigidbody_panel, Panel):
         col.prop(rbo, "use_deactivation")
         sub = col.column()
         sub.active = rbo.use_deactivation
-        sub.prop(rbo, "start_deactivated")
+        sub.prop(rbo, "use_start_deactivated")
         sub.prop(rbo, "deactivate_linear_velocity", text="Linear Vel")
         sub.prop(rbo, "deactivate_angular_velocity", text="Angular Vel")
         # TODO: other params such as time?
index a49c6d623ca4e9b65cd4511654fbf6f5722a9526..202c1c2506e11cfc63b7f69401ebcd7c2b514928 100644 (file)
@@ -59,10 +59,10 @@ class PHYSICS_PT_rigid_body_constraint(PHYSICS_PT_rigidbody_constraint_panel, Pa
             sub.prop(rbc, "breaking_threshold", text="Threshold")
 
         row = layout.row()
-        row.prop(rbc, "override_solver_iterations", text="Override Iterations")
+        row.prop(rbc, "use_override_solver_iterations", text="Override Iterations")
         sub = row.row()
-        sub.active = rbc.override_solver_iterations
-        sub.prop(rbc, "num_solver_iterations", text="Iterations")
+        sub.active = rbc.use_override_solver_iterations
+        sub.prop(rbc, "solver_iterations", text="Iterations")
 
         if rbc.type == 'HINGE':
             col = layout.column(align=True)
index 487f43aa973b8dbd4fd03371f37c336bd063ecc7..4a1b99ee81038cd79695e7f338095a22021931e5 100644 (file)
@@ -93,9 +93,9 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
 
                 sub = col.column(align=True)
 
-                sub.prop(flow, "initial_velocity")
+                sub.prop(flow, "use_initial_velocity")
                 sub = sub.column()
-                sub.active = flow.initial_velocity
+                sub.active = flow.use_initial_velocity
                 sub.prop(flow, "velocity_factor")
                 if flow.smoke_flow_source == "MESH":
                     sub.prop(flow, "velocity_normal")
@@ -244,7 +244,7 @@ class PHYSICS_PT_smoke_highres(PhysicButtonsPanel, Panel):
         col = split.column()
         col.label(text="Resolution:")
         col.prop(md, "amplify", text="Divisions")
-        col.prop(md, "smooth_emitter")
+        col.prop(md, "use_smooth_emitter")
 
         col = split.column()
         col.label(text="Noise Method:")
index eed8c84a389c6a21f41f2f6b4e4576b89840b8c0..a04283de8bf6290db0fbc2571e1cf2bd130ac11a 100644 (file)
@@ -290,7 +290,7 @@ class SCENE_PT_rigid_body_world(SceneButtonsPanel, Panel):
 
             col = split.column()
             col.prop(rbw, "steps_per_second", text="Steps Per Second")
-            col.prop(rbw, "num_solver_iterations", text="Solver Iterations")
+            col.prop(rbw, "solver_iterations", text="Solver Iterations")
 
 
 class SCENE_PT_rigid_body_cache(SceneButtonsPanel, Panel):
index 5aadeb1153f726880bca3d3d65110b288c5c62f6..54a788f3e4671bbfa98a5f2a4ce5759d091dbd99 100644 (file)
@@ -744,7 +744,7 @@ class IMAGE_PT_tools_brush_texture(BrushButtonsPanel, Panel):
             row.prop(brush, "use_primary_overlay", toggle=True, text="", icon='RESTRICT_VIEW_ON')
         sub = row.row()
         sub.prop(brush, "texture_overlay_alpha", text="Alpha")
-        sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+        sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
 
 
@@ -771,7 +771,7 @@ class IMAGE_PT_tools_mask_texture(BrushButtonsPanel, Panel):
         
         sub = row.row()
         sub.prop(brush, "texture_overlay_alpha", text="Alpha")
-        sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+        sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
 
 class IMAGE_PT_tools_brush_tool(BrushButtonsPanel, Panel):
index 86f25fd39956de4ba35ec432d7d7d964dd4be641..f58679e836d72d14bd40b1415beadb419aab548f 100644 (file)
@@ -283,7 +283,7 @@ class NODE_PT_quality(bpy.types.Panel):
         col = layout.column()
         col.prop(tree, "use_opencl")
         col.prop(tree, "use_groupnode_buffer")
-        col.prop(tree, "two_pass")
+        col.prop(tree, "use_two_pass")
         col.prop(tree, "use_viewer_border")
         col.prop(snode, "show_highlight")
         col.prop(snode, "use_hidden_preview")
index 641f9fc529f28867f1319b2cd2e0544023370f6a..3477353ba0dc0a04e7d4838e210c30be13fd3892 100644 (file)
@@ -98,7 +98,7 @@ class SEQUENCER_HT_header(Header):
                 row.prop(ed, "show_overlay", text="", icon='GHOST_ENABLED')
                 if ed.show_overlay:
                     row.prop(ed, "overlay_frame", text="")
-                    row.prop(ed, "overlay_lock", text="", icon='LOCKED')
+                    row.prop(ed, "use_overlay_lock", text="", icon='LOCKED')
 
                     row = layout.row()
                     row.prop(st, "overlay_type", text="")
index 8aae19e8bb06337c5dcd0af0ee2e2bc14feed16b..6be5c0e6e044da972cdad9c663bd1212d871df14 100644 (file)
@@ -681,7 +681,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel):
         
             sub = row.row()
             sub.prop(brush, "cursor_overlay_alpha", text="Alpha")
-            sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+            sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
         # Texture Paint Mode #
 
@@ -717,7 +717,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel):
         
             sub = row.row()
             sub.prop(brush, "cursor_overlay_alpha", text="Alpha")
-            sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+            sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
 
         # Weight Paint Mode #
@@ -774,7 +774,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel):
         
             sub = row.row()
             sub.prop(brush, "cursor_overlay_alpha", text="Alpha")
-            sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+            sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
 
 class VIEW3D_PT_tools_brush_texture(Panel, View3DPaintPanel):
@@ -814,7 +814,7 @@ class VIEW3D_PT_tools_brush_texture(Panel, View3DPaintPanel):
         
         sub = row.row()
         sub.prop(brush, "texture_overlay_alpha", text="Alpha")
-        sub.prop(brush, "primary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+        sub.prop(brush, "use_primary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
 
 class VIEW3D_PT_tools_mask_texture(View3DPanel, Panel):
@@ -852,7 +852,7 @@ class VIEW3D_PT_tools_mask_texture(View3DPanel, Panel):
         
         sub = row.row()
         sub.prop(brush, "mask_overlay_alpha", text="Alpha")
-        sub.prop(brush, "secondary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
+        sub.prop(brush, "use_secondary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
 
 
 class VIEW3D_PT_tools_brush_stroke(Panel, View3DPaintPanel):
index 5398f886396b15567bf32764edab22997a71eb01..cf640dd29d62468f9bf91b04834f6d01350a9765 100644 (file)
@@ -673,7 +673,7 @@ void uiTemplateImage(uiLayout *layout, bContext *C, PointerRNA *ptr, const char
 
                        col = uiLayoutColumn(layout, FALSE);
                        uiTemplateColorspaceSettings(col, &imaptr, "colorspace_settings");
-                       uiItemR(col, &imaptr, "view_as_render", 0, NULL, ICON_NONE);
+                       uiItemR(col, &imaptr, "use_view_as_render", 0, NULL, ICON_NONE);
 
                        if (ima->source != IMA_SRC_GENERATED) {
                                if (compact == 0) { /* background image view doesnt need these */
index 409fc72126c7137b0c47be48d2dbf17b930785b8..fbf64138e4c99e0fd4e10d06fc7ea6a68f7cddba 100644 (file)
@@ -1027,17 +1027,17 @@ static void rna_def_brush(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Use Cursor Overlay", "Show cursor in viewport");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
-       prop = RNA_def_property(srna, "cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
        RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
-       prop = RNA_def_property(srna, "primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
        RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
 
-       prop = RNA_def_property(srna, "secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
        RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
        RNA_def_property_update(prop, 0, "rna_Brush_update");
index d6ca900397a7cd37c96fd32c2e5bf5be8496e9d6..45ce3676b5af006fa25375262de6819faa113d45 100644 (file)
@@ -416,7 +416,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Generate Speed Vectors", "Generate speed vectors for vector blur");
 
        /* no collision object surface */
-       prop = RNA_def_property(srna, "surface_noobs", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_surface_noobs", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSSG_NOOBS);
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_ui_text(prop, "Remove air bubbles",
index 8113619388383f0acd090a5bf157ed24d2c66e38..f795222438b5f6be86194138b4dd824a765a3c93 100644 (file)
@@ -559,7 +559,7 @@ static void rna_def_image(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        
 
-       prop = RNA_def_property(srna, "view_as_render", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_VIEW_AS_RENDER);
        RNA_def_property_ui_text(prop, "View as Render", "Apply render part of display transformation when displaying this image on the screen");
        RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
index 8c83c89bb5f2122282c078388b8a49fc35102ad2..5db9329cd272a47e6e4ca371597a166f2a3c10ab 100644 (file)
@@ -412,7 +412,7 @@ static void rna_def_modifier_material_common(StructRNA *srna)
                {0, NULL, 0, NULL, NULL}
        };
 
-       prop = RNA_def_property(srna, "material_attr", PROP_ENUM, PROP_NONE);
+       prop = RNA_def_property(srna, "material_attribute", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "mat_attr");
        RNA_def_property_enum_items(prop, mat_attr_items);
        RNA_def_property_ui_text(prop, "Material Attribute", "Specify which material attribute is used");
@@ -569,14 +569,14 @@ static void rna_def_linestyle_modifiers(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Orientation", "Angle of the main direction");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "min_thickness", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "thickness_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min_thickness");
        RNA_def_property_range(prop, 0.0f, 10000.0f);
        RNA_def_property_ui_text(prop, "Min Thickness",
                                 "Minimum thickness in the direction perpendicular to the main direction");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "max_thickness", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "thickness_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max_thickness");
        RNA_def_property_range(prop, 0.0f, 10000.0f);
        RNA_def_property_ui_text(prop, "Max Thickness", "Maximum thickness in the main direction");
@@ -657,7 +657,7 @@ static void rna_def_linestyle_modifiers(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Smooth", "If true, the spatial noise is smooth");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "pure_random", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_pure_random", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", LS_MODIFIER_SPATIAL_NOISE_PURERANDOM);
        RNA_def_property_ui_text(prop, "Pure Random", "If true, the spatial noise does not show any coherence");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
@@ -982,7 +982,7 @@ static void rna_def_linestyle(BlenderRNA *brna)
        RNA_def_property_struct_type(prop, "LineStyleGeometryModifier");
        RNA_def_property_ui_text(prop, "Geometry Modifiers", "List of stroke geometry modifiers");
 
-       prop = RNA_def_property(srna, "same_object", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_same_object", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_SAME_OBJECT);
        RNA_def_property_ui_text(prop, "Same Object", "If true, only feature edges of the same object are joined");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
@@ -998,47 +998,47 @@ static void rna_def_linestyle(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Split Length", "Curvilinear 2D length for chain splitting");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "use_min_angle", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_angle_min", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MIN_2D_ANGLE);
        RNA_def_property_ui_text(prop, "Use Min 2D Angle",
                                 "Split chains at points with angles smaller than the minimum 2D angle");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "min_angle", PROP_FLOAT, PROP_ANGLE);
+       prop = RNA_def_property(srna, "angle_min", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "min_angle");
        RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
        RNA_def_property_ui_text(prop, "Min 2D Angle", "Minimum 2D angle for splitting chains");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "use_max_angle", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_angle_max", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MAX_2D_ANGLE);
        RNA_def_property_ui_text(prop, "Use Max 2D Angle",
                                 "Split chains at points with angles larger than the maximum 2D angle");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "max_angle", PROP_FLOAT, PROP_ANGLE);
+       prop = RNA_def_property(srna, "angle_max", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "max_angle");
        RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
        RNA_def_property_ui_text(prop, "Max 2D Angle", "Maximum 2D angle for splitting chains");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "use_min_length", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_length_min", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MIN_2D_LENGTH);
        RNA_def_property_ui_text(prop, "Use Min 2D Length", "Enable the selection of chains by a minimum 2D length");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "min_length", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "length_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min_length");
        RNA_def_property_range(prop, 0.0f, 10000.0f);
        RNA_def_property_ui_text(prop, "Min 2D Length", "Minimum curvilinear 2D length for the selection of chains");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "use_max_length", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_length_max", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MAX_2D_LENGTH);
        RNA_def_property_ui_text(prop, "Use Max 2D Length", "Enable the selection of chains by a maximum 2D length");
        RNA_def_property_update(prop, NC_LINESTYLE, NULL);
 
-       prop = RNA_def_property(srna, "max_length", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "length_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max_length");
        RNA_def_property_range(prop, 0.0f, 10000.0f);
        RNA_def_property_ui_text(prop, "Max 2D Length", "Maximum curvilinear 2D length for the selection of chains");
index b94d7e4cf3867d805b03fb517c66ddba3ba4dca0..618feae57d46d66b2d20317bc99ac90af69e107d 100644 (file)
@@ -3249,7 +3249,7 @@ static void rna_def_modifier_remesh(BlenderRNA *brna)
                                 "edges closer to the input");
        RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-       prop = RNA_def_property(srna, "remove_disconnected_pieces", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_remove_disconnected", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_REMESH_FLOOD_FILL);
        RNA_def_property_ui_text(prop, "Remove Disconnected Pieces", "");
        RNA_def_property_update(prop, 0, "rna_Modifier_update");
index f7670560e20bd26336ef09ac3da538ab9c3e6e89..2469fb9792c3f6bb3396385cf79a3ae86f8b61da 100644 (file)
@@ -6878,7 +6878,7 @@ static void rna_def_composite_nodetree(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "flag", NTREE_COM_GROUPNODE_BUFFER);
        RNA_def_property_ui_text(prop, "Buffer Groups", "Enable buffering of group nodes");
 
-       prop = RNA_def_property(srna, "two_pass", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_two_pass", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", NTREE_TWO_PASS);
        RNA_def_property_ui_text(prop, "Two Pass", "Use two pass execution during editing: first calculate fast nodes, "
                                                   "second pass calculate all nodes");
index c611e0fdd949468dbac3f3afe67de7f4a471299c..f818bfc396aa00be1914f179f2abd880de157148 100644 (file)
@@ -2479,11 +2479,11 @@ static void rna_def_object(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
        
        /* depsgraph hack */
-       prop = RNA_def_property(srna, "extra_recalc_object", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_extra_recalc_object", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "depsflag", OB_DEPS_EXTRA_OB_RECALC);
        RNA_def_property_ui_text(prop, "Extra Object Update", "Refresh this object again on frame changes, dependency graph hack");
        
-       prop = RNA_def_property(srna, "extra_recalc_data", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_extra_recalc_data", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "depsflag", OB_DEPS_EXTRA_DATA_RECALC);
        RNA_def_property_ui_text(prop, "Extra Data Update", "Refresh this object's data again on frame changes, dependency graph hack");
        
index 2c4f970a1f5e5490bc3f95ff13546513f0379ee2..9208f1273fc783adb679e38e002e20bfa1d5adac 100644 (file)
@@ -1623,7 +1623,7 @@ static void rna_def_fluid_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Factor Repulsion", "Repulsion is a factor of stiffness");
        RNA_def_property_update(prop, 0, "rna_Particle_reset");
 
-       prop = RNA_def_property(srna, "factor_density", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_factor_density", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_DENSITY);
        RNA_def_property_ui_text(prop, "Factor Density",
                                 "Density is calculated as a factor of default density (depends on particle size)");
@@ -2499,7 +2499,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Timestep", "The simulation timestep per frame (seconds per frame)");
        RNA_def_property_update(prop, 0, "rna_Particle_reset");
 
-       prop = RNA_def_property(srna, "adaptive_subframes", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_adaptive_subframes", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "time_flag", PART_TIME_AUTOSF);
        RNA_def_property_ui_text(prop, "Automatic Subframes", "Automatically set the number of subframes");
        RNA_def_property_update(prop, 0, "rna_Particle_reset");
index 3ca0594d42b1020d4089fd63ed42d6adfe649d35..2a76160f040129c7777f2de290aa055e65116201 100644 (file)
@@ -794,7 +794,7 @@ static void rna_def_rigidbody_object(BlenderRNA *brna)
                                 "but can cause glitches)");
        RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
        
-       prop = RNA_def_property(srna, "start_deactivated", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_start_deactivated", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED);
        RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivate rigid body at the start of the simulation");
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
@@ -949,14 +949,14 @@ static void rna_def_rigidbody_constraint(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 
        /* Solver Iterations */
-       prop = RNA_def_property(srna, "override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_override_solver_iterations_set");
        RNA_def_property_ui_text(prop, "Override Solver Iterations",
                                 "Override the number of solver iterations for this constraint");
        RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 
-       prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
+       prop = RNA_def_property(srna, "solver_iterations", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
        RNA_def_property_range(prop, 1, 1000);
        RNA_def_property_ui_range(prop, 1, 100, 1, -1);
index 0df7cfe3480716a9a426bb898c9c3c92de12bbb9..e589bde07440ec4d2b1c64c700f343d6f4b49646 100644 (file)
@@ -3364,7 +3364,7 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        RNA_def_property_boolean_funcs(prop, "rna_GameSettings_auto_start_get", "rna_GameSettings_auto_start_set");
        RNA_def_property_ui_text(prop, "Auto Start", "Automatically start game at load time");
 
-       prop = RNA_def_property(srna, "restrict_animation_updates", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_restrict_animation_updates", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_RESTRICT_ANIM_UPDATES);
        RNA_def_property_ui_text(prop, "Restrict Animation Updates",
                                 "Restrict the number of animation updates to the animation FPS (this is "
index 209c19b97655268e43ade27f745e45e48972080d..4d7856110388efd13c4c12467a92ea1147c1f1de 100644 (file)
@@ -1534,7 +1534,7 @@ static void rna_def_editor(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Draw Axes", "Partial overlay on top of the sequencer");
        RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
 
-       prop = RNA_def_property(srna, "overlay_lock", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_overlay_lock", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_ABS);
        RNA_def_property_ui_text(prop, "Overlay Lock", "");
        RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_overlay_lock_set");
index 1025fb4b1fd2624dddfdf285b6ffb2509f4e3864..76f005cdd2b3a223819f1e448f3aed1ffce31b84 100644 (file)
@@ -324,7 +324,7 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Effector Weights", "");
 
-       prop = RNA_def_property(srna, "smooth_emitter", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_smooth_emitter", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_HIGH_SMOOTH);
        RNA_def_property_ui_text(prop, "Smooth Emitter", "Smooth emitted smoke to avoid blockiness");
        RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
@@ -508,7 +508,7 @@ static void rna_def_smoke_flow_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Absolute Density", "Only allow given density value in emitter area");
        RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset");
 
-       prop = RNA_def_property(srna, "initial_velocity", PROP_BOOLEAN, PROP_NONE);
+       prop = RNA_def_property(srna, "use_initial_velocity", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_FLOW_INITVELOCITY);
        RNA_def_property_ui_text(prop, "Initial Velocity", "Smoke has some initial velocity when it is emitted");
        RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset");