Merged changes in the trunk up to revision 40520.

release/scripts/startup/bl_operators/__init__.py

@@ -24,11 +24,11 @@ if "bpy" in locals():
         _reload(val)
 _modules = (
     "add_mesh_torus",
-    "animsys_update",
+    "anim",
+    "console",
     "freestyle",
     "image",
     "mesh",
-    "nla",
     "object_align",
     "object",
     "object_randomize_transform",
@@ -40,6 +40,7 @@ _modules = (
     "uvcalc_lightmap",
     "uvcalc_smart_project",
     "vertexpaint_dirt",
+    "view3d",
     "wm",
 )
 __import__(name=__name__, fromlist=_modules)

release/scripts/startup/bl_operators/anim.py

@@ -0,0 +1,274 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8-80 compliant>
+
+if "bpy" in locals():
+    import imp
+    if "anim_utils" in locals():
+        imp.reload(anim_utils)
+
+import bpy
+from bpy.types import Operator
+from bpy.props import (IntProperty,
+                       BoolProperty,
+                       EnumProperty,
+                       StringProperty,
+                       )
+
+
+class ANIM_OT_keying_set_export(Operator):
+    "Export Keying Set to a python script"
+    bl_idname = "anim.keying_set_export"
+    bl_label = "Export Keying Set..."
+
+    filepath = StringProperty(
+            name="File Path",
+            )
+    filter_folder = BoolProperty(
+            name="Filter folders",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_text = BoolProperty(
+            name="Filter text",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_python = BoolProperty(
+            name="Filter python",
+            default=True,
+            options={'HIDDEN'},
+            )
+
+    def execute(self, context):
+        if not self.filepath:
+            raise Exception("Filepath not set")
+
+        f = open(self.filepath, "w")
+        if not f:
+            raise Exception("Could not open file")
+
+        scene = context.scene
+        ks = scene.keying_sets.active
+
+        f.write("# Keying Set: %s\n" % ks.name)
+
+        f.write("import bpy\n\n")
+        # XXX, why not current scene?
+        f.write("scene= bpy.data.scenes[0]\n\n")
+
+        # Add KeyingSet and set general settings
+        f.write("# Keying Set Level declarations\n")
+        f.write("ks= scene.keying_sets.new(name=\"%s\")\n" % ks.name)
+
+        if not ks.is_path_absolute:
+            f.write("ks.is_path_absolute = False\n")
+        f.write("\n")
+
+        f.write("ks.bl_options = %r\n" % ks.bl_options)
+        f.write("\n")
+
+        # --------------------------------------------------------
+        # generate and write set of lookups for id's used in paths
+
+        # cache for syncing ID-blocks to bpy paths + shorthands
+        id_to_paths_cache = {}
+
+        for ksp in ks.paths:
+            if ksp.id is None:
+                continue
+            if ksp.id in id_to_paths_cache:
+                continue
+
+            """
+            - idtype_list is used to get the list of id-datablocks from
+              bpy.data.* since this info isn't available elsewhere
+            - id.bl_rna.name gives a name suitable for UI,
+              with a capitalised first letter, but we need
+              the plural form that's all lower case
+            """
+
+            idtype_list = ksp.id.bl_rna.name.lower() + "s"
+            id_bpy_path = "bpy.data.%s[\"%s\"]" % (idtype_list, ksp.id.name)
+
+            # shorthand ID for the ID-block (as used in the script)
+            short_id = "id_%d" % len(id_to_paths_cache)
+
+            # store this in the cache now
+            id_to_paths_cache[ksp.id] = [short_id, id_bpy_path]
+
+        f.write("# ID's that are commonly used\n")
+        for id_pair in id_to_paths_cache.values():
+            f.write("%s = %s\n" % (id_pair[0], id_pair[1]))
+        f.write("\n")
+
+        # write paths
+        f.write("# Path Definitions\n")
+        for ksp in ks.paths:
+            f.write("ksp = ks.paths.add(")
+
+            # id-block + data_path
+            if ksp.id:
+                # find the relevant shorthand from the cache
+                id_bpy_path = id_to_paths_cache[ksp.id][0]
+            else:
+                id_bpy_path = "None"  # XXX...
+            f.write("%s, '%s'" % (id_bpy_path, ksp.data_path))
+
+            # array index settings (if applicable)
+            if ksp.use_entire_array:
+                f.write(", index=-1")
+            else:
+                f.write(", index=%d" % ksp.array_index)
+
+            # grouping settings (if applicable)
+            # NOTE: the current default is KEYINGSET, but if this changes,
+            # change this code too
+            if ksp.group_method == 'NAMED':
+                f.write(", group_method='%s', group_name=\"%s\"" %
+                        (ksp.group_method, ksp.group))
+            elif ksp.group_method != 'KEYINGSET':
+                f.write(", group_method='%s'" % ksp.group_method)
+
+            # finish off
+            f.write(")\n")
+
+        f.write("\n")
+        f.close()
+
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+
+class BakeAction(Operator):
+    """Bake animation to an Action"""
+    bl_idname = "nla.bake"
+    bl_label = "Bake Action"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    frame_start = IntProperty(
+            name="Start Frame",
+            description="Start frame for baking",
+            min=0, max=300000,
+            default=1,
+            )
+    frame_end = IntProperty(
+            name="End Frame",
+            description="End frame for baking",
+            min=1, max=300000,
+            default=250,
+            )
+    step = IntProperty(
+            name="Frame Step",
+            description="Frame Step",
+            min=1, max=120,
+            default=1,
+            )
+    only_selected = BoolProperty(
+            name="Only Selected",
+            default=True,
+            )
+    clear_consraints = BoolProperty(
+            name="Clear Constraints",
+            default=False,
+            )
+    bake_types = EnumProperty(
+            name="Bake Data",
+            options={'ENUM_FLAG'},
+            items=(('POSE', "Pose", ""),
+                   ('OBJECT', "Object", ""),
+                   ),
+            default={'POSE'},
+            )
+
+    def execute(self, context):
+
+        from bpy_extras import anim_utils
+
+        action = anim_utils.bake_action(self.frame_start,
+                                        self.frame_end,
+                                        self.step,
+                                        self.only_selected,
+                                        'POSE' in self.bake_types,
+                                        'OBJECT' in self.bake_types,
+                                        self.clear_consraints,
+                                        True,
+                                 )
+
+        if action is None:
+            self.report({'INFO'}, "Nothing to bake")
+            return {'CANCELLED'}
+
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        return wm.invoke_props_dialog(self)
+
+
+class ClearUselessActions(Operator):
+    """Mark actions with no F-Curves for deletion after save+reload of """ \
+    """file preserving "action libraries"""
+    bl_idname = "anim.clear_useless_actions"
+    bl_label = "Clear Useless Actions"
+    bl_options = {'REGISTER', 'UNDO'}
+
+    only_unused = BoolProperty(name="Only Unused",
+            description="Only unused (Fake User only) actions get considered",
+            default=True)
+
+    @classmethod
+    def poll(cls, context):
+        return len(bpy.data.actions) != 0
+
+    def execute(self, context):
+        removed = 0
+
+        for action in bpy.data.actions:
+            # if only user is "fake" user...
+            if ((self.only_unused is False) or
+                (action.use_fake_user and action.users == 1)):
+
+                # if it has F-Curves, then it's a "action library"
+                # (i.e. walk, wave, jump, etc.)
+                # and should be left alone as that's what fake users are for!
+                if not action.fcurves:
+                    # mark action for deletion
+                    action.user_clear()
+                    removed += 1
+
+        self.report({'INFO'}, "Removed %d empty and/or fake-user only Actions"
+                              % removed)
+        return {'FINISHED'}
+
+
+class UpdateAnimData(Operator):
+    """Update data paths from 2.56 and previous versions, """ \
+    """modifying data paths of drivers and fcurves"""
+    bl_idname = "anim.update_data_paths"
+    bl_label = "Update Animation Data"
+
+    def execute(self, context):
+        import animsys_refactor
+        animsys_refactor.update_data_paths(animsys_refactor.data_2_56_to_2_59)
+        return {'FINISHED'}

release/scripts/startup/bl_operators/animsys_update.py

@@ -1,699 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# <pep8 compliant>
-
-data_path_update = [
-    ("ClothCollisionSettings", "min_distance", "distance_min"),
-    ("ClothCollisionSettings", "self_min_distance", "self_distance_min"),
-    ("ClothCollisionSettings", "enable_collision", "use_collision"),
-    ("ClothCollisionSettings", "enable_self_collision", "use_self_collision"),
-    ("ClothSettings", "pin_cloth", "use_pin_cloth"),
-    ("ClothSettings", "stiffness_scaling", "use_stiffness_scale"),
-    ("CollisionSettings", "random_damping", "damping_random"),
-    ("CollisionSettings", "random_friction", "friction_random"),
-    ("CollisionSettings", "inner_thickness", "thickness_inner"),
-    ("CollisionSettings", "outer_thickness", "thickness_outer"),
-    ("CollisionSettings", "kill_particles", "use_particle_kill"),
-    ("Constraint", "proxy_local", "is_proxy_local"),
-    ("ActionConstraint", "maximum", "max"),
-    ("ActionConstraint", "minimum", "min"),
-    ("FollowPathConstraint", "use_fixed_position", "use_fixed_location"),
-    ("KinematicConstraint", "chain_length", "chain_count"),
-    ("KinematicConstraint", "pos_lock_x", "lock_location_x"),
-    ("KinematicConstraint", "pos_lock_y", "lock_location_y"),
-    ("KinematicConstraint", "pos_lock_z", "lock_location_z"),
-    ("KinematicConstraint", "rot_lock_x", "lock_rotation_x"),
-    ("KinematicConstraint", "rot_lock_y", "lock_rotation_y"),
-    ("KinematicConstraint", "rot_lock_z", "lock_rotation_z"),
-    ("KinematicConstraint", "axis_reference", "reference_axis"),
-    ("KinematicConstraint", "use_position", "use_location"),
-    ("LimitLocationConstraint", "maximum_x", "max_x"),
-    ("LimitLocationConstraint", "maximum_y", "max_y"),
-    ("LimitLocationConstraint", "maximum_z", "max_z"),
-    ("LimitLocationConstraint", "minimum_x", "min_x"),
-    ("LimitLocationConstraint", "minimum_y", "min_y"),
-    ("LimitLocationConstraint", "minimum_z", "min_z"),
-    ("LimitLocationConstraint", "use_maximum_x", "use_max_x"),
-    ("LimitLocationConstraint", "use_maximum_y", "use_max_y"),
-    ("LimitLocationConstraint", "use_maximum_z", "use_max_z"),
-    ("LimitLocationConstraint", "use_minimum_x", "use_min_x"),
-    ("LimitLocationConstraint", "use_minimum_y", "use_min_y"),
-    ("LimitLocationConstraint", "use_minimum_z", "use_min_z"),
-    ("LimitLocationConstraint", "limit_transform", "use_transform_limit"),
-    ("LimitRotationConstraint", "maximum_x", "max_x"),
-    ("LimitRotationConstraint", "maximum_y", "max_y"),
-    ("LimitRotationConstraint", "maximum_z", "max_z"),
-    ("LimitRotationConstraint", "minimum_x", "min_x"),
-    ("LimitRotationConstraint", "minimum_y", "min_y"),
-    ("LimitRotationConstraint", "minimum_z", "min_z"),
-    ("LimitRotationConstraint", "limit_transform", "use_transform_limit"),
-    ("LimitScaleConstraint", "maximum_x", "max_x"),
-    ("LimitScaleConstraint", "maximum_y", "max_y"),
-    ("LimitScaleConstraint", "maximum_z", "max_z"),
-    ("LimitScaleConstraint", "minimum_x", "min_x"),
-    ("LimitScaleConstraint", "minimum_y", "min_y"),
-    ("LimitScaleConstraint", "minimum_z", "min_z"),
-    ("LimitScaleConstraint", "use_maximum_x", "use_max_x"),
-    ("LimitScaleConstraint", "use_maximum_y", "use_max_y"),
-    ("LimitScaleConstraint", "use_maximum_z", "use_max_z"),
-    ("LimitScaleConstraint", "use_minimum_x", "use_min_x"),
-    ("LimitScaleConstraint", "use_minimum_y", "use_min_y"),
-    ("LimitScaleConstraint", "use_minimum_z", "use_min_z"),
-    ("LimitScaleConstraint", "limit_transform", "use_transform_limit"),
-    ("PivotConstraint", "enabled_rotation_range", "rotation_range"),
-    ("PivotConstraint", "use_relative_position", "use_relative_location"),
-    ("PythonConstraint", "number_of_targets", "target_count"),
-    ("SplineIKConstraint", "chain_length", "chain_count"),
-    ("SplineIKConstraint", "chain_offset", "use_chain_offset"),
-    ("SplineIKConstraint", "even_divisions", "use_even_divisions"),
-    ("SplineIKConstraint", "y_stretch", "use_y_stretch"),
-    ("SplineIKConstraint", "xz_scaling_mode", "xz_scale_mode"),
-    ("StretchToConstraint", "original_length", "rest_length"),
-    ("TrackToConstraint", "target_z", "use_target_z"),
-    ("TransformConstraint", "extrapolate_motion", "use_motion_extrapolate"),
-    ("FieldSettings", "do_location", "apply_to_location"),
-    ("FieldSettings", "do_rotation", "apply_to_rotation"),
-    ("FieldSettings", "maximum_distance", "distance_max"),
-    ("FieldSettings", "minimum_distance", "distance_min"),
-    ("FieldSettings", "radial_maximum", "radial_max"),
-    ("FieldSettings", "radial_minimum", "radial_min"),
-    ("FieldSettings", "force_2d", "use_2d_force"),
-    ("FieldSettings", "do_absorption", "use_absorption"),
-    ("FieldSettings", "global_coordinates", "use_global_coords"),
-    ("FieldSettings", "guide_path_add", "use_guide_path_add"),
-    ("FieldSettings", "multiple_springs", "use_multiple_springs"),
-    ("FieldSettings", "use_coordinates", "use_object_coords"),
-    ("FieldSettings", "root_coordinates", "use_root_coords"),
-    ("ControlFluidSettings", "reverse_frames", "use_reverse_frames"),
-    ("DomainFluidSettings", "real_world_size", "simulation_scale"),
-    ("DomainFluidSettings", "surface_smoothing", "surface_smooth"),
-    ("DomainFluidSettings", "reverse_frames", "use_reverse_frames"),
-    ("DomainFluidSettings", "generate_speed_vectors", "use_speed_vectors"),
-    ("DomainFluidSettings", "override_time", "use_time_override"),
-    ("FluidFluidSettings", "export_animated_mesh", "use_animated_mesh"),
-    ("InflowFluidSettings", "export_animated_mesh", "use_animated_mesh"),
-    ("InflowFluidSettings", "local_coordinates", "use_local_coords"),
-    ("ObstacleFluidSettings", "export_animated_mesh", "use_animated_mesh"),
-    ("OutflowFluidSettings", "export_animated_mesh", "use_animated_mesh"),
-    ("ParticleFluidSettings", "drops", "use_drops"),
-    ("ParticleFluidSettings", "floats", "use_floats"),
-    ("Armature", "drawtype", "draw_type"),
-    ("Armature", "layer_protection", "layers_protected"),
-    ("Armature", "auto_ik", "use_auto_ik"),
-    ("Armature", "delay_deform", "use_deform_delay"),
-    ("Armature", "deform_envelope", "use_deform_envelopes"),
-    ("Armature", "deform_quaternion", "use_deform_preserve_volume"),
-    ("Armature", "deform_vertexgroups", "use_deform_vertex_groups"),
-    ("Armature", "x_axis_mirror", "use_mirror_x"),
-    ("Curve", "width", "offset"),
-    ("Image", "animation_speed", "fps"),
-    ("Image", "animation_end", "frame_end"),
-    ("Image", "animation_start", "frame_start"),
-    ("Image", "animated", "use_animation"),
-    ("Image", "clamp_x", "use_clamp_x"),
-    ("Image", "clamp_y", "use_clamp_y"),
-    ("Image", "premultiply", "use_premultiply"),
-    ("AreaLamp", "shadow_ray_sampling_method", "shadow_ray_sample_method"),
-    ("AreaLamp", "only_shadow", "use_only_shadow"),
-    ("AreaLamp", "shadow_layer", "use_shadow_layer"),
-    ("AreaLamp", "umbra", "use_umbra"),
-    ("PointLamp", "shadow_ray_sampling_method", "shadow_ray_sample_method"),
-    ("PointLamp", "only_shadow", "use_only_shadow"),
-    ("PointLamp", "shadow_layer", "use_shadow_layer"),
-    ("PointLamp", "sphere", "use_sphere"),
-    ("SpotLamp", "shadow_ray_sampling_method", "shadow_ray_sample_method"),
-    ("SpotLamp", "auto_clip_end", "use_auto_clip_end"),
-    ("SpotLamp", "auto_clip_start", "use_auto_clip_start"),
-    ("SpotLamp", "only_shadow", "use_only_shadow"),
-    ("SpotLamp", "shadow_layer", "use_shadow_layer"),
-    ("SpotLamp", "sphere", "use_sphere"),
-    ("SunLamp", "only_shadow", "use_only_shadow"),
-    ("SunLamp", "shadow_layer", "use_shadow_layer"),
-    ("Material", "z_offset", "offset_z"),
-    ("Material", "shadow_casting_alpha", "shadow_cast_alpha"),
-    ("Material", "cast_approximate", "use_cast_approximate"),
-    ("Material", "cast_buffer_shadows", "use_cast_buffer_shadows"),
-    ("Material", "cast_shadows_only", "use_cast_shadows_only"),
-    ("Material", "face_texture", "use_face_texture"),
-    ("Material", "face_texture_alpha", "use_face_texture_alpha"),
-    ("Material", "full_oversampling", "use_full_oversampling"),
-    ("Material", "light_group_exclusive", "use_light_group_exclusive"),
-    ("Material", "object_color", "use_object_color"),
-    ("Material", "only_shadow", "use_only_shadow"),
-    ("Material", "ray_shadow_bias", "use_ray_shadow_bias"),
-    ("Material", "traceable", "use_raytrace"),
-    ("Material", "shadeless", "use_shadeless"),
-    ("Material", "tangent_shading", "use_tangent_shading"),
-    ("Material", "transparency", "use_transparency"),
-    ("Material", "receive_transparent_shadows", "use_transparent_shadows"),
-    ("Material", "vertex_color_light", "use_vertex_color_light"),
-    ("Material", "vertex_color_paint", "use_vertex_color_paint"),
-    ("Mesh", "autosmooth_angle", "auto_smooth_angle"),
-    ("Mesh", "autosmooth", "use_auto_smooth"),
-    ("Object", "max_draw_type", "draw_type"),
-    ("Object", "use_dupli_verts_rotation", "use_dupli_vertices_rotation"),
-    ("Object", "shape_key_edit_mode", "use_shape_key_edit_mode"),
-    ("Object", "slow_parent", "use_slow_parent"),
-    ("Object", "time_offset_add_parent", "use_time_offset_add_parent"),
-    ("Object", "time_offset_edit", "use_time_offset_edit"),
-    ("Object", "time_offset_parent", "use_time_offset_parent"),
-    ("Object", "time_offset_particle", "use_time_offset_particle"),
-    ("ParticleSettings", "adaptive_pix", "adaptive_pixel"),
-    ("ParticleSettings", "child_effector", "apply_effector_to_children"),
-    ("ParticleSettings", "child_guide", "apply_guide_to_children"),
-    ("ParticleSettings", "billboard_split_offset", "billboard_offset_split"),
-    ("ParticleSettings", "billboard_random_tilt", "billboard_tilt_random"),
-    ("ParticleSettings", "child_length_thres", "child_length_threshold"),
-    ("ParticleSettings", "child_random_size", "child_size_random"),
-    ("ParticleSettings", "clumppow", "clump_shape"),
-    ("ParticleSettings", "damp_factor", "damping"),
-    ("ParticleSettings", "draw_as", "draw_method"),
-    ("ParticleSettings", "random_factor", "factor_random"),
-    ("ParticleSettings", "grid_invert", "invert_grid"),
-    ("ParticleSettings", "random_length", "length_random"),
-    ("ParticleSettings", "random_lifetime", "lifetime_random"),
-    ("ParticleSettings", "billboard_lock", "lock_billboard"),
-    ("ParticleSettings", "boids_2d", "lock_boids_to_surface"),
-    ("ParticleSettings", "object_aligned_factor", "object_align_factor"),
-    ("ParticleSettings", "random_phase_factor", "phase_factor_random"),
-    ("ParticleSettings", "ren_as", "render_type"),
-    ("ParticleSettings", "rendered_child_nbr", "rendered_child_count"),
-    ("ParticleSettings", "random_rotation_factor", "rotation_factor_random"),
-    ("ParticleSettings", "rough1", "roughness_1"),
-    ("ParticleSettings", "rough1_size", "roughness_1_size"),
-    ("ParticleSettings", "rough2", "roughness_2"),
-    ("ParticleSettings", "rough2_size", "roughness_2_size"),
-    ("ParticleSettings", "rough2_thres", "roughness_2_threshold"),
-    ("ParticleSettings", "rough_end_shape", "roughness_end_shape"),
-    ("ParticleSettings", "rough_endpoint", "roughness_endpoint"),
-    ("ParticleSettings", "random_size", "size_random"),
-    ("ParticleSettings", "abs_path_time", "use_absolute_path_time"),
-    ("ParticleSettings", "animate_branching", "use_animate_branching"),
-    ("ParticleSettings", "branching", "use_branching"),
-    ("ParticleSettings", "died", "use_dead"),
-    ("ParticleSettings", "die_on_collision", "use_die_on_collision"),
-    ("ParticleSettings", "rotation_dynamic", "use_dynamic_rotation"),
-    ("ParticleSettings", "even_distribution", "use_even_distribution"),
-    ("ParticleSettings", "rand_group", "use_group_pick_random"),
-    ("ParticleSettings", "hair_bspline", "use_hair_bspline"),
-    ("ParticleSettings", "sizemass", "use_multiply_size_mass"),
-    ("ParticleSettings", "react_multiple", "use_react_multiple"),
-    ("ParticleSettings", "react_start_end", "use_react_start_end"),
-    ("ParticleSettings", "render_adaptive", "use_render_adaptive"),
-    ("ParticleSettings", "self_effect", "use_self_effect"),
-    ("ParticleSettings", "enable_simplify", "use_simplify"),
-    ("ParticleSettings", "size_deflect", "use_size_deflect"),
-    ("ParticleSettings", "render_strand", "use_strand_primitive"),
-    ("ParticleSettings", "symmetric_branching", "use_symmetric_branching"),
-    ("ParticleSettings", "velocity_length", "use_velocity_length"),
-    ("ParticleSettings", "whole_group", "use_whole_group"),
-    ("CloudsTexture", "noise_size", "noise_scale"),
-    ("DistortedNoiseTexture", "noise_size", "noise_scale"),
-    ("EnvironmentMapTexture", "filter_size_minimum", "use_filter_size_min"),
-    ("EnvironmentMapTexture", "mipmap_gauss", "use_mipmap_gauss"),
-    ("ImageTexture", "calculate_alpha", "use_calculate_alpha"),
-    ("ImageTexture", "checker_even", "use_checker_even"),
-    ("ImageTexture", "checker_odd", "use_checker_odd"),
-    ("ImageTexture", "filter_size_minimum", "use_filter_size_min"),
-    ("ImageTexture", "flip_axis", "use_flip_axis"),
-    ("ImageTexture", "mipmap_gauss", "use_mipmap_gauss"),
-    ("ImageTexture", "mirror_x", "use_mirror_x"),
-    ("ImageTexture", "mirror_y", "use_mirror_y"),
-    ("ImageTexture", "normal_map", "use_normal_map"),
-    ("MarbleTexture", "noise_size", "noise_scale"),
-    ("MarbleTexture", "noisebasis2", "noise_basis_2"),
-    ("MarbleTexture", "noisebasis_2", "noise_basis_2"),
-    ("MusgraveTexture", "highest_dimension", "dimension_max"),
-    ("MusgraveTexture", "noise_size", "noise_scale"),
-    ("StucciTexture", "noise_size", "noise_scale"),
-    ("VoronoiTexture", "coloring", "color_mode"),
-    ("VoronoiTexture", "noise_size", "noise_scale"),
-    ("WoodTexture", "noise_size", "noise_scale"),
-    ("WoodTexture", "noisebasis2", "noise_basis_2"),
-    ("WoodTexture", "noisebasis_2", "noise_basis_2"),
-    ("World", "blend_sky", "use_sky_blend"),
-    ("World", "paper_sky", "use_sky_paper"),
-    ("World", "real_sky", "use_sky_real"),
-    ("ImageUser", "auto_refresh", "use_auto_refresh"),
-    ("MaterialHalo", "flares_sub", "flare_subflare_count"),
-    ("MaterialHalo", "flare_subsize", "flare_subflare_size"),
-    ("MaterialHalo", "line_number", "line_count"),
-    ("MaterialHalo", "rings", "ring_count"),
-    ("MaterialHalo", "star_tips", "star_tip_count"),
-    ("MaterialHalo", "xalpha", "use_extreme_alpha"),
-    ("MaterialHalo", "flare_mode", "use_flare_mode"),
-    ("MaterialHalo", "vertex_normal", "use_vertex_normal"),
-    ("MaterialPhysics", "align_to_normal", "use_normal_align"),
-    ("MaterialStrand", "min_size", "size_min"),
-    ("MaterialStrand", "blender_units", "use_blender_units"),
-    ("MaterialStrand", "surface_diffuse", "use_surface_diffuse"),
-    ("MaterialStrand", "tangent_shading", "use_tangent_shading"),
-    ("MaterialSubsurfaceScattering", "error_tolerance", "error_threshold"),
-    ("MaterialVolume", "depth_cutoff", "depth_threshold"),
-    ("MaterialVolume", "lighting_mode", "light_method"),
-    ("MaterialVolume", "step_calculation", "step_method"),
-    ("MaterialVolume", "external_shadows", "use_external_shadows"),
-    ("MaterialVolume", "light_cache", "use_light_cache"),
-    ("ArmatureModifier", "multi_modifier", "use_multi_modifier"),
-    ("ArrayModifier", "constant_offset_displacement", "constant_offset_displace"),
-    ("ArrayModifier", "merge_distance", "merge_threshold"),
-    ("ArrayModifier", "relative_offset_displacement", "relative_offset_displace"),
-    ("ArrayModifier", "constant_offset", "use_constant_offset"),
-    ("ArrayModifier", "merge_adjacent_vertices", "use_merge_vertices"),
-    ("ArrayModifier", "merge_end_vertices", "use_merge_vertices_cap"),
-    ("ArrayModifier", "add_offset_object", "use_object_offset"),
-    ("ArrayModifier", "relative_offset", "use_relative_offset"),
-    ("BevelModifier", "only_vertices", "use_only_vertices"),
-    ("CastModifier", "from_radius", "use_radius_as_size"),
-    ("DisplaceModifier", "midlevel", "mid_level"),
-    ("DisplaceModifier", "texture_coordinates", "texture_coords"),
-    ("EdgeSplitModifier", "use_sharp", "use_edge_sharp"),
-    ("ExplodeModifier", "split_edges", "use_edge_split"),
-    ("MirrorModifier", "merge_limit", "merge_threshold"),
-    ("MirrorModifier", "mirror_u", "use_mirror_u"),
-    ("MirrorModifier", "mirror_v", "use_mirror_v"),
-    ("MirrorModifier", "mirror_vertex_groups", "use_mirror_vertex_groups"),
-    ("ParticleInstanceModifier", "particle_system_number", "particle_system_index"),
-    ("ParticleInstanceModifier", "keep_shape", "use_preserve_shape"),
-    ("ShrinkwrapModifier", "cull_back_faces", "use_cull_back_faces"),
-    ("ShrinkwrapModifier", "cull_front_faces", "use_cull_front_faces"),
-    ("ShrinkwrapModifier", "keep_above_surface", "use_keep_above_surface"),
-    ("SimpleDeformModifier", "lock_x_axis", "lock_x"),
-    ("SimpleDeformModifier", "lock_y_axis", "lock_y"),
-    ("SmokeModifier", "smoke_type", "type"),
-    ("SubsurfModifier", "subsurf_uv", "use_subsurf_uv"),
-    ("UVProjectModifier", "num_projectors", "projector_count"),
-    ("UVProjectModifier", "override_image", "use_image_override"),
-    ("WaveModifier", "texture_coordinates", "texture_coords"),
-    ("WaveModifier", "x_normal", "use_normal_x"),
-    ("WaveModifier", "y_normal", "use_normal_y"),
-    ("WaveModifier", "z_normal", "use_normal_z"),
-    ("NlaStrip", "blending", "blend_type"),
-    ("NlaStrip", "animated_influence", "use_animated_influence"),
-    ("NlaStrip", "animated_time", "use_animated_time"),
-    ("NlaStrip", "animated_time_cyclic", "use_animated_time_cyclic"),
-    ("NlaStrip", "auto_blending", "use_auto_blend"),
-    ("CompositorNodeAlphaOver", "convert_premul", "use_premultiply"),
-    ("CompositorNodeBlur", "sizex", "size_x"),
-    ("CompositorNodeBlur", "sizey", "size_y"),
-    ("CompositorNodeChannelMatte", "algorithm", "limit_method"),
-    ("CompositorNodeChromaMatte", "acceptance", "tolerance"),
-    ("CompositorNodeColorBalance", "correction_formula", "correction_method"),
-    ("CompositorNodeColorSpill", "algorithm", "limit_method"),
-    ("CompositorNodeColorSpill", "unspill", "use_unspill"),
-    ("CompositorNodeCrop", "x2", "max_x"),
-    ("CompositorNodeCrop", "y2", "max_y"),
-    ("CompositorNodeCrop", "x1", "min_x"),
-    ("CompositorNodeCrop", "y1", "min_y"),
-    ("CompositorNodeCrop", "crop_size", "use_crop_size"),
-    ("CompositorNodeDefocus", "max_blur", "blur_max"),
-    ("CompositorNodeDefocus", "gamma_correction", "use_gamma_correction"),
-    ("CompositorNodeGlare", "rotate_45", "use_rotate_45"),
-    ("CompositorNodeImage", "auto_refresh", "use_auto_refresh"),
-    ("CompositorNodeLensdist", "projector", "use_projector"),
-    ("CompositorNodeVecBlur", "max_speed", "speed_max"),
-    ("CompositorNodeVecBlur", "min_speed", "speed_min"),
-    ("ShaderNodeMapping", "maximum", "max"),
-    ("ShaderNodeMapping", "minimum", "min"),
-    ("ShaderNodeMapping", "clamp_maximum", "use_max"),
-    ("ShaderNodeMapping", "clamp_minimum", "use_min"),
-    ("VertexPaint", "all_faces", "use_all_faces"),
-    ("VertexPaint", "spray", "use_spray"),
-    ("ParticleEdit", "add_keys", "default_key_count"),
-    ("ParticleEdit", "selection_mode", "select_mode"),
-    ("ParticleEdit", "auto_velocity", "use_auto_velocity"),
-    ("ParticleEdit", "add_interpolate", "use_default_interpolate"),
-    ("ParticleEdit", "emitter_deflect", "use_emitter_deflect"),
-    ("ParticleEdit", "fade_time", "use_fade_time"),
-    ("ParticleEdit", "keep_lengths", "use_preserve_length"),
-    ("ParticleEdit", "keep_root", "use_preserve_root"),
-    ("ParticleSystem", "vertex_group_clump_negate", "invert_vertex_group_clump"),
-    ("ParticleSystem", "vertex_group_density_negate", "invert_vertex_group_density"),
-    ("ParticleSystem", "vertex_group_field_negate", "invert_vertex_group_field"),
-    ("ParticleSystem", "vertex_group_kink_negate", "invert_vertex_group_kink"),
-    ("ParticleSystem", "vertex_group_length_negate", "invert_vertex_group_length"),
-    ("ParticleSystem", "vertex_group_rotation_negate", "invert_vertex_group_rotation"),
-    ("ParticleSystem", "vertex_group_roughness1_negate", "invert_vertex_group_roughness_1"),
-    ("ParticleSystem", "vertex_group_roughness2_negate", "invert_vertex_group_roughness_2"),
-    ("ParticleSystem", "vertex_group_roughness_end_negate", "invert_vertex_group_roughness_end"),
-    ("ParticleSystem", "vertex_group_size_negate", "invert_vertex_group_size"),
-    ("ParticleSystem", "vertex_group_tangent_negate", "invert_vertex_group_tangent"),
-    ("ParticleSystem", "vertex_group_velocity_negate", "invert_vertex_group_velocity"),
-    ("ParticleSystem", "hair_dynamics", "use_hair_dynamics"),
-    ("ParticleSystem", "keyed_timing", "use_keyed_timing"),
-    ("PointDensity", "falloff_softness", "falloff_soft"),
-    ("PointDensity", "particle_cache", "particle_cache_space"),
-    ("PointDensity", "turbulence_size", "turbulence_scale"),
-    ("PointDensity", "turbulence", "use_turbulence"),
-    ("PointDensity", "vertices_cache", "vertex_cache_space"),
-    ("PoseBone", "ik_lin_weight", "ik_linear_weight"),
-    ("PoseBone", "ik_rot_weight", "ik_rotation_weight"),
-    ("PoseBone", "ik_limit_x", "use_ik_limit_x"),
-    ("PoseBone", "ik_limit_y", "use_ik_limit_y"),
-    ("PoseBone", "ik_limit_z", "use_ik_limit_z"),
-    ("PoseBone", "ik_lin_control", "use_ik_linear_control"),
-    ("PoseBone", "ik_rot_control", "use_ik_rotation_control"),
-    ("Bone", "use_hinge", "use_inherit_rotation"),
-    ("SPHFluidSettings", "spring_k", "spring_force"),
-    ("SPHFluidSettings", "stiffness_k", "stiffness"),
-    ("SPHFluidSettings", "stiffness_knear", "stiffness_near"),
-    ("SceneGameData", "framing_color", "frame_color"),
-    ("SceneGameData", "framing_type", "frame_type"),
-    ("SceneGameData", "eye_separation", "stereo_eye_separation"),
-    ("SceneGameData", "activity_culling", "use_activity_culling"),
-    ("SceneGameData", "auto_start", "use_auto_start"),
-    ("SceneGameData", "glsl_extra_textures", "use_glsl_extra_textures"),
-    ("SceneGameData", "glsl_lights", "use_glsl_lights"),
-    ("SceneGameData", "glsl_nodes", "use_glsl_nodes"),
-    ("SceneGameData", "glsl_ramps", "use_glsl_ramps"),
-    ("SceneGameData", "glsl_shaders", "use_glsl_shaders"),
-    ("SceneGameData", "glsl_shadows", "use_glsl_shadows"),
-    ("Sequence", "blend_opacity", "blend_alpha"),
-    ("Sequence", "blend_mode", "blend_type"),
-    ("Sequence", "frame_final_length", "frame_final_duration"),
-    ("Sequence", "use_effect_default_fade", "use_default_fade"),
-    ("SequenceColorBalance", "inverse_gain", "invert_gain"),
-    ("SequenceColorBalance", "inverse_gamma", "invert_gamma"),
-    ("SequenceColorBalance", "inverse_lift", "invert_lift"),
-    ("EffectSequence", "multiply_colors", "color_multiply"),
-    ("EffectSequence", "de_interlace", "use_deinterlace"),
-    ("EffectSequence", "flip_x", "use_flip_x"),
-    ("EffectSequence", "flip_y", "use_flip_y"),
-    ("EffectSequence", "convert_float", "use_float"),
-    ("EffectSequence", "premultiply", "use_premultiply"),
-    ("EffectSequence", "proxy_custom_directory", "use_proxy_custom_directory"),
-    ("EffectSequence", "proxy_custom_file", "use_proxy_custom_file"),
-    ("EffectSequence", "reverse_frames", "use_reverse_frames"),
-    ("GlowSequence", "blur_distance", "blur_radius"),
-    ("GlowSequence", "only_boost", "use_only_boost"),
-    ("SpeedControlSequence", "curve_compress_y", "use_curve_compress_y"),
-    ("SpeedControlSequence", "curve_velocity", "use_curve_velocity"),
-    ("SpeedControlSequence", "frame_blending", "use_frame_blend"),
-    ("TransformSequence", "uniform_scale", "use_uniform_scale"),
-    ("ImageSequence", "animation_end_offset", "animation_offset_end"),
-    ("ImageSequence", "animation_start_offset", "animation_offset_start"),
-    ("ImageSequence", "multiply_colors", "color_multiply"),
-    ("ImageSequence", "de_interlace", "use_deinterlace"),
-    ("ImageSequence", "flip_x", "use_flip_x"),
-    ("ImageSequence", "flip_y", "use_flip_y"),
-    ("ImageSequence", "convert_float", "use_float"),
-    ("ImageSequence", "premultiply", "use_premultiply"),
-    ("ImageSequence", "proxy_custom_directory", "use_proxy_custom_directory"),
-    ("ImageSequence", "proxy_custom_file", "use_proxy_custom_file"),
-    ("ImageSequence", "reverse_frames", "use_reverse_frames"),
-    ("MetaSequence", "animation_end_offset", "animation_offset_end"),
-    ("MetaSequence", "animation_start_offset", "animation_offset_start"),
-    ("MetaSequence", "multiply_colors", "color_multiply"),
-    ("MetaSequence", "de_interlace", "use_deinterlace"),
-    ("MetaSequence", "flip_x", "use_flip_x"),
-    ("MetaSequence", "flip_y", "use_flip_y"),
-    ("MetaSequence", "convert_float", "use_float"),
-    ("MetaSequence", "premultiply", "use_premultiply"),
-    ("MetaSequence", "proxy_custom_directory", "use_proxy_custom_directory"),
-    ("MetaSequence", "proxy_custom_file", "use_proxy_custom_file"),
-    ("MetaSequence", "reverse_frames", "use_reverse_frames"),
-    ("MovieSequence", "animation_end_offset", "animation_offset_end"),
-    ("MovieSequence", "animation_start_offset", "animation_offset_start"),
-    ("MovieSequence", "multiply_colors", "color_multiply"),
-    ("MovieSequence", "de_interlace", "use_deinterlace"),
-    ("MovieSequence", "flip_x", "use_flip_x"),
-    ("MovieSequence", "flip_y", "use_flip_y"),
-    ("MovieSequence", "convert_float", "use_float"),
-    ("MovieSequence", "premultiply", "use_premultiply"),
-    ("MovieSequence", "proxy_custom_directory", "use_proxy_custom_directory"),
-    ("MovieSequence", "proxy_custom_file", "use_proxy_custom_file"),
-    ("MovieSequence", "reverse_frames", "use_reverse_frames"),
-    ("MulticamSequence", "animation_end_offset", "animation_offset_end"),
-    ("MulticamSequence", "animation_start_offset", "animation_offset_start"),
-    ("MulticamSequence", "multiply_colors", "color_multiply"),
-    ("MulticamSequence", "de_interlace", "use_deinterlace"),
-    ("MulticamSequence", "flip_x", "use_flip_x"),
-    ("MulticamSequence", "flip_y", "use_flip_y"),
-    ("MulticamSequence", "convert_float", "use_float"),
-    ("MulticamSequence", "premultiply", "use_premultiply"),
-    ("MulticamSequence", "proxy_custom_directory", "use_proxy_custom_directory"),
-    ("MulticamSequence", "proxy_custom_file", "use_proxy_custom_file"),
-    ("MulticamSequence", "reverse_frames", "use_reverse_frames"),
-    ("SceneSequence", "animation_end_offset", "animation_offset_end"),
-    ("SceneSequence", "animation_start_offset", "animation_offset_start"),
-    ("SceneSequence", "multiply_colors", "color_multiply"),
-    ("SceneSequence", "de_interlace", "use_deinterlace"),
-    ("SceneSequence", "flip_x", "use_flip_x"),
-    ("SceneSequence", "flip_y", "use_flip_y"),
-    ("SceneSequence", "convert_float", "use_float"),
-    ("SceneSequence", "premultiply", "use_premultiply"),
-    ("SceneSequence", "proxy_custom_directory", "use_proxy_custom_directory"),
-    ("SceneSequence", "proxy_custom_file", "use_proxy_custom_file"),
-    ("SceneSequence", "reverse_frames", "use_reverse_frames"),
-    ("SoundSequence", "animation_end_offset", "animation_offset_end"),
-    ("SoundSequence", "animation_start_offset", "animation_offset_start"),
-    ("SmokeDomainSettings", "smoke_domain_colli", "collision_extents"),
-    ("SmokeDomainSettings", "smoke_cache_high_comp", "point_cache_compress_high_type"),
-    ("SmokeDomainSettings", "smoke_cache_comp", "point_cache_compress_type"),
-    ("SmokeDomainSettings", "maxres", "resolution_max"),
-    ("SmokeDomainSettings", "smoothemitter", "smooth_emitter"),
-    ("SmokeDomainSettings", "dissolve_smoke", "use_dissolve_smoke"),
-    ("SmokeDomainSettings", "dissolve_smoke_log", "use_dissolve_smoke_log"),
-    ("SmokeDomainSettings", "highres", "use_high_resolution"),
-    ("SoftBodySettings", "bending", "bend"),
-    ("SoftBodySettings", "error_limit", "error_threshold"),
-    ("SoftBodySettings", "lcom", "location_mass_center"),
-    ("SoftBodySettings", "lrot", "rotation_estimate"),
-    ("SoftBodySettings", "lscale", "scale_estimate"),
-    ("SoftBodySettings", "maxstep", "step_max"),
-    ("SoftBodySettings", "minstep", "step_min"),
-    ("SoftBodySettings", "diagnose", "use_diagnose"),
-    ("SoftBodySettings", "edge_collision", "use_edge_collision"),
-    ("SoftBodySettings", "estimate_matrix", "use_estimate_matrix"),
-    ("SoftBodySettings", "face_collision", "use_face_collision"),
-    ("SoftBodySettings", "self_collision", "use_self_collision"),
-    ("SoftBodySettings", "stiff_quads", "use_stiff_quads"),
-    ("TexMapping", "maximum", "max"),
-    ("TexMapping", "minimum", "min"),
-    ("TexMapping", "has_maximum", "use_max"),
-    ("TexMapping", "has_minimum", "use_min"),
-    ("TextCharacterFormat", "bold", "use_bold"),
-    ("TextCharacterFormat", "italic", "use_italic"),
-    ("TextCharacterFormat", "underline", "use_underline"),
-    ("TextureSlot", "rgb_to_intensity", "use_rgb_to_intensity"),
-    ("TextureSlot", "stencil", "use_stencil"),
-    ("LampTextureSlot", "texture_coordinates", "texture_coords"),
-    ("LampTextureSlot", "map_color", "use_map_color"),
-    ("LampTextureSlot", "map_shadow", "use_map_shadow"),
-    ("MaterialTextureSlot", "coloremission_factor", "color_emission_factor"),
-    ("MaterialTextureSlot", "colordiff_factor", "diffuse_color_factor"),
-    ("MaterialTextureSlot", "x_mapping", "mapping_x"),
-    ("MaterialTextureSlot", "y_mapping", "mapping_y"),
-    ("MaterialTextureSlot", "z_mapping", "mapping_z"),
-    ("MaterialTextureSlot", "colorreflection_factor", "reflection_color_factor"),
-    ("MaterialTextureSlot", "colorspec_factor", "specular_color_factor"),
-    ("MaterialTextureSlot", "texture_coordinates", "texture_coords"),
-    ("MaterialTextureSlot", "colortransmission_factor", "transmission_color_factor"),
-    ("MaterialTextureSlot", "from_dupli", "use_from_dupli"),
-    ("MaterialTextureSlot", "from_original", "use_from_original"),
-    ("MaterialTextureSlot", "map_alpha", "use_map_alpha"),
-    ("MaterialTextureSlot", "map_ambient", "use_map_ambient"),
-    ("MaterialTextureSlot", "map_colordiff", "use_map_color_diff"),
-    ("MaterialTextureSlot", "map_coloremission", "use_map_color_emission"),
-    ("MaterialTextureSlot", "map_colorreflection", "use_map_color_reflection"),
-    ("MaterialTextureSlot", "map_colorspec", "use_map_color_spec"),
-    ("MaterialTextureSlot", "map_colortransmission", "use_map_color_transmission"),
-    ("MaterialTextureSlot", "map_density", "use_map_density"),
-    ("MaterialTextureSlot", "map_diffuse", "use_map_diffuse"),
-    ("MaterialTextureSlot", "map_displacement", "use_map_displacement"),
-    ("MaterialTextureSlot", "map_emission", "use_map_emission"),
-    ("MaterialTextureSlot", "map_emit", "use_map_emit"),
-    ("MaterialTextureSlot", "map_hardness", "use_map_hardness"),
-    ("MaterialTextureSlot", "map_mirror", "use_map_mirror"),
-    ("MaterialTextureSlot", "map_normal", "use_map_normal"),
-    ("MaterialTextureSlot", "map_raymir", "use_map_raymir"),
-    ("MaterialTextureSlot", "map_reflection", "use_map_reflect"),
-    ("MaterialTextureSlot", "map_scattering", "use_map_scatter"),
-    ("MaterialTextureSlot", "map_specular", "use_map_specular"),
-    ("MaterialTextureSlot", "map_translucency", "use_map_translucency"),
-    ("MaterialTextureSlot", "map_warp", "use_map_warp"),
-    ("WorldTextureSlot", "texture_coordinates", "texture_coords"),
-    ("WorldTextureSlot", "map_blend", "use_map_blend"),
-    ("WorldTextureSlot", "map_horizon", "use_map_horizon"),
-    ("WorldTextureSlot", "map_zenith_down", "use_map_zenith_down"),
-    ("WorldTextureSlot", "map_zenith_up", "use_map_zenith_up"),
-    ("VoxelData", "still_frame_number", "still_frame"),
-    ("WorldLighting", "ao_blend_mode", "ao_blend_type"),
-    ("WorldLighting", "error_tolerance", "error_threshold"),
-    ("WorldLighting", "use_ambient_occlusion", "use_ambient_occlusian"),
-    ("WorldLighting", "pixel_cache", "use_cache"),
-    ("WorldLighting", "use_environment_lighting", "use_environment_light"),
-    ("WorldLighting", "use_indirect_lighting", "use_indirect_light"),
-    ("WorldStarsSettings", "color_randomization", "color_random"),
-    ("WorldStarsSettings", "min_distance", "distance_min"),
-    ("WorldLighting", "falloff", "use_falloff"),
-    ("Constraint", "disabled", "is_valid"),
-    ("ClampToConstraint", "cyclic", "use_cyclic"),
-    ("ImageTexture", "filter", "filter_type"),
-    ("ImageTexture", "interpolation", "use_interpolation"),
-    ("ImageTexture", "mipmap", "use_mipmap"),
-    ("ImageUser", "frames", "frame_duration"),
-    ("ImageUser", "offset", "frame_offset"),
-    ("ImageUser", "cyclic", "use_cyclic"),
-    ("ArmatureModifier", "invert", "invert_vertex_group"),
-    ("ArmatureModifier", "quaternion", "use_deform_preserve_volume"),
-    ("ArrayModifier", "length", "fit_length"),
-    ("BevelModifier", "angle", "angle_limit"),
-    ("BuildModifier", "length", "frame_duration"),
-    ("BuildModifier", "randomize", "use_random_order"),
-    ("CastModifier", "x", "use_x"),
-    ("CastModifier", "y", "use_y"),
-    ("CastModifier", "z", "use_z"),
-    ("ExplodeModifier", "size", "use_size"),
-    ("MaskModifier", "invert", "invert_vertex_group"),
-    ("MeshDeformModifier", "invert", "invert_vertex_group"),
-    ("MeshDeformModifier", "dynamic", "use_dynamic_bind"),
-    ("MirrorModifier", "clip", "use_clip"),
-    ("MirrorModifier", "x", "use_x"),
-    ("MirrorModifier", "y", "use_y"),
-    ("MirrorModifier", "z", "use_z"),
-    ("ParticleInstanceModifier", "children", "use_children"),
-    ("ParticleInstanceModifier", "normal", "use_normal"),
-    ("ParticleInstanceModifier", "size", "use_size"),
-    ("ShrinkwrapModifier", "negative", "use_negative_direction"),
-    ("ShrinkwrapModifier", "positive", "use_positive_direction"),
-    ("ShrinkwrapModifier", "x", "use_project_x"),
-    ("ShrinkwrapModifier", "y", "use_project_y"),
-    ("ShrinkwrapModifier", "z", "use_project_z"),
-    ("ShrinkwrapModifier", "mode", "wrap_method"),
-    ("SimpleDeformModifier", "mode", "deform_method"),
-    ("SimpleDeformModifier", "relative", "use_relative"),
-    ("SmoothModifier", "repeat", "iterations"),
-    ("SmoothModifier", "x", "use_x"),
-    ("SmoothModifier", "y", "use_y"),
-    ("SmoothModifier", "z", "use_z"),
-    ("SolidifyModifier", "invert", "invert_vertex_group"),
-    ("WaveModifier", "cyclic", "use_cyclic"),
-    ("WaveModifier", "normals", "use_normal"),
-    ("WaveModifier", "x", "use_x"),
-    ("WaveModifier", "y", "use_y"),
-    ("DampedTrackConstraint", "track", "track_axis"),
-    ("FloorConstraint", "sticky", "use_sticky"),
-    ("FollowPathConstraint", "forward", "forward_axis"),
-    ("FollowPathConstraint", "up", "up_axis"),
-    ("LockedTrackConstraint", "lock", "lock_axis"),
-    ("LockedTrackConstraint", "track", "track_axis"),
-    ("MaintainVolumeConstraint", "axis", "free_axis"),
-    ("TrackToConstraint", "track", "track_axis"),
-    ("TrackToConstraint", "up", "up_axis"),
-    ("GameProperty", "debug", "show_debug"),
-    ("Image", "tiles", "use_tiles"),
-    ("Lamp", "diffuse", "use_diffuse"),
-    ("Lamp", "negative", "use_negative"),
-    ("Lamp", "layer", "use_own_layer"),
-    ("Lamp", "specular", "use_specular"),
-    ("AreaLamp", "dither", "use_dither"),
-    ("AreaLamp", "jitter", "use_jitter"),
-    ("SpotLamp", "square", "use_square"),
-    ("Material", "cubic", "use_cubic"),
-    ("Material", "shadows", "use_shadows"),
-    ("ParticleSettings", "amount", "count"),
-    ("ParticleSettings", "display", "draw_percentage"),
-    ("ParticleSettings", "velocity", "show_velocity"),
-    ("ParticleSettings", "trand", "use_emit_random"),
-    ("ParticleSettings", "parent", "use_parent_particles"),
-    ("ParticleSettings", "emitter", "use_render_emitter"),
-    ("ParticleSettings", "viewport", "use_simplify_viewport"),
-    ("Texture", "brightness", "intensity"),
-    ("CloudsTexture", "stype", "cloud_type"),
-    ("EnvironmentMapTexture", "filter", "filter_type"),
-    ("EnvironmentMapTexture", "mipmap", "use_mipmap"),
-    ("MarbleTexture", "stype", "marble_type"),
-    ("StucciTexture", "stype", "stucci_type"),
-    ("WoodTexture", "stype", "wood_type"),
-    ("World", "range", "color_range"),
-    ("World", "lighting", "light_settings"),
-    ("World", "mist", "mist_settings"),
-    ("World", "stars", "star_settings"),
-    ("MaterialHalo", "lines", "use_lines"),
-    ("MaterialHalo", "ring", "use_ring"),
-    ("MaterialHalo", "soft", "use_soft"),
-    ("MaterialHalo", "star", "use_star"),
-    ("MaterialHalo", "texture", "use_texture"),
-    ("MaterialPhysics", "damp", "damping"),
-    ("MaterialRaytraceTransparency", "limit", "depth_max"),
-    ("NlaStrip", "reversed", "use_reverse"),
-    ("CompositorNodeBlur", "bokeh", "use_bokeh"),
-    ("CompositorNodeBlur", "gamma", "use_gamma_correction"),
-    ("CompositorNodeBlur", "relative", "use_relative"),
-    ("CompositorNodeChannelMatte", "high", "limit_max"),
-    ("CompositorNodeChannelMatte", "low", "limit_min"),
-    ("CompositorNodeChannelMatte", "channel", "matte_channel"),
-    ("CompositorNodeChromaMatte", "cutoff", "threshold"),
-    ("CompositorNodeColorMatte", "h", "color_hue"),
-    ("CompositorNodeColorMatte", "s", "color_saturation"),
-    ("CompositorNodeColorMatte", "v", "color_value"),
-    ("CompositorNodeDBlur", "wrap", "use_wrap"),
-    ("CompositorNodeDefocus", "preview", "use_preview"),
-    ("CompositorNodeHueSat", "hue", "color_hue"),
-    ("CompositorNodeHueSat", "sat", "color_saturation"),
-    ("CompositorNodeHueSat", "val", "color_value"),
-    ("CompositorNodeImage", "frames", "frame_duration"),
-    ("CompositorNodeImage", "offset", "frame_offset"),
-    ("CompositorNodeImage", "start", "frame_start"),
-    ("CompositorNodeImage", "cyclic", "use_cyclic"),
-    ("CompositorNodeInvert", "alpha", "invert_alpha"),
-    ("CompositorNodeInvert", "rgb", "invert_rgb"),
-    ("CompositorNodeLensdist", "fit", "use_fit"),
-    ("CompositorNodeLensdist", "jitter", "use_jitter"),
-    ("CompositorNodeMixRGB", "alpha", "use_alpha"),
-    ("CompositorNodeRotate", "filter", "filter_type"),
-    ("CompositorNodeTime", "end", "frame_end"),
-    ("CompositorNodeTime", "start", "frame_start"),
-    ("CompositorNodeVecBlur", "curved", "use_curved"),
-    ("ShaderNodeExtendedMaterial", "diffuse", "use_diffuse"),
-    ("ShaderNodeExtendedMaterial", "specular", "use_specular"),
-    ("ShaderNodeMaterial", "diffuse", "use_diffuse"),
-    ("ShaderNodeMaterial", "specular", "use_specular"),
-    ("ShaderNodeMixRGB", "alpha", "use_alpha"),
-    ("TextureNodeCurveTime", "end", "frame_end"),
-    ("TextureNodeCurveTime", "start", "frame_start"),
-    ("TextureNodeMixRGB", "alpha", "use_alpha"),
-    ("TextureSlot", "negate", "invert"),
-    ("TextureSlot", "size", "scale"),
-    ("SoftBodySettings", "damp", "damping"),
-    ("SequenceCrop", "right", "max_x"),
-    ("SequenceCrop", "top", "max_y"),
-    ("SequenceCrop", "bottom", "min_x"),
-    ("SequenceCrop", "left", "min_y"),
-    ("Sequence", "speed_fader", "speed_factor"),
-    ("SpeedControlSequence", "global_speed", "multiply_speed"),
-    ("SpeedControlSequence", "use_curve_velocity", "use_as_speed"),
-    ("SpeedControlSequence", "use_curve_compress_y", "scale_to_length"),
-    ("Key", "keys", "key_blocks"),
-    ]
-
-
-from bpy.types import Operator
-
-
-class UpdateAnimData(Operator):
-    """Update data paths from 2.56 and previous versions, modifying data paths of drivers and fcurves"""
-    bl_idname = "anim.update_data_paths"
-    bl_label = "Update Animation Data"
-
-    def execute(self, context):
-        import animsys_refactor
-        animsys_refactor.update_data_paths(data_path_update)
-        return {'FINISHED'}

release/scripts/startup/bl_operators/console.py

@@ -0,0 +1,106 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8-80 compliant>
+
+import bpy
+from bpy.types import Operator
+from bpy.props import StringProperty
+
+
+class ConsoleExec(Operator):
+    '''Execute the current console line as a python expression'''
+    bl_idname = "console.execute"
+    bl_label = "Console Execute"
+
+    def execute(self, context):
+        sc = context.space_data
+
+        module = __import__("console_" + sc.language)
+        execute = getattr(module, "execute", None)
+
+        if execute:
+            return execute(context)
+        else:
+            print("Error: bpy.ops.console.execute_" + sc.language + " - not found")
+            return {'FINISHED'}
+
+
+class ConsoleAutocomplete(Operator):
+    '''Evaluate the namespace up until the cursor and give a list of options or complete the name if there is only one'''
+    bl_idname = "console.autocomplete"
+    bl_label = "Console Autocomplete"
+
+    def execute(self, context):
+        sc = context.space_data
+        module = __import__("console_" + sc.language)
+        autocomplete = getattr(module, "autocomplete", None)
+
+        if autocomplete:
+            return autocomplete(context)
+        else:
+            print("Error: bpy.ops.console.autocomplete_" + sc.language + " - not found")
+            return {'FINISHED'}
+
+
+class ConsoleBanner(Operator):
+    '''Print a message whem the terminal initializes'''
+    bl_idname = "console.banner"
+    bl_label = "Console Banner"
+
+    def execute(self, context):
+        sc = context.space_data
+
+        # default to python
+        if not sc.language:
+            sc.language = 'python'
+
+        module = __import__("console_" + sc.language)
+        banner = getattr(module, "banner", None)
+
+        if banner:
+            return banner(context)
+        else:
+            print("Error: bpy.ops.console.banner_" + sc.language + " - not found")
+            return {'FINISHED'}
+
+
+class ConsoleLanguage(Operator):
+    '''Set the current language for this console'''
+    bl_idname = "console.language"
+    bl_label = "Console Language"
+
+    language = StringProperty(
+            name="Language",
+            maxlen=32,
+            )
+
+    def execute(self, context):
+        sc = context.space_data
+
+        # defailt to python
+        sc.language = self.language
+
+        bpy.ops.console.banner()
+
+        # insert a new blank line
+        bpy.ops.console.history_append(text="", current_character=0,
+            remove_duplicates=True)
+
+        return {'FINISHED'}
+        

release/scripts/startup/bl_operators/mesh.py

@@ -25,7 +25,7 @@ from bpy.props import EnumProperty
 
 
 class MeshSelectInteriorFaces(Operator):
-    '''Select faces where all edges have more then 2 face users.'''
+    '''Select faces where all edges have more then 2 face users'''
 
     bl_idname = "mesh.faces_select_interior"
     bl_label = "Select Interior Faces"

release/scripts/startup/bl_operators/nla.py

@@ -1,306 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# <pep8-80 compliant>
-
-import bpy
-from bpy.types import Operator
-
-
-def pose_frame_info(obj):
-    from mathutils import Matrix
-
-    info = {}
-
-    pose = obj.pose
-
-    pose_items = pose.bones.items()
-
-    for name, pbone in pose_items:
-        binfo = {}
-        bone = pbone.bone
-
-        binfo["parent"] = getattr(bone.parent, "name", None)
-        binfo["bone"] = bone
-        binfo["pbone"] = pbone
-        binfo["matrix_local"] = bone.matrix_local.copy()
-        try:
-            binfo["matrix_local_inv"] = binfo["matrix_local"].inverted()
-        except:
-            binfo["matrix_local_inv"] = Matrix()
-
-        binfo["matrix"] = bone.matrix.copy()
-        binfo["matrix_pose"] = pbone.matrix.copy()
-        try:
-            binfo["matrix_pose_inv"] = binfo["matrix_pose"].inverted()
-        except:
-            binfo["matrix_pose_inv"] = Matrix()
-
-        info[name] = binfo
-
-    for name, pbone in pose_items:
-        binfo = info[name]
-        binfo_parent = binfo.get("parent", None)
-        if binfo_parent:
-            binfo_parent = info[binfo_parent]
-
-        matrix = binfo["matrix_pose"]
-        rest_matrix = binfo["matrix_local"]
-
-        if binfo_parent:
-            matrix = binfo_parent["matrix_pose_inv"] * matrix
-            rest_matrix = binfo_parent["matrix_local_inv"] * rest_matrix
-
-        binfo["matrix_key"] = rest_matrix.inverted() * matrix
-
-    return info
-
-
-def obj_frame_info(obj):
-    info = {}
-    # parent = obj.parent
-    info["matrix_key"] = obj.matrix_local.copy()
-    return info
-
-
-def bake(frame_start,
-         frame_end, step=1,
-         only_selected=False,
-         do_pose=True,
-         do_object=True,
-         do_constraint_clear=False,
-         action=None):
-
-    scene = bpy.context.scene
-    obj = bpy.context.object
-    pose = obj.pose
-    frame_back = scene.frame_current
-
-    if pose is None:
-        do_pose = False
-
-    if do_pose is None and do_object is None:
-        return None
-
-    pose_info = []
-    obj_info = []
-
-    frame_range = range(frame_start, frame_end + 1, step)
-
-    # -------------------------------------------------------------------------
-    # Collect transformations
-
-    # could speed this up by applying steps here too...
-    for f in frame_range:
-        scene.frame_set(f)
-
-        if do_pose:
-            pose_info.append(pose_frame_info(obj))
-        if do_object:
-            obj_info.append(obj_frame_info(obj))
-
-        f += 1
-
-    # -------------------------------------------------------------------------
-    # Create action
-
-    # incase animation data hassnt been created
-    atd = obj.animation_data_create()
-    if action is None:
-        action = bpy.data.actions.new("Action")
-    atd.action = action
-
-    if do_pose:
-        pose_items = pose.bones.items()
-    else:
-        pose_items = []  # skip
-
-    # -------------------------------------------------------------------------
-    # Apply transformations to action
-
-    # pose
-    for name, pbone in (pose_items if do_pose else ()):
-        if only_selected and not pbone.bone.select:
-            continue
-
-        if do_constraint_clear:
-            while pbone.constraints:
-                pbone.constraints.remove(pbone.constraints[0])
-
-        for f in frame_range:
-            matrix = pose_info[(f - frame_start) // step][name]["matrix_key"]
-
-            # pbone.location = matrix.to_translation()
-            # pbone.rotation_quaternion = matrix.to_quaternion()
-            pbone.matrix_basis = matrix
-
-            pbone.keyframe_insert("location", -1, f, name)
-
-            rotation_mode = pbone.rotation_mode
-
-            if rotation_mode == 'QUATERNION':
-                pbone.keyframe_insert("rotation_quaternion", -1, f, name)
-            elif rotation_mode == 'AXIS_ANGLE':
-                pbone.keyframe_insert("rotation_axis_angle", -1, f, name)
-            else:  # euler, XYZ, ZXY etc
-                pbone.keyframe_insert("rotation_euler", -1, f, name)
-
-            pbone.keyframe_insert("scale", -1, f, name)
-
-    # object. TODO. multiple objects
-    if do_object:
-        if do_constraint_clear:
-            while obj.constraints:
-                obj.constraints.remove(obj.constraints[0])
-
-        for f in frame_range:
-            matrix = obj_info[(f - frame_start) // step]["matrix_key"]
-            obj.matrix_local = matrix
-
-            obj.keyframe_insert("location", -1, f)
-
-            rotation_mode = obj.rotation_mode
-
-            if rotation_mode == 'QUATERNION':
-                obj.keyframe_insert("rotation_quaternion", -1, f)
-            elif rotation_mode == 'AXIS_ANGLE':
-                obj.keyframe_insert("rotation_axis_angle", -1, f)
-            else:  # euler, XYZ, ZXY etc
-                obj.keyframe_insert("rotation_euler", -1, f)
-
-            obj.keyframe_insert("scale", -1, f)
-
-    scene.frame_set(frame_back)
-
-    return action
-
-
-from bpy.props import IntProperty, BoolProperty, EnumProperty
-
-
-class BakeAction(Operator):
-    '''Bake animation to an Action'''
-    bl_idname = "nla.bake"
-    bl_label = "Bake Action"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    frame_start = IntProperty(
-            name="Start Frame",
-            description="Start frame for baking",
-            min=0, max=300000,
-            default=1,
-            )
-    frame_end = IntProperty(
-            name="End Frame",
-            description="End frame for baking",
-            min=1, max=300000,
-            default=250,
-            )
-    step = IntProperty(
-            name="Frame Step",
-            description="Frame Step",
-            min=1, max=120,
-            default=1,
-            )
-    only_selected = BoolProperty(
-            name="Only Selected",
-            default=True,
-            )
-    clear_consraints = BoolProperty(
-            name="Clear Constraints",
-            default=False,
-            )
-    bake_types = EnumProperty(
-            name="Bake Data",
-            options={'ENUM_FLAG'},
-            items=(('POSE', "Pose", ""),
-                   ('OBJECT', "Object", ""),
-                   ),
-            default={'POSE'},
-            )
-
-    def execute(self, context):
-
-        action = bake(self.frame_start,
-                      self.frame_end,
-                      self.step,
-                      self.only_selected,
-                      'POSE' in self.bake_types,
-                      'OBJECT' in self.bake_types,
-                      self.clear_consraints,
-                      )
-
-        if action is None:
-            self.report({'INFO'}, "Nothing to bake")
-            return {'CANCELLED'}
-
-        # basic cleanup, could move elsewhere
-        for fcu in action.fcurves:
-            keyframe_points = fcu.keyframe_points
-            i = 1
-            while i < len(fcu.keyframe_points) - 1:
-                val_prev = keyframe_points[i - 1].co[1]
-                val_next = keyframe_points[i + 1].co[1]
-                val = keyframe_points[i].co[1]
-
-                if abs(val - val_prev) + abs(val - val_next) < 0.0001:
-                    keyframe_points.remove(keyframe_points[i])
-                else:
-                    i += 1
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-
-class ClearUselessActions(Operator):
-    '''Mark actions with no F-Curves for deletion after save+reload of ''' \
-    '''file preserving "action libraries"'''
-    bl_idname = "anim.clear_useless_actions"
-    bl_label = "Clear Useless Actions"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    only_unused = BoolProperty(name="Only Unused",
-            description="Only unused (Fake User only) actions get considered",
-            default=True)
-
-    @classmethod
-    def poll(cls, context):
-        return len(bpy.data.actions) != 0
-
-    def execute(self, context):
-        removed = 0
-
-        for action in bpy.data.actions:
-            # if only user is "fake" user...
-            if ((self.only_unused is False) or
-                (action.use_fake_user and action.users == 1)):
-
-                # if it has F-Curves, then it's a "action library"
-                # (i.e. walk, wave, jump, etc.)
-                # and should be left alone as that's what fake users are for!
-                if not action.fcurves:
-                    # mark action for deletion
-                    action.user_clear()
-                    removed += 1
-
-        self.report({'INFO'}, "Removed %d empty and/or fake-user only Actions"
-                              % removed)
-        return {'FINISHED'}

release/scripts/startup/bl_operators/screen_play_rendered_anim.py

@@ -66,7 +66,7 @@ def guess_player_path(preset):
 
 
 class PlayRenderedAnim(Operator):
-    '''Plays back rendered frames/movies using an external player.'''
+    '''Plays back rendered frames/movies using an external player'''
     bl_idname = "render.play_rendered_anim"
     bl_label = "Play Rendered Animation"
     bl_options = {'REGISTER'}

release/scripts/startup/bl_operators/sequencer.py

@@ -25,7 +25,7 @@ from bpy.props import IntProperty
 
 
 class SequencerCrossfadeSounds(Operator):
-    '''Do crossfading volume animation of two selected sound strips.'''
+    '''Do crossfading volume animation of two selected sound strips'''
 
     bl_idname = "sequencer.crossfade_sounds"
     bl_label = "Crossfade sounds"
@@ -76,7 +76,7 @@ class SequencerCrossfadeSounds(Operator):
 
 
 class SequencerCutMulticam(Operator):
-    '''Cut multicam strip and select camera.'''
+    '''Cut multicam strip and select camera'''
 
     bl_idname = "sequencer.cut_multicam"
     bl_label = "Cut multicam"
@@ -118,7 +118,7 @@ class SequencerCutMulticam(Operator):
 
 
 class SequencerDeinterlaceSelectedMovies(Operator):
-    '''Deinterlace all selected movie sources.'''
+    '''Deinterlace all selected movie sources'''
 
     bl_idname = "sequencer.deinterlace_selected_movies"
     bl_label = "Deinterlace Movies"

release/scripts/startup/bl_operators/uvcalc_smart_project.py

@@ -1105,7 +1105,8 @@ from bpy.props import FloatProperty
 
 
 class SmartProject(Operator):
-    '''This script projection unwraps the selected faces of a mesh. it operates on all selected mesh objects, and can be used unwrap selected faces, or all faces.'''
+    '''This script projection unwraps the selected faces of a mesh. ''' \
+    '''it operates on all selected mesh objects, and can be used unwrap selected faces, or all faces'''
     bl_idname = "uv.smart_project"
     bl_label = "Smart UV Project"
     bl_options = {'REGISTER', 'UNDO'}

release/scripts/startup/bl_operators/view3d.py

@@ -0,0 +1,77 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8-80 compliant>
+
+import bpy
+from bpy.types import Operator
+
+
+class VIEW3D_OT_edit_mesh_extrude_individual_move(Operator):
+    "Extrude individual elements and move"
+    bl_label = "Extrude Individual and Move"
+    bl_idname = "view3d.edit_mesh_extrude_individual_move"
+
+    def execute(self, context):
+        mesh = context.object.data
+        select_mode = context.tool_settings.mesh_select_mode
+
+        totface = mesh.total_face_sel
+        totedge = mesh.total_edge_sel
+        # totvert = mesh.total_vert_sel
+
+        if select_mode[2] and totface == 1:
+            bpy.ops.mesh.extrude_region_move('INVOKE_REGION_WIN', TRANSFORM_OT_translate={"constraint_orientation": 'NORMAL', "constraint_axis": (False, False, True)})
+        elif select_mode[2] and totface > 1:
+            bpy.ops.mesh.extrude_faces_move('INVOKE_REGION_WIN')
+        elif select_mode[1] and totedge >= 1:
+            bpy.ops.mesh.extrude_edges_move('INVOKE_REGION_WIN')
+        else:
+            bpy.ops.mesh.extrude_vertices_move('INVOKE_REGION_WIN')
+
+        # ignore return from operators above because they are 'RUNNING_MODAL', and cause this one not to be freed. [#24671]
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        return self.execute(context)
+
+
+class VIEW3D_OT_edit_mesh_extrude_move(Operator):
+    "Extrude and move along normals"
+    bl_label = "Extrude and Move on Normals"
+    bl_idname = "view3d.edit_mesh_extrude_move_normal"
+
+    def execute(self, context):
+        mesh = context.object.data
+
+        totface = mesh.total_face_sel
+        totedge = mesh.total_edge_sel
+        # totvert = mesh.total_vert_sel
+
+        if totface >= 1:
+            bpy.ops.mesh.extrude_region_move('INVOKE_REGION_WIN', TRANSFORM_OT_translate={"constraint_orientation": 'NORMAL', "constraint_axis": (False, False, True)})
+        elif totedge == 1:
+            bpy.ops.mesh.extrude_region_move('INVOKE_REGION_WIN', TRANSFORM_OT_translate={"constraint_orientation": 'NORMAL', "constraint_axis": (True, True, False)})
+        else:
+            bpy.ops.mesh.extrude_region_move('INVOKE_REGION_WIN')
+
+        # ignore return from operators above because they are 'RUNNING_MODAL', and cause this one not to be freed. [#24671]
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        return self.execute(context)

release/scripts/startup/bl_operators/wm.py

@@ -172,7 +172,7 @@ class BRUSH_OT_active_index_set(Operator):
 
 
 class WM_OT_context_set_boolean(Operator):
-    '''Set a context value.'''
+    '''Set a context value'''
     bl_idname = "wm.context_set_boolean"
     bl_label = "Context Set Boolean"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -188,7 +188,7 @@ class WM_OT_context_set_boolean(Operator):
 
 
 class WM_OT_context_set_int(Operator):  # same as enum
-    '''Set a context value.'''
+    '''Set a context value'''
     bl_idname = "wm.context_set_int"
     bl_label = "Context Set"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -205,7 +205,7 @@ class WM_OT_context_set_int(Operator):  # same as enum
 
 
 class WM_OT_context_scale_int(Operator):
-    '''Scale an int context value.'''
+    '''Scale an int context value'''
     bl_idname = "wm.context_scale_int"
     bl_label = "Context Set"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -248,7 +248,7 @@ class WM_OT_context_scale_int(Operator):
 
 
 class WM_OT_context_set_float(Operator):  # same as enum
-    '''Set a context value.'''
+    '''Set a context value'''
     bl_idname = "wm.context_set_float"
     bl_label = "Context Set Float"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -265,7 +265,7 @@ class WM_OT_context_set_float(Operator):  # same as enum
 
 
 class WM_OT_context_set_string(Operator):  # same as enum
-    '''Set a context value.'''
+    '''Set a context value'''
     bl_idname = "wm.context_set_string"
     bl_label = "Context Set String"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -281,7 +281,7 @@ class WM_OT_context_set_string(Operator):  # same as enum
 
 
 class WM_OT_context_set_enum(Operator):
-    '''Set a context value.'''
+    '''Set a context value'''
     bl_idname = "wm.context_set_enum"
     bl_label = "Context Set Enum"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -297,7 +297,7 @@ class WM_OT_context_set_enum(Operator):
 
 
 class WM_OT_context_set_value(Operator):
-    '''Set a context value.'''
+    '''Set a context value'''
     bl_idname = "wm.context_set_value"
     bl_label = "Context Set Value"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -318,7 +318,7 @@ class WM_OT_context_set_value(Operator):
 
 
 class WM_OT_context_toggle(Operator):
-    '''Toggle a context value.'''
+    '''Toggle a context value'''
     bl_idname = "wm.context_toggle"
     bl_label = "Context Toggle"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -337,7 +337,7 @@ class WM_OT_context_toggle(Operator):
 
 
 class WM_OT_context_toggle_enum(Operator):
-    '''Toggle a context value.'''
+    '''Toggle a context value'''
     bl_idname = "wm.context_toggle_enum"
     bl_label = "Context Toggle Values"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -371,7 +371,7 @@ class WM_OT_context_toggle_enum(Operator):
 
 class WM_OT_context_cycle_int(Operator):
     '''Set a context value. Useful for cycling active material, '''
-    '''vertex keys, groups' etc.'''
+    '''vertex keys, groups' etc'''
     bl_idname = "wm.context_cycle_int"
     bl_label = "Context Int Cycle"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -405,7 +405,7 @@ class WM_OT_context_cycle_int(Operator):
 
 
 class WM_OT_context_cycle_enum(Operator):
-    '''Toggle a context value.'''
+    '''Toggle a context value'''
     bl_idname = "wm.context_cycle_enum"
     bl_label = "Context Enum Cycle"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -458,7 +458,7 @@ class WM_OT_context_cycle_enum(Operator):
 
 class WM_OT_context_cycle_array(Operator):
     '''Set a context array value.
-    Useful for cycling the active mesh edit mode.'''
+    Useful for cycling the active mesh edit mode'''
     bl_idname = "wm.context_cycle_array"
     bl_label = "Context Array Cycle"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -518,7 +518,7 @@ class WM_OT_context_menu_enum(Operator):
 
 
 class WM_OT_context_set_id(Operator):
-    '''Toggle a context value.'''
+    '''Toggle a context value'''
     bl_idname = "wm.context_set_id"
     bl_label = "Set Library ID"
     bl_options = {'UNDO', 'INTERNAL'}
@@ -1179,3 +1179,718 @@ class WM_OT_copy_prev_settings(Operator):
             return {'FINISHED'}
 
         return {'CANCELLED'}
+
+        
+class WM_OT_keyconfig_test(Operator):
+    "Test keyconfig for conflicts"
+    bl_idname = "wm.keyconfig_test"
+    bl_label = "Test Key Configuration for Conflicts"
+
+    def testEntry(self, kc, entry, src=None, parent=None):
+        result = False
+
+        def kmistr(kmi):
+            if km.is_modal:
+                s = ["kmi = km.keymap_items.new_modal(\'%s\', \'%s\', \'%s\'" % (kmi.propvalue, kmi.type, kmi.value)]
+            else:
+                s = ["kmi = km.keymap_items.new(\'%s\', \'%s\', \'%s\'" % (kmi.idname, kmi.type, kmi.value)]
+
+            if kmi.any:
+                s.append(", any=True")
+            else:
+                if kmi.shift:
+                    s.append(", shift=True")
+                if kmi.ctrl:
+                    s.append(", ctrl=True")
+                if kmi.alt:
+                    s.append(", alt=True")
+                if kmi.oskey:
+                    s.append(", oskey=True")
+            if kmi.key_modifier and kmi.key_modifier != 'NONE':
+                s.append(", key_modifier=\'%s\'" % kmi.key_modifier)
+
+            s.append(")\n")
+
+            props = kmi.properties
+
+            if props is not None:
+                export_properties("kmi.properties", props, s)
+
+            return "".join(s).strip()
+
+        idname, spaceid, regionid, children = entry
+
+        km = kc.keymaps.find(idname, space_type=spaceid, region_type=regionid)
+
+        if km:
+            km = km.active()
+
+            if src:
+                for item in km.keymap_items:
+                    if src.compare(item):
+                        print("===========")
+                        print(parent.name)
+                        print(kmistr(src))
+                        print(km.name)
+                        print(kmistr(item))
+                        result = True
+
+                for child in children:
+                    if self.testEntry(kc, child, src, parent):
+                        result = True
+            else:
+                for i in range(len(km.keymap_items)):
+                    src = km.keymap_items[i]
+
+                    for child in children:
+                        if self.testEntry(kc, child, src, km):
+                            result = True
+
+                    for j in range(len(km.keymap_items) - i - 1):
+                        item = km.keymap_items[j + i + 1]
+                        if src.compare(item):
+                            print("===========")
+                            print(km.name)
+                            print(kmistr(src))
+                            print(kmistr(item))
+                            result = True
+
+                for child in children:
+                    if self.testEntry(kc, child):
+                        result = True
+
+        return result
+
+    def testConfig(self, kc):
+        result = False
+        for entry in KM_HIERARCHY:
+            if self.testEntry(kc, entry):
+                result = True
+        return result
+
+    def execute(self, context):
+        wm = context.window_manager
+        kc = wm.keyconfigs.default
+
+        if self.testConfig(kc):
+            print("CONFLICT")
+
+        return {'FINISHED'}
+
+
+def _string_value(value):
+    if isinstance(value, str) or isinstance(value, bool) or isinstance(value, float) or isinstance(value, int):
+        result = repr(value)
+    elif getattr(value, '__len__', False):
+        return repr(list(value))
+    else:
+        print("Export key configuration: can't write ", value)
+
+    return result
+
+
+class WM_OT_keyconfig_import(Operator):
+    "Import key configuration from a python script"
+    bl_idname = "wm.keyconfig_import"
+    bl_label = "Import Key Configuration..."
+
+    filepath = StringProperty(
+            name="File Path",
+            description="Filepath to write file to",
+            default="keymap.py",
+            )
+    filter_folder = BoolProperty(
+            name="Filter folders",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_text = BoolProperty(
+            name="Filter text",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_python = BoolProperty(
+            name="Filter python",
+            default=True,
+            options={'HIDDEN'},
+            )
+    keep_original = BoolProperty(
+            name="Keep original",
+            description="Keep original file after copying to configuration folder",
+            default=True,
+            )
+
+    def execute(self, context):
+        from os.path import basename
+        import shutil
+
+        if not self.filepath:
+            self.report({'ERROR'}, "Filepath not set")
+            return {'CANCELLED'}
+
+        config_name = basename(self.filepath)
+
+        path = bpy.utils.user_resource('SCRIPTS', os.path.join("presets", "keyconfig"), create=True)
+        path = os.path.join(path, config_name)
+
+        try:
+            if self.keep_original:
+                shutil.copy(self.filepath, path)
+            else:
+                shutil.move(self.filepath, path)
+        except Exception as e:
+            self.report({'ERROR'}, "Installing keymap failed: %s" % e)
+            return {'CANCELLED'}
+
+        # sneaky way to check we're actually running the code.
+        bpy.utils.keyconfig_set(path)
+
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+# This operator is also used by interaction presets saving - AddPresetBase
+
+
+class WM_OT_keyconfig_export(Operator):
+    "Export key configuration to a python script"
+    bl_idname = "wm.keyconfig_export"
+    bl_label = "Export Key Configuration..."
+
+    filepath = StringProperty(
+            name="File Path",
+            description="Filepath to write file to",
+            default="keymap.py",
+            )
+    filter_folder = BoolProperty(
+            name="Filter folders",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_text = BoolProperty(
+            name="Filter text",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_python = BoolProperty(
+            name="Filter python",
+            default=True,
+            options={'HIDDEN'},
+            )
+
+    def execute(self, context):
+        if not self.filepath:
+            raise Exception("Filepath not set")
+
+        if not self.filepath.endswith('.py'):
+            self.filepath += '.py'
+
+        f = open(self.filepath, "w")
+        if not f:
+            raise Exception("Could not open file")
+
+        wm = context.window_manager
+        kc = wm.keyconfigs.active
+
+        f.write("import bpy\n")
+        f.write("import os\n\n")
+        f.write("wm = bpy.context.window_manager\n")
+        f.write("kc = wm.keyconfigs.new(os.path.splitext(os.path.basename(__file__))[0])\n\n")  # keymap must be created by caller
+
+        # Generate a list of keymaps to export:
+        #
+        # First add all user_modified keymaps (found in keyconfigs.user.keymaps list),
+        # then add all remaining keymaps from the currently active custom keyconfig.
+        #
+        # This will create a final list of keymaps that can be used as a 'diff' against
+        # the default blender keyconfig, recreating the current setup from a fresh blender
+        # without needing to export keymaps which haven't been edited.
+
+        class FakeKeyConfig():
+            keymaps = []
+        edited_kc = FakeKeyConfig()
+        for km in wm.keyconfigs.user.keymaps:
+            if km.is_user_modified:
+                edited_kc.keymaps.append(km)
+        # merge edited keymaps with non-default keyconfig, if it exists
+        if kc != wm.keyconfigs.default:
+            export_keymaps = _merge_keymaps(edited_kc, kc)
+        else:
+            export_keymaps = _merge_keymaps(edited_kc, edited_kc)
+
+        for km, kc_x in export_keymaps:
+
+            km = km.active()
+
+            f.write("# Map %s\n" % km.name)
+            f.write("km = kc.keymaps.new('%s', space_type='%s', region_type='%s', modal=%s)\n\n" % (km.name, km.space_type, km.region_type, km.is_modal))
+            for kmi in km.keymap_items:
+                if km.is_modal:
+                    f.write("kmi = km.keymap_items.new_modal('%s', '%s', '%s'" % (kmi.propvalue, kmi.type, kmi.value))
+                else:
+                    f.write("kmi = km.keymap_items.new('%s', '%s', '%s'" % (kmi.idname, kmi.type, kmi.value))
+                if kmi.any:
+                    f.write(", any=True")
+                else:
+                    if kmi.shift:
+                        f.write(", shift=True")
+                    if kmi.ctrl:
+                        f.write(", ctrl=True")
+                    if kmi.alt:
+                        f.write(", alt=True")
+                    if kmi.oskey:
+                        f.write(", oskey=True")
+                if kmi.key_modifier and kmi.key_modifier != 'NONE':
+                    f.write(", key_modifier='%s'" % kmi.key_modifier)
+                f.write(")\n")
+
+                props = kmi.properties
+
+                if props is not None:
+                    f.write("".join(export_properties("kmi.properties", props)))
+
+            f.write("\n")
+
+        f.close()
+
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+
+class WM_OT_keymap_restore(Operator):
+    "Restore key map(s)"
+    bl_idname = "wm.keymap_restore"
+    bl_label = "Restore Key Map(s)"
+
+    all = BoolProperty(
+            name="All Keymaps",
+            description="Restore all keymaps to default",
+            )
+
+    def execute(self, context):
+        wm = context.window_manager
+
+        if self.all:
+            for km in wm.keyconfigs.user.keymaps:
+                km.restore_to_default()
+        else:
+            km = context.keymap
+            km.restore_to_default()
+
+        return {'FINISHED'}
+
+
+class WM_OT_keyitem_restore(Operator):
+    "Restore key map item"
+    bl_idname = "wm.keyitem_restore"
+    bl_label = "Restore Key Map Item"
+
+    item_id = IntProperty(
+            name="Item Identifier",
+            description="Identifier of the item to remove",
+            )
+
+    @classmethod
+    def poll(cls, context):
+        keymap = getattr(context, "keymap", None)
+        return keymap
+
+    def execute(self, context):
+        km = context.keymap
+        kmi = km.keymap_items.from_id(self.item_id)
+
+        if (not kmi.is_user_defined) and kmi.is_user_modified:
+            km.restore_item_to_default(kmi)
+
+        return {'FINISHED'}
+
+
+class WM_OT_keyitem_add(Operator):
+    "Add key map item"
+    bl_idname = "wm.keyitem_add"
+    bl_label = "Add Key Map Item"
+
+    def execute(self, context):
+        km = context.keymap
+
+        if km.is_modal:
+            km.keymap_items.new_modal("", 'A', 'PRESS')  # kmi
+        else:
+            km.keymap_items.new("none", 'A', 'PRESS')  # kmi
+
+        # clear filter and expand keymap so we can see the newly added item
+        if context.space_data.filter_text != "":
+            context.space_data.filter_text = ""
+            km.show_expanded_items = True
+            km.show_expanded_children = True
+
+        return {'FINISHED'}
+
+
+class WM_OT_keyitem_remove(Operator):
+    "Remove key map item"
+    bl_idname = "wm.keyitem_remove"
+    bl_label = "Remove Key Map Item"
+
+    item_id = IntProperty(
+            name="Item Identifier",
+            description="Identifier of the item to remove",
+            )
+
+    @classmethod
+    def poll(cls, context):
+        return hasattr(context, "keymap")
+
+    def execute(self, context):
+        km = context.keymap
+        kmi = km.keymap_items.from_id(self.item_id)
+        km.keymap_items.remove(kmi)
+        return {'FINISHED'}
+
+
+class WM_OT_keyconfig_remove(Operator):
+    "Remove key config"
+    bl_idname = "wm.keyconfig_remove"
+    bl_label = "Remove Key Config"
+
+    @classmethod
+    def poll(cls, context):
+        wm = context.window_manager
+        keyconf = wm.keyconfigs.active
+        return keyconf and keyconf.is_user_defined
+
+    def execute(self, context):
+        wm = context.window_manager
+        keyconfig = wm.keyconfigs.active
+        wm.keyconfigs.remove(keyconfig)
+        return {'FINISHED'}
+
+
+class WM_OT_operator_cheat_sheet(Operator):
+    bl_idname = "wm.operator_cheat_sheet"
+    bl_label = "Operator Cheat Sheet"
+
+    def execute(self, context):
+        op_strings = []
+        tot = 0
+        for op_module_name in dir(bpy.ops):
+            op_module = getattr(bpy.ops, op_module_name)
+            for op_submodule_name in dir(op_module):
+                op = getattr(op_module, op_submodule_name)
+                text = repr(op)
+                if text.split("\n")[-1].startswith('bpy.ops.'):
+                    op_strings.append(text)
+                    tot += 1
+
+            op_strings.append('')
+
+        textblock = bpy.data.texts.new("OperatorList.txt")
+        textblock.write('# %d Operators\n\n' % tot)
+        textblock.write('\n'.join(op_strings))
+        self.report({'INFO'}, "See OperatorList.txt textblock")
+        return {'FINISHED'}
+        
+        
+class WM_OT_addon_enable(Operator):
+    "Enable an addon"
+    bl_idname = "wm.addon_enable"
+    bl_label = "Enable Add-On"
+
+    module = StringProperty(
+            name="Module",
+            description="Module name of the addon to enable",
+            )
+
+    def execute(self, context):
+        import addon_utils
+
+        mod = addon_utils.enable(self.module)
+
+        if mod:
+            info = addon_utils.module_bl_info(mod)
+
+            info_ver = info.get("blender", (0, 0, 0))
+
+            if info_ver > bpy.app.version:
+                self.report({'WARNING'}, ("This script was written Blender "
+                                          "version %d.%d.%d and might not "
+                                          "function (correctly), "
+                                          "though it is enabled") %
+                                         info_ver)
+            return {'FINISHED'}
+        else:
+            return {'CANCELLED'}
+
+
+class WM_OT_addon_disable(Operator):
+    "Disable an addon"
+    bl_idname = "wm.addon_disable"
+    bl_label = "Disable Add-On"
+
+    module = StringProperty(
+            name="Module",
+            description="Module name of the addon to disable",
+            )
+
+    def execute(self, context):
+        import addon_utils
+
+        addon_utils.disable(self.module)
+        return {'FINISHED'}
+
+
+class WM_OT_addon_install(Operator):
+    "Install an addon"
+    bl_idname = "wm.addon_install"
+    bl_label = "Install Add-On..."
+
+    overwrite = BoolProperty(
+            name="Overwrite",
+            description="Remove existing addons with the same ID",
+            default=True,
+            )
+    target = EnumProperty(
+            name="Target Path",
+            items=(('DEFAULT', "Default", ""),
+                   ('PREFS', "User Prefs", "")),
+            )
+
+    filepath = StringProperty(
+            name="File Path",
+            description="File path to write file to",
+            )
+    filter_folder = BoolProperty(
+            name="Filter folders",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_python = BoolProperty(
+            name="Filter python",
+            default=True,
+            options={'HIDDEN'},
+            )
+    filter_glob = StringProperty(
+            default="*.py;*.zip",
+            options={'HIDDEN'},
+            )
+
+    @staticmethod
+    def _module_remove(path_addons, module):
+        module = os.path.splitext(module)[0]
+        for f in os.listdir(path_addons):
+            f_base = os.path.splitext(f)[0]
+            if f_base == module:
+                f_full = os.path.join(path_addons, f)
+
+                if os.path.isdir(f_full):
+                    os.rmdir(f_full)
+                else:
+                    os.remove(f_full)
+
+    def execute(self, context):
+        import addon_utils
+        import traceback
+        import zipfile
+        import shutil
+
+        pyfile = self.filepath
+
+        if self.target == 'DEFAULT':
+            # dont use bpy.utils.script_paths("addons") because we may not be able to write to it.
+            path_addons = bpy.utils.user_resource('SCRIPTS', "addons", create=True)
+        else:
+            path_addons = bpy.context.user_preferences.filepaths.script_directory
+            if path_addons:
+                path_addons = os.path.join(path_addons, "addons")
+
+        if not path_addons:
+            self.report({'ERROR'}, "Failed to get addons path")
+            return {'CANCELLED'}
+
+        # create dir is if missing.
+        if not os.path.exists(path_addons):
+            os.makedirs(path_addons)
+
+        # Check if we are installing from a target path,
+        # doing so causes 2+ addons of same name or when the same from/to
+        # location is used, removal of the file!
+        addon_path = ""
+        pyfile_dir = os.path.dirname(pyfile)
+        for addon_path in addon_utils.paths():
+            if os.path.samefile(pyfile_dir, addon_path):
+                self.report({'ERROR'}, "Source file is in the addon search path: %r" % addon_path)
+                return {'CANCELLED'}
+        del addon_path
+        del pyfile_dir
+        # done checking for exceptional case
+
+        addons_old = {mod.__name__ for mod in addon_utils.modules(addon_utils.addons_fake_modules)}
+
+        #check to see if the file is in compressed format (.zip)
+        if zipfile.is_zipfile(pyfile):
+            try:
+                file_to_extract = zipfile.ZipFile(pyfile, 'r')
+            except:
+                traceback.print_exc()
+                return {'CANCELLED'}
+
+            if self.overwrite:
+                for f in file_to_extract.namelist():
+                    WM_OT_addon_install._module_remove(path_addons, f)
+            else:
+                for f in file_to_extract.namelist():
+                    path_dest = os.path.join(path_addons, os.path.basename(f))
+                    if os.path.exists(path_dest):
+                        self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
+                        return {'CANCELLED'}
+
+            try:  # extract the file to "addons"
+                file_to_extract.extractall(path_addons)
+
+                # zip files can create this dir with metadata, don't need it
+                macosx_dir = os.path.join(path_addons, '__MACOSX')
+                if os.path.isdir(macosx_dir):
+                    shutil.rmtree(macosx_dir)
+
+            except:
+                traceback.print_exc()
+                return {'CANCELLED'}
+
+        else:
+            path_dest = os.path.join(path_addons, os.path.basename(pyfile))
+
+            if self.overwrite:
+                WM_OT_addon_install._module_remove(path_addons, os.path.basename(pyfile))
+            elif os.path.exists(path_dest):
+                self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
+                return {'CANCELLED'}
+
+            #if not compressed file just copy into the addon path
+            try:
+                shutil.copyfile(pyfile, path_dest)
+
+            except:
+                traceback.print_exc()
+                return {'CANCELLED'}
+
+        addons_new = {mod.__name__ for mod in addon_utils.modules(addon_utils.addons_fake_modules)} - addons_old
+        addons_new.discard("modules")
+
+        # disable any addons we may have enabled previously and removed.
+        # this is unlikely but do just incase. bug [#23978]
+        for new_addon in addons_new:
+            addon_utils.disable(new_addon)
+
+        # possible the zip contains multiple addons, we could disallow this
+        # but for now just use the first
+        for mod in addon_utils.modules(addon_utils.addons_fake_modules):
+            if mod.__name__ in addons_new:
+                info = addon_utils.module_bl_info(mod)
+
+                # show the newly installed addon.
+                context.window_manager.addon_filter = 'All'
+                context.window_manager.addon_search = info["name"]
+                break
+
+        # incase a new module path was created to install this addon.
+        bpy.utils.refresh_script_paths()
+
+        # TODO, should not be a warning.
+        # self.report({'WARNING'}, "File installed to '%s'\n" % path_dest)
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        wm.fileselect_add(self)
+        return {'RUNNING_MODAL'}
+
+
+class WM_OT_addon_remove(Operator):
+    "Disable an addon"
+    bl_idname = "wm.addon_remove"
+    bl_label = "Remove Add-On"
+
+    module = StringProperty(
+            name="Module",
+            description="Module name of the addon to remove",
+            )
+
+    @staticmethod
+    def path_from_addon(module):
+        import addon_utils
+
+        for mod in addon_utils.modules(addon_utils.addons_fake_modules):
+            if mod.__name__ == module:
+                filepath = mod.__file__
+                if os.path.exists(filepath):
+                    if os.path.splitext(os.path.basename(filepath))[0] == "__init__":
+                        return os.path.dirname(filepath), True
+                    else:
+                        return filepath, False
+        return None, False
+
+    def execute(self, context):
+        import addon_utils
+
+        path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
+        if path is None:
+            self.report('WARNING', "Addon path %r could not be found" % path)
+            return {'CANCELLED'}
+
+        # incase its enabled
+        addon_utils.disable(self.module)
+
+        import shutil
+        if isdir:
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+
+        context.area.tag_redraw()
+        return {'FINISHED'}
+
+    # lame confirmation check
+    def draw(self, context):
+        self.layout.label(text="Remove Addon: %r?" % self.module)
+        path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
+        self.layout.label(text="Path: %r" % path)
+
+    def invoke(self, context, event):
+        wm = context.window_manager
+        return wm.invoke_props_dialog(self, width=600)
+
+
+class WM_OT_addon_expand(Operator):
+    "Display more information on this add-on"
+    bl_idname = "wm.addon_expand"
+    bl_label = ""
+
+    module = StringProperty(
+            name="Module",
+            description="Module name of the addon to expand",
+            )
+
+    def execute(self, context):
+        import addon_utils
+
+        module_name = self.module
+
+        # unlikely to fail, module should have already been imported
+        try:
+            # mod = __import__(module_name)
+            mod = addon_utils.addons_fake_modules.get(module_name)
+        except:
+            import traceback
+            traceback.print_exc()
+            return {'CANCELLED'}
+
+        info = addon_utils.module_bl_info(mod)
+        info["show_expanded"] = not info["show_expanded"]
+        return {'FINISHED'}

release/scripts/startup/bl_ui/__init__.py

@@ -96,7 +96,7 @@ def register():
 
         items_unique = set()
 
-        for mod in addon_utils.modules(space_userpref.USERPREF_PT_addons._addons_fake_modules):
+        for mod in addon_utils.modules(addon_utils.addons_fake_modules):
             info = addon_utils.module_bl_info(mod)
             items_unique.add(info["category"])
 

release/scripts/startup/bl_ui/properties_animviz.py

@@ -23,7 +23,6 @@
 # NOTE:
 # The specialised panel types are derived in their respective UI modules
 # dont register these classes since they are only helpers.
-from blf import gettext as _
 
 
 class MotionPathButtonsPanel():
@@ -44,23 +43,23 @@ class MotionPathButtonsPanel():
         col = split.column()
         sub = col.column(align=True)
         if (mps.type == 'CURRENT_FRAME'):
-            sub.prop(mps, "frame_before", text=_("Before"))
-            sub.prop(mps, "frame_after", text=_("After"))
+            sub.prop(mps, "frame_before", text="Before")
+            sub.prop(mps, "frame_after", text="After")
         elif (mps.type == 'RANGE'):
-            sub.prop(mps, "frame_start", text=_("Start"))
-            sub.prop(mps, "frame_end", text=_("End"))
+            sub.prop(mps, "frame_start", text="Start")
+            sub.prop(mps, "frame_end", text="End")
 
-        sub.prop(mps, "frame_step", text=_("Step"))
+        sub.prop(mps, "frame_step", text="Step")
         if bones:
             col.row().prop(mps, "bake_location", expand=True)
 
         col = split.column()
-        col.label(text=_("Display:"))
-        col.prop(mps, "show_frame_numbers", text=_("Frame Numbers"))
-        col.prop(mps, "show_keyframe_highlight", text=_("Keyframes"))
+        col.label(text="Display:")
+        col.prop(mps, "show_frame_numbers", text="Frame Numbers")
+        col.prop(mps, "show_keyframe_highlight", text="Keyframes")
         if bones:
-            col.prop(mps, "show_keyframe_action_all", text=_("+ Non-Grouped Keyframes"))
-        col.prop(mps, "show_keyframe_numbers", text=_("Keyframe Numbers"))
+            col.prop(mps, "show_keyframe_action_all", text="+ Non-Grouped Keyframes")
+        col.prop(mps, "show_keyframe_numbers", text="Keyframe Numbers")
 
 
 # FIXME: this panel still needs to be ported so that it will work correctly with animviz
@@ -83,16 +82,16 @@ class OnionSkinButtonsPanel():
 
         sub = col.column(align=True)
         if arm.ghost_type == 'RANGE':
-            sub.prop(arm, "ghost_frame_start", text=_("Start"))
-            sub.prop(arm, "ghost_frame_end", text=_("End"))
-            sub.prop(arm, "ghost_size", text=_("Step"))
+            sub.prop(arm, "ghost_frame_start", text="Start")
+            sub.prop(arm, "ghost_frame_end", text="End")
+            sub.prop(arm, "ghost_size", text="Step")
         elif arm.ghost_type == 'CURRENT_FRAME':
-            sub.prop(arm, "ghost_step", text=_("Range"))
-            sub.prop(arm, "ghost_size", text=_("Step"))
+            sub.prop(arm, "ghost_step", text="Range")
+            sub.prop(arm, "ghost_size", text="Step")
 
         col = split.column()
-        col.label(text=_("Display:"))
-        col.prop(arm, "show_only_ghost_selected", text=_("Selected Only"))
+        col.label(text="Display:")
+        col.prop(arm, "show_only_ghost_selected", text="Selected Only")
 
 if __name__ == "__main__":  # only for live edit.
     import bpy

release/scripts/startup/bl_ui/properties_data_armature.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel, Menu
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class ArmatureButtonsPanel():
@@ -61,16 +60,16 @@ class DATA_PT_skeleton(ArmatureButtonsPanel, Panel):
         layout.prop(arm, "pose_position", expand=True)
 
         col = layout.column()
-        col.label(text=_("Layers:"))
+        col.label(text="Layers:")
         col.prop(arm, "layers", text="")
-        col.label(text=_("Protected Layers:"))
+        col.label(text="Protected Layers:")
         col.prop(arm, "layers_protected", text="")
 
         layout.label(text="Deform:")
         flow = layout.column_flow()
-        flow.prop(arm, "use_deform_vertex_groups", text=_("Vertex Groups"))
-        flow.prop(arm, "use_deform_envelopes", text=_("Envelopes"))
-        flow.prop(arm, "use_deform_preserve_volume", text=_("Quaternion"))
+        flow.prop(arm, "use_deform_vertex_groups", text="Vertex Groups")
+        flow.prop(arm, "use_deform_envelopes", text="Envelopes")
+        flow.prop(arm, "use_deform_preserve_volume", text="Quaternion")
 
         if context.scene.render.engine == "BLENDER_GAME":
             layout.row().prop(arm, "vert_deformer", expand=True)
@@ -90,15 +89,15 @@ class DATA_PT_display(ArmatureButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(arm, "show_names", text=_("Names"))
-        col.prop(arm, "show_axes", text=_("Axes"))
-        col.prop(arm, "show_bone_custom_shapes", text=_("Shapes"))
+        col.prop(arm, "show_names", text="Names")
+        col.prop(arm, "show_axes", text="Axes")
+        col.prop(arm, "show_bone_custom_shapes", text="Shapes")
 
         col = split.column()
-        col.prop(arm, "show_group_colors", text=_("Colors"))
+        col.prop(arm, "show_group_colors", text="Colors")
         if ob:
-            col.prop(ob, "show_x_ray", text=_("X-Ray"))
-        col.prop(arm, "use_deform_delay", text=_("Delay Refresh"))
+            col.prop(ob, "show_x_ray", text="X-Ray")
+        col.prop(arm, "use_deform_delay", text="Delay Refresh")
 
 
 class DATA_PT_bone_group_specials(Menu):
@@ -162,12 +161,12 @@ class DATA_PT_bone_groups(ArmatureButtonsPanel, Panel):
         row.active = (ob.proxy is None)
 
         sub = row.row(align=True)
-        sub.operator("pose.group_assign", text=_("Assign"))
-        sub.operator("pose.group_unassign", text=_("Remove"))  # row.operator("pose.bone_group_remove_from", text=_("Remove"))
+        sub.operator("pose.group_assign", text="Assign")
+        sub.operator("pose.group_unassign", text="Remove")  # row.operator("pose.bone_group_remove_from", text="Remove")
 
         sub = row.row(align=True)
-        sub.operator("pose.group_select", text=_("Select"))
-        sub.operator("pose.group_deselect", text=_("Deselect"))
+        sub.operator("pose.group_select", text="Select")
+        sub.operator("pose.group_deselect", text="Deselect")
 
 
 class DATA_PT_pose_library(ArmatureButtonsPanel, Panel):
@@ -231,16 +230,16 @@ class DATA_PT_ghost(ArmatureButtonsPanel, Panel):
         col = split.column(align=True)
 
         if arm.ghost_type == 'RANGE':
-            col.prop(arm, "ghost_frame_start", text=_("Start"))
-            col.prop(arm, "ghost_frame_end", text=_("End"))
-            col.prop(arm, "ghost_size", text=_("Step"))
+            col.prop(arm, "ghost_frame_start", text="Start")
+            col.prop(arm, "ghost_frame_end", text="End")
+            col.prop(arm, "ghost_size", text="Step")
         elif arm.ghost_type == 'CURRENT_FRAME':
-            col.prop(arm, "ghost_step", text=_("Range"))
-            col.prop(arm, "ghost_size", text=_("Step"))
+            col.prop(arm, "ghost_step", text="Range")
+            col.prop(arm, "ghost_size", text="Step")
 
         col = split.column()
-        col.label(text=_("Display:"))
-        col.prop(arm, "show_only_ghost_selected", text=_("Selected Only"))
+        col.label(text="Display:")
+        col.prop(arm, "show_only_ghost_selected", text="Selected Only")
 
 
 class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
@@ -264,7 +263,7 @@ class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
             layout.prop(itasc, "mode", expand=True)
             simulation = (itasc.mode == 'SIMULATION')
             if simulation:
-                layout.label(text=_("Reiteration:"))
+                layout.label(text="Reiteration:")
                 layout.prop(itasc, "reiteration_method", expand=True)
 
             row = layout.row()
@@ -276,8 +275,8 @@ class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
                 layout.prop(itasc, "use_auto_step")
                 row = layout.row()
                 if itasc.use_auto_step:
-                    row.prop(itasc, "step_min", text=_("Min"))
-                    row.prop(itasc, "step_max", text=_("Max"))
+                    row.prop(itasc, "step_min", text="Min")
+                    row.prop(itasc, "step_max", text="Max")
                 else:
                     row.prop(itasc, "step_count")
 
@@ -287,7 +286,7 @@ class DATA_PT_iksolver_itasc(ArmatureButtonsPanel, Panel):
                 layout.prop(itasc, "velocity_max")
             if itasc.solver == 'DLS':
                 row = layout.row()
-                row.prop(itasc, "damping_max", text=_("Damp"), slider=True)
+                row.prop(itasc, "damping_max", text="Damp", slider=True)
                 row.prop(itasc, "damping_epsilon", text="Eps", slider=True)
 
 from bl_ui.properties_animviz import (
@@ -315,8 +314,8 @@ class DATA_PT_motion_paths(MotionPathButtonsPanel, Panel):
         layout.separator()
 
         split = layout.split()
-        split.operator("pose.paths_calculate", text=_("Calculate Paths"))
-        split.operator("pose.paths_clear", text=_("Clear Paths"))
+        split.operator("pose.paths_calculate", text="Calculate Paths")
+        split.operator("pose.paths_clear", text="Clear Paths")
 
 
 class DATA_PT_onion_skinning(OnionSkinButtonsPanel):  # , Panel): # inherit from panel when ready

release/scripts/startup/bl_ui/properties_data_bone.py

@@ -21,7 +21,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class BoneButtonsPanel():
@@ -77,14 +76,14 @@ class BONE_PT_transform(BoneButtonsPanel, Panel):
 
             col = row.column()
             if pchan.rotation_mode == 'QUATERNION':
-                col.prop(pchan, "rotation_quaternion", text=_("Rotation"))
+                col.prop(pchan, "rotation_quaternion", text="Rotation")
             elif pchan.rotation_mode == 'AXIS_ANGLE':
-                #col.label(text=_("Rotation"))
-                #col.prop(pchan, "rotation_angle", text=_("Angle"))
-                #col.prop(pchan, "rotation_axis", text=_("Axis"))
-                col.prop(pchan, "rotation_axis_angle", text=_("Rotation"))
+                #col.label(text="Rotation")
+                #col.prop(pchan, "rotation_angle", text="Angle")
+                #col.prop(pchan, "rotation_axis", text="Axis")
+                col.prop(pchan, "rotation_axis_angle", text="Rotation")
             else:
-                col.prop(pchan, "rotation_euler", text=_("Rotation"))
+                col.prop(pchan, "rotation_euler", text="Rotation")
 
             row.column().prop(pchan, "scale")
 
@@ -98,7 +97,7 @@ class BONE_PT_transform(BoneButtonsPanel, Panel):
 
             col = row.column()
             sub = col.column(align=True)
-            sub.label(text=_("Roll:"))
+            sub.label(text="Roll:")
             sub.prop(bone, "roll", text="")
             sub.label()
             sub.prop(bone, "lock")
@@ -127,12 +126,12 @@ class BONE_PT_transform_locks(BoneButtonsPanel, Panel):
 
         col = row.column()
         if pchan.rotation_mode in {'QUATERNION', 'AXIS_ANGLE'}:
-            col.prop(pchan, "lock_rotations_4d", text=_("Lock Rotation"))
+            col.prop(pchan, "lock_rotations_4d", text="Lock Rotation")
             if pchan.lock_rotations_4d:
                 col.prop(pchan, "lock_rotation_w", text="W")
             col.prop(pchan, "lock_rotation", text="")
         else:
-            col.prop(pchan, "lock_rotation", text=_("Rotation"))
+            col.prop(pchan, "lock_rotation", text="Rotation")
 
         row.column().prop(pchan, "lock_scale")
 
@@ -156,17 +155,17 @@ class BONE_PT_relations(BoneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Layers:"))
+        col.label(text="Layers:")
         col.prop(bone, "layers", text="")
 
         col.separator()
 
         if ob and pchan:
-            col.label(text=_("Bone Group:"))
+            col.label(text="Bone Group:")
             col.prop_search(pchan, "bone_group", ob.pose, "bone_groups", text="")
 
         col = split.column()
-        col.label(text=_("Parent:"))
+        col.label(text="Parent:")
         if context.bone:
             col.prop(bone, "parent", text="")
         else:
@@ -175,11 +174,11 @@ class BONE_PT_relations(BoneButtonsPanel, Panel):
         sub = col.column()
         sub.active = (bone.parent is not None)
         sub.prop(bone, "use_connect")
-        sub.prop(bone, "use_inherit_rotation", text=_("Inherit Rotation"))
-        sub.prop(bone, "use_inherit_scale", text=_("Inherit Scale"))
+        sub.prop(bone, "use_inherit_rotation", text="Inherit Rotation")
+        sub.prop(bone, "use_inherit_scale", text="Inherit Scale")
         sub = col.column()
         sub.active = (not bone.parent or not bone.use_connect)
-        sub.prop(bone, "use_local_location", text=_("Local Location"))
+        sub.prop(bone, "use_local_location", text="Local Location")
 
 
 class BONE_PT_display(BoneButtonsPanel, Panel):
@@ -207,16 +206,16 @@ class BONE_PT_display(BoneButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.prop(bone, "show_wire", text=_("Wireframe"))
-            col.prop(bone, "hide", text=_("Hide"))
+            col.prop(bone, "show_wire", text="Wireframe")
+            col.prop(bone, "hide", text="Hide")
 
             if pchan:
                 col = split.column()
 
-                col.label(text=_("Custom Shape:"))
+                col.label(text="Custom Shape:")
                 col.prop(pchan, "custom_shape", text="")
                 if pchan.custom_shape:
-                    col.prop_search(pchan, "custom_shape_transform", ob.pose, "bones", text=_("At"))
+                    col.prop_search(pchan, "custom_shape_transform", ob.pose, "bones", text="At")
 
 
 class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
@@ -242,13 +241,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         split.prop(pchan, "lock_ik_x", icon='LOCKED' if pchan.lock_ik_x else 'UNLOCKED', text="X")
         split.active = pchan.is_in_ik_chain
         row = split.row()
-        row.prop(pchan, "ik_stiffness_x", text=_("Stiffness"), slider=True)
+        row.prop(pchan, "ik_stiffness_x", text="Stiffness", slider=True)
         row.active = pchan.lock_ik_x == False and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
         sub = split.row()
 
-        sub.prop(pchan, "use_ik_limit_x", text=_("Limit"))
+        sub.prop(pchan, "use_ik_limit_x", text="Limit")
         sub.active = pchan.lock_ik_x == False and pchan.is_in_ik_chain
         sub = split.row(align=True)
         sub.prop(pchan, "ik_min_x", text="")
@@ -259,13 +258,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         split.prop(pchan, "lock_ik_y", icon='LOCKED' if pchan.lock_ik_y else 'UNLOCKED', text="Y")
         split.active = pchan.is_in_ik_chain
         row = split.row()
-        row.prop(pchan, "ik_stiffness_y", text=_("Stiffness"), slider=True)
+        row.prop(pchan, "ik_stiffness_y", text="Stiffness", slider=True)
         row.active = pchan.lock_ik_y == False and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
         sub = split.row()
 
-        sub.prop(pchan, "use_ik_limit_y", text=_("Limit"))
+        sub.prop(pchan, "use_ik_limit_y", text="Limit")
         sub.active = pchan.lock_ik_y == False and pchan.is_in_ik_chain
 
         sub = split.row(align=True)
@@ -277,13 +276,13 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         split.prop(pchan, "lock_ik_z", icon='LOCKED' if pchan.lock_ik_z else 'UNLOCKED', text="Z")
         split.active = pchan.is_in_ik_chain
         sub = split.row()
-        sub.prop(pchan, "ik_stiffness_z", text=_("Stiffness"), slider=True)
+        sub.prop(pchan, "ik_stiffness_z", text="Stiffness", slider=True)
         sub.active = pchan.lock_ik_z == False and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
         sub = split.row()
 
-        sub.prop(pchan, "use_ik_limit_z", text=_("Limit"))
+        sub.prop(pchan, "use_ik_limit_z", text="Limit")
         sub.active = pchan.lock_ik_z == False and pchan.is_in_ik_chain
         sub = split.row(align=True)
         sub.prop(pchan, "ik_min_z", text="")
@@ -291,7 +290,7 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         sub.active = pchan.lock_ik_z == False and pchan.use_ik_limit_z and pchan.is_in_ik_chain
 
         split = layout.split(percentage=0.25)
-        split.label(text=_("Stretch:"))
+        split.label(text="Stretch:")
         sub = split.row()
         sub.prop(pchan, "ik_stretch", text="", slider=True)
         sub.active = pchan.is_in_ik_chain
@@ -299,15 +298,15 @@ class BONE_PT_inverse_kinematics(BoneButtonsPanel, Panel):
         if ob.pose.ik_solver == 'ITASC':
             split = layout.split()
             col = split.column()
-            col.prop(pchan, "use_ik_rotation_control", text=_("Control Rotation"))
+            col.prop(pchan, "use_ik_rotation_control", text="Control Rotation")
             col.active = pchan.is_in_ik_chain
             col = split.column()
-            col.prop(pchan, "ik_rotation_weight", text=_("Weight"), slider=True)
+            col.prop(pchan, "ik_rotation_weight", text="Weight", slider=True)
             col.active = pchan.is_in_ik_chain
             # not supported yet
             #row = layout.row()
-            #row.prop(pchan, "use_ik_linear_control", text=_("Joint Size"))
-            #row.prop(pchan, "ik_linear_weight", text=_("Weight"), slider=True)
+            #row.prop(pchan, "use_ik_linear_control", text="Joint Size")
+            #row.prop(pchan, "ik_linear_weight", text="Weight", slider=True)
 
 
 class BONE_PT_deform(BoneButtonsPanel, Panel):
@@ -335,27 +334,27 @@ class BONE_PT_deform(BoneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Envelope:"))
+        col.label(text="Envelope:")
 
         sub = col.column(align=True)
-        sub.prop(bone, "envelope_distance", text=_("Distance"))
-        sub.prop(bone, "envelope_weight", text=_("Weight"))
-        col.prop(bone, "use_envelope_multiply", text=_("Multiply"))
+        sub.prop(bone, "envelope_distance", text="Distance")
+        sub.prop(bone, "envelope_weight", text="Weight")
+        col.prop(bone, "use_envelope_multiply", text="Multiply")
 
         sub = col.column(align=True)
-        sub.label(text=_("Radius:"))
-        sub.prop(bone, "head_radius", text=_("Head"))
-        sub.prop(bone, "tail_radius", text=_("Tail"))
+        sub.label(text="Radius:")
+        sub.prop(bone, "head_radius", text="Head")
+        sub.prop(bone, "tail_radius", text="Tail")
 
         col = split.column()
-        col.label(text=_("Curved Bones:"))
+        col.label(text="Curved Bones:")
 
         sub = col.column(align=True)
-        sub.prop(bone, "bbone_segments", text=_("Segments"))
-        sub.prop(bone, "bbone_in", text=_("Ease In"))
-        sub.prop(bone, "bbone_out", text=_("Ease Out"))
+        sub.prop(bone, "bbone_segments", text="Segments")
+        sub.prop(bone, "bbone_in", text="Ease In")
+        sub.prop(bone, "bbone_out", text="Ease Out")
 
-        col.label(text=_("Offset:"))
+        col.label(text="Offset:")
         col.prop(bone, "use_cyclic_offset")
 
 

release/scripts/startup/bl_ui/properties_data_camera.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class CameraButtonsPanel():
@@ -92,16 +91,16 @@ class DATA_PT_camera(CameraButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text=_("Shift:"))
+        col.label(text="Shift:")
         col.prop(cam, "shift_x", text="X")
         col.prop(cam, "shift_y", text="Y")
 
         col = split.column(align=True)
-        col.label(text=_("Clipping:"))
-        col.prop(cam, "clip_start", text=_("Start"))
-        col.prop(cam, "clip_end", text=_("End"))
+        col.label(text="Clipping:")
+        col.prop(cam, "clip_start", text="Start")
+        col.prop(cam, "clip_end", text="End")
 
-        layout.label(text=_("Depth of Field:"))
+        layout.label(text="Depth of Field:")
 
         split = layout.split()
         split.prop(cam, "dof_object", text="")
@@ -110,7 +109,7 @@ class DATA_PT_camera(CameraButtonsPanel, Panel):
 
         if cam.dof_object is not None:
             col.enabled = False
-        col.prop(cam, "dof_distance", text=_("Distance"))
+        col.prop(cam, "dof_distance", text="Distance")
 
 
 class DATA_PT_camera_display(CameraButtonsPanel, Panel):
@@ -125,19 +124,19 @@ class DATA_PT_camera_display(CameraButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(cam, "show_limits", text=_("Limits"))
-        col.prop(cam, "show_mist", text=_("Mist"))
-        col.prop(cam, "show_title_safe", text=_("Title Safe"))
-        col.prop(cam, "show_name", text=_("Name"))
+        col.prop(cam, "show_limits", text="Limits")
+        col.prop(cam, "show_mist", text="Mist")
+        col.prop(cam, "show_title_safe", text="Title Safe")
+        col.prop(cam, "show_name", text="Name")
         col.prop_menu_enum(cam, "show_guide")
 
         col = split.column()
-        col.prop(cam, "draw_size", text=_("Size"))
+        col.prop(cam, "draw_size", text="Size")
         col.separator()
-        col.prop(cam, "show_passepartout", text=_("Passepartout"))
+        col.prop(cam, "show_passepartout", text="Passepartout")
         sub = col.column()
         sub.active = cam.show_passepartout
-        sub.prop(cam, "passepartout_alpha", text=_("Alpha"), slider=True)
+        sub.prop(cam, "passepartout_alpha", text="Alpha", slider=True)
 
 
 class DATA_PT_custom_props_camera(CameraButtonsPanel, PropertyPanel, Panel):

release/scripts/startup/bl_ui/properties_data_curve.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class CurveButtonsPanel():
@@ -68,7 +67,7 @@ class DATA_PT_context_curve(CurveButtonsPanel, Panel):
 
 
 class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
-    bl_label = _("Shape")
+    bl_label = "Shape"
 
     def draw(self, context):
         layout = self.layout
@@ -86,17 +85,17 @@ class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Resolution:"))
+        col.label(text="Resolution:")
         sub = col.column(align=True)
-        sub.prop(curve, "resolution_u", text=_("Preview U"))
-        sub.prop(curve, "render_resolution_u", text=_("Render U"))
+        sub.prop(curve, "resolution_u", text="Preview U")
+        sub.prop(curve, "render_resolution_u", text="Render U")
         if is_curve:
-            col.label(text=_("Twisting:"))
+            col.label(text="Twisting:")
             col.prop(curve, "twist_mode", text="")
-            col.prop(curve, "twist_smooth", text=_("Smooth"))
+            col.prop(curve, "twist_smooth", text="Smooth")
         if is_text:
-            col.label(text=_("Display:"))
-            col.prop(curve, "use_fast_edit", text=_("Fast Editing"))
+            col.label(text="Display:")
+            col.prop(curve, "use_fast_edit", text="Fast Editing")
 
         col = split.column()
 
@@ -104,15 +103,15 @@ class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
             sub = col.column()
             sub.label(text="")
             sub = col.column(align=True)
-            sub.prop(curve, "resolution_v", text=_("Preview V"))
-            sub.prop(curve, "render_resolution_v", text=_("Render V"))
+            sub.prop(curve, "resolution_v", text="Preview V")
+            sub.prop(curve, "render_resolution_v", text="Render V")
 
         if (is_curve or is_text):
-            col.label(text=_("Fill:"))
+            col.label(text="Fill:")
             sub = col.column()
             sub.active = (curve.dimensions == '2D' or (curve.bevel_object is None and curve.dimensions == '3D'))
             sub.prop(curve, "fill_mode", text="")
-            col.prop(curve, "use_fill_deform", text=_("Fill Deformed"))
+            col.prop(curve, "use_fill_deform", text="Fill Deformed")
 
 
 class DATA_PT_curve_texture_space(CurveButtonsPanel, Panel):
@@ -130,8 +129,8 @@ class DATA_PT_curve_texture_space(CurveButtonsPanel, Panel):
         row.prop(curve, "use_uv_as_generated")
 
         row = layout.row()
-        row.column().prop(curve, "texspace_location", text=_("Location"))
-        row.column().prop(curve, "texspace_size", text=_("Size"))
+        row.column().prop(curve, "texspace_location", text="Location")
+        row.column().prop(curve, "texspace_size", text="Size")
 
 
 class DATA_PT_geometry_curve(CurveButtonsPanel, Panel):
@@ -153,17 +152,17 @@ class DATA_PT_geometry_curve(CurveButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Modification:"))
+        col.label(text="Modification:")
         col.prop(curve, "offset")
         col.prop(curve, "extrude")
-        col.label(text=_("Taper Object:"))
+        col.label(text="Taper Object:")
         col.prop(curve, "taper_object", text="")
 
         col = split.column()
-        col.label(text=_("Bevel:"))
-        col.prop(curve, "bevel_depth", text=_("Depth"))
-        col.prop(curve, "bevel_resolution", text=_("Resolution"))
-        col.label(text=_("Bevel Object:"))
+        col.label(text="Bevel:")
+        col.prop(curve, "bevel_depth", text="Depth")
+        col.prop(curve, "bevel_resolution", text="Resolution")
+        col.label(text="Bevel Object:")
         col.prop(curve, "bevel_object", text="")
 
 
@@ -183,7 +182,7 @@ class DATA_PT_pathanim(CurveButtonsPanelCurve, Panel):
         layout.active = curve.use_path
 
         col = layout.column()
-        layout.prop(curve, "path_duration", text=_("Frames"))
+        layout.prop(curve, "path_duration", text="Frames")
         layout.prop(curve, "eval_time")
 
         split = layout.split()
@@ -195,7 +194,7 @@ class DATA_PT_pathanim(CurveButtonsPanelCurve, Panel):
 
         col = split.column()
         col.prop(curve, "use_radius")
-        col.prop(curve, "use_time_offset", text=_("Offset Children"))
+        col.prop(curve, "use_time_offset", text="Offset Children")
 
 
 class DATA_PT_active_spline(CurveButtonsPanelActive, Panel):
@@ -216,20 +215,20 @@ class DATA_PT_active_spline(CurveButtonsPanelActive, Panel):
             # These settings are below but its easier to have
             # poly's set aside since they use so few settings
             col = split.column()
-            col.label(text=_("Cyclic:"))
+            col.label(text="Cyclic:")
             col.prop(act_spline, "use_smooth")
             col = split.column()
             col.prop(act_spline, "use_cyclic_u", text="U")
 
         else:
             col = split.column()
-            col.label(text=_("Cyclic:"))
+            col.label(text="Cyclic:")
             if act_spline.type == 'NURBS':
-                col.label(text=_("Bezier:"))
-                col.label(text=_("Endpoint:"))
-                col.label(text=_("Order:"))
+                col.label(text="Bezier:")
+                col.label(text="Endpoint:")
+                col.label(text="Order:")
 
-            col.label(text=_("Resolution:"))
+            col.label(text="Resolution:")
 
             col = split.column()
             col.prop(act_spline, "use_cyclic_u", text="U")
@@ -262,9 +261,9 @@ class DATA_PT_active_spline(CurveButtonsPanelActive, Panel):
                 col = split.column()
                 col.active = (curve.dimensions == '3D')
 
-                col.label(text=_("Interpolation:"))
-                col.prop(act_spline, "tilt_interpolation", text=_("Tilt"))
-                col.prop(act_spline, "radius_interpolation", text=_("Radius"))
+                col.label(text="Interpolation:")
+                col.prop(act_spline, "tilt_interpolation", text="Tilt")
+                col.prop(act_spline, "radius_interpolation", text="Radius")
 
             layout.prop(act_spline, "use_smooth")
 
@@ -283,16 +282,16 @@ class DATA_PT_font(CurveButtonsPanel, Panel):
         char = context.curve.edit_format
 
         row = layout.split(percentage=0.25)
-        row.label(text=_("Regular"))
+        row.label(text="Regular")
         row.template_ID(text, "font", open="font.open", unlink="font.unlink")
         row = layout.split(percentage=0.25)
-        row.label(text=_("Bold"))
+        row.label(text="Bold")
         row.template_ID(text, "font_bold", open="font.open", unlink="font.unlink")
         row = layout.split(percentage=0.25)
-        row.label(text=_("Italic"))
+        row.label(text="Italic")
         row.template_ID(text, "font_italic", open="font.open", unlink="font.unlink")
         row = layout.split(percentage=0.25)
-        row.label(text=_("Bold & Italic"))
+        row.label(text="Bold & Italic")
         row.template_ID(text, "font_bold_italic", open="font.open", unlink="font.unlink")
 
         #layout.prop(text, "font")
@@ -300,36 +299,36 @@ class DATA_PT_font(CurveButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(text, "size", text=_("Size"))
+        col.prop(text, "size", text="Size")
         col = split.column()
         col.prop(text, "shear")
 
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Object Font:"))
+        col.label(text="Object Font:")
         col.prop(text, "family", text="")
 
         col = split.column()
-        col.label(text=_("Text on Curve:"))
+        col.label(text="Text on Curve:")
         col.prop(text, "follow_curve", text="")
 
         split = layout.split()
 
         col = split.column()
         colsub = col.column(align=True)
-        colsub.label(text=_("Underline:"))
-        colsub.prop(text, "underline_position", text=_("Position"))
-        colsub.prop(text, "underline_height", text=_("Thickness"))
+        colsub.label(text="Underline:")
+        colsub.prop(text, "underline_position", text="Position")
+        colsub.prop(text, "underline_height", text="Thickness")
 
         col = split.column()
-        col.label(text=_("Character:"))
+        col.label(text="Character:")
         col.prop(char, "use_bold")
         col.prop(char, "use_italic")
         col.prop(char, "use_underline")
 
         row = layout.row()
-        row.prop(text, "small_caps_scale", text=_("Small Caps"))
+        row.prop(text, "small_caps_scale", text="Small Caps")
         row.prop(char, "use_small_caps")
 
 
@@ -345,19 +344,19 @@ class DATA_PT_paragraph(CurveButtonsPanel, Panel):
 
         text = context.curve
 
-        layout.label(text=_("Align:"))
+        layout.label(text="Align:")
         layout.prop(text, "align", expand=True)
 
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text=_("Spacing:"))
-        col.prop(text, "space_character", text=_("Character"))
-        col.prop(text, "space_word", text=_("Word"))
-        col.prop(text, "space_line", text=_("Line"))
+        col.label(text="Spacing:")
+        col.prop(text, "space_character", text="Character")
+        col.prop(text, "space_word", text="Word")
+        col.prop(text, "space_line", text="Line")
 
         col = split.column(align=True)
-        col.label(text=_("Offset:"))
+        col.label(text="Offset:")
         col.prop(text, "offset_x", text="X")
         col.prop(text, "offset_y", text="Y")
 
@@ -389,13 +388,13 @@ class DATA_PT_text_boxes(CurveButtonsPanel, Panel):
 
             col = split.column(align=True)
 
-            col.label(text=_("Dimensions:"))
-            col.prop(box, "width", text=_("Width"))
-            col.prop(box, "height", text=_("Height"))
+            col.label(text="Dimensions:")
+            col.prop(box, "width", text="Width")
+            col.prop(box, "height", text="Height")
 
             col = split.column(align=True)
 
-            col.label(text=_("Offset:"))
+            col.label(text="Offset:")
             col.prop(box, "x", text="X")
             col.prop(box, "y", text="Y")
 

release/scripts/startup/bl_ui/properties_data_empty.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 
 class DataButtonsPanel():
@@ -40,17 +39,17 @@ class DATA_PT_empty(DataButtonsPanel, Panel):
 
         ob = context.object
 
-        layout.prop(ob, "empty_draw_type", text=_("Display"))
+        layout.prop(ob, "empty_draw_type", text="Display")
 
         if ob.empty_draw_type == 'IMAGE':
             layout.template_ID(ob, "data", open="image.open", unlink="image.unlink")
 
-            layout.prop(ob, "color", text=_("Transparency"), index=3, slider=True)
+            layout.prop(ob, "color", text="Transparency", index=3, slider=True)
             row = layout.row(align=True)
-            row.prop(ob, "empty_image_offset", text=_("Offset X"), index=0)
-            row.prop(ob, "empty_image_offset", text=_("Offset Y"), index=1)
+            row.prop(ob, "empty_image_offset", text="Offset X", index=0)
+            row.prop(ob, "empty_image_offset", text="Offset Y", index=1)
 
-        layout.prop(ob, "empty_draw_size", text=_("Size"))
+        layout.prop(ob, "empty_draw_size", text="Size")
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/properties_data_lamp.py

@@ -20,11 +20,10 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class LAMP_MT_sunsky_presets(Menu):
-    bl_label = _("Sun & Sky Presets")
+    bl_label = "Sun & Sky Presets"
     preset_subdir = "sunsky"
     preset_operator = "script.execute_preset"
     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
@@ -94,15 +93,15 @@ class DATA_PT_lamp(DataButtonsPanel, Panel):
         sub.prop(lamp, "energy")
 
         if lamp.type in {'POINT', 'SPOT'}:
-            sub.label(text=_("Falloff:"))
+            sub.label(text="Falloff:")
             sub.prop(lamp, "falloff_type", text="")
             sub.prop(lamp, "distance")
 
             if lamp.falloff_type == 'LINEAR_QUADRATIC_WEIGHTED':
-                col.label(text=_("Attenuation Factors:"))
+                col.label(text="Attenuation Factors:")
                 sub = col.column(align=True)
-                sub.prop(lamp, "linear_attenuation", slider=True, text=_("Linear"))
-                sub.prop(lamp, "quadratic_attenuation", slider=True, text=_("Quadratic"))
+                sub.prop(lamp, "linear_attenuation", slider=True, text="Linear")
+                sub.prop(lamp, "quadratic_attenuation", slider=True, text="Quadratic")
 
             col.prop(lamp, "use_sphere")
 
@@ -112,7 +111,7 @@ class DATA_PT_lamp(DataButtonsPanel, Panel):
 
         col = split.column()
         col.prop(lamp, "use_negative")
-        col.prop(lamp, "use_own_layer", text=_("This Layer Only"))
+        col.prop(lamp, "use_own_layer", text="This Layer Only")
         col.prop(lamp, "use_specular")
         col.prop(lamp, "use_diffuse")
 
@@ -140,34 +139,34 @@ class DATA_PT_sunsky(DataButtonsPanel, Panel):
 
         row = layout.row()
         row.active = lamp.use_sky or lamp.use_atmosphere
-        row.prop(lamp, "atmosphere_turbidity", text=_("Turbidity"))
+        row.prop(lamp, "atmosphere_turbidity", text="Turbidity")
 
         split = layout.split()
 
         col = split.column()
         col.active = lamp.use_sky
-        col.label(text=_("Blending:"))
+        col.label(text="Blending:")
         sub = col.column()
         sub.prop(lamp, "sky_blend_type", text="")
-        sub.prop(lamp, "sky_blend", text=_("Factor"))
+        sub.prop(lamp, "sky_blend", text="Factor")
 
-        col.label(text=_("Color Space:"))
+        col.label(text="Color Space:")
         sub = col.column()
         sub.row().prop(lamp, "sky_color_space", expand=True)
-        sub.prop(lamp, "sky_exposure", text=_("Exposure"))
+        sub.prop(lamp, "sky_exposure", text="Exposure")
 
         col = split.column()
         col.active = lamp.use_sky
-        col.label(text=_("Horizon:"))
+        col.label(text="Horizon:")
         sub = col.column()
-        sub.prop(lamp, "horizon_brightness", text=_("Brightness"))
-        sub.prop(lamp, "spread", text=_("Spread"))
+        sub.prop(lamp, "horizon_brightness", text="Brightness")
+        sub.prop(lamp, "spread", text="Spread")
 
-        col.label(text=_("Sun:"))
+        col.label(text="Sun:")
         sub = col.column()
-        sub.prop(lamp, "sun_brightness", text=_("Brightness"))
-        sub.prop(lamp, "sun_size", text=_("Size"))
-        sub.prop(lamp, "backscattered_light", slider=True, text=_("Back Light"))
+        sub.prop(lamp, "sun_brightness", text="Brightness")
+        sub.prop(lamp, "sun_size", text="Size")
+        sub.prop(lamp, "backscattered_light", slider=True, text="Back Light")
 
         layout.separator()
 
@@ -177,16 +176,16 @@ class DATA_PT_sunsky(DataButtonsPanel, Panel):
 
         col = split.column()
         col.active = lamp.use_atmosphere
-        col.label(text=_("Intensity:"))
-        col.prop(lamp, "sun_intensity", text=_("Sun"))
-        col.prop(lamp, "atmosphere_distance_factor", text=_("Distance"))
+        col.label(text="Intensity:")
+        col.prop(lamp, "sun_intensity", text="Sun")
+        col.prop(lamp, "atmosphere_distance_factor", text="Distance")
 
         col = split.column()
         col.active = lamp.use_atmosphere
-        col.label(text=_("Scattering:"))
+        col.label(text="Scattering:")
         sub = col.column(align=True)
-        sub.prop(lamp, "atmosphere_inscattering", slider=True, text=_("Inscattering"))
-        sub.prop(lamp, "atmosphere_extinction", slider=True, text=_("Extinction"))
+        sub.prop(lamp, "atmosphere_inscattering", slider=True, text="Inscattering")
+        sub.prop(lamp, "atmosphere_extinction", slider=True, text="Extinction")
 
 
 class DATA_PT_shadow(DataButtonsPanel, Panel):
@@ -210,15 +209,15 @@ class DATA_PT_shadow(DataButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Form factor sampling:"))
+            col.label(text="Form factor sampling:")
 
             sub = col.row(align=True)
 
             if lamp.shape == 'SQUARE':
-                sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples"))
+                sub.prop(lamp, "shadow_ray_samples_x", text="Samples")
             elif lamp.shape == 'RECTANGLE':
-                sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples X"))
-                sub.prop(lamp, "shadow_ray_samples_y", text=_("Samples Y"))
+                sub.prop(lamp, "shadow_ray_samples_x", text="Samples X")
+                sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y")
 
         if lamp.shadow_method != 'NOSHADOW':
             split = layout.split()
@@ -227,34 +226,34 @@ class DATA_PT_shadow(DataButtonsPanel, Panel):
             col.prop(lamp, "shadow_color", text="")
 
             col = split.column()
-            col.prop(lamp, "use_shadow_layer", text=_("This Layer Only"))
+            col.prop(lamp, "use_shadow_layer", text="This Layer Only")
             col.prop(lamp, "use_only_shadow")
 
         if lamp.shadow_method == 'RAY_SHADOW':
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Sampling:"))
+            col.label(text="Sampling:")
 
             if lamp.type in {'POINT', 'SUN', 'SPOT'}:
                 sub = col.row()
 
-                sub.prop(lamp, "shadow_ray_samples", text=_("Samples"))
-                sub.prop(lamp, "shadow_soft_size", text=_("Soft Size"))
+                sub.prop(lamp, "shadow_ray_samples", text="Samples")
+                sub.prop(lamp, "shadow_soft_size", text="Soft Size")
 
             elif lamp.type == 'AREA':
                 sub = col.row(align=True)
 
                 if lamp.shape == 'SQUARE':
-                    sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples"))
+                    sub.prop(lamp, "shadow_ray_samples_x", text="Samples")
                 elif lamp.shape == 'RECTANGLE':
-                    sub.prop(lamp, "shadow_ray_samples_x", text=_("Samples X"))
-                    sub.prop(lamp, "shadow_ray_samples_y", text=_("Samples Y"))
+                    sub.prop(lamp, "shadow_ray_samples_x", text="Samples X")
+                    sub.prop(lamp, "shadow_ray_samples_y", text="Samples Y")
 
             col.row().prop(lamp, "shadow_ray_sample_method", expand=True)
 
             if lamp.shadow_ray_sample_method == 'ADAPTIVE_QMC':
-                layout.prop(lamp, "shadow_adaptive_threshold", text=_("Threshold"))
+                layout.prop(lamp, "shadow_adaptive_threshold", text="Threshold")
 
             if lamp.type == 'AREA' and lamp.shadow_ray_sample_method == 'CONSTANT_JITTERED':
                 row = layout.row()
@@ -264,44 +263,44 @@ class DATA_PT_shadow(DataButtonsPanel, Panel):
 
         elif lamp.shadow_method == 'BUFFER_SHADOW':
             col = layout.column()
-            col.label(text=_("Buffer Type:"))
+            col.label(text="Buffer Type:")
             col.row().prop(lamp, "shadow_buffer_type", expand=True)
 
             if lamp.shadow_buffer_type in {'REGULAR', 'HALFWAY', 'DEEP'}:
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Filter Type:"))
+                col.label(text="Filter Type:")
                 col.prop(lamp, "shadow_filter_type", text="")
                 sub = col.column(align=True)
-                sub.prop(lamp, "shadow_buffer_soft", text=_("Soft"))
-                sub.prop(lamp, "shadow_buffer_bias", text=_("Bias"))
+                sub.prop(lamp, "shadow_buffer_soft", text="Soft")
+                sub.prop(lamp, "shadow_buffer_bias", text="Bias")
 
                 col = split.column()
-                col.label(text=_("Sample Buffers:"))
+                col.label(text="Sample Buffers:")
                 col.prop(lamp, "shadow_sample_buffers", text="")
                 sub = col.column(align=True)
-                sub.prop(lamp, "shadow_buffer_size", text=_("Size"))
-                sub.prop(lamp, "shadow_buffer_samples", text=_("Samples"))
+                sub.prop(lamp, "shadow_buffer_size", text="Size")
+                sub.prop(lamp, "shadow_buffer_samples", text="Samples")
                 if lamp.shadow_buffer_type == 'DEEP':
                     col.prop(lamp, "compression_threshold")
 
             elif lamp.shadow_buffer_type == 'IRREGULAR':
-                layout.prop(lamp, "shadow_buffer_bias", text=_("Bias"))
+                layout.prop(lamp, "shadow_buffer_bias", text="Bias")
 
             split = layout.split()
 
             col = split.column()
-            col.prop(lamp, "use_auto_clip_start", text=_("Autoclip Start"))
+            col.prop(lamp, "use_auto_clip_start", text="Autoclip Start")
             sub = col.column()
             sub.active = not lamp.use_auto_clip_start
-            sub.prop(lamp, "shadow_buffer_clip_start", text=_("Clip Start"))
+            sub.prop(lamp, "shadow_buffer_clip_start", text="Clip Start")
 
             col = split.column()
-            col.prop(lamp, "use_auto_clip_end", text=_("Autoclip End"))
+            col.prop(lamp, "use_auto_clip_end", text="Autoclip End")
             sub = col.column()
             sub.active = not lamp.use_auto_clip_end
-            sub.prop(lamp, "shadow_buffer_clip_end", text=_(" Clip End"))
+            sub.prop(lamp, "shadow_buffer_clip_end", text=" Clip End")
 
 
 class DATA_PT_area(DataButtonsPanel, Panel):
@@ -326,8 +325,8 @@ class DATA_PT_area(DataButtonsPanel, Panel):
         if (lamp.shape == 'SQUARE'):
             sub.prop(lamp, "size")
         elif (lamp.shape == 'RECTANGLE'):
-            sub.prop(lamp, "size", text=_("Size X"))
-            sub.prop(lamp, "size_y", text=_("Size Y"))
+            sub.prop(lamp, "size", text="Size X")
+            sub.prop(lamp, "size_y", text="Size Y")
 
 
 class DATA_PT_spot(DataButtonsPanel, Panel):
@@ -349,8 +348,8 @@ class DATA_PT_spot(DataButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column()
-        sub.prop(lamp, "spot_size", text=_("Size"))
-        sub.prop(lamp, "spot_blend", text=_("Blend"), slider=True)
+        sub.prop(lamp, "spot_size", text="Size")
+        sub.prop(lamp, "spot_blend", text="Blend", slider=True)
         col.prop(lamp, "use_square")
         col.prop(lamp, "show_cone")
 
@@ -359,9 +358,9 @@ class DATA_PT_spot(DataButtonsPanel, Panel):
         col.prop(lamp, "use_halo")
         sub = col.column(align=True)
         sub.active = lamp.use_halo
-        sub.prop(lamp, "halo_intensity", text=_("Intensity"))
+        sub.prop(lamp, "halo_intensity", text="Intensity")
         if lamp.shadow_method == 'BUFFER_SHADOW':
-            sub.prop(lamp, "halo_step", text=_("Step"))
+            sub.prop(lamp, "halo_step", text="Step")
 
 
 class DATA_PT_falloff_curve(DataButtonsPanel, Panel):

release/scripts/startup/bl_ui/properties_data_mesh.py

@@ -20,11 +20,10 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class MESH_MT_vertex_group_specials(Menu):
-    bl_label = _("Vertex Group Specials")
+    bl_label = "Vertex Group Specials"
     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 
     def draw(self, context):
@@ -35,7 +34,7 @@ class MESH_MT_vertex_group_specials(Menu):
         layout.operator("object.vertex_group_copy_to_linked", icon='LINK_AREA')
         layout.operator("object.vertex_group_copy_to_selected", icon='LINK_AREA')
         layout.operator("object.vertex_group_mirror", icon='ARROW_LEFTRIGHT')
-        layout.operator("object.vertex_group_remove", icon='X', text=_("Delete All")).all = True
+        layout.operator("object.vertex_group_remove", icon='X', text="Delete All").all = True
         layout.separator()
         layout.operator("object.vertex_group_lock", icon='LOCK', text="Lock All").action = 'SELECT'
         layout.operator("object.vertex_group_lock", icon='UNLOCK', text="UnLock All").action = 'DESELECT'
@@ -52,7 +51,7 @@ class MESH_MT_shape_key_specials(Menu):
         layout.operator("object.shape_key_transfer", icon='COPY_ID')  # icon is not ideal
         layout.operator("object.join_shapes", icon='COPY_ID')  # icon is not ideal
         layout.operator("object.shape_key_mirror", icon='ARROW_LEFTRIGHT')
-        op = layout.operator("object.shape_key_add", icon='ZOOMIN', text=_("New Shape From Mix"))
+        op = layout.operator("object.shape_key_add", icon='ZOOMIN', text="New Shape From Mix")
         op.from_mix = True
 
 
@@ -100,7 +99,7 @@ class DATA_PT_normals(MeshButtonsPanel, Panel):
         col.prop(mesh, "use_auto_smooth")
         sub = col.column()
         sub.active = mesh.use_auto_smooth
-        sub.prop(mesh, "auto_smooth_angle", text=_("Angle"))
+        sub.prop(mesh, "auto_smooth_angle", text="Angle")
 
         split.prop(mesh, "show_double_sided")
 
@@ -121,8 +120,8 @@ class DATA_PT_texture_space(MeshButtonsPanel, Panel):
 
         layout.prop(mesh, "use_auto_texspace")
         row = layout.row()
-        row.column().prop(mesh, "texspace_location", text=_("Location"))
-        row.column().prop(mesh, "texspace_size", text=_("Size"))
+        row.column().prop(mesh, "texspace_location", text="Location")
+        row.column().prop(mesh, "texspace_size", text="Size")
 
 
 class DATA_PT_vertex_groups(MeshButtonsPanel, Panel):
@@ -164,14 +163,14 @@ class DATA_PT_vertex_groups(MeshButtonsPanel, Panel):
             row = layout.row()
 
             sub = row.row(align=True)
-            sub.operator("object.vertex_group_assign", text=_("Assign"))
-            sub.operator("object.vertex_group_remove_from", text=_("Remove"))
+            sub.operator("object.vertex_group_assign", text="Assign")
+            sub.operator("object.vertex_group_remove_from", text="Remove")
 
             sub = row.row(align=True)
-            sub.operator("object.vertex_group_select", text=_("Select"))
-            sub.operator("object.vertex_group_deselect", text=_("Deselect"))
+            sub.operator("object.vertex_group_select", text="Select")
+            sub.operator("object.vertex_group_deselect", text="Deselect")
 
-            layout.prop(context.tool_settings, "vertex_group_weight", text=_("Weight"))
+            layout.prop(context.tool_settings, "vertex_group_weight", text="Weight")
 
 
 class DATA_PT_shape_keys(MeshButtonsPanel, Panel):
@@ -251,13 +250,13 @@ class DATA_PT_shape_keys(MeshButtonsPanel, Panel):
 
                     col = split.column(align=True)
                     col.active = enable_edit_value
-                    col.label(text=_("Range:"))
-                    col.prop(kb, "slider_min", text=_("Min"))
-                    col.prop(kb, "slider_max", text=_("Max"))
+                    col.label(text="Range:")
+                    col.prop(kb, "slider_min", text="Min")
+                    col.prop(kb, "slider_max", text="Max")
 
                     col = split.column(align=True)
                     col.active = enable_edit_value
-                    col.label(text=_("Blend:"))
+                    col.label(text="Blend:")
                     col.prop_search(kb, "vertex_group", ob, "vertex_groups", text="")
                     col.prop_search(kb, "relative_key", key, "key_blocks", text="")
 

release/scripts/startup/bl_ui/properties_data_metaball.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class DataButtonsPanel():
@@ -61,16 +60,16 @@ class DATA_PT_metaball(DataButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Resolution:"))
+        col.label(text="Resolution:")
         sub = col.column(align=True)
-        sub.prop(mball, "resolution", text=_("View"))
-        sub.prop(mball, "render_resolution", text=_("Render"))
+        sub.prop(mball, "resolution", text="View")
+        sub.prop(mball, "render_resolution", text="Render")
 
         col = split.column()
-        col.label(text=_("Settings:"))
-        col.prop(mball, "threshold", text=_("Threshold"))
+        col.label(text="Settings:")
+        col.prop(mball, "threshold", text="Threshold")
 
-        layout.label(text=_("Update:"))
+        layout.label(text="Update:")
         layout.prop(mball, "update_method", expand=True)
 
 
@@ -87,8 +86,8 @@ class DATA_PT_mball_texture_space(DataButtonsPanel, Panel):
         layout.prop(mball, "use_auto_texspace")
 
         row = layout.row()
-        row.column().prop(mball, "texspace_location", text=_("Location"))
-        row.column().prop(mball, "texspace_size", text=_("Size"))
+        row.column().prop(mball, "texspace_location", text="Location")
+        row.column().prop(mball, "texspace_size", text="Size")
 
 
 class DATA_PT_metaball_element(DataButtonsPanel, Panel):
@@ -108,25 +107,25 @@ class DATA_PT_metaball_element(DataButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text=_("Settings:"))
-        col.prop(metaelem, "stiffness", text=_("Stiffness"))
-        col.prop(metaelem, "use_negative", text=_("Negative"))
-        col.prop(metaelem, "hide", text=_("Hide"))
+        col.label(text="Settings:")
+        col.prop(metaelem, "stiffness", text="Stiffness")
+        col.prop(metaelem, "use_negative", text="Negative")
+        col.prop(metaelem, "hide", text="Hide")
 
         col = split.column(align=True)
 
         if metaelem.type in {'CUBE', 'ELLIPSOID'}:
-            col.label(text=_("Size:"))
+            col.label(text="Size:")
             col.prop(metaelem, "size_x", text="X")
             col.prop(metaelem, "size_y", text="Y")
             col.prop(metaelem, "size_z", text="Z")
 
         elif metaelem.type == 'TUBE':
-            col.label(text=_("Size:"))
+            col.label(text="Size:")
             col.prop(metaelem, "size_x", text="X")
 
         elif metaelem.type == 'PLANE':
-            col.label(text=_("Size:"))
+            col.label(text="Size:")
             col.prop(metaelem, "size_x", text="X")
             col.prop(metaelem, "size_y", text="Y")
 

release/scripts/startup/bl_ui/properties_data_modifier.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 
 class ModifierButtonsPanel():
@@ -52,14 +51,14 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Object:"))
+        col.label(text="Object:")
         col.prop(md, "object", text="")
         col.prop(md, "use_deform_preserve_volume")
 
         col = split.column()
-        col.label(text=_("Bind To:"))
-        col.prop(md, "use_vertex_groups", text=_("Vertex Groups"))
-        col.prop(md, "use_bone_envelopes", text=_("Bone Envelopes"))
+        col.label(text="Bind To:")
+        col.prop(md, "use_vertex_groups", text="Vertex Groups")
+        col.prop(md, "use_bone_envelopes", text="Bone Envelopes")
 
         layout.separator()
 
@@ -93,11 +92,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         col.separator()
 
-        col.prop(md, "use_merge_vertices", text=_("Merge"))
+        col.prop(md, "use_merge_vertices", text="Merge")
         sub = col.column()
         sub.active = md.use_merge_vertices
-        sub.prop(md, "use_merge_vertices_cap", text=_("First Last"))
-        sub.prop(md, "merge_threshold", text=_("Distance"))
+        sub.prop(md, "use_merge_vertices_cap", text="First Last")
+        sub.prop(md, "merge_threshold", text="Distance")
 
         col = split.column()
         col.prop(md, "use_relative_offset")
@@ -123,7 +122,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split.prop(md, "width")
         split.prop(md, "use_only_vertices")
 
-        layout.label(text=_("Limit Method:"))
+        layout.label(text="Limit Method:")
         layout.row().prop(md, "limit_method", expand=True)
         if md.limit_method == 'ANGLE':
             layout.prop(md, "angle_limit")
@@ -134,11 +133,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Operation:"))
+        col.label(text="Operation:")
         col.prop(md, "operation", text="")
 
         col = split.column()
-        col.label(text=_("Object:"))
+        col.label(text="Object:")
         col.prop(md, "object", text="")
 
     def BUILD(self, layout, ob, md):
@@ -157,7 +156,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
     def CAST(self, layout, ob, md):
         split = layout.split(percentage=0.25)
 
-        split.label(text=_("Cast Type:"))
+        split.label(text="Cast Type:")
         split.prop(md, "cast_type", text="")
 
         split = layout.split(percentage=0.25)
@@ -176,52 +175,52 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
         col = split.column()
-        col.label(text=_("Control Object:"))
+        col.label(text="Control Object:")
         col.prop(md, "object", text="")
         if md.object:
             col.prop(md, "use_transform")
 
     def CLOTH(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Physics context"))
+        layout.label(text="Settings can be found inside the Physics context")
 
     def COLLISION(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Physics context"))
+        layout.label(text="Settings can be found inside the Physics context")
 
     def CURVE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Object:"))
+        col.label(text="Object:")
         col.prop(md, "object", text="")
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
-        layout.label(text=_("Deformation Axis:"))
+        layout.label(text="Deformation Axis:")
         layout.row().prop(md, "deform_axis", expand=True)
 
     def DECIMATE(self, layout, ob, md):
         layout.prop(md, "ratio")
-        layout.label(text=_("Face Count") + ": %d" % md.face_count)
+        layout.label(text="Face Count" + ": %d" % md.face_count)
 
     def DISPLACE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Texture:"))
+        col.label(text="Texture:")
         col.template_ID(md, "texture", new="texture.new")
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         col = split.column()
-        col.label(text=_("Direction:"))
+        col.label(text="Direction:")
         col.prop(md, "direction", text="")
-        col.label(text=_("Texture Coordinates:"))
+        col.label(text="Texture Coordinates:")
         col.prop(md, "texture_coords", text="")
         if md.texture_coords == 'OBJECT':
-            layout.prop(md, "texture_coords_object", text=_("Object"))
+            layout.prop(md, "texture_coords_object", text="Object")
         elif md.texture_coords == 'UV' and ob.type == 'MESH':
             layout.prop_search(md, "uv_layer", ob.data, "uv_textures")
 
@@ -235,23 +234,23 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(md, "use_edge_angle", text=_("Edge Angle"))
+        col.prop(md, "use_edge_angle", text="Edge Angle")
         sub = col.column()
         sub.active = md.use_edge_angle
         sub.prop(md, "split_angle")
 
-        split.prop(md, "use_edge_sharp", text=_("Sharp Edges"))
+        split.prop(md, "use_edge_sharp", text="Sharp Edges")
 
     def EXPLODE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Vertex group:"))
+        col.label(text="Vertex group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
         sub = col.column()
         sub.active = bool(md.vertex_group)
         sub.prop(md, "protect")
-        col.label(text=_("Particle UV"))
+        col.label(text="Particle UV")
         col.prop_search(md, "particle_uv", ob.data, "uv_textures", text="")
 
         col = split.column()
@@ -261,22 +260,22 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "show_dead")
         col.prop(md, "use_size")
 
-        layout.operator("object.explode_refresh", text=_("Refresh"))
+        layout.operator("object.explode_refresh", text="Refresh")
 
     def FLUID_SIMULATION(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Physics context"))
+        layout.label(text="Settings can be found inside the Physics context")
 
     def HOOK(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Object:"))
+        col.label(text="Object:")
         col.prop(md, "object", text="")
         if md.object and md.object.type == 'ARMATURE':
-            col.label(text=_("Bone:"))
+            col.label(text="Bone:")
             col.prop_search(md, "subtarget", md.object.data, "bones", text="")
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         layout.separator()
@@ -288,38 +287,38 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "force", slider=True)
 
         col = split.column()
-        col.operator("object.hook_reset", text=_("Reset"))
-        col.operator("object.hook_recenter", text=_("Recenter"))
+        col.operator("object.hook_reset", text="Reset")
+        col.operator("object.hook_recenter", text="Recenter")
 
         if ob.mode == 'EDIT':
             layout.separator()
             row = layout.row()
-            row.operator("object.hook_select", text=_("Select"))
-            row.operator("object.hook_assign", text=_("Assign"))
+            row.operator("object.hook_select", text="Select")
+            row.operator("object.hook_assign", text="Assign")
 
     def LATTICE(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Object:"))
+        col.label(text="Object:")
         col.prop(md, "object", text="")
 
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
     def MASK(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Mode:"))
+        col.label(text="Mode:")
         col.prop(md, "mode", text="")
         col = split.column()
         if md.mode == 'ARMATURE':
-            col.label(text=_("Armature:"))
+            col.label(text="Armature:")
             col.prop(md, "armature", text="")
         elif md.mode == 'VERTEX_GROUP':
-            col.label(text=_("Vertex Group:"))
+            col.label(text="Vertex Group:")
             col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         sub = col.column()
@@ -331,11 +330,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column()
-        sub.label(text=_("Object:"))
+        sub.label(text="Object:")
         sub.prop(md, "object", text="")
         sub.active = not md.is_bound
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         sub = col.column()
@@ -345,9 +344,9 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         layout.separator()
 
         if md.is_bound:
-            layout.operator("object.meshdeform_bind", text=_("Unbind"))
+            layout.operator("object.meshdeform_bind", text="Unbind")
         else:
-            layout.operator("object.meshdeform_bind", text=_("Bind"))
+            layout.operator("object.meshdeform_bind", text="Bind")
 
             row = layout.row()
             row.prop(md, "precision")
@@ -357,19 +356,19 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split(percentage=0.25)
 
         col = split.column()
-        col.label(text=_("Axis:"))
+        col.label(text="Axis:")
         col.prop(md, "use_x")
         col.prop(md, "use_y")
         col.prop(md, "use_z")
 
         col = split.column()
-        col.label(text=_("Options:"))
-        col.prop(md, "use_mirror_merge", text=_("Merge"))
-        col.prop(md, "use_clip", text=_("Clipping"))
-        col.prop(md, "use_mirror_vertex_groups", text=_("Vertex Groups"))
+        col.label(text="Options:")
+        col.prop(md, "use_mirror_merge", text="Merge")
+        col.prop(md, "use_clip", text="Clipping")
+        col.prop(md, "use_mirror_vertex_groups", text="Vertex Groups")
 
         col = split.column()
-        col.label(text=_("Textures:"))
+        col.label(text="Textures:")
         col.prop(md, "use_mirror_u", text="U")
         col.prop(md, "use_mirror_v", text="V")
 
@@ -377,7 +376,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         if md.use_mirror_merge == True:
             col.prop(md, "merge_threshold")
-        col.label(text=_("Mirror Object:"))
+        col.label(text="Mirror Object:")
         col.prop(md, "mirror_object", text="")
 
     def NAVMESH(self, layout, ob, md):
@@ -389,17 +388,17 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         split = layout.split()
         col = split.column()
-        col.prop(md, "levels", text=_("Preview"))
-        col.prop(md, "sculpt_levels", text=_("Sculpt"))
-        col.prop(md, "render_levels", text=_("Render"))
+        col.prop(md, "levels", text="Preview")
+        col.prop(md, "sculpt_levels", text="Sculpt")
+        col.prop(md, "render_levels", text="Render")
 
         col = split.column()
 
         col.enabled = ob.mode != 'EDIT'
-        col.operator("object.multires_subdivide", text=_("Subdivide"))
-        col.operator("object.multires_higher_levels_delete", text=_("Delete Higher"))
-        col.operator("object.multires_reshape", text=_("Reshape"))
-        col.operator("object.multires_base_apply", text=_("Apply Base"))
+        col.operator("object.multires_subdivide", text="Subdivide")
+        col.operator("object.multires_higher_levels_delete", text="Delete Higher")
+        col.operator("object.multires_reshape", text="Reshape")
+        col.operator("object.multires_base_apply", text="Apply Base")
         col.prop(md, "use_subsurf_uv")
         col.prop(md, "show_only_control_edges")
 
@@ -408,34 +407,34 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col = layout.column()
         row = col.row()
         if md.is_external:
-            row.operator("object.multires_external_pack", text=_("Pack External"))
+            row.operator("object.multires_external_pack", text="Pack External")
             row.label()
             row = col.row()
             row.prop(md, "filepath", text="")
         else:
-            row.operator("object.multires_external_save", text=_("Save External..."))
+            row.operator("object.multires_external_save", text="Save External...")
             row.label()
 
     def PARTICLE_INSTANCE(self, layout, ob, md):
         layout.prop(md, "object")
-        layout.prop(md, "particle_system_index", text=_("Particle System"))
+        layout.prop(md, "particle_system_index", text="Particle System")
 
         split = layout.split()
         col = split.column()
-        col.label(text=_("Create From:"))
+        col.label(text="Create From:")
         col.prop(md, "use_normal")
         col.prop(md, "use_children")
         col.prop(md, "use_size")
 
         col = split.column()
-        col.label(text=_("Show Particles When:"))
+        col.label(text="Show Particles When:")
         col.prop(md, "show_alive")
         col.prop(md, "show_unborn")
         col.prop(md, "show_dead")
 
         layout.separator()
 
-        layout.prop(md, "use_path", text=_("Create Along Paths"))
+        layout.prop(md, "use_path", text="Create Along Paths")
 
         split = layout.split()
         split.active = md.use_path
@@ -445,17 +444,17 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
 
         col = split.column()
         col.prop(md, "position", slider=True)
-        col.prop(md, "random_position", text=_("Random"), slider=True)
+        col.prop(md, "random_position", text="Random", slider=True)
 
     def PARTICLE_SYSTEM(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Particle context"))
+        layout.label(text="Settings can be found inside the Particle context")
 
     def SCREW(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
         col.prop(md, "axis")
-        col.prop(md, "object", text=_("AxisOb"))
+        col.prop(md, "object", text="AxisOb")
         col.prop(md, "angle")
         col.prop(md, "steps")
         col.prop(md, "render_steps")
@@ -474,10 +473,10 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
     def SHRINKWRAP(self, layout, ob, md):
         split = layout.split()
         col = split.column()
-        col.label(text=_("Target:"))
+        col.label(text="Target:")
         col.prop(md, "target", text="")
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         split = layout.split()
@@ -487,28 +486,28 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "subsurf_levels")
 
         col = split.column()
-        col.label(text=_("Mode:"))
+        col.label(text="Mode:")
         col.prop(md, "wrap_method", text="")
 
         if md.wrap_method == 'PROJECT':
             split = layout.split(percentage=0.25)
 
             col = split.column()
-            col.label(text=_("Axis:"))
+            col.label(text="Axis:")
             col.prop(md, "use_project_x")
             col.prop(md, "use_project_y")
             col.prop(md, "use_project_z")
 
             col = split.column()
-            col.label(text=_("Direction:"))
+            col.label(text="Direction:")
             col.prop(md, "use_negative_direction")
             col.prop(md, "use_positive_direction")
 
             col = split.column()
-            col.label(text=_("Cull Faces:"))
+            col.label(text="Cull Faces:")
             col.prop(md, "cull_face", expand=True)
 
-            layout.label(text=_("Auxiliary Target:"))
+            layout.label(text="Auxiliary Target:")
             layout.prop(md, "auxiliary_target", text="")
 
         elif md.wrap_method == 'NEAREST_SURFACEPOINT':
@@ -518,24 +517,24 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Mode:"))
+        col.label(text="Mode:")
         col.prop(md, "deform_method", text="")
 
         col = split.column()
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Origin:"))
+        col.label(text="Origin:")
         col.prop(md, "origin", text="")
         sub = col.column()
         sub.active = (md.origin is not None)
         sub.prop(md, "use_relative")
 
         col = split.column()
-        col.label(text=_("Deform:"))
+        col.label(text="Deform:")
         col.prop(md, "factor")
         col.prop(md, "limits", slider=True)
         if md.deform_method in {'TAPER', 'STRETCH'}:
@@ -543,13 +542,13 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
             col.prop(md, "lock_y")
 
     def SMOKE(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Physics context"))
+        layout.label(text="Settings can be found inside the Physics context")
 
     def SMOOTH(self, layout, ob, md):
         split = layout.split(percentage=0.25)
 
         col = split.column()
-        col.label(text=_("Axis:"))
+        col.label(text="Axis:")
         col.prop(md, "use_x")
         col.prop(md, "use_y")
         col.prop(md, "use_z")
@@ -557,11 +556,11 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col = split.column()
         col.prop(md, "factor")
         col.prop(md, "iterations")
-        col.label(text=_("Vertex Group:"))
+        col.label(text="Vertex Group:")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
     def SOFT_BODY(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Physics context"))
+        layout.label(text="Settings can be found inside the Physics context")
 
     def SOLIDIFY(self, layout, ob, md):
         split = layout.split()
@@ -570,19 +569,19 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         col.prop(md, "thickness")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
-        col.label(text=_("Crease:"))
-        col.prop(md, "edge_crease_inner", text=_("Inner"))
-        col.prop(md, "edge_crease_outer", text=_("Outer"))
-        col.prop(md, "edge_crease_rim", text=_("Rim"))
-        col.label(text=_("Material Index Offset:"))
+        col.label(text="Crease:")
+        col.prop(md, "edge_crease_inner", text="Inner")
+        col.prop(md, "edge_crease_outer", text="Outer")
+        col.prop(md, "edge_crease_rim", text="Rim")
+        col.label(text="Material Index Offset:")
 
         col = split.column()
 
         col.prop(md, "offset")
         sub = col.column()
         sub.active = bool(md.vertex_group)
-        sub.prop(md, "invert_vertex_group", text=_("Invert"))
-        sub.prop(md, "thickness_vertex_group", text=_("Factor"))
+        sub.prop(md, "invert_vertex_group", text="Invert")
+        sub.prop(md, "thickness_vertex_group", text="Factor")
 
         col.prop(md, "use_even_offset")
         col.prop(md, "use_quality_normals")
@@ -593,64 +592,64 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         row.prop(md, "material_offset", text="")
         row = row.row()
         row.active = md.use_rim
-        row.prop(md, "material_offset_rim", text=_("Rim"))
+        row.prop(md, "material_offset_rim", text="Rim")
 
     def SUBSURF(self, layout, ob, md):
         layout.row().prop(md, "subdivision_type", expand=True)
 
         split = layout.split()
         col = split.column()
-        col.label(text=_("Subdivisions:"))
-        col.prop(md, "levels", text=_("View"))
-        col.prop(md, "render_levels", text=_("Render"))
+        col.label(text="Subdivisions:")
+        col.prop(md, "levels", text="View")
+        col.prop(md, "render_levels", text="Render")
 
         col = split.column()
-        col.label(text=_("Options:"))
+        col.label(text="Options:")
         col.prop(md, "use_subsurf_uv")
         col.prop(md, "show_only_control_edges")
 
     def SURFACE(self, layout, ob, md):
-        layout.label(text=_("Settings can be found inside the Physics context"))
+        layout.label(text="Settings can be found inside the Physics context")
 
     def UV_PROJECT(self, layout, ob, md):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Image:"))
+        col.label(text="Image:")
         col.prop(md, "image", text="")
 
         col = split.column()
-        col.label(text=_("UV Layer:"))
+        col.label(text="UV Layer:")
         col.prop_search(md, "uv_layer", ob.data, "uv_textures", text="")
 
         split = layout.split()
         col = split.column()
         col.prop(md, "use_image_override")
-        col.prop(md, "projector_count", text=_("Projectors"))
+        col.prop(md, "projector_count", text="Projectors")
         for proj in md.projectors:
             col.prop(proj, "object", text="")
 
         col = split.column()
         sub = col.column(align=True)
-        sub.prop(md, "aspect_x", text=_("Aspect X"))
-        sub.prop(md, "aspect_y", text=_("Aspect Y"))
+        sub.prop(md, "aspect_x", text="Aspect X")
+        sub.prop(md, "aspect_y", text="Aspect Y")
 
         sub = col.column(align=True)
-        sub.prop(md, "scale_x", text=_("Scale X"))
-        sub.prop(md, "scale_y", text=_("Scale Y"))
+        sub.prop(md, "scale_x", text="Scale X")
+        sub.prop(md, "scale_y", text="Scale Y")
 
     def WARP(self, layout, ob, md):
         use_falloff = (md.falloff_type != 'NONE')
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("From:"))
+        col.label(text="From:")
         col.prop(md, "object_from", text="")
 
         col.prop(md, "use_volume_preserve")
 
         col = split.column()
-        col.label(text=_("To:"))
+        col.label(text="To:")
         col.prop(md, "object_to", text="")
         col.prop_search(md, "vertex_group", ob, "vertex_groups", text="")
 
@@ -669,15 +668,15 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         # 2 new columns
         split = layout.split()
         col = split.column()
-        col.label(text=_("Texture:"))
+        col.label(text="Texture:")
         col.prop(md, "texture", text="")
 
         col = split.column()
-        col.label(text=_("Texture Coordinates:"))
+        col.label(text="Texture Coordinates:")
         col.prop(md, "texture_coords", text="")
 
         if md.texture_coords == 'OBJECT':
-            layout.prop(md, "texture_coords_object", text=_("Object"))
+            layout.prop(md, "texture_coords_object", text="Object")
         elif md.texture_coords == 'UV' and ob.type == 'MESH':
             layout.prop_search(md, "uv_layer", ob.data, "uv_textures")
 
@@ -685,7 +684,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Motion:"))
+        col.label(text="Motion:")
         col.prop(md, "use_x")
         col.prop(md, "use_y")
         col.prop(md, "use_cyclic")
@@ -701,18 +700,18 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Time:"))
+        col.label(text="Time:")
         sub = col.column(align=True)
-        sub.prop(md, "time_offset", text=_("Offset"))
-        sub.prop(md, "lifetime", text=_("Life"))
-        col.prop(md, "damping_time", text=_("Damping"))
+        sub.prop(md, "time_offset", text="Offset")
+        sub.prop(md, "lifetime", text="Life")
+        col.prop(md, "damping_time", text="Damping")
 
         col = split.column()
-        col.label(text=_("Position:"))
+        col.label(text="Position:")
         sub = col.column(align=True)
         sub.prop(md, "start_position_x", text="X")
         sub.prop(md, "start_position_y", text="Y")
-        col.prop(md, "falloff_radius", text=_("Falloff"))
+        col.prop(md, "falloff_radius", text="Falloff")
 
         layout.separator()
 
@@ -720,7 +719,7 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
         layout.prop_search(md, "vertex_group", ob, "vertex_groups")
         split = layout.split(percentage=0.33)
         col = split.column()
-        col.label(text=_("Texture"))
+        col.label(text="Texture")
         col = split.column()
         col.template_ID(md, "texture", new="texture.new")
         layout.prop(md, "texture_coords")

release/scripts/startup/bl_ui/properties_game.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 
 class PhysicsButtonsPanel():
@@ -55,7 +54,7 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             col = split.column()
             col.prop(game, "use_actor")
             col.prop(game, "use_ghost")
-            col.prop(ob, "hide_render", text=_("Invisible"))  # out of place but useful
+            col.prop(ob, "hide_render", text="Invisible")  # out of place but useful
 
             col = split.column()
             col.prop(game, "use_material_physics_fh")
@@ -67,7 +66,7 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Attributes:"))
+            col.label(text="Attributes:")
             col.prop(game, "mass")
             col.prop(game, "radius")
             col.prop(game, "form_factor")
@@ -82,29 +81,29 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Velocity:"))
+            col.label(text="Velocity:")
             sub = col.column(align=True)
-            sub.prop(game, "velocity_min", text=_("Minimum"))
-            sub.prop(game, "velocity_max", text=_("Maximum"))
+            sub.prop(game, "velocity_min", text="Minimum")
+            sub.prop(game, "velocity_max", text="Maximum")
 
             col = split.column()
-            col.label(text=_("Damping:"))
+            col.label(text="Damping:")
             sub = col.column(align=True)
-            sub.prop(game, "damping", text=_("Translation"), slider=True)
-            sub.prop(game, "rotation_damping", text=_("Rotation"), slider=True)
+            sub.prop(game, "damping", text="Translation", slider=True)
+            sub.prop(game, "rotation_damping", text="Rotation", slider=True)
 
             layout.separator()
 
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Lock Translation:"))
+            col.label(text="Lock Translation:")
             col.prop(game, "lock_location_x", text="X")
             col.prop(game, "lock_location_y", text="Y")
             col.prop(game, "lock_location_z", text="Z")
 
             col = split.column()
-            col.label(text=_("Lock Rotation:"))
+            col.label(text="Lock Rotation:")
             col.prop(game, "lock_rotation_x", text="X")
             col.prop(game, "lock_rotation_y", text="Y")
             col.prop(game, "lock_rotation_z", text="Z")
@@ -113,21 +112,21 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             col = layout.column()
             col.prop(game, "use_actor")
             col.prop(game, "use_ghost")
-            col.prop(ob, "hide_render", text=_("Invisible"))
+            col.prop(ob, "hide_render", text="Invisible")
 
             layout.separator()
 
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Attributes:"))
+            col.label(text="Attributes:")
             col.prop(game, "mass")
             col.prop(soft, "weld_threshold")
             col.prop(soft, "location_iterations")
             col.prop(soft, "linear_stiffness", slider=True)
             col.prop(soft, "dynamic_friction", slider=True)
             col.prop(soft, "collision_margin", slider=True)
-            col.prop(soft, "use_bending_constraints", text=_("Bending Constraints"))
+            col.prop(soft, "use_bending_constraints", text="Bending Constraints")
 
             col = split.column()
             col.prop(soft, "use_shape_match")
@@ -137,25 +136,25 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
 
             col.separator()
 
-            col.label(text=_("Cluster Collision:"))
+            col.label(text="Cluster Collision:")
             col.prop(soft, "use_cluster_rigid_to_softbody")
             col.prop(soft, "use_cluster_soft_to_softbody")
             sub = col.column()
             sub.active = (soft.use_cluster_rigid_to_softbody or soft.use_cluster_soft_to_softbody)
-            sub.prop(soft, "cluster_iterations", text=_("Iterations"))
+            sub.prop(soft, "cluster_iterations", text="Iterations")
 
         elif game.physics_type == 'STATIC':
             col = layout.column()
             col.prop(game, "use_actor")
             col.prop(game, "use_ghost")
-            col.prop(ob, "hide_render", text=_("Invisible"))
+            col.prop(ob, "hide_render", text="Invisible")
 
             layout.separator()
 
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Attributes:"))
+            col.label(text="Attributes:")
             col.prop(game, "radius")
 
             col = split.column()
@@ -166,7 +165,7 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, Panel):
             subsub.prop(game, "friction_coefficients", text="", slider=True)
 
         elif game.physics_type in {'SENSOR', 'INVISIBLE', 'NO_COLLISION', 'OCCLUDE'}:
-            layout.prop(ob, "hide_render", text=_("Invisible"))
+            layout.prop(ob, "hide_render", text="Invisible")
 
 
 class PHYSICS_PT_game_collision_bounds(PhysicsButtonsPanel, Panel):
@@ -190,11 +189,11 @@ class PHYSICS_PT_game_collision_bounds(PhysicsButtonsPanel, Panel):
         game = context.active_object.game
 
         layout.active = game.use_collision_bounds
-        layout.prop(game, "collision_bounds_type", text=_("Bounds"))
+        layout.prop(game, "collision_bounds_type", text="Bounds")
 
         row = layout.row()
-        row.prop(game, "collision_margin", text=_("Margin"), slider=True)
-        row.prop(game, "use_collision_compound", text=_("Compound"))
+        row.prop(game, "collision_margin", text="Margin", slider=True)
+        row.prop(game, "use_collision_compound", text="Compound")
 
 
 class PHYSICS_PT_game_obstacles(PhysicsButtonsPanel, Panel):
@@ -243,7 +242,7 @@ class RENDER_PT_game(RenderButtonsPanel, Panel):
         layout = self.layout
 
         row = layout.row()
-        row.operator("view3d.game_start", text=_("Start"))
+        row.operator("view3d.game_start", text="Start")
         row.label()
 
 
@@ -261,20 +260,20 @@ class RENDER_PT_game_player(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Resolution:"))
+        col.label(text="Resolution:")
         sub = col.column(align=True)
         sub.prop(gs, "resolution_x", slider=False, text="X")
         sub.prop(gs, "resolution_y", slider=False, text="Y")
 
         col = split.column()
-        col.label(text=_("Quality:"))
+        col.label(text="Quality:")
         sub = col.column(align=True)
-        sub.prop(gs, "depth", text=_("Bit Depth"), slider=False)
-        sub.prop(gs, "frequency", text=_("FPS"), slider=False)
+        sub.prop(gs, "depth", text="Bit Depth", slider=False)
+        sub.prop(gs, "frequency", text="FPS", slider=False)
 
         # framing:
         col = layout.column()
-        col.label(text=_("Framing:"))
+        col.label(text="Framing:")
         col.row().prop(gs, "frame_type", expand=True)
         if gs.frame_type == 'LETTERBOX':
             col.prop(gs, "frame_color", text="")
@@ -300,7 +299,7 @@ class RENDER_PT_game_stereo(RenderButtonsPanel, Panel):
 
         # dome:
         elif stereo_mode == 'DOME':
-            layout.prop(gs, "dome_mode", text=_("Dome Type"))
+            layout.prop(gs, "dome_mode", text="Dome Type")
 
             dome_type = gs.dome_mode
 
@@ -311,23 +310,23 @@ class RENDER_PT_game_stereo(RenderButtonsPanel, Panel):
                dome_type == 'TRUNCATED_FRONT':
 
                 col = split.column()
-                col.prop(gs, "dome_buffer_resolution", text=_("Resolution"), slider=True)
+                col.prop(gs, "dome_buffer_resolution", text="Resolution", slider=True)
                 col.prop(gs, "dome_angle", slider=True)
 
                 col = split.column()
-                col.prop(gs, "dome_tesselation", text=_("Tesselation"))
+                col.prop(gs, "dome_tesselation", text="Tesselation")
                 col.prop(gs, "dome_tilt")
 
             elif dome_type == 'PANORAM_SPH':
                 col = split.column()
 
-                col.prop(gs, "dome_buffer_resolution", text=_("Resolution"), slider=True)
+                col.prop(gs, "dome_buffer_resolution", text="Resolution", slider=True)
                 col = split.column()
-                col.prop(gs, "dome_tesselation", text=_("Tesselation"))
+                col.prop(gs, "dome_tesselation", text="Tesselation")
 
             else:  # cube map
                 col = split.column()
-                col.prop(gs, "dome_buffer_resolution", text=_("Resolution"), slider=True)
+                col.prop(gs, "dome_buffer_resolution", text="Resolution", slider=True)
 
                 col = split.column()
 
@@ -349,15 +348,15 @@ class RENDER_PT_game_shading(RenderButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.prop(gs, "use_glsl_lights", text=_("Lights"))
-            col.prop(gs, "use_glsl_shaders", text=_("Shaders"))
-            col.prop(gs, "use_glsl_shadows", text=_("Shadows"))
-            col.prop(gs, "use_glsl_color_management", text=_("Color Management"))
+            col.prop(gs, "use_glsl_lights", text="Lights")
+            col.prop(gs, "use_glsl_shaders", text="Shaders")
+            col.prop(gs, "use_glsl_shadows", text="Shadows")
+            col.prop(gs, "use_glsl_color_management", text="Color Management")
 
             col = split.column()
-            col.prop(gs, "use_glsl_ramps", text=_("Ramps"))
-            col.prop(gs, "use_glsl_nodes", text=_("Nodes"))
-            col.prop(gs, "use_glsl_extra_textures", text=_("Extra Textures"))
+            col.prop(gs, "use_glsl_ramps", text="Ramps")
+            col.prop(gs, "use_glsl_nodes", text="Nodes")
+            col.prop(gs, "use_glsl_extra_textures", text="Extra Textures")
 
 
 class RENDER_PT_game_performance(RenderButtonsPanel, Panel):
@@ -385,11 +384,11 @@ class RENDER_PT_game_display(RenderButtonsPanel, Panel):
 
         gs = context.scene.game_settings
         flow = layout.column_flow()
-        flow.prop(gs, "show_debug_properties", text=_("Debug Properties"))
-        flow.prop(gs, "show_framerate_profile", text=_("Framerate and Profile"))
-        flow.prop(gs, "show_physics_visualization", text=_("Physics Visualization"))
+        flow.prop(gs, "show_debug_properties", text="Debug Properties")
+        flow.prop(gs, "show_framerate_profile", text="Framerate and Profile")
+        flow.prop(gs, "show_physics_visualization", text="Physics Visualization")
         flow.prop(gs, "use_deprecation_warnings")
-        flow.prop(gs, "show_mouse", text=_("Mouse Cursor"))
+        flow.prop(gs, "show_mouse", text="Mouse Cursor")
 
 
 class SceneButtonsPanel():
@@ -547,37 +546,37 @@ class WORLD_PT_game_physics(WorldButtonsPanel, Panel):
 
         layout.prop(gs, "physics_engine")
         if gs.physics_engine != 'NONE':
-            layout.prop(gs, "physics_gravity", text=_("Gravity"))
+            layout.prop(gs, "physics_gravity", text="Gravity")
 
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Physics Steps:"))
+            col.label(text="Physics Steps:")
             sub = col.column(align=True)
-            sub.prop(gs, "physics_step_max", text=_("Max"))
-            sub.prop(gs, "physics_step_sub", text=_("Substeps"))
-            col.prop(gs, "fps", text=_("FPS"))
+            sub.prop(gs, "physics_step_max", text="Max")
+            sub.prop(gs, "physics_step_sub", text="Substeps")
+            col.prop(gs, "fps", text="FPS")
 
             col = split.column()
-            col.label(text=_("Logic Steps:"))
-            col.prop(gs, "logic_step_max", text=_("Max"))
+            col.label(text="Logic Steps:")
+            col.prop(gs, "logic_step_max", text="Max")
 
             col = layout.column()
-            col.prop(gs, "use_occlusion_culling", text=_("Occlusion Culling"))
+            col.prop(gs, "use_occlusion_culling", text="Occlusion Culling")
             sub = col.column()
             sub.active = gs.use_occlusion_culling
-            sub.prop(gs, "occlusion_culling_resolution", text=_("Resolution"))
+            sub.prop(gs, "occlusion_culling_resolution", text="Resolution")
 
         else:
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Physics Steps:"))
-            col.prop(gs, "fps", text=_("FPS"))
+            col.label(text="Physics Steps:")
+            col.prop(gs, "fps", text="FPS")
 
             col = split.column()
-            col.label(text=_("Logic Steps:"))
-            col.prop(gs, "logic_step_max", text=_("Max"))
+            col.label(text="Logic Steps:")
+            col.prop(gs, "logic_step_max", text="Max")
 
 
 class WORLD_PT_game_physics_obstacles(WorldButtonsPanel, Panel):

release/scripts/startup/bl_ui/properties_material.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 def active_node_mat(mat):
@@ -115,9 +114,9 @@ class MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
 
             if ob.mode == 'EDIT':
                 row = layout.row(align=True)
-                row.operator("object.material_slot_assign", text=_("Assign"))
-                row.operator("object.material_slot_select", text=_("Select"))
-                row.operator("object.material_slot_deselect", text=_("Deselect"))
+                row.operator("object.material_slot_assign", text="Assign")
+                row.operator("object.material_slot_select", text="Select")
+                row.operator("object.material_slot_deselect", text="Deselect")
 
         split = layout.split(percentage=0.65)
 
@@ -143,7 +142,7 @@ class MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
                 if mat.active_node_material:
                     row.prop(mat.active_node_material, "name", text="")
                 else:
-                    row.label(text=_("No material node selected"))
+                    row.label(text="No material node selected")
 
 
 class MATERIAL_PT_preview(MaterialButtonsPanel, Panel):
@@ -198,8 +197,8 @@ class MATERIAL_PT_pipeline(MaterialButtonsPanel, Panel):
         col = split.column()
         col.active = mat_type
 
-        col.prop(mat, "use_cast_shadows_only", text=_("Cast Only"))
-        col.prop(mat, "shadow_cast_alpha", text=_("Casting Alpha"))
+        col.prop(mat, "use_cast_shadows_only", text="Cast Only")
+        col.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
         col.prop(mat, "use_cast_buffer_shadows")
         col.prop(mat, "use_cast_approximate")
         col.prop(mat, "pass_index")
@@ -226,12 +225,12 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
         col.prop(mat, "diffuse_color", text="")
         sub = col.column()
         sub.active = (not mat.use_shadeless)
-        sub.prop(mat, "diffuse_intensity", text=_("Intensity"))
+        sub.prop(mat, "diffuse_intensity", text="Intensity")
 
         col = split.column()
         col.active = (not mat.use_shadeless)
         col.prop(mat, "diffuse_shader", text="")
-        col.prop(mat, "use_diffuse_ramp", text=_("Ramp"))
+        col.prop(mat, "use_diffuse_ramp", text="Ramp")
 
         col = layout.column()
         col.active = (not mat.use_shadeless)
@@ -241,12 +240,12 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
             col.prop(mat, "darkness")
         elif mat.diffuse_shader == 'TOON':
             row = col.row()
-            row.prop(mat, "diffuse_toon_size", text=_("Size"))
-            row.prop(mat, "diffuse_toon_smooth", text=_("Smooth"))
+            row.prop(mat, "diffuse_toon_size", text="Size")
+            row.prop(mat, "diffuse_toon_smooth", text="Smooth")
         elif mat.diffuse_shader == 'FRESNEL':
             row = col.row()
-            row.prop(mat, "diffuse_fresnel", text=_("Fresnel"))
-            row.prop(mat, "diffuse_fresnel_factor", text=_("Factor"))
+            row.prop(mat, "diffuse_fresnel", text="Fresnel")
+            row.prop(mat, "diffuse_fresnel_factor", text="Factor")
 
         if mat.use_diffuse_ramp:
             col = layout.column()
@@ -256,10 +255,10 @@ class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
             col.separator()
 
             row = col.row()
-            row.prop(mat, "diffuse_ramp_input", text=_("Input"))
-            row.prop(mat, "diffuse_ramp_blend", text=_("Blend"))
+            row.prop(mat, "diffuse_ramp_input", text="Input")
+            row.prop(mat, "diffuse_ramp_blend", text="Blend")
 
-            col.prop(mat, "diffuse_ramp_factor", text=_("Factor"))
+            col.prop(mat, "diffuse_ramp_factor", text="Factor")
 
 
 class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
@@ -283,25 +282,25 @@ class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
 
         col = split.column()
         col.prop(mat, "specular_color", text="")
-        col.prop(mat, "specular_intensity", text=_("Intensity"))
+        col.prop(mat, "specular_intensity", text="Intensity")
 
         col = split.column()
         col.prop(mat, "specular_shader", text="")
-        col.prop(mat, "use_specular_ramp", text=_("Ramp"))
+        col.prop(mat, "use_specular_ramp", text="Ramp")
 
         col = layout.column()
         if mat.specular_shader in {'COOKTORR', 'PHONG'}:
-            col.prop(mat, "specular_hardness", text=_("Hardness"))
+            col.prop(mat, "specular_hardness", text="Hardness")
         elif mat.specular_shader == 'BLINN':
             row = col.row()
-            row.prop(mat, "specular_hardness", text=_("Hardness"))
-            row.prop(mat, "specular_ior", text=_("IOR"))
+            row.prop(mat, "specular_hardness", text="Hardness")
+            row.prop(mat, "specular_ior", text="IOR")
         elif mat.specular_shader == 'WARDISO':
-            col.prop(mat, "specular_slope", text=_("Slope"))
+            col.prop(mat, "specular_slope", text="Slope")
         elif mat.specular_shader == 'TOON':
             row = col.row()
-            row.prop(mat, "specular_toon_size", text=_("Size"))
-            row.prop(mat, "specular_toon_smooth", text=_("Smooth"))
+            row.prop(mat, "specular_toon_size", text="Size")
+            row.prop(mat, "specular_toon_smooth", text="Smooth")
 
         if mat.use_specular_ramp:
             layout.separator()
@@ -309,10 +308,10 @@ class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
             layout.separator()
 
             row = layout.row()
-            row.prop(mat, "specular_ramp_input", text=_("Input"))
-            row.prop(mat, "specular_ramp_blend", text=_("Blend"))
+            row.prop(mat, "specular_ramp_input", text="Input")
+            row.prop(mat, "specular_ramp_blend", text="Blend")
 
-            layout.prop(mat, "specular_ramp_factor", text=_("Factor"))
+            layout.prop(mat, "specular_ramp_factor", text="Factor")
 
 
 class MATERIAL_PT_shading(MaterialButtonsPanel, Panel):
@@ -385,14 +384,14 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
         col.prop(mat, "alpha")
         row = col.row()
         row.active = (base_mat.transparency_method != 'MASK') and (not mat.use_shadeless)
-        row.prop(mat, "specular_alpha", text=_("Specular"))
+        row.prop(mat, "specular_alpha", text="Specular")
 
         col = split.column()
         col.active = (not mat.use_shadeless)
         col.prop(rayt, "fresnel")
         sub = col.column()
         sub.active = rayt.fresnel > 0
-        sub.prop(rayt, "fresnel_factor", text=_("Blend"))
+        sub.prop(rayt, "fresnel_factor", text="Blend")
 
         if base_mat.transparency_method == 'RAYTRACE':
             layout.separator()
@@ -407,12 +406,12 @@ class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
             col.prop(rayt, "depth")
 
             col = split.column()
-            col.label(text=_("Gloss:"))
-            col.prop(rayt, "gloss_factor", text=_("Amount"))
+            col.label(text="Gloss:")
+            col.prop(rayt, "gloss_factor", text="Amount")
             sub = col.column()
             sub.active = rayt.gloss_factor < 1.0
-            sub.prop(rayt, "gloss_threshold", text=_("Threshold"))
-            sub.prop(rayt, "gloss_samples", text=_("Samples"))
+            sub.prop(rayt, "gloss_threshold", text="Threshold")
+            sub.prop(rayt, "gloss_samples", text="Samples")
 
 
 class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
@@ -449,28 +448,28 @@ class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
         col.prop(raym, "fresnel")
         sub = col.column()
         sub.active = raym.fresnel > 0
-        sub.prop(raym, "fresnel_factor", text=_("Blend"))
+        sub.prop(raym, "fresnel_factor", text="Blend")
 
         split = layout.split()
 
         col = split.column()
         col.separator()
         col.prop(raym, "depth")
-        col.prop(raym, "distance", text=_("Max Dist"))
+        col.prop(raym, "distance", text="Max Dist")
         col.separator()
         sub = col.split(percentage=0.4)
         sub.active = raym.distance > 0.0
-        sub.label(text=_("Fade To:"))
+        sub.label(text="Fade To:")
         sub.prop(raym, "fade_to", text="")
 
         col = split.column()
-        col.label(text=_("Gloss:"))
-        col.prop(raym, "gloss_factor", text=_("Amount"))
+        col.label(text="Gloss:")
+        col.prop(raym, "gloss_factor", text="Amount")
         sub = col.column()
         sub.active = raym.gloss_factor < 1.0
-        sub.prop(raym, "gloss_threshold", text=_("Threshold"))
-        sub.prop(raym, "gloss_samples", text=_("Samples"))
-        sub.prop(raym, "gloss_anisotropic", text=_("Anisotropic"))
+        sub.prop(raym, "gloss_threshold", text="Threshold")
+        sub.prop(raym, "gloss_samples", text="Samples")
+        sub.prop(raym, "gloss_anisotropic", text="Anisotropic")
 
 
 class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
@@ -511,18 +510,18 @@ class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
         col.prop(sss, "ior")
         col.prop(sss, "scale")
         col.prop(sss, "color", text="")
-        col.prop(sss, "radius", text=_("RGB Radius"), expand=True)
+        col.prop(sss, "radius", text="RGB Radius", expand=True)
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text=_("Blend:"))
-        sub.prop(sss, "color_factor", text=_("Color"))
-        sub.prop(sss, "texture_factor", text=_("Texture"))
-        sub.label(text=_("Scattering Weight:"))
+        sub.label(text="Blend:")
+        sub.prop(sss, "color_factor", text="Color")
+        sub.prop(sss, "texture_factor", text="Texture")
+        sub.label(text="Scattering Weight:")
         sub.prop(sss, "front")
         sub.prop(sss, "back")
         col.separator()
-        col.prop(sss, "error_threshold", text=_("Error"))
+        col.prop(sss, "error_threshold", text="Error")
 
 
 class MATERIAL_PT_halo(MaterialButtonsPanel, Panel):
@@ -562,7 +561,7 @@ class MATERIAL_PT_halo(MaterialButtonsPanel, Panel):
         col.prop(halo, "hardness")
         col.prop(halo, "add")
 
-        layout.label(text=_("Options:"))
+        layout.label(text="Options:")
 
         split = layout.split()
         col = split.column()
@@ -604,13 +603,13 @@ class MATERIAL_PT_flare(MaterialButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(halo, "flare_size", text=_("Size"))
-        col.prop(halo, "flare_boost", text=_("Boost"))
-        col.prop(halo, "flare_seed", text=_("Seed"))
+        col.prop(halo, "flare_size", text="Size")
+        col.prop(halo, "flare_boost", text="Boost")
+        col.prop(halo, "flare_seed", text="Seed")
 
         col = split.column()
-        col.prop(halo, "flare_subflare_count", text=_("Subflares"))
-        col.prop(halo, "flare_subflare_size", text=_("Subsize"))
+        col.prop(halo, "flare_subflare_count", text="Subflares")
+        col.prop(halo, "flare_subflare_size", text="Subsize")
 
 
 class MATERIAL_PT_game_settings(MaterialButtonsPanel, bpy.types.Panel):
@@ -662,7 +661,7 @@ class MATERIAL_PT_physics(MaterialButtonsPanel, bpy.types.Panel):
         row.prop(phys, "elasticity", slider=True)
 
         row = layout.row()
-        row.label(text=_("Force Field:"))
+        row.label(text="Force Field:")
 
         row = layout.row()
         row.prop(phys, "fh_force")
@@ -694,10 +693,10 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text=_("Size:"))
-        sub.prop(tan, "root_size", text=_("Root"))
-        sub.prop(tan, "tip_size", text=_("Tip"))
-        sub.prop(tan, "size_min", text=_("Minimum"))
+        sub.label(text="Size:")
+        sub.prop(tan, "root_size", text="Root")
+        sub.prop(tan, "tip_size", text="Tip")
+        sub.prop(tan, "size_min", text="Minimum")
         sub.prop(tan, "use_blender_units")
         sub = col.column()
         sub.active = (not mat.use_shadeless)
@@ -705,7 +704,7 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
         col.prop(tan, "shape")
 
         col = split.column()
-        col.label(text=_("Shading:"))
+        col.label(text="Shading:")
         col.prop(tan, "width_fade")
         ob = context.object
         if ob and ob.type == 'MESH':
@@ -715,9 +714,9 @@ class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
         col.separator()
         sub = col.column()
         sub.active = (not mat.use_shadeless)
-        sub.label(_("Surface diffuse:"))
+        sub.label("Surface diffuse:")
         sub = col.column()
-        sub.prop(tan, "blend_distance", text=_("Distance"))
+        sub.prop(tan, "blend_distance", text="Distance")
 
 
 class MATERIAL_PT_options(MaterialButtonsPanel, Panel):
@@ -750,11 +749,11 @@ class MATERIAL_PT_options(MaterialButtonsPanel, Panel):
             sub.prop(mat, "offset_z")
             sub.active = mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'
         sub = col.column(align=True)
-        sub.label(text=_("Light Group:"))
+        sub.label(text="Light Group:")
         sub.prop(mat, "light_group", text="")
         row = sub.row()
         row.active = bool(mat.light_group)
-        row.prop(mat, "use_light_group_exclusive", text=_("Exclusive"))
+        row.prop(mat, "use_light_group_exclusive", text="Exclusive")
 
         col = split.column()
         col.prop(mat, "use_face_texture")
@@ -789,12 +788,12 @@ class MATERIAL_PT_shadow(MaterialButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(mat, "use_shadows", text=_("Receive"))
-        col.prop(mat, "use_transparent_shadows", text=_("Receive Transparent"))
+        col.prop(mat, "use_shadows", text="Receive")
+        col.prop(mat, "use_transparent_shadows", text="Receive Transparent")
         if simple_material(base_mat):
-            col.prop(mat, "use_cast_shadows_only", text=_("Cast Only"))
-            col.prop(mat, "shadow_cast_alpha", text=_("Casting Alpha"))
-        col.prop(mat, "use_only_shadow", text=_("Shadows Only"))
+            col.prop(mat, "use_cast_shadows_only", text="Cast Only")
+            col.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
+        col.prop(mat, "use_only_shadow", text="Shadows Only")
         sub = col.column()
         sub.active = mat.use_only_shadow
         sub.prop(mat, "shadow_only_type", text="")
@@ -804,11 +803,11 @@ class MATERIAL_PT_shadow(MaterialButtonsPanel, Panel):
             col.prop(mat, "use_cast_buffer_shadows")
         sub = col.column()
         sub.active = mat.use_cast_buffer_shadows
-        sub.prop(mat, "shadow_buffer_bias", text=_("Buffer Bias"))
-        col.prop(mat, "use_ray_shadow_bias", text=_("Auto Ray Bias"))
+        sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias")
+        col.prop(mat, "use_ray_shadow_bias", text="Auto Ray Bias")
         sub = col.column()
         sub.active = (not mat.use_ray_shadow_bias)
-        sub.prop(mat, "shadow_ray_bias", text=_("Ray Bias"))
+        sub.prop(mat, "shadow_ray_bias", text="Ray Bias")
         if simple_material(base_mat):
             col.prop(mat, "use_cast_approximate")
 
@@ -921,7 +920,7 @@ class MATERIAL_PT_volume_lighting(VolumeButtonsPanel, Panel):
             sub = col.column()
             sub.enabled = True
             sub.active = False
-            sub.label(_("Light Cache Enabled"))
+            sub.label("Light Cache Enabled")
             col.prop(vol, "cache_resolution")
 
             sub = col.column(align=True)
@@ -960,7 +959,7 @@ class MATERIAL_PT_volume_integration(VolumeButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Step Calculation:"))
+        col.label(text="Step Calculation:")
         col.prop(vol, "step_method", text="")
         col = col.column(align=True)
         col.prop(vol, "step_size")
@@ -995,11 +994,11 @@ class MATERIAL_PT_volume_options(VolumeButtonsPanel, Panel):
         col.prop(mat, "use_mist")
 
         col = split.column()
-        col.label(text=_("Light Group:"))
+        col.label(text="Light Group:")
         col.prop(mat, "light_group", text="")
         row = col.row()
         row.active = bool(mat.light_group)
-        row.prop(mat, "use_light_group_exclusive", text=_("Exclusive"))
+        row.prop(mat, "use_light_group_exclusive", text="Exclusive")
 
 
 class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel, Panel):

release/scripts/startup/bl_ui/properties_object.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class ObjectButtonsPanel():
@@ -56,14 +55,14 @@ class OBJECT_PT_transform(ObjectButtonsPanel, Panel):
 
         row.column().prop(ob, "location")
         if ob.rotation_mode == 'QUATERNION':
-            row.column().prop(ob, "rotation_quaternion", text=_("Rotation"))
+            row.column().prop(ob, "rotation_quaternion", text="Rotation")
         elif ob.rotation_mode == 'AXIS_ANGLE':
-            #row.column().label(text=_("Rotation"))
-            #row.column().prop(pchan, "rotation_angle", text=_("Angle"))
-            #row.column().prop(pchan, "rotation_axis", text=_("Axis"))
-            row.column().prop(ob, "rotation_axis_angle", text=_("Rotation"))
+            #row.column().label(text="Rotation")
+            #row.column().prop(pchan, "rotation_angle", text="Angle")
+            #row.column().prop(pchan, "rotation_axis", text="Axis")
+            row.column().prop(ob, "rotation_axis_angle", text="Rotation")
         else:
-            row.column().prop(ob, "rotation_euler", text=_("Rotation"))
+            row.column().prop(ob, "rotation_euler", text="Rotation")
 
         row.column().prop(ob, "scale")
 
@@ -83,15 +82,15 @@ class OBJECT_PT_delta_transform(ObjectButtonsPanel, Panel):
 
         row.column().prop(ob, "delta_location")
         if ob.rotation_mode == 'QUATERNION':
-            row.column().prop(ob, "delta_rotation_quaternion", text=_("Rotation"))
+            row.column().prop(ob, "delta_rotation_quaternion", text="Rotation")
         elif ob.rotation_mode == 'AXIS_ANGLE':
-            #row.column().label(text=_("Rotation"))
-            #row.column().prop(pchan, "delta_rotation_angle", text=_("Angle"))
-            #row.column().prop(pchan, "delta_rotation_axis", text=_("Axis"))
-            #row.column().prop(ob, "delta_rotation_axis_angle", text=_("Rotation"))
-            row.column().label(text=_("Not for Axis-Angle"))
+            #row.column().label(text="Rotation")
+            #row.column().prop(pchan, "delta_rotation_angle", text="Angle")
+            #row.column().prop(pchan, "delta_rotation_axis", text="Axis")
+            #row.column().prop(ob, "delta_rotation_axis_angle", text="Rotation")
+            row.column().label(text="Not for Axis-Angle")
         else:
-            row.column().prop(ob, "delta_rotation_euler", text=_("Rotation"))
+            row.column().prop(ob, "delta_rotation_euler", text="Rotation")
 
         row.column().prop(ob, "delta_scale")
 
@@ -108,18 +107,18 @@ class OBJECT_PT_transform_locks(ObjectButtonsPanel, Panel):
         row = layout.row()
 
         col = row.column()
-        col.prop(ob, "lock_location", text=_("Location"))
+        col.prop(ob, "lock_location", text="Location")
 
         col = row.column()
         if ob.rotation_mode in {'QUATERNION', 'AXIS_ANGLE'}:
-            col.prop(ob, "lock_rotations_4d", text=_("Rotation"))
+            col.prop(ob, "lock_rotations_4d", text="Rotation")
             if ob.lock_rotations_4d:
                 col.prop(ob, "lock_rotation_w", text="W")
             col.prop(ob, "lock_rotation", text="")
         else:
-            col.prop(ob, "lock_rotation", text=_("Rotation"))
+            col.prop(ob, "lock_rotation", text="Rotation")
 
-        row.column().prop(ob, "lock_scale", text=_("Scale"))
+        row.column().prop(ob, "lock_scale", text="Scale")
 
 
 class OBJECT_PT_relations(ObjectButtonsPanel, Panel):
@@ -138,7 +137,7 @@ class OBJECT_PT_relations(ObjectButtonsPanel, Panel):
         col.prop(ob, "pass_index")
 
         col = split.column()
-        col.label(text=_("Parent:"))
+        col.label(text="Parent:")
         col.prop(ob, "parent", text="")
 
         sub = col.column()
@@ -158,7 +157,7 @@ class OBJECT_PT_groups(ObjectButtonsPanel, Panel):
         ob = context.object
 
         row = layout.row(align=True)
-        row.operator("object.group_link", text=_("Add to Group"))
+        row.operator("object.group_link", text="Add to Group")
         row.operator("object.group_add", text="", icon='ZOOMIN')
 
         # XXX, this is bad practice, yes, I wrote it :( - campbell
@@ -177,12 +176,12 @@ class OBJECT_PT_groups(ObjectButtonsPanel, Panel):
                 split = col.box().split()
 
                 col = split.column()
-                col.prop(group, "layers", text=_("Dupli"))
+                col.prop(group, "layers", text="Dupli")
 
                 col = split.column()
                 col.prop(group, "dupli_offset", text="")
 
-                prop = col.operator("wm.context_set_value", text=_("From Cursor"))
+                prop = col.operator("wm.context_set_value", text="From Cursor")
                 prop.data_path = "object.users_group[%d].dupli_offset" % index
                 prop.value = value
                 index += 1
@@ -198,11 +197,11 @@ class OBJECT_PT_display(ObjectButtonsPanel, Panel):
 
         split = layout.split()
         col = split.column()
-        col.prop(ob, "draw_type", text=_("Type"))
+        col.prop(ob, "draw_type", text="Type")
 
         col = split.column()
         row = col.row()
-        row.prop(ob, "show_bounds", text=_("Bounds"))
+        row.prop(ob, "show_bounds", text="Bounds")
         sub = row.row()
         sub.active = ob.show_bounds
         sub.prop(ob, "draw_bounds_type", text="")
@@ -210,16 +209,16 @@ class OBJECT_PT_display(ObjectButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(ob, "show_name", text=_("Name"))
-        col.prop(ob, "show_axis", text=_("Axis"))
-        col.prop(ob, "show_wire", text=_("Wire"))
-        col.prop(ob, "color", text=_("Object Color"))
+        col.prop(ob, "show_name", text="Name")
+        col.prop(ob, "show_axis", text="Axis")
+        col.prop(ob, "show_wire", text="Wire")
+        col.prop(ob, "color", text="Object Color")
 
         col = split.column()
-        col.prop(ob, "show_texture_space", text=_("Texture Space"))
-        col.prop(ob, "show_x_ray", text=_("X-Ray"))
+        col.prop(ob, "show_texture_space", text="Texture Space")
+        col.prop(ob, "show_x_ray", text="X-Ray")
         if ob.type == 'MESH':
-            col.prop(ob, "show_transparent", text=_("Transparency"))
+            col.prop(ob, "show_transparent", text="Transparency")
 
 
 class OBJECT_PT_duplication(ObjectButtonsPanel, Panel):
@@ -236,26 +235,26 @@ class OBJECT_PT_duplication(ObjectButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column(align=True)
-            col.prop(ob, "dupli_frames_start", text=_("Start"))
-            col.prop(ob, "dupli_frames_end", text=_("End"))
+            col.prop(ob, "dupli_frames_start", text="Start")
+            col.prop(ob, "dupli_frames_end", text="End")
 
             col = split.column(align=True)
-            col.prop(ob, "dupli_frames_on", text=_("On"))
-            col.prop(ob, "dupli_frames_off", text=_("Off"))
+            col.prop(ob, "dupli_frames_on", text="On")
+            col.prop(ob, "dupli_frames_off", text="Off")
 
-            layout.prop(ob, "use_dupli_frames_speed", text=_("Speed"))
+            layout.prop(ob, "use_dupli_frames_speed", text="Speed")
 
         elif ob.dupli_type == 'VERTS':
-            layout.prop(ob, "use_dupli_vertices_rotation", text=_("Rotation"))
+            layout.prop(ob, "use_dupli_vertices_rotation", text="Rotation")
 
         elif ob.dupli_type == 'FACES':
 
             row = layout.row()
-            row.prop(ob, "use_dupli_faces_scale", text=_("Scale"))
-            row.prop(ob, "dupli_faces_scale", text=_("Inherit Scale"))
+            row.prop(ob, "use_dupli_faces_scale", text="Scale")
+            row.prop(ob, "dupli_faces_scale", text="Inherit Scale")
 
         elif ob.dupli_type == 'GROUP':
-            layout.prop(ob, "dupli_group", text=_("Group"))
+            layout.prop(ob, "dupli_group", text="Group")
 
 
 # XXX: the following options are all quite buggy, ancient hacks that should be dropped
@@ -272,21 +271,21 @@ class OBJECT_PT_animation(ObjectButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Time Offset:"))
-        col.prop(ob, "use_time_offset_edit", text=_("Edit"))
+        col.label(text="Time Offset:")
+        col.prop(ob, "use_time_offset_edit", text="Edit")
         row = col.row()
-        row.prop(ob, "use_time_offset_parent", text=_("Parent"))
+        row.prop(ob, "use_time_offset_parent", text="Parent")
         row.active = (ob.parent is not None)
         row = col.row()
         row.prop(ob, "use_slow_parent")
         row.active = (ob.parent is not None)
-        col.prop(ob, "time_offset", text=_("Offset"))
+        col.prop(ob, "time_offset", text="Offset")
 
         # XXX: these are still used for a few curve-related tracking features
         col = split.column()
-        col.label(text=_("Tracking Axes:"))
-        col.prop(ob, "track_axis", text=_("Axis"))
-        col.prop(ob, "up_axis", text=_("Up Axis"))
+        col.label(text="Tracking Axes:")
+        col.prop(ob, "track_axis", text="Axis")
+        col.prop(ob, "up_axis", text="Up Axis")
 
 
 from bl_ui.properties_animviz import (
@@ -313,8 +312,8 @@ class OBJECT_PT_motion_paths(MotionPathButtonsPanel, Panel):
         layout.separator()
 
         row = layout.row()
-        row.operator("object.paths_calculate", text=_("Calculate Paths"))
-        row.operator("object.paths_clear", text=_("Clear Paths"))
+        row.operator("object.paths_calculate", text="Calculate Paths")
+        row.operator("object.paths_clear", text="Clear Paths")
 
 
 class OBJECT_PT_onion_skinning(OnionSkinButtonsPanel):  # , Panel): # inherit from panel when ready

release/scripts/startup/bl_ui/properties_object_constraint.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 
 class ConstraintButtonsPanel():
@@ -44,7 +43,7 @@ class ConstraintButtonsPanel():
 
             split = layout.split(percentage=0.2)
 
-            split.label(text=_("Space:"))
+            split.label(text="Space:")
             row = split.row()
 
             if target:
@@ -61,21 +60,21 @@ class ConstraintButtonsPanel():
 
         if con.target and subtargets:
             if con.target.type == 'ARMATURE':
-                layout.prop_search(con, "subtarget", con.target.data, "bones", text=_("Bone"))
+                layout.prop_search(con, "subtarget", con.target.data, "bones", text="Bone")
 
                 if hasattr(con, "head_tail"):
                     row = layout.row()
-                    row.label(text=_("Head/Tail:"))
+                    row.label(text="Head/Tail:")
                     row.prop(con, "head_tail", text="")
             elif con.target.type in {'MESH', 'LATTICE'}:
-                layout.prop_search(con, "subtarget", con.target, "vertex_groups", text=_("Vertex Group"))
+                layout.prop_search(con, "subtarget", con.target, "vertex_groups", text="Vertex Group")
 
     def ik_template(self, layout, con):
         # only used for iTaSC
         layout.prop(con, "pole_target")
 
         if con.pole_target and con.pole_target.type == 'ARMATURE':
-            layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text=_("Bone"))
+            layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text="Bone")
 
         if con.pole_target:
             row = layout.row()
@@ -97,19 +96,19 @@ class ConstraintButtonsPanel():
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Location:"))
+        col.label(text="Location:")
         col.prop(con, "use_location_x", text="X")
         col.prop(con, "use_location_y", text="Y")
         col.prop(con, "use_location_z", text="Z")
 
         col = split.column()
-        col.label(text=_("Rotation:"))
+        col.label(text="Rotation:")
         col.prop(con, "use_rotation_x", text="X")
         col.prop(con, "use_rotation_y", text="Y")
         col.prop(con, "use_rotation_z", text="Z")
 
         col = split.column()
-        col.label(text=_("Scale:"))
+        col.label(text="Scale:")
         col.prop(con, "use_scale_x", text="X")
         col.prop(con, "use_scale_y", text="Y")
         col.prop(con, "use_scale_z", text="Z")
@@ -122,11 +121,11 @@ class ConstraintButtonsPanel():
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text=_("To:"))
+        row.label(text="To:")
         row.prop(con, "track_axis", expand=True)
 
         row = layout.row()
-        row.prop(con, "up_axis", text=_("Up"))
+        row.prop(con, "up_axis", text="Up")
         row.prop(con, "use_target_z")
 
         self.space_template(layout, con)
@@ -141,7 +140,7 @@ class ConstraintButtonsPanel():
             layout.prop(con, "pole_target")
 
             if con.pole_target and con.pole_target.type == 'ARMATURE':
-                layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text=_("Bone"))
+                layout.prop_search(con, "pole_subtarget", con.pole_target.data, "bones", text="Bone")
 
             if con.pole_target:
                 row = layout.row()
@@ -153,11 +152,11 @@ class ConstraintButtonsPanel():
             col.prop(con, "iterations")
             col.prop(con, "chain_count")
 
-            col.label(text=_("Weight:"))
-            col.prop(con, "weight", text=_("Position"), slider=True)
+            col.label(text="Weight:")
+            col.prop(con, "weight", text="Position", slider=True)
             sub = col.column()
             sub.active = con.use_rotation
-            sub.prop(con, "orient_weight", text=_("Rotation"), slider=True)
+            sub.prop(con, "orient_weight", text="Rotation", slider=True)
 
             col = split.column()
             col.prop(con, "use_tail")
@@ -171,16 +170,16 @@ class ConstraintButtonsPanel():
         self.ik_template(layout, con)
 
         row = layout.row()
-        row.label(text=_("Axis Ref:"))
+        row.label(text="Axis Ref:")
         row.prop(con, "reference_axis", expand=True)
         split = layout.split(percentage=0.33)
         split.row().prop(con, "use_location")
         row = split.row()
-        row.prop(con, "weight", text=_("Weight"), slider=True)
+        row.prop(con, "weight", text="Weight", slider=True)
         row.active = con.use_location
         split = layout.split(percentage=0.33)
         row = split.row()
-        row.label(text=_("Lock:"))
+        row.label(text="Lock:")
         row = split.row()
         row.prop(con, "lock_location_x", text="X")
         row.prop(con, "lock_location_y", text="Y")
@@ -190,11 +189,11 @@ class ConstraintButtonsPanel():
         split = layout.split(percentage=0.33)
         split.row().prop(con, "use_rotation")
         row = split.row()
-        row.prop(con, "orient_weight", text=_("Weight"), slider=True)
+        row.prop(con, "orient_weight", text="Weight", slider=True)
         row.active = con.use_rotation
         split = layout.split(percentage=0.33)
         row = split.row()
-        row.label(text=_("Lock:"))
+        row.label(text="Lock:")
         row = split.row()
         row.prop(con, "lock_rotation_x", text="X")
         row.prop(con, "lock_rotation_y", text="Y")
@@ -208,8 +207,8 @@ class ConstraintButtonsPanel():
         layout.prop(con, "limit_mode")
 
         row = layout.row()
-        row.prop(con, "weight", text=_("Weight"), slider=True)
-        row.prop(con, "distance", text=_("Distance"), slider=True)
+        row.prop(con, "weight", text="Weight", slider=True)
+        row.prop(con, "distance", text="Distance", slider=True)
 
     def FOLLOW_PATH(self, context, layout, con):
         self.target_template(layout, con)
@@ -223,16 +222,16 @@ class ConstraintButtonsPanel():
         col = split.column()
         col.prop(con, "use_fixed_location")
         if con.use_fixed_location:
-            col.prop(con, "offset_factor", text=_("Offset"))
+            col.prop(con, "offset_factor", text="Offset")
         else:
             col.prop(con, "offset")
 
         row = layout.row()
-        row.label(text=_("Forward:"))
+        row.label(text="Forward:")
         row.prop(con, "forward_axis", expand=True)
 
         row = layout.row()
-        row.prop(con, "up_axis", text=_("Up"))
+        row.prop(con, "up_axis", text="Up")
         row.label()
 
     def LIMIT_ROTATION(self, context, layout, con):
@@ -242,27 +241,27 @@ class ConstraintButtonsPanel():
         col.prop(con, "use_limit_x")
         sub = col.column()
         sub.active = con.use_limit_x
-        sub.prop(con, "min_x", text=_("Min"))
-        sub.prop(con, "max_x", text=_("Max"))
+        sub.prop(con, "min_x", text="Min")
+        sub.prop(con, "max_x", text="Max")
 
         col = split.column(align=True)
         col.prop(con, "use_limit_y")
         sub = col.column()
         sub.active = con.use_limit_y
-        sub.prop(con, "min_y", text=_("Min"))
-        sub.prop(con, "max_y", text=_("Max"))
+        sub.prop(con, "min_y", text="Min")
+        sub.prop(con, "max_y", text="Max")
 
         col = split.column(align=True)
         col.prop(con, "use_limit_z")
         sub = col.column()
         sub.active = con.use_limit_z
-        sub.prop(con, "min_z", text=_("Min"))
-        sub.prop(con, "max_z", text=_("Max"))
+        sub.prop(con, "min_z", text="Min")
+        sub.prop(con, "max_z", text="Max")
 
         layout.prop(con, "use_transform_limit")
 
         row = layout.row()
-        row.label(text=_("Convert:"))
+        row.label(text="Convert:")
         row.prop(con, "owner_space", text="")
 
     def LIMIT_LOCATION(self, context, layout, con):
@@ -303,7 +302,7 @@ class ConstraintButtonsPanel():
         row.label()
 
         row = layout.row()
-        row.label(text=_("Convert:"))
+        row.label(text="Convert:")
         row.prop(con, "owner_space", text="")
 
     def LIMIT_SCALE(self, context, layout, con):
@@ -344,7 +343,7 @@ class ConstraintButtonsPanel():
         row.label()
 
         row = layout.row()
-        row.label(text=_("Convert:"))
+        row.label(text="Convert:")
         row.prop(con, "owner_space", text="")
 
     def COPY_ROTATION(self, context, layout, con):
@@ -356,19 +355,19 @@ class ConstraintButtonsPanel():
         col.prop(con, "use_x", text="X")
         sub = col.column()
         sub.active = con.use_x
-        sub.prop(con, "invert_x", text=_("Invert"))
+        sub.prop(con, "invert_x", text="Invert")
 
         col = split.column()
         col.prop(con, "use_y", text="Y")
         sub = col.column()
         sub.active = con.use_y
-        sub.prop(con, "invert_y", text=_("Invert"))
+        sub.prop(con, "invert_y", text="Invert")
 
         col = split.column()
         col.prop(con, "use_z", text="Z")
         sub = col.column()
         sub.active = con.use_z
-        sub.prop(con, "invert_z", text=_("Invert"))
+        sub.prop(con, "invert_z", text="Invert")
 
         layout.prop(con, "use_offset")
 
@@ -383,19 +382,19 @@ class ConstraintButtonsPanel():
         col.prop(con, "use_x", text="X")
         sub = col.column()
         sub.active = con.use_x
-        sub.prop(con, "invert_x", text=_("Invert"))
+        sub.prop(con, "invert_x", text="Invert")
 
         col = split.column()
         col.prop(con, "use_y", text="Y")
         sub = col.column()
         sub.active = con.use_y
-        sub.prop(con, "invert_y", text=_("Invert"))
+        sub.prop(con, "invert_y", text="Invert")
 
         col = split.column()
         col.prop(con, "use_z", text="Z")
         sub = col.column()
         sub.active = con.use_z
-        sub.prop(con, "invert_z", text=_("Invert"))
+        sub.prop(con, "invert_z", text="Invert")
 
         layout.prop(con, "use_offset")
 
@@ -416,7 +415,7 @@ class ConstraintButtonsPanel():
     def MAINTAIN_VOLUME(self, context, layout, con):
 
         row = layout.row()
-        row.label(text=_("Free:"))
+        row.label(text="Free:")
         row.prop(con, "free_axis", expand=True)
 
         layout.prop(con, "volume")
@@ -440,28 +439,28 @@ class ConstraintButtonsPanel():
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text=_("Action Length:"))
-        col.prop(con, "frame_start", text=_("Start"))
-        col.prop(con, "frame_end", text=_("End"))
+        col.label(text="Action Length:")
+        col.prop(con, "frame_start", text="Start")
+        col.prop(con, "frame_end", text="End")
 
         col = split.column(align=True)
-        col.label(text=_("Target Range:"))
-        col.prop(con, "min", text=_("Min"))
-        col.prop(con, "max", text=_("Max"))
+        col.label(text="Target Range:")
+        col.prop(con, "min", text="Min")
+        col.prop(con, "max", text="Max")
 
         row = layout.row()
-        row.label(text=_("Convert:"))
+        row.label(text="Convert:")
         row.prop(con, "target_space", text="")
 
     def LOCKED_TRACK(self, context, layout, con):
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text=_("To:"))
+        row.label(text="To:")
         row.prop(con, "track_axis", expand=True)
 
         row = layout.row()
-        row.label(text=_("Lock:"))
+        row.label(text="Lock:")
         row.prop(con, "lock_axis", expand=True)
 
     def LIMIT_DISTANCE(self, context, layout, con):
@@ -472,7 +471,7 @@ class ConstraintButtonsPanel():
         col.operator("constraint.limitdistance_reset")
 
         row = layout.row()
-        row.label(text=_("Clamp Region:"))
+        row.label(text="Clamp Region:")
         row.prop(con, "limit_mode", text="")
 
         row = layout.row()
@@ -483,16 +482,16 @@ class ConstraintButtonsPanel():
         self.target_template(layout, con)
 
         row = layout.row()
-        row.prop(con, "rest_length", text=_("Rest Length"))
-        row.operator("constraint.stretchto_reset", text=_("Reset"))
+        row.prop(con, "rest_length", text="Rest Length")
+        row.operator("constraint.stretchto_reset", text="Reset")
 
-        layout.prop(con, "bulge", text=_("Volume Variation"))
+        layout.prop(con, "bulge", text="Volume Variation")
 
         row = layout.row()
-        row.label(text=_("Volume:"))
+        row.label(text="Volume:")
         row.prop(con, "volume", expand=True)
 
-        row.label(text=_("Plane:"))
+        row.label(text="Plane:")
         row.prop(con, "keep_axis", expand=True)
 
     def FLOOR(self, context, layout, con):
@@ -505,7 +504,7 @@ class ConstraintButtonsPanel():
         layout.prop(con, "offset")
 
         row = layout.row()
-        row.label(text=_("Min/Max:"))
+        row.label(text="Min/Max:")
         row.prop(con, "floor_location", expand=True)
 
         self.space_template(layout, con)
@@ -517,113 +516,113 @@ class ConstraintButtonsPanel():
         layout.prop(con, "child")
 
         row = layout.row()
-        row.prop(con, "use_linked_collision", text=_("Linked Collision"))
-        row.prop(con, "show_pivot", text=_("Display Pivot"))
+        row.prop(con, "use_linked_collision", text="Linked Collision")
+        row.prop(con, "show_pivot", text="Display Pivot")
 
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text=_("Pivot:"))
+        col.label(text="Pivot:")
         col.prop(con, "pivot_x", text="X")
         col.prop(con, "pivot_y", text="Y")
         col.prop(con, "pivot_z", text="Z")
 
         col = split.column(align=True)
-        col.label(text=_("Axis:"))
+        col.label(text="Axis:")
         col.prop(con, "axis_x", text="X")
         col.prop(con, "axis_y", text="Y")
         col.prop(con, "axis_z", text="Z")
 
         if con.pivot_type == 'CONE_TWIST':
-            layout.label(text=_("Limits:"))
+            layout.label(text="Limits:")
             split = layout.split()
 
             col = split.column()
-            col.prop(con, "use_angular_limit_x", text=_("Angle X"))
+            col.prop(con, "use_angular_limit_x", text="Angle X")
             sub = col.column()
             sub.active = con.use_angular_limit_x
             sub.prop(con, "limit_angle_max_x", text="")
 
             col = split.column()
-            col.prop(con, "use_angular_limit_y", text=_("Angle Y"))
+            col.prop(con, "use_angular_limit_y", text="Angle Y")
             sub = col.column()
             sub.active = con.use_angular_limit_y
             sub.prop(con, "limit_angle_max_y", text="")
 
             col = split.column()
-            col.prop(con, "use_angular_limit_z", text=_("Angle Z"))
+            col.prop(con, "use_angular_limit_z", text="Angle Z")
             sub = col.column()
             sub.active = con.use_angular_limit_z
             sub.prop(con, "limit_angle_max_z", text="")
 
         elif con.pivot_type == 'GENERIC_6_DOF':
-            layout.label(text=_("Limits:"))
+            layout.label(text="Limits:")
             split = layout.split()
 
             col = split.column(align=True)
             col.prop(con, "use_limit_x", text="X")
             sub = col.column()
             sub.active = con.use_limit_x
-            sub.prop(con, "limit_min_x", text=_("Min"))
-            sub.prop(con, "limit_max_x", text=_("Max"))
+            sub.prop(con, "limit_min_x", text="Min")
+            sub.prop(con, "limit_max_x", text="Max")
 
             col = split.column(align=True)
             col.prop(con, "use_limit_y", text="Y")
             sub = col.column()
             sub.active = con.use_limit_y
-            sub.prop(con, "limit_min_y", text=_("Min"))
-            sub.prop(con, "limit_max_y", text=_("Max"))
+            sub.prop(con, "limit_min_y", text="Min")
+            sub.prop(con, "limit_max_y", text="Max")
 
             col = split.column(align=True)
             col.prop(con, "use_limit_z", text="Z")
             sub = col.column()
             sub.active = con.use_limit_z
-            sub.prop(con, "limit_min_z", text=_("Min"))
-            sub.prop(con, "limit_max_z", text=_("Max"))
+            sub.prop(con, "limit_min_z", text="Min")
+            sub.prop(con, "limit_max_z", text="Max")
 
             split = layout.split()
 
             col = split.column(align=True)
-            col.prop(con, "use_angular_limit_x", text=_("Angle X"))
+            col.prop(con, "use_angular_limit_x", text="Angle X")
             sub = col.column()
             sub.active = con.use_angular_limit_x
-            sub.prop(con, "limit_angle_min_x", text=_("Min"))
-            sub.prop(con, "limit_angle_max_x", text=_("Max"))
+            sub.prop(con, "limit_angle_min_x", text="Min")
+            sub.prop(con, "limit_angle_max_x", text="Max")
 
             col = split.column(align=True)
-            col.prop(con, "use_angular_limit_y", text=_("Angle Y"))
+            col.prop(con, "use_angular_limit_y", text="Angle Y")
             sub = col.column()
             sub.active = con.use_angular_limit_y
-            sub.prop(con, "limit_angle_min_y", text=_("Min"))
-            sub.prop(con, "limit_angle_max_y", text=_("Max"))
+            sub.prop(con, "limit_angle_min_y", text="Min")
+            sub.prop(con, "limit_angle_max_y", text="Max")
 
             col = split.column(align=True)
-            col.prop(con, "use_angular_limit_z", text=_("Angle Z"))
+            col.prop(con, "use_angular_limit_z", text="Angle Z")
             sub = col.column()
             sub.active = con.use_angular_limit_z
-            sub.prop(con, "limit_angle_min_z", text=_("Min"))
-            sub.prop(con, "limit_angle_max_z", text=_("Max"))
+            sub.prop(con, "limit_angle_min_z", text="Min")
+            sub.prop(con, "limit_angle_max_z", text="Max")
 
         elif con.pivot_type == 'HINGE':
-            layout.label(text=_("Limits:"))
+            layout.label(text="Limits:")
             split = layout.split()
 
             row = split.row(align=True)
             col = row.column()
-            col.prop(con, "use_angular_limit_x", text=_("Angle X"))
+            col.prop(con, "use_angular_limit_x", text="Angle X")
 
             col = row.column()
             col.active = con.use_angular_limit_x
-            col.prop(con, "limit_angle_min_x", text=_("Min"))
+            col.prop(con, "limit_angle_min_x", text="Min")
             col = row.column()
             col.active = con.use_angular_limit_x
-            col.prop(con, "limit_angle_max_x", text=_("Max"))
+            col.prop(con, "limit_angle_max_x", text="Max")
 
     def CLAMP_TO(self, context, layout, con):
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text=_("Main Axis:"))
+        row.label(text="Main Axis:")
         row.prop(con, "main_axis", expand=True)
 
         layout.prop(con, "use_cyclic")
@@ -631,32 +630,32 @@ class ConstraintButtonsPanel():
     def TRANSFORM(self, context, layout, con):
         self.target_template(layout, con)
 
-        layout.prop(con, "use_motion_extrapolate", text=_("Extrapolate"))
+        layout.prop(con, "use_motion_extrapolate", text="Extrapolate")
 
         col = layout.column()
-        col.row().label(text=_("Source:"))
+        col.row().label(text="Source:")
         col.row().prop(con, "map_from", expand=True)
 
         split = layout.split()
 
         sub = split.column(align=True)
         sub.label(text="X:")
-        sub.prop(con, "from_min_x", text=_("Min"))
-        sub.prop(con, "from_max_x", text=_("Max"))
+        sub.prop(con, "from_min_x", text="Min")
+        sub.prop(con, "from_max_x", text="Max")
 
         sub = split.column(align=True)
         sub.label(text="Y:")
-        sub.prop(con, "from_min_y", text=_("Min"))
-        sub.prop(con, "from_max_y", text=_("Max"))
+        sub.prop(con, "from_min_y", text="Min")
+        sub.prop(con, "from_max_y", text="Max")
 
         sub = split.column(align=True)
         sub.label(text="Z:")
-        sub.prop(con, "from_min_z", text=_("Min"))
-        sub.prop(con, "from_max_z", text=_("Max"))
+        sub.prop(con, "from_min_z", text="Min")
+        sub.prop(con, "from_max_z", text="Max")
 
         col = layout.column()
         row = col.row()
-        row.label(text=_("Source to Destination Mapping:"))
+        row.label(text="Source to Destination Mapping:")
 
         # note: chr(187) is the ASCII arrow ( >> ). Blender Text Editor can't
         # open it. Thus we are using the hardcoded value instead.
@@ -675,7 +674,7 @@ class ConstraintButtonsPanel():
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Destination:"))
+        col.label(text="Destination:")
         col.row().prop(con, "map_to", expand=True)
 
         split = layout.split()
@@ -684,22 +683,22 @@ class ConstraintButtonsPanel():
         col.label(text="X:")
 
         sub = col.column(align=True)
-        sub.prop(con, "to_min_x", text=_("Min"))
-        sub.prop(con, "to_max_x", text=_("Max"))
+        sub.prop(con, "to_min_x", text="Min")
+        sub.prop(con, "to_max_x", text="Max")
 
         col = split.column()
         col.label(text="Y:")
 
         sub = col.column(align=True)
-        sub.prop(con, "to_min_y", text=_("Min"))
-        sub.prop(con, "to_max_y", text=_("Max"))
+        sub.prop(con, "to_min_y", text="Min")
+        sub.prop(con, "to_max_y", text="Max")
 
         col = split.column()
         col.label(text="Z:")
 
         sub = col.column(align=True)
-        sub.prop(con, "to_min_z", text=_("Min"))
-        sub.prop(con, "to_max_z", text=_("Max"))
+        sub.prop(con, "to_min_z", text="Min")
+        sub.prop(con, "to_max_z", text="Max")
 
         self.space_template(layout, con)
 
@@ -719,20 +718,20 @@ class ConstraintButtonsPanel():
         self.target_template(layout, con)
 
         row = layout.row()
-        row.label(text=_("To:"))
+        row.label(text="To:")
         row.prop(con, "track_axis", expand=True)
 
     def SPLINE_IK(self, context, layout, con):
         self.target_template(layout, con)
 
         col = layout.column()
-        col.label(text=_("Spline Fitting:"))
+        col.label(text="Spline Fitting:")
         col.prop(con, "chain_count")
         col.prop(con, "use_even_divisions")
         col.prop(con, "use_chain_offset")
 
         col = layout.column()
-        col.label(text=_("Chain Scaling:"))
+        col.label(text="Chain Scaling:")
         col.prop(con, "use_y_stretch")
         col.prop(con, "xz_scale_mode")
         col.prop(con, "use_curve_radius")
@@ -742,20 +741,20 @@ class ConstraintButtonsPanel():
 
         if con.target:
             col = layout.column()
-            col.prop(con, "offset", text=_("Pivot Offset"))
+            col.prop(con, "offset", text="Pivot Offset")
         else:
             col = layout.column()
             col.prop(con, "use_relative_location")
             if con.use_relative_location:
-                col.prop(con, "offset", text=_("Relative Pivot Point"))
+                col.prop(con, "offset", text="Relative Pivot Point")
             else:
-                col.prop(con, "offset", text=_("Absolute Pivot Point"))
+                col.prop(con, "offset", text="Absolute Pivot Point")
 
         col = layout.column()
-        col.prop(con, "rotation_range", text=_("Pivot When"))
+        col.prop(con, "rotation_range", text="Pivot When")
 
     def SCRIPT(self, context, layout, con):
-        layout.label(_("Blender 2.5 has no py-constraints"))
+        layout.label("Blender 2.5 has no py-constraints")
 
 
 class OBJECT_PT_constraints(ConstraintButtonsPanel, Panel):
@@ -774,7 +773,7 @@ class OBJECT_PT_constraints(ConstraintButtonsPanel, Panel):
         if ob.mode == 'POSE':
             box = layout.box()
             box.alert = True
-            box.label(icon='INFO', text=_("See Bone Constraints tab to Add Constraints to active bone"))
+            box.label(icon='INFO', text="See Bone Constraints tab to Add Constraints to active bone")
         else:
             layout.operator_menu_enum("object.constraint_add", "type")
 

release/scripts/startup/bl_ui/properties_particle.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -109,17 +108,17 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
             layout.template_ID(context.space_data, "pin_id")
 
             if part.is_fluid:
-                layout.label(text=_("Settings used for fluid"))
+                layout.label(text="Settings used for fluid")
                 return
 
-            layout.prop(part, "type", text=_("Type"))
+            layout.prop(part, "type", text="Type")
 
         elif not psys.settings:
             split = layout.split(percentage=0.32)
 
             col = split.column()
-            col.label(text=_("Name:"))
-            col.label(text=_("Settings:"))
+            col.label(text="Name:")
+            col.label(text="Settings:")
 
             col = split.column()
             col.prop(psys, "name", text="")
@@ -129,10 +128,10 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
 
             split = layout.split(percentage=0.32)
             col = split.column()
-            col.label(text=_("Name:"))
+            col.label(text="Name:")
             if part.is_fluid == False:
-                col.label(text=_("Settings:"))
-                col.label(text=_("Type:"))
+                col.label(text="Settings:")
+                col.label(text="Type:")
 
             col = split.column()
             col.prop(psys, "name", text="")
@@ -142,8 +141,8 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
                 row.template_ID(psys, "settings", new="particle.new")
 
             #row = layout.row()
-            #row.label(text=_("Viewport"))
-            #row.label(text=_("Render"))
+            #row.label(text="Viewport")
+            #row.label(text="Render")
 
             if part.is_fluid:
                 layout.label(text=str(part.count) + " fluid particles for this frame")
@@ -158,7 +157,7 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
             split = layout.split(percentage=0.65)
             if part.type == 'HAIR':
                 if psys is not None and psys.is_edited:
-                    split.operator("particle.edited_clear", text=_("Free Edit"))
+                    split.operator("particle.edited_clear", text="Free Edit")
                 else:
                     row = split.row()
                     row.enabled = particle_panel_enabled(context, psys)
@@ -175,7 +174,7 @@ class PARTICLE_PT_context_particles(ParticleButtonsPanel, Panel):
             elif psys is not None and part.type == 'REACTOR':
                 split.enabled = particle_panel_enabled(context, psys)
                 split.prop(psys, "reactor_target_object")
-                split.prop(psys, "reactor_target_particle_system", text=_("Particle System"))
+                split.prop(psys, "reactor_target_particle_system", text="Particle System")
 
 
 class PARTICLE_PT_emission(ParticleButtonsPanel, Panel):
@@ -222,7 +221,7 @@ class PARTICLE_PT_emission(ParticleButtonsPanel, Panel):
             col.prop(part, "lifetime")
             col.prop(part, "lifetime_random", slider=True)
 
-        layout.label(text=_("Emit From:"))
+        layout.label(text="Emit From:")
         layout.prop(part, "emit_from", expand=True)
 
         row = layout.row()
@@ -240,11 +239,11 @@ class PARTICLE_PT_emission(ParticleButtonsPanel, Panel):
 
             row = layout.row()
             if part.distribution == 'JIT':
-                row.prop(part, "userjit", text=_("Particles/Face"))
-                row.prop(part, "jitter_factor", text=_("Jittering Amount"), slider=True)
+                row.prop(part, "userjit", text="Particles/Face")
+                row.prop(part, "jitter_factor", text="Jittering Amount", slider=True)
             elif part.distribution == 'GRID':
                 row.prop(part, "grid_resolution")
-                row.prop(part, "grid_random", text=_("Random"), slider=True)
+                row.prop(part, "grid_random", text="Random", slider=True)
 
 
 class PARTICLE_PT_hair_dynamics(ParticleButtonsPanel, Panel):
@@ -285,22 +284,22 @@ class PARTICLE_PT_hair_dynamics(ParticleButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Material:"))
+        col.label(text="Material:")
         sub = col.column(align=True)
-        sub.prop(cloth, "pin_stiffness", text=_("Stiffness"))
+        sub.prop(cloth, "pin_stiffness", text="Stiffness")
         sub.prop(cloth, "mass")
-        sub.prop(cloth, "bending_stiffness", text=_("Bending"))
+        sub.prop(cloth, "bending_stiffness", text="Bending")
         sub.prop(cloth, "internal_friction", slider=True)
         sub.prop(cloth, "collider_friction", slider=True)
 
         col = split.column()
-        col.label(text=_("Damping:"))
+        col.label(text="Damping:")
         sub = col.column(align=True)
-        sub.prop(cloth, "spring_damping", text=_("Spring"))
-        sub.prop(cloth, "air_damping", text=_("Air"))
+        sub.prop(cloth, "spring_damping", text="Spring")
+        sub.prop(cloth, "air_damping", text="Air")
 
-        col.label(text=_("Quality:"))
-        col.prop(cloth, "quality", text=_("Steps"), slider=True)
+        col.label(text="Quality:")
+        col.prop(cloth, "quality", text="Steps", slider=True)
 
 
 class PARTICLE_PT_cache(ParticleButtonsPanel, Panel):
@@ -356,17 +355,17 @@ class PARTICLE_PT_velocity(ParticleButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Emitter Geometry:"))
+        col.label(text="Emitter Geometry:")
         col.prop(part, "normal_factor")
         sub = col.column(align=True)
         sub.prop(part, "tangent_factor")
         sub.prop(part, "tangent_phase", slider=True)
 
         col = split.column()
-        col.label(text=_("Emitter Object:"))
+        col.label(text="Emitter Object:")
         col.prop(part, "object_align_factor", text="")
 
-        layout.label(text=_("Other:"))
+        layout.label(text="Other:")
         row = layout.row()
         if part.emit_from == 'PARTICLE':
             row.prop(part, "particle_factor")
@@ -407,21 +406,21 @@ class PARTICLE_PT_rotation(ParticleButtonsPanel, Panel):
         layout.enabled = particle_panel_enabled(context, psys)
 
         row = layout.row()
-        row.label(text=_("Initial Rotation:"))
+        row.label(text="Initial Rotation:")
         row.prop(part, "use_dynamic_rotation")
 
         split = layout.split()
 
         col = split.column(align=True)
         col.prop(part, "rotation_mode", text="")
-        col.prop(part, "rotation_factor_random", slider=True, text=_("Random"))
+        col.prop(part, "rotation_factor_random", slider=True, text="Random")
 
         col = split.column(align=True)
         col.prop(part, "phase_factor", slider=True)
-        col.prop(part, "phase_factor_random", text=_("Random"), slider=True)
+        col.prop(part, "phase_factor_random", text="Random", slider=True)
 
         col = layout.column()
-        col.label(text=_("Angular Velocity:"))
+        col.label(text="Angular Velocity:")
         col.row().prop(part, "angular_velocity_mode", expand=True)
 
         if part.angular_velocity_mode != 'NONE':
@@ -462,19 +461,19 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
         if part.physics_type != 'NO':
             col = row.column(align=True)
             col.prop(part, "mass")
-            col.prop(part, "use_multiply_size_mass", text=_("Multiply mass with size"))
+            col.prop(part, "use_multiply_size_mass", text="Multiply mass with size")
 
         if part.physics_type in {'NEWTON', 'FLUID'}:
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Forces:"))
+            col.label(text="Forces:")
             col.prop(part, "brownian_factor")
             col.prop(part, "drag_factor", slider=True)
             col.prop(part, "damping", slider=True)
 
             col = split.column()
-            col.label(text=_("Integration:"))
+            col.label(text="Integration:")
             col.prop(part, "integrator", text="")
             col.prop(part, "timestep")
             col.prop(part, "subframes")
@@ -489,13 +488,13 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Fluid properties:"))
-                col.prop(fluid, "stiffness", text=_("Stiffness"))
-                col.prop(fluid, "linear_viscosity", text=_("Viscosity"))
-                col.prop(fluid, "buoyancy", text=_("Buoancy"), slider=True)
+                col.label(text="Fluid properties:")
+                col.prop(fluid, "stiffness", text="Stiffness")
+                col.prop(fluid, "linear_viscosity", text="Viscosity")
+                col.prop(fluid, "buoyancy", text="Buoancy", slider=True)
 
                 col = split.column()
-                col.label(text=_("Advanced:"))
+                col.label(text="Advanced:")
 
                 sub = col.row()
                 sub.prop(fluid, "repulsion", slider=fluid.factor_repulsion)
@@ -516,8 +515,8 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Springs:"))
-                col.prop(fluid, "spring_force", text=_("Force"))
+                col.label(text="Springs:")
+                col.prop(fluid, "spring_force", text="Force")
                 col.prop(fluid, "use_viscoelastic_springs")
                 sub = col.column(align=True)
                 sub.active = fluid.use_viscoelastic_springs
@@ -525,7 +524,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 sub.prop(fluid, "plasticity", slider=True)
 
                 col = split.column()
-                col.label(text=_("Advanced:"))
+                col.label(text="Advanced:")
                 sub = col.row()
                 sub.prop(fluid, "rest_length", slider=fluid.factor_rest_length)
                 sub.prop(fluid, "factor_rest_length", text="")
@@ -533,7 +532,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                 sub = col.column()
                 sub.active = fluid.use_viscoelastic_springs
                 sub.prop(fluid, "use_initial_rest_length")
-                sub.prop(fluid, "spring_frames", text=_("Frames"))
+                sub.prop(fluid, "spring_frames", text="Frames")
 
         elif part.physics_type == 'KEYED':
             split = layout.split()
@@ -542,11 +541,11 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             row = layout.row()
             col = row.column()
             col.active = not psys.use_keyed_timing
-            col.prop(part, "keyed_loops", text=_("Loops"))
+            col.prop(part, "keyed_loops", text="Loops")
             if psys:
-                row.prop(psys, "use_keyed_timing", text=_("Use Timing"))
+                row.prop(psys, "use_keyed_timing", text="Use Timing")
 
-            layout.label(text=_("Keys:"))
+            layout.label(text="Keys:")
         elif part.physics_type == 'BOIDS':
             boids = part.boids
 
@@ -582,7 +581,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             row = layout.row()
 
             col = row.column(align=True)
-            col.label(text=_("Battle:"))
+            col.label(text="Battle:")
             col.prop(boids, "health")
             col.prop(boids, "strength")
             col.prop(boids, "aggression")
@@ -590,16 +589,16 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
             col.prop(boids, "range")
 
             col = row.column()
-            col.label(text=_("Misc:"))
+            col.label(text="Misc:")
             col.prop(boids, "bank", slider=True)
             col.prop(boids, "pitch", slider=True)
             col.prop(boids, "height", slider=True)
 
         if psys and part.physics_type in {'KEYED', 'BOIDS', 'FLUID'}:
             if part.physics_type == 'BOIDS':
-                layout.label(text=_("Relations:"))
+                layout.label(text="Relations:")
             elif part.physics_type == 'FLUID':
-                layout.label(text=_("Fluid interaction:"))
+                layout.label(text="Fluid interaction:")
 
             row = layout.row()
             row.template_list(psys, "targets", psys, "active_particle_target_index")
@@ -622,7 +621,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     #doesn't work yet
                     #col.alert = key.valid
                     col.prop(key, "object", text="")
-                    col.prop(key, "system", text=_("System"))
+                    col.prop(key, "system", text="System")
                     col = row.column()
                     col.active = psys.use_keyed_timing
                     col.prop(key, "time")
@@ -632,7 +631,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     #doesn't work yet
                     #sub.alert = key.valid
                     sub.prop(key, "object", text="")
-                    sub.prop(key, "system", text=_("System"))
+                    sub.prop(key, "system", text="System")
 
                     layout.prop(key, "alliance", expand=True)
                 elif part.physics_type == 'FLUID':
@@ -640,7 +639,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
                     #doesn't work yet
                     #sub.alert = key.valid
                     sub.prop(key, "object", text="")
-                    sub.prop(key, "system", text=_("System"))
+                    sub.prop(key, "system", text="System")
 
 
 class PARTICLE_PT_boidbrain(ParticleButtonsPanel, Panel):
@@ -679,7 +678,7 @@ class PARTICLE_PT_boidbrain(ParticleButtonsPanel, Panel):
 
         state = boids.active_boid_state
 
-        #layout.prop(state, "name", text=_("State name"))
+        #layout.prop(state, "name", text="State name")
 
         row = layout.row()
         row.prop(state, "ruleset_type")
@@ -722,7 +721,7 @@ class PARTICLE_PT_boidbrain(ParticleButtonsPanel, Panel):
                 row.prop(rule, "use_predict")
                 row.prop(rule, "fear_factor")
             elif rule.type == 'FOLLOW_PATH':
-                row.label(text=_("Not yet functional"))
+                row.label(text="Not yet functional")
             elif rule.type == 'AVOID_COLLISION':
                 row.prop(rule, "use_avoid")
                 row.prop(rule, "use_avoid_collision")
@@ -801,14 +800,14 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
             sub.active = (part.use_render_adaptive is True and part.use_strand_primitive is False)
             sub.prop(part, "adaptive_pixel")
             col.prop(part, "use_hair_bspline")
-            col.prop(part, "render_step", text=_("Steps"))
+            col.prop(part, "render_step", text="Steps")
 
             col = split.column()
-            col.label(text=_("Timing:"))
+            col.label(text="Timing:")
             col.prop(part, "use_absolute_path_time")
-            col.prop(part, "path_start", text=_("Start"), slider=not part.use_absolute_path_time)
-            col.prop(part, "path_end", text=_("End"), slider=not part.use_absolute_path_time)
-            col.prop(part, "length_random", text=_("Random"), slider=True)
+            col.prop(part, "path_start", text="Start", slider=not part.use_absolute_path_time)
+            col.prop(part, "path_end", text="End", slider=not part.use_absolute_path_time)
+            col.prop(part, "length_random", text="Random", slider=True)
 
             row = layout.row()
             col = row.column()
@@ -865,30 +864,30 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
         elif part.render_type == 'BILLBOARD':
             ob = context.object
 
-            col.label(text=_("Align:"))
+            col.label(text="Align:")
 
             row = layout.row()
             row.prop(part, "billboard_align", expand=True)
-            row.prop(part, "lock_billboard", text=_("Lock"))
+            row.prop(part, "lock_billboard", text="Lock")
             row = layout.row()
             row.prop(part, "billboard_object")
 
             row = layout.row()
             col = row.column(align=True)
-            col.label(text=_("Tilt:"))
-            col.prop(part, "billboard_tilt", text=_("Angle"), slider=True)
-            col.prop(part, "billboard_tilt_random", text=_("Random"), slider=True)
+            col.label(text="Tilt:")
+            col.prop(part, "billboard_tilt", text="Angle", slider=True)
+            col.prop(part, "billboard_tilt_random", text="Random", slider=True)
             col = row.column()
             col.prop(part, "billboard_offset")
 
             row = layout.row()
             col = row.column()
-            col.prop(part, "billboard_size", text=_("Scale"))
+            col.prop(part, "billboard_size", text="Scale")
             if part.billboard_align == 'VEL':
                 col = row.column(align=True)
-                col.label(_("Velocity Scale:"))
-                col.prop(part, "billboard_velocity_head", text=_("Head"))
-                col.prop(part, "billboard_velocity_tail", text=_("Tail"))
+                col.label("Velocity Scale:")
+                col.prop(part, "billboard_velocity_head", text="Head")
+                col.prop(part, "billboard_velocity_tail", text="Tail")
 
             if psys:
                 col = layout.column()
@@ -896,8 +895,8 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
                 col.prop_search(psys, "billboard_time_index_uv", ob.data, "uv_textures")
 
             split = layout.split(percentage=0.33)
-            split.label(text=_("Split uv's:"))
-            split.prop(part, "billboard_uv_split", text=_("Number of splits"))
+            split.label(text="Split uv's:")
+            split.prop(part, "billboard_uv_split", text="Number of splits")
 
             if psys:
                 col = layout.column()
@@ -905,9 +904,9 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
                 col.prop_search(psys, "billboard_split_uv", ob.data, "uv_textures")
 
             row = col.row()
-            row.label(text=_("Animate:"))
+            row.label(text="Animate:")
             row.prop(part, "billboard_animation", text="")
-            row.label(text=_("Offset:"))
+            row.label(text="Offset:")
             row.prop(part, "billboard_offset_split", text="")
 
         if part.render_type == 'HALO' or part.render_type == 'LINE' or part.render_type == 'BILLBOARD':
@@ -915,10 +914,10 @@ class PARTICLE_PT_render(ParticleButtonsPanel, Panel):
             col = row.column()
             col.prop(part, "trail_count")
             if part.trail_count > 1:
-                col.prop(part, "use_absolute_path_time", text=_("Length in frames"))
+                col.prop(part, "use_absolute_path_time", text="Length in frames")
                 col = row.column()
-                col.prop(part, "path_end", text=_("Length"), slider=not part.use_absolute_path_time)
-                col.prop(part, "length_random", text=_("Random"), slider=True)
+                col.prop(part, "path_end", text="Length", slider=not part.use_absolute_path_time)
+                col.prop(part, "length_random", text="Random", slider=True)
             else:
                 col = row.column()
                 col.label(text="")
@@ -966,11 +965,11 @@ class PARTICLE_PT_draw(ParticleButtonsPanel, Panel):
         if part.draw_percentage != 100 and psys is not None:
             if part.type == 'HAIR':
                 if psys.use_hair_dynamics and psys.point_cache.is_baked == False:
-                    layout.row().label(text=_("Display percentage makes dynamics inaccurate without baking!"))
+                    layout.row().label(text="Display percentage makes dynamics inaccurate without baking!")
             else:
                 phystype = part.physics_type
                 if phystype != 'NO' and phystype != 'KEYED' and psys.point_cache.is_baked == False:
-                    layout.row().label(text=_("Display percentage makes dynamics inaccurate without baking!"))
+                    layout.row().label(text="Display percentage makes dynamics inaccurate without baking!")
 
         row = layout.row()
         col = row.column()
@@ -981,11 +980,11 @@ class PARTICLE_PT_draw(ParticleButtonsPanel, Panel):
             col.prop(part, "show_health")
 
         col = row.column(align=True)
-        col.label(text=_("Color:"))
+        col.label(text="Color:")
         col.prop(part, "draw_color", text="")
         sub = col.row()
         sub.active = part.draw_color in ('VELOCITY', 'ACCELERATION')
-        sub.prop(part, "color_maximum", text=_("Max"))
+        sub.prop(part, "color_maximum", text="Max")
 
         if (path):
             col.prop(part, "draw_step")
@@ -1014,24 +1013,24 @@ class PARTICLE_PT_children(ParticleButtonsPanel, Panel):
         row = layout.row()
 
         col = row.column(align=True)
-        col.prop(part, "child_nbr", text=_("Display"))
-        col.prop(part, "rendered_child_count", text=_("Render"))
+        col.prop(part, "child_nbr", text="Display")
+        col.prop(part, "rendered_child_count", text="Render")
 
         if part.child_type == 'INTERPOLATED':
             col = row.column()
             if psys:
-                col.prop(psys, "child_seed", text=_("Seed"))
+                col.prop(psys, "child_seed", text="Seed")
             col.prop(part, "virtual_parents", slider=True)
             col.prop(part, "create_long_hair_children")
         else:
             col = row.column(align=True)
-            col.prop(part, "child_size", text=_("Size"))
-            col.prop(part, "child_size_random", text=_("Random"))
+            col.prop(part, "child_size", text="Size")
+            col.prop(part, "child_size_random", text="Random")
 
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Effects:"))
+        col.label(text="Effects:")
 
         sub = col.column(align=True)
         sub.prop(part, "clump_factor", slider=True)
@@ -1043,38 +1042,38 @@ class PARTICLE_PT_children(ParticleButtonsPanel, Panel):
 
         if part.child_type == 'SIMPLE':
             sub = col.column(align=True)
-            sub.prop(part, "child_radius", text=_("Radius"))
-            sub.prop(part, "child_roundness", text=_("Roundness"), slider=True)
+            sub.prop(part, "child_radius", text="Radius")
+            sub.prop(part, "child_roundness", text="Roundness", slider=True)
             if psys:
-                sub.prop(psys, "child_seed", text=_("Seed"))
+                sub.prop(psys, "child_seed", text="Seed")
         elif part.virtual_parents > 0.0:
             sub = col.column(align=True)
-            sub.label(text=_("Parting not"))
-            sub.label(text=_("available with"))
-            sub.label(text=_("virtual parents"))
+            sub.label(text="Parting not")
+            sub.label(text="available with")
+            sub.label(text="virtual parents")
         else:
             sub = col.column(align=True)
-            sub.prop(part, "child_parting_factor", text=_("Parting"), slider=True)
-            sub.prop(part, "child_parting_min", text=_("Min"))
-            sub.prop(part, "child_parting_max", text=_("Max"))
+            sub.prop(part, "child_parting_factor", text="Parting", slider=True)
+            sub.prop(part, "child_parting_min", text="Min")
+            sub.prop(part, "child_parting_max", text="Max")
 
         col = split.column()
-        col.label(text=_("Roughness:"))
+        col.label(text="Roughness:")
 
         sub = col.column(align=True)
-        sub.prop(part, "roughness_1", text=_("Uniform"))
-        sub.prop(part, "roughness_1_size", text=_("Size"))
+        sub.prop(part, "roughness_1", text="Uniform")
+        sub.prop(part, "roughness_1_size", text="Size")
 
         sub = col.column(align=True)
         sub.prop(part, "roughness_endpoint", "Endpoint")
         sub.prop(part, "roughness_end_shape")
 
         sub = col.column(align=True)
-        sub.prop(part, "roughness_2", text=_("Random"))
-        sub.prop(part, "roughness_2_size", text=_("Size"))
+        sub.prop(part, "roughness_2", text="Random")
+        sub.prop(part, "roughness_2_size", text="Size")
         sub.prop(part, "roughness_2_threshold", slider=True)
 
-        layout.row().label(text=_("Kink:"))
+        layout.row().label(text="Kink:")
         layout.row().prop(part, "kink", expand=True)
 
         split = layout.split()
@@ -1083,7 +1082,7 @@ class PARTICLE_PT_children(ParticleButtonsPanel, Panel):
         col = split.column()
         sub = col.column(align=True)
         sub.prop(part, "kink_amplitude")
-        sub.prop(part, "kink_amplitude_clump", text=_("Clump"), slider=True)
+        sub.prop(part, "kink_amplitude_clump", text="Clump", slider=True)
         col.prop(part, "kink_flat", slider=True)
         col = split.column()
         sub = col.column(align=True)
@@ -1124,25 +1123,25 @@ class PARTICLE_PT_force_fields(ParticleButtonsPanel, Panel):
 
         row = layout.row()
         row.prop(part, "use_self_effect")
-        row.prop(part, "effector_amount", text=_("Amount"))
+        row.prop(part, "effector_amount", text="Amount")
 
         split = layout.split(percentage=0.2)
-        split.label(text=_("Type 1:"))
+        split.label(text="Type 1:")
         split.prop(part.force_field_1, "type", text="")
         basic_force_field_settings_ui(self, context, part.force_field_1)
         if part.force_field_1.type != 'NONE':
-            layout.label(text=_("Falloff:"))
+            layout.label(text="Falloff:")
         basic_force_field_falloff_ui(self, context, part.force_field_1)
 
         if part.force_field_1.type != 'NONE':
             layout.label(text="")
 
         split = layout.split(percentage=0.2)
-        split.label(text=_("Type 2:"))
+        split.label(text="Type 2:")
         split.prop(part.force_field_2, "type", text="")
         basic_force_field_settings_ui(self, context, part.force_field_2)
         if part.force_field_2.type != 'NONE':
-            layout.label(text=_("Falloff:"))
+            layout.label(text="Falloff:")
         basic_force_field_falloff_ui(self, context, part.force_field_2)
 
 
@@ -1164,56 +1163,56 @@ class PARTICLE_PT_vertexgroups(ParticleButtonsPanel, Panel):
         psys = context.particle_system
 
         row = layout.row()
-        row.label(text=_("Vertex Group"))
-        row.label(text=_("Negate"))
+        row.label(text="Vertex Group")
+        row.label(text="Negate")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_density", ob, "vertex_groups", text=_("Density"))
+        row.prop_search(psys, "vertex_group_density", ob, "vertex_groups", text="Density")
         row.prop(psys, "invert_vertex_group_density", text="")
 
         # Commented out vertex groups don't work and are still waiting for better implementation
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_velocity", ob, "vertex_groups", text=_("Velocity"))
+        # row.prop_search(psys, "vertex_group_velocity", ob, "vertex_groups", text="Velocity")
         # row.prop(psys, "invert_vertex_group_velocity", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_length", ob, "vertex_groups", text=_("Length"))
+        row.prop_search(psys, "vertex_group_length", ob, "vertex_groups", text="Length")
         row.prop(psys, "invert_vertex_group_length", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_clump", ob, "vertex_groups", text=_("Clump"))
+        row.prop_search(psys, "vertex_group_clump", ob, "vertex_groups", text="Clump")
         row.prop(psys, "invert_vertex_group_clump", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_kink", ob, "vertex_groups", text=_("Kink"))
+        row.prop_search(psys, "vertex_group_kink", ob, "vertex_groups", text="Kink")
         row.prop(psys, "invert_vertex_group_kink", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_roughness_1", ob, "vertex_groups", text=_("Roughness 1"))
+        row.prop_search(psys, "vertex_group_roughness_1", ob, "vertex_groups", text="Roughness 1")
         row.prop(psys, "invert_vertex_group_roughness_1", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_roughness_2", ob, "vertex_groups", text=_("Roughness 2"))
+        row.prop_search(psys, "vertex_group_roughness_2", ob, "vertex_groups", text="Roughness 2")
         row.prop(psys, "invert_vertex_group_roughness_2", text="")
 
         row = layout.row()
-        row.prop_search(psys, "vertex_group_roughness_end", ob, "vertex_groups", text=_("Roughness End"))
+        row.prop_search(psys, "vertex_group_roughness_end", ob, "vertex_groups", text="Roughness End")
         row.prop(psys, "invert_vertex_group_roughness_end", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_size", ob, "vertex_groups", text=_("Size"))
+        # row.prop_search(psys, "vertex_group_size", ob, "vertex_groups", text="Size")
         # row.prop(psys, "invert_vertex_group_size", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_tangent", ob, "vertex_groups", text=_("Tangent"))
+        # row.prop_search(psys, "vertex_group_tangent", ob, "vertex_groups", text="Tangent")
         # row.prop(psys, "invert_vertex_group_tangent", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_rotation", ob, "vertex_groups", text=_("Rotation"))
+        # row.prop_search(psys, "vertex_group_rotation", ob, "vertex_groups", text="Rotation")
         # row.prop(psys, "invert_vertex_group_rotation", text="")
 
         # row = layout.row()
-        # row.prop_search(psys, "vertex_group_field", ob, "vertex_groups", text=_("Field"))
+        # row.prop_search(psys, "vertex_group_field", ob, "vertex_groups", text="Field")
         # row.prop(psys, "invert_vertex_group_field", text="")
 
 

release/scripts/startup/bl_ui/properties_physics_cloth.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Menu, Panel
-from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -71,50 +70,50 @@ class PHYSICS_PT_cloth(PhysicButtonsPanel, Panel):
 
             col = split.column()
 
-            col.label(text=_("Presets:"))
+            col.label(text="Presets:")
             sub = col.row(align=True)
             sub.menu("CLOTH_MT_presets", text=bpy.types.CLOTH_MT_presets.bl_label)
             sub.operator("cloth.preset_add", text="", icon="ZOOMIN")
             sub.operator("cloth.preset_add", text="", icon="ZOOMOUT").remove_active = True
 
-            col.label(text=_("Quality:"))
-            col.prop(cloth, "quality", text=_("Steps"), slider=True)
+            col.label(text="Quality:")
+            col.prop(cloth, "quality", text="Steps", slider=True)
 
-            col.label(text=_("Material:"))
+            col.label(text="Material:")
             col.prop(cloth, "mass")
-            col.prop(cloth, "structural_stiffness", text=_("Structural"))
-            col.prop(cloth, "bending_stiffness", text=_("Bending"))
+            col.prop(cloth, "structural_stiffness", text="Structural")
+            col.prop(cloth, "bending_stiffness", text="Bending")
 
             col = split.column()
 
-            col.label(text=_("Damping:"))
-            col.prop(cloth, "spring_damping", text=_("Spring"))
-            col.prop(cloth, "air_damping", text=_("Air"))
+            col.label(text="Damping:")
+            col.prop(cloth, "spring_damping", text="Spring")
+            col.prop(cloth, "air_damping", text="Air")
 
-            col.prop(cloth, "use_pin_cloth", text=_("Pinning"))
+            col.prop(cloth, "use_pin_cloth", text="Pinning")
             sub = col.column()
             sub.active = cloth.use_pin_cloth
             sub.prop_search(cloth, "vertex_group_mass", ob, "vertex_groups", text="")
-            sub.prop(cloth, "pin_stiffness", text=_("Stiffness"))
+            sub.prop(cloth, "pin_stiffness", text="Stiffness")
 
-            col.label(text=_("Pre roll:"))
-            col.prop(cloth, "pre_roll", text=_("Frame"))
+            col.label(text="Pre roll:")
+            col.prop(cloth, "pre_roll", text="Frame")
 
             # Disabled for now
             """
             if cloth.vertex_group_mass:
-                layout.label(text=_("Goal:"))
+                layout.label(text="Goal:")
 
                 col = layout.column_flow()
-                col.prop(cloth, "goal_default", text=_("Default"))
-                col.prop(cloth, "goal_spring", text=_("Stiffness"))
-                col.prop(cloth, "goal_friction", text=_("Friction"))
+                col.prop(cloth, "goal_default", text="Default")
+                col.prop(cloth, "goal_spring", text="Stiffness")
+                col.prop(cloth, "goal_friction", text="Friction")
             """
 
             key = ob.data.shape_keys
 
             if key:
-                col.label(text=_("Rest Shape Key:"))
+                col.label(text="Rest Shape Key:")
                 col.prop_search(cloth, "rest_shape_key", key, "key_blocks", text="")
 
 
@@ -156,18 +155,18 @@ class PHYSICS_PT_cloth_collision(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(cloth, "collision_quality", slider=True, text=_("Quality"))
-        col.prop(cloth, "distance_min", slider=True, text=_("Distance"))
-        col.prop(cloth, "repel_force", slider=True, text=_("Repel"))
-        col.prop(cloth, "distance_repel", slider=True, text=_("Repel Distance"))
+        col.prop(cloth, "collision_quality", slider=True, text="Quality")
+        col.prop(cloth, "distance_min", slider=True, text="Distance")
+        col.prop(cloth, "repel_force", slider=True, text="Repel")
+        col.prop(cloth, "distance_repel", slider=True, text="Repel Distance")
         col.prop(cloth, "friction")
 
         col = split.column()
-        col.prop(cloth, "use_self_collision", text=_("Self Collision"))
+        col.prop(cloth, "use_self_collision", text="Self Collision")
         sub = col.column()
         sub.active = cloth.use_self_collision
-        sub.prop(cloth, "self_collision_quality", slider=True, text=_("Quality"))
-        sub.prop(cloth, "self_distance_min", slider=True, text=_("Distance"))
+        sub.prop(cloth, "self_collision_quality", slider=True, text="Quality")
+        sub.prop(cloth, "self_distance_min", slider=True, text="Distance")
 
         layout.prop(cloth, "group")
 
@@ -198,14 +197,14 @@ class PHYSICS_PT_cloth_stiffness(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Structural Stiffness:"))
+        col.label(text="Structural Stiffness:")
         col.prop_search(cloth, "vertex_group_structural_stiffness", ob, "vertex_groups", text="")
-        col.prop(cloth, "structural_stiffness_max", text=_("Max"))
+        col.prop(cloth, "structural_stiffness_max", text="Max")
 
         col = split.column()
-        col.label(text=_("Bending Stiffness:"))
+        col.label(text="Bending Stiffness:")
         col.prop_search(cloth, "vertex_group_bending", ob, "vertex_groups", text="")
-        col.prop(cloth, "bending_stiffness_max", text=_("Max"))
+        col.prop(cloth, "bending_stiffness_max", text="Max")
 
 
 class PHYSICS_PT_cloth_field_weights(PhysicButtonsPanel, Panel):

release/scripts/startup/bl_ui/properties_physics_common.py

@@ -20,7 +20,6 @@
 
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 
 class PhysicButtonsPanel():
@@ -54,27 +53,27 @@ class PHYSICS_PT_add(PhysicButtonsPanel, Panel):
         ob = context.object
 
         layout = self.layout
-        layout.label(_("Enable physics for:"))
+        layout.label("Enable physics for:")
         split = layout.split()
         col = split.column()
 
         if(context.object.field.type == 'NONE'):
-            col.operator("object.forcefield_toggle", text=_("Force Field"), icon='FORCE_FORCE')
+            col.operator("object.forcefield_toggle", text="Force Field", icon='FORCE_FORCE')
         else:
-            col.operator("object.forcefield_toggle", text=_("Force Field"), icon='X')
+            col.operator("object.forcefield_toggle", text="Force Field", icon='X')
 
         if(ob.type == 'MESH'):
-            physics_add(self, col, context.collision, _("Collision"), 'COLLISION', 'MOD_PHYSICS', False)
-            physics_add(self, col, context.cloth, _("Cloth"), 'CLOTH', 'MOD_CLOTH', True)
+            physics_add(self, col, context.collision, "Collision", 'COLLISION', 'MOD_PHYSICS', False)
+            physics_add(self, col, context.cloth, "Cloth", 'CLOTH', 'MOD_CLOTH', True)
 
         col = split.column()
 
         if(ob.type == 'MESH' or ob.type == 'LATTICE'or ob.type == 'CURVE'):
-            physics_add(self, col, context.soft_body, _("Soft Body"), 'SOFT_BODY', 'MOD_SOFT', True)
+            physics_add(self, col, context.soft_body, "Soft Body", 'SOFT_BODY', 'MOD_SOFT', True)
 
         if(ob.type == 'MESH'):
-            physics_add(self, col, context.fluid, _("Fluid"), 'FLUID_SIMULATION', 'MOD_FLUIDSIM', True)
-            physics_add(self, col, context.smoke, _("Smoke"), 'SMOKE', 'MOD_SMOKE', True)
+            physics_add(self, col, context.fluid, "Fluid", 'FLUID_SIMULATION', 'MOD_FLUIDSIM', True)
+            physics_add(self, col, context.smoke, "Smoke", 'SMOKE', 'MOD_SMOKE', True)
 
 
 #cachetype can be 'PSYS' 'HAIR' 'SMOKE' etc
@@ -96,11 +95,11 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
 
     if cache.use_external:
         split = layout.split(percentage=0.80)
-        split.prop(cache, "name", text=_("File Name"))
+        split.prop(cache, "name", text="File Name")
         split.prop(cache, "index", text="")
 
         row = layout.row()
-        row.label(text=_("File Path:"))
+        row.label(text="File Path:")
         row.prop(cache, "use_library_path", "Use Lib Path")
 
         layout.prop(cache, "filepath", text="")
@@ -109,13 +108,13 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
     else:
         if cachetype == 'SMOKE':
             if not bpy.data.is_saved:
-                layout.label(text=_("Cache is disabled until the file is saved"))
+                layout.label(text="Cache is disabled until the file is saved")
                 layout.enabled = False
 
         if cache.use_disk_cache:
-            layout.prop(cache, "name", text=_("File Name"))
+            layout.prop(cache, "name", text="File Name")
         else:
-            layout.prop(cache, "name", text=_("Cache Name"))
+            layout.prop(cache, "name", text="Cache Name")
 
         row = layout.row(align=True)
 
@@ -143,7 +142,7 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
             row = layout.row()
             row.enabled = enabled and bpy.data.is_saved
             row.active = cache.use_disk_cache
-            row.label(text=_("Compression:"))
+            row.label(text="Compression:")
             row.prop(cache, "compression", expand=True)
 
         layout.separator()
@@ -153,22 +152,22 @@ def point_cache_ui(self, context, cache, enabled, cachetype):
         col = split.column()
 
         if cache.is_baked == True:
-            col.operator("ptcache.free_bake", text=_("Free Bake"))
+            col.operator("ptcache.free_bake", text="Free Bake")
         else:
-            col.operator("ptcache.bake", text=_("Bake")).bake = True
+            col.operator("ptcache.bake", text="Bake").bake = True
 
         sub = col.row()
         sub.enabled = (cache.frames_skipped or cache.is_outdated) and enabled
-        sub.operator("ptcache.bake", text=_("Calculate To Frame")).bake = False
+        sub.operator("ptcache.bake", text="Calculate To Frame").bake = False
 
         sub = col.column()
         sub.enabled = enabled
-        sub.operator("ptcache.bake_from_cache", text=_("Current Cache to Bake"))
+        sub.operator("ptcache.bake_from_cache", text="Current Cache to Bake")
 
         col = split.column()
-        col.operator("ptcache.bake_all", text=_("Bake All Dynamics")).bake = True
-        col.operator("ptcache.free_bake_all", text=_("Free All Bakes"))
-        col.operator("ptcache.bake_all", text=_("Update All To Frame")).bake = False
+        col.operator("ptcache.bake_all", text="Bake All Dynamics").bake = True
+        col.operator("ptcache.free_bake_all", text="Free All Bakes")
+        col.operator("ptcache.bake_all", text="Update All To Frame").bake = False
 
 
 def effector_weights_ui(self, context, weights):
@@ -216,7 +215,7 @@ def basic_force_field_settings_ui(self, context, field):
     col = split.column()
 
     if field.type == 'DRAG':
-        col.prop(field, "linear_drag", text=_("Linear"))
+        col.prop(field, "linear_drag", text="Linear")
     else:
         col.prop(field, "strength")
 
@@ -224,12 +223,12 @@ def basic_force_field_settings_ui(self, context, field):
         col.prop(field, "size")
         col.prop(field, "flow")
     elif field.type == 'HARMONIC':
-        col.prop(field, "harmonic_damping", text=_("Damping"))
+        col.prop(field, "harmonic_damping", text="Damping")
         col.prop(field, "rest_length")
     elif field.type == 'VORTEX' and field.shape != 'POINT':
         col.prop(field, "inflow")
     elif field.type == 'DRAG':
-        col.prop(field, "quadratic_drag", text=_("Quadratic"))
+        col.prop(field, "quadratic_drag", text="Quadratic")
     else:
         col.prop(field, "flow")
 
@@ -238,19 +237,19 @@ def basic_force_field_settings_ui(self, context, field):
     sub.prop(field, "noise")
     sub.prop(field, "seed")
     if field.type == 'TURBULENCE':
-        col.prop(field, "use_global_coords", text=_("Global"))
+        col.prop(field, "use_global_coords", text="Global")
     elif field.type == 'HARMONIC':
         col.prop(field, "use_multiple_springs")
 
     split = layout.split()
 
     col = split.column()
-    col.label(text=_("Effect point:"))
+    col.label(text="Effect point:")
     col.prop(field, "apply_to_location")
     col.prop(field, "apply_to_rotation")
 
     col = split.column()
-    col.label(text=_("Collision:"))
+    col.label(text="Collision:")
     col.prop(field, "use_absorption")
 
 
@@ -266,7 +265,7 @@ def basic_force_field_falloff_ui(self, context, field):
     col.prop(field, "z_direction", text="")
 
     col = split.column()
-    col.prop(field, "falloff_power", text=_("Power"))
+    col.prop(field, "falloff_power", text="Power")
 
     split = layout.split()
     col = split.column()
@@ -274,14 +273,14 @@ def basic_force_field_falloff_ui(self, context, field):
     row.prop(field, "use_min_distance", text="")
     sub = row.row()
     sub.active = field.use_min_distance
-    sub.prop(field, "distance_min", text=_("Minimum"))
+    sub.prop(field, "distance_min", text="Minimum")
 
     col = split.column()
     row = col.row(align=True)
     row.prop(field, "use_max_distance", text="")
     sub = row.row()
     sub.active = field.use_max_distance
-    sub.prop(field, "distance_max", text=_("Maximum"))
+    sub.prop(field, "distance_max", text="Maximum")
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/properties_physics_field.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     basic_force_field_settings_ui,
@@ -54,13 +53,13 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
         field = ob.field
 
         split = layout.split(percentage=0.2)
-        split.label(text=_("Type:"))
+        split.label(text="Type:")
 
         split.prop(field, "type", text="")
 
         if field.type not in {'NONE', 'GUIDE', 'TEXTURE'}:
             split = layout.split(percentage=0.2)
-            split.label(text=_("Shape:"))
+            split.label(text="Shape:")
             split.prop(field, "shape", text="")
 
         split = layout.split()
@@ -76,7 +75,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
             col.prop(field, "use_guide_path_weight")
 
             col = split.column()
-            col.label(text=_("Clumping:"))
+            col.label(text="Clumping:")
             col.prop(field, "guide_clump_amount")
             col.prop(field, "guide_clump_shape")
 
@@ -117,7 +116,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
 
         if field.type not in {'NONE', 'GUIDE'}:
 
-            layout.label(text=_("Falloff:"))
+            layout.label(text="Falloff:")
             layout.prop(field, "falloff_type", expand=True)
 
             basic_force_field_falloff_ui(self, context, field)
@@ -128,20 +127,20 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
                 split = layout.split(percentage=0.35)
 
                 col = split.column()
-                col.label(text=_("Angular:"))
-                col.prop(field, "use_radial_min", text=_("Use Minimum"))
-                col.prop(field, "use_radial_max", text=_("Use Maximum"))
+                col.label(text="Angular:")
+                col.prop(field, "use_radial_min", text="Use Minimum")
+                col.prop(field, "use_radial_max", text="Use Maximum")
 
                 col = split.column()
-                col.prop(field, "radial_falloff", text=_("Power"))
+                col.prop(field, "radial_falloff", text="Power")
 
                 sub = col.column()
                 sub.active = field.use_radial_min
-                sub.prop(field, "radial_min", text=_("Angle"))
+                sub.prop(field, "radial_min", text="Angle")
 
                 sub = col.column()
                 sub.active = field.use_radial_max
-                sub.prop(field, "radial_max", text=_("Angle"))
+                sub.prop(field, "radial_max", text="Angle")
 
             elif field.falloff_type == 'TUBE':
                 layout.separator()
@@ -149,20 +148,20 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
                 split = layout.split(percentage=0.35)
 
                 col = split.column()
-                col.label(text=_("Radial:"))
-                col.prop(field, "use_radial_min", text=_("Use Minimum"))
-                col.prop(field, "use_radial_max", text=_("Use Maximum"))
+                col.label(text="Radial:")
+                col.prop(field, "use_radial_min", text="Use Minimum")
+                col.prop(field, "use_radial_max", text="Use Maximum")
 
                 col = split.column()
-                col.prop(field, "radial_falloff", text=_("Power"))
+                col.prop(field, "radial_falloff", text="Power")
 
                 sub = col.column()
                 sub.active = field.use_radial_min
-                sub.prop(field, "radial_min", text=_("Distance"))
+                sub.prop(field, "radial_min", text="Distance")
 
                 sub = col.column()
                 sub.active = field.use_radial_max
-                sub.prop(field, "radial_max", text=_("Distance"))
+                sub.prop(field, "radial_max", text="Distance")
 
 
 class PHYSICS_PT_collision(PhysicButtonsPanel, Panel):
@@ -192,31 +191,31 @@ class PHYSICS_PT_collision(PhysicButtonsPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("Particle:"))
+            col.label(text="Particle:")
             col.prop(settings, "permeability", slider=True)
             col.prop(settings, "stickness")
             col.prop(settings, "use_particle_kill")
-            col.label(text=_("Particle Damping:"))
+            col.label(text="Particle Damping:")
             sub = col.column(align=True)
-            sub.prop(settings, "damping_factor", text=_("Factor"), slider=True)
-            sub.prop(settings, "damping_random", text=_("Random"), slider=True)
+            sub.prop(settings, "damping_factor", text="Factor", slider=True)
+            sub.prop(settings, "damping_random", text="Random", slider=True)
 
-            col.label(text=_("Particle Friction:"))
+            col.label(text="Particle Friction:")
             sub = col.column(align=True)
-            sub.prop(settings, "friction_factor", text=_("Factor"), slider=True)
-            sub.prop(settings, "friction_random", text=_("Random"), slider=True)
+            sub.prop(settings, "friction_factor", text="Factor", slider=True)
+            sub.prop(settings, "friction_random", text="Random", slider=True)
 
             col = split.column()
-            col.label(text=_("Soft Body and Cloth:"))
+            col.label(text="Soft Body and Cloth:")
             sub = col.column(align=True)
-            sub.prop(settings, "thickness_outer", text=_("Outer"), slider=True)
-            sub.prop(settings, "thickness_inner", text=_("Inner"), slider=True)
+            sub.prop(settings, "thickness_outer", text="Outer", slider=True)
+            sub.prop(settings, "thickness_inner", text="Inner", slider=True)
 
-            col.label(text=_("Soft Body Damping:"))
-            col.prop(settings, "damping", text=_("Factor"), slider=True)
+            col.label(text="Soft Body Damping:")
+            col.prop(settings, "damping", text="Factor", slider=True)
 
-            col.label(text=_("Force Fields:"))
-            col.prop(settings, "absorption", text=_("Absorption"))
+            col.label(text="Force Fields:")
+            col.prop(settings, "absorption", text="Absorption")
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/properties_physics_fluid.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 
 class PhysicButtonsPanel():
@@ -47,7 +46,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
 
             row = layout.row()
             if fluid is None:
-                row.label(_("Built without fluids"))
+                row.label("Built without fluids")
                 return
 
             row.prop(fluid, "type")
@@ -59,28 +58,28 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 layout.active = fluid.use
 
             if fluid.type == 'DOMAIN':
-                layout.operator("fluid.bake", text=_("Bake (Req. Memory:") + " %s)" % fluid.memory_estimate, icon='MOD_FLUIDSIM')
+                layout.operator("fluid.bake", text="Bake (Req. Memory:" + " %s)" % fluid.memory_estimate, icon='MOD_FLUIDSIM')
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Resolution:"))
-                col.prop(fluid, "resolution", text=_("Final"))
-                col.label(text=_("Render Display:"))
+                col.label(text="Resolution:")
+                col.prop(fluid, "resolution", text="Final")
+                col.label(text="Render Display:")
                 col.prop(fluid, "render_display_mode", text="")
 
                 col = split.column()
                 col.label()
-                col.prop(fluid, "preview_resolution", text=_("Preview"))
-                col.label(text=_("Viewport Display:"))
+                col.prop(fluid, "preview_resolution", text="Preview")
+                col.label(text="Viewport Display:")
                 col.prop(fluid, "viewport_display_mode", text="")
 
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Time:"))
+                col.label(text="Time:")
                 sub = col.column(align=True)
-                sub.prop(fluid, "start_time", text=_("Start"))
-                sub.prop(fluid, "end_time", text=_("End"))
+                sub.prop(fluid, "start_time", text="Start")
+                sub.prop(fluid, "end_time", text="End")
 
                 col = split.column()
                 col.label()
@@ -93,36 +92,36 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Volume Initialization:"))
+                col.label(text="Volume Initialization:")
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
 
                 col = split.column()
-                col.label(text=_("Initial Velocity:"))
+                col.label(text="Initial Velocity:")
                 col.prop(fluid, "initial_velocity", text="")
 
             elif fluid.type == 'OBSTACLE':
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Volume Initialization:"))
+                col.label(text="Volume Initialization:")
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
 
                 col = split.column()
-                col.label(text=_("Slip Type:"))
+                col.label(text="Slip Type:")
                 col.prop(fluid, "slip_type", text="")
                 if fluid.slip_type == 'PARTIALSLIP':
-                    col.prop(fluid, "partial_slip_factor", slider=True, text=_("Amount"))
+                    col.prop(fluid, "partial_slip_factor", slider=True, text="Amount")
 
-                col.label(text=_("Impact:"))
-                col.prop(fluid, "impact_factor", text=_("Factor"))
+                col.label(text="Impact:")
+                col.prop(fluid, "impact_factor", text="Factor")
 
             elif fluid.type == 'INFLOW':
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Volume Initialization:"))
+                col.label(text="Volume Initialization:")
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
                 row = col.row()
@@ -130,14 +129,14 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 row.prop(fluid, "use_local_coords")
 
                 col = split.column()
-                col.label(text=_("Inflow Velocity:"))
+                col.label(text="Inflow Velocity:")
                 col.prop(fluid, "inflow_velocity", text="")
 
             elif fluid.type == 'OUTFLOW':
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Volume Initialization:"))
+                col.label(text="Volume Initialization:")
                 col.prop(fluid, "volume_initialization", text="")
                 col.prop(fluid, "use_animated_mesh")
 
@@ -147,12 +146,12 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Influence:"))
-                col.prop(fluid, "particle_influence", text=_("Size"))
-                col.prop(fluid, "alpha_influence", text=_("Alpha"))
+                col.label(text="Influence:")
+                col.prop(fluid, "particle_influence", text="Size")
+                col.prop(fluid, "alpha_influence", text="Alpha")
 
                 col = split.column()
-                col.label(text=_("Type:"))
+                col.label(text="Type:")
                 col.prop(fluid, "use_drops")
                 col.prop(fluid, "use_floats")
                 col.prop(fluid, "show_tracer")
@@ -168,24 +167,24 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, Panel):
                 col.prop(fluid, "use_reverse_frames")
 
                 col = split.column()
-                col.label(text=_("Time:"))
+                col.label(text="Time:")
                 sub = col.column(align=True)
-                sub.prop(fluid, "start_time", text=_("Start"))
-                sub.prop(fluid, "end_time", text=_("End"))
+                sub.prop(fluid, "start_time", text="Start")
+                sub.prop(fluid, "end_time", text="End")
 
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Attraction Force:"))
+                col.label(text="Attraction Force:")
                 sub = col.column(align=True)
-                sub.prop(fluid, "attraction_strength", text=_("Strength"))
-                sub.prop(fluid, "attraction_radius", text=_("Radius"))
+                sub.prop(fluid, "attraction_strength", text="Strength")
+                sub.prop(fluid, "attraction_radius", text="Radius")
 
                 col = split.column()
-                col.label(text=_("Velocity Force:"))
+                col.label(text="Velocity Force:")
                 sub = col.column(align=True)
-                sub.prop(fluid, "velocity_strength", text=_("Strength"))
-                sub.prop(fluid, "velocity_radius", text=_("Radius"))
+                sub.prop(fluid, "velocity_strength", text="Strength")
+                sub.prop(fluid, "velocity_radius", text="Radius")
 
 
 class PHYSICS_PT_domain_gravity(PhysicButtonsPanel, Panel):
@@ -207,33 +206,33 @@ class PHYSICS_PT_domain_gravity(PhysicButtonsPanel, Panel):
 
         col = split.column()
         if scene.use_gravity:
-            col.label(text=_("Using Scene Gravity"), icon="SCENE_DATA")
+            col.label(text="Using Scene Gravity", icon="SCENE_DATA")
             sub = col.column()
             sub.enabled = False
             sub.prop(fluid, "gravity", text="")
         else:
-            col.label(text=_("Gravity:"))
+            col.label(text="Gravity:")
             col.prop(fluid, "gravity", text="")
 
         if scene.unit_settings.system != 'NONE':
-            col.label(text=_("Using Scene Size Units"), icon="SCENE_DATA")
+            col.label(text="Using Scene Size Units", icon="SCENE_DATA")
             sub = col.column()
             sub.enabled = False
-            sub.prop(fluid, "simulation_scale", text=_("Metres"))
+            sub.prop(fluid, "simulation_scale", text="Metres")
         else:
-            col.label(text=_("Real World Size:"))
-            col.prop(fluid, "simulation_scale", text=_("Metres"))
+            col.label(text="Real World Size:")
+            col.prop(fluid, "simulation_scale", text="Metres")
 
         col = split.column()
-        col.label(text=_("Viscosity Presets:"))
+        col.label(text="Viscosity Presets:")
         sub = col.column(align=True)
         sub.prop(fluid, "viscosity_preset", text="")
 
         if fluid.viscosity_preset == 'MANUAL':
-            sub.prop(fluid, "viscosity_base", text=_("Base"))
-            sub.prop(fluid, "viscosity_exponent", text=_("Exponent"), slider=True)
+            sub.prop(fluid, "viscosity_base", text="Base")
+            sub.prop(fluid, "viscosity_exponent", text="Exponent", slider=True)
 
-        col.label(text=_("Optimization:"))
+        col.label(text="Optimization:")
         col.prop(fluid, "grid_levels", slider=True)
         col.prop(fluid, "compressibility", slider=True)
 
@@ -255,16 +254,16 @@ class PHYSICS_PT_domain_boundary(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Slip Type:"))
+        col.label(text="Slip Type:")
         col.prop(fluid, "slip_type", text="")
         if fluid.slip_type == 'PARTIALSLIP':
-            col.prop(fluid, "partial_slip_factor", slider=True, text=_("Amount"))
+            col.prop(fluid, "partial_slip_factor", slider=True, text="Amount")
         col.prop(fluid, "surface_noobs")
 
         col = split.column()
-        col.label(text=_("Surface:"))
-        col.prop(fluid, "surface_smooth", text=_("Smoothing"))
-        col.prop(fluid, "surface_subdivisions", text=_("Subdivisions"))
+        col.label(text="Surface:")
+        col.prop(fluid, "surface_smooth", text="Smoothing")
+        col.prop(fluid, "surface_subdivisions", text="Subdivisions")
 
 
 class PHYSICS_PT_domain_particles(PhysicButtonsPanel, Panel):

release/scripts/startup/bl_ui/properties_physics_smoke.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -59,23 +58,23 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
                 split.enabled = not domain.point_cache.is_baked
 
                 col = split.column()
-                col.label(text=_("Resolution:"))
-                col.prop(domain, "resolution_max", text=_("Divisions"))
-                col.label(text=_("Time:"))
-                col.prop(domain, "time_scale", text=_("Scale"))
-                col.label(text=_("Border Collisions:"))
+                col.label(text="Resolution:")
+                col.prop(domain, "resolution_max", text="Divisions")
+                col.label(text="Time:")
+                col.prop(domain, "time_scale", text="Scale")
+                col.label(text="Border Collisions:")
                 col.prop(domain, "collision_extents", text="")
 
                 col = split.column()
-                col.label(text=_("Behavior:"))
+                col.label(text="Behavior:")
                 col.prop(domain, "alpha")
-                col.prop(domain, "beta", text=_("Temp. Diff."))
+                col.prop(domain, "beta", text="Temp. Diff.")
                 col.prop(domain, "vorticity")
-                col.prop(domain, "use_dissolve_smoke", text=_("Dissolve"))
+                col.prop(domain, "use_dissolve_smoke", text="Dissolve")
                 sub = col.column()
                 sub.active = domain.use_dissolve_smoke
-                sub.prop(domain, "dissolve_speed", text=_("Time"))
-                sub.prop(domain, "use_dissolve_smoke_log", text_("Slow"))
+                sub.prop(domain, "dissolve_speed", text="Time")
+                sub.prop(domain, "use_dissolve_smoke_log", text="Slow")
 
             elif md.smoke_type == 'FLOW':
 
@@ -85,20 +84,20 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
 
                 col = split.column()
                 col.prop(flow, "use_outflow")
-                col.label(text=_("Particle System:"))
+                col.label(text="Particle System:")
                 col.prop_search(flow, "particle_system", ob, "particle_systems", text="")
 
                 sub = col.column()
                 sub.active = not md.flow_settings.use_outflow
 
-                sub.prop(flow, "initial_velocity", text=_("Initial Velocity"))
+                sub.prop(flow, "initial_velocity", text="Initial Velocity")
                 sub = sub.column()
                 sub.active = flow.initial_velocity
-                sub.prop(flow, "velocity_factor", text=_("Multiplier"))
+                sub.prop(flow, "velocity_factor", text="Multiplier")
 
                 sub = split.column()
                 sub.active = not md.flow_settings.use_outflow
-                sub.label(text=_("Initial Values:"))
+                sub.label(text="Initial Values:")
                 sub.prop(flow, "use_absolute")
                 sub.prop(flow, "density")
                 sub.prop(flow, "temperature")
@@ -121,14 +120,14 @@ class PHYSICS_PT_smoke_groups(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Flow Group:"))
+        col.label(text="Flow Group:")
         col.prop(group, "fluid_group", text="")
 
-        #col.label(text=_("Effector Group:"))
+        #col.label(text="Effector Group:")
         #col.prop(group, "effector_group", text="")
 
         col = split.column()
-        col.label(text=_("Collision Group:"))
+        col.label(text="Collision Group:")
         col.prop(group, "collision_group", text="")
 
 
@@ -157,12 +156,12 @@ class PHYSICS_PT_smoke_highres(PhysicButtonsPanel, Panel):
         split.enabled = not md.point_cache.is_baked
 
         col = split.column()
-        col.label(text=_("Resolution:"))
-        col.prop(md, "amplify", text=_("Divisions"))
+        col.label(text="Resolution:")
+        col.prop(md, "amplify", text="Divisions")
         col.prop(md, "smooth_emitter")
 
         col = split.column()
-        col.label(text=_("Noise Method:"))
+        col.label(text="Noise Method:")
         col.row().prop(md, "noise_type", text="")
         col.prop(md, "strength")
 
@@ -184,7 +183,7 @@ class PHYSICS_PT_smoke_cache(PhysicButtonsPanel, Panel):
         md = context.smoke.domain_settings
         cache = md.point_cache
 
-        layout.label(text=_("Compression:"))
+        layout.label(text="Compression:")
         layout.prop(md, "point_cache_compress_type", expand=True)
 
         point_cache_ui(self, context, cache, (cache.is_baked is False), 'SMOKE')

release/scripts/startup/bl_ui/properties_physics_softbody.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Panel
-from blf import gettext as _
 
 from bl_ui.properties_physics_common import (
     point_cache_ui,
@@ -62,13 +61,13 @@ class PHYSICS_PT_softbody(PhysicButtonsPanel, Panel):
             split.enabled = softbody_panel_enabled(md)
 
             col = split.column()
-            col.label(text=_("Object:"))
+            col.label(text="Object:")
             col.prop(softbody, "friction")
             col.prop(softbody, "mass")
-            col.prop_search(softbody, "vertex_group_mass", ob, "vertex_groups", text=_("Mass:"))
+            col.prop_search(softbody, "vertex_group_mass", ob, "vertex_groups", text="Mass:")
 
             col = split.column()
-            col.label(text=_("Simulation:"))
+            col.label(text="Simulation:")
             col.prop(softbody, "speed")
 
 
@@ -114,18 +113,18 @@ class PHYSICS_PT_softbody_goal(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Goal Strengths:"))
-        col.prop(softbody, "goal_default", text=_("Default"))
+        col.label(text="Goal Strengths:")
+        col.prop(softbody, "goal_default", text="Default")
         sub = col.column(align=True)
-        sub.prop(softbody, "goal_min", text=_("Minimum"))
-        sub.prop(softbody, "goal_max", text=_("Maximum"))
+        sub.prop(softbody, "goal_min", text="Minimum")
+        sub.prop(softbody, "goal_max", text="Maximum")
 
         col = split.column()
-        col.label(text=_("Goal Settings:"))
-        col.prop(softbody, "goal_spring", text=_("Stiffness"))
-        col.prop(softbody, "goal_friction", text=_("Damping"))
+        col.label(text="Goal Settings:")
+        col.prop(softbody, "goal_spring", text="Stiffness")
+        col.prop(softbody, "goal_friction", text="Damping")
 
-        layout.prop_search(softbody, "vertex_group_goal", ob, "vertex_groups", text=_("Vertex Group"))
+        layout.prop_search(softbody, "vertex_group_goal", ob, "vertex_groups", text="Vertex Group")
 
 
 class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
@@ -154,14 +153,14 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Springs:"))
+        col.label(text="Springs:")
         col.prop(softbody, "pull")
         col.prop(softbody, "push")
         col.prop(softbody, "damping")
         col.prop(softbody, "plastic")
         col.prop(softbody, "bend")
-        col.prop(softbody, "spring_length", text=_("Length"))
-        col.prop_search(softbody, "vertex_group_spring", ob, "vertex_groups", text=_("Springs:"))
+        col.prop(softbody, "spring_length", text="Length")
+        col.prop_search(softbody, "vertex_group_spring", ob, "vertex_groups", text="Springs:")
 
         col = split.column()
         col.prop(softbody, "use_stiff_quads")
@@ -169,16 +168,16 @@ class PHYSICS_PT_softbody_edge(PhysicButtonsPanel, Panel):
         sub.active = softbody.use_stiff_quads
         sub.prop(softbody, "shear")
 
-        col.label(text=_("Aerodynamics:"))
+        col.label(text="Aerodynamics:")
         col.row().prop(softbody, "aerodynamics_type", expand=True)
-        col.prop(softbody, "aero", text=_("Factor"))
+        col.prop(softbody, "aero", text="Factor")
 
         #sub = col.column()
         #sub.enabled = softbody.aero > 0
 
-        col.label(text=_("Collision:"))
-        col.prop(softbody, "use_edge_collision", text=_("Edge"))
-        col.prop(softbody, "use_face_collision", text=_("Face"))
+        col.label(text="Collision:")
+        col.prop(softbody, "use_edge_collision", text="Edge")
+        col.prop(softbody, "use_face_collision", text="Face")
 
 
 class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
@@ -203,14 +202,14 @@ class PHYSICS_PT_softbody_collision(PhysicButtonsPanel, Panel):
 
         layout.active = softbody.use_self_collision and softbody_panel_enabled(md)
 
-        layout.label(text=_("Collision Ball Size Calculation:"))
+        layout.label(text="Collision Ball Size Calculation:")
         layout.prop(softbody, "collision_type", expand=True)
 
         col = layout.column(align=True)
-        col.label(text=_("Ball:"))
-        col.prop(softbody, "ball_size", text=_("Size"))
-        col.prop(softbody, "ball_stiff", text=_("Stiffness"))
-        col.prop(softbody, "ball_damp", text=_("Dampening"))
+        col.label(text="Ball:")
+        col.prop(softbody, "ball_size", text="Size")
+        col.prop(softbody, "ball_stiff", text="Stiffness")
+        col.prop(softbody, "ball_damp", text="Dampening")
 
 
 class PHYSICS_PT_softbody_solver(PhysicButtonsPanel, Panel):
@@ -233,18 +232,18 @@ class PHYSICS_PT_softbody_solver(PhysicButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column(align=True)
-        col.label(text=_("Step Size:"))
+        col.label(text="Step Size:")
         col.prop(softbody, "step_min")
         col.prop(softbody, "step_max")
-        col.prop(softbody, "use_auto_step", text=_("Auto-Step"))
+        col.prop(softbody, "use_auto_step", text="Auto-Step")
 
         col = split.column()
         col.prop(softbody, "error_threshold")
-        col.label(text=_("Helpers:"))
+        col.label(text="Helpers:")
         col.prop(softbody, "choke")
         col.prop(softbody, "fuzzy")
 
-        layout.label(text=_("Diagnostics:"))
+        layout.label(text="Diagnostics:")
         layout.prop(softbody, "use_diagnose")
         layout.prop(softbody, "use_estimate_matrix")
 

release/scripts/startup/bl_ui/properties_render.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Menu, Panel
-from blf import gettext as _
 
 
 class RENDER_MT_presets(Menu):
@@ -65,10 +64,10 @@ class RENDER_PT_render(RenderButtonsPanel, Panel):
         rd = context.scene.render
 
         row = layout.row()
-        row.operator("render.render", text=_("Image"), icon='RENDER_STILL')
-        row.operator("render.render", text=_("Animation"), icon='RENDER_ANIMATION').animation = True
+        row.operator("render.render", text="Image", icon='RENDER_STILL')
+        row.operator("render.render", text="Animation", icon='RENDER_ANIMATION').animation = True
 
-        layout.prop(rd, "display_mode", text=_("Display"))
+        layout.prop(rd, "display_mode", text="Display")
 
 
 class RENDER_PT_layers(RenderButtonsPanel, Panel):
@@ -98,25 +97,25 @@ class RENDER_PT_layers(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(scene, "layers", text=_("Scene"))
+        col.prop(scene, "layers", text="Scene")
         col.label(text="")
-        col.prop(rl, "light_override", text=_("Light"))
-        col.prop(rl, "material_override", text=_("Material"))
+        col.prop(rl, "light_override", text="Light")
+        col.prop(rl, "material_override", text="Material")
 
         col = split.column()
-        col.prop(rl, "layers", text=_("Layer"))
-        col.label(text=_("Mask Layers:"))
+        col.prop(rl, "layers", text="Layer")
+        col.label(text="Mask Layers:")
         col.prop(rl, "layers_zmask", text="")
 
         layout.separator()
-        layout.label(text=_("Include:"))
+        layout.label(text="Include:")
 
         split = layout.split()
 
         col = split.column()
         col.prop(rl, "use_zmask")
         row = col.row()
-        row.prop(rl, "invert_zmask", text=_("Negate"))
+        row.prop(rl, "invert_zmask", text="Negate")
         row.active = rl.use_zmask
         col.prop(rl, "use_all_z")
 
@@ -136,7 +135,7 @@ class RENDER_PT_layers(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Passes:"))
+        col.label(text="Passes:")
         col.prop(rl, "use_pass_combined")
         col.prop(rl, "use_pass_z")
         col.prop(rl, "use_pass_vector")
@@ -624,29 +623,29 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text=_("Resolution:"))
+        sub.label(text="Resolution:")
         sub.prop(rd, "resolution_x", text="X")
         sub.prop(rd, "resolution_y", text="Y")
         sub.prop(rd, "resolution_percentage", text="")
 
-        sub.label(text=_("Aspect Ratio:"))
+        sub.label(text="Aspect Ratio:")
         sub.prop(rd, "pixel_aspect_x", text="X")
         sub.prop(rd, "pixel_aspect_y", text="Y")
 
         row = col.row()
-        row.prop(rd, "use_border", text=_("Border"))
+        row.prop(rd, "use_border", text="Border")
         sub = row.row()
         sub.active = rd.use_border
-        sub.prop(rd, "use_crop_to_border", text=_("Crop"))
+        sub.prop(rd, "use_crop_to_border", text="Crop")
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text=_("Frame Range:"))
+        sub.label(text="Frame Range:")
         sub.prop(scene, "frame_start")
         sub.prop(scene, "frame_end")
         sub.prop(scene, "frame_step")
 
-        sub.label(text=_("Frame Rate:"))
+        sub.label(text="Frame Rate:")
         if rd.fps_base == 1:
             fps_rate = round(rd.fps / rd.fps_base)
         else:
@@ -656,7 +655,7 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
         custom_framerate = (fps_rate not in {23.98, 24, 25, 29.97, 30, 50, 59.94, 60})
 
         if custom_framerate == True:
-            fps_label_text = _("Custom (") + str(fps_rate) + " fps)"
+            fps_label_text = "Custom (" + str(fps_rate) + " fps)"
         else:
             fps_label_text = str(fps_rate) + " fps"
 
@@ -666,10 +665,10 @@ class RENDER_PT_dimensions(RenderButtonsPanel, Panel):
             sub.prop(rd, "fps")
             sub.prop(rd, "fps_base", text="/")
         subrow = sub.row(align=True)
-        subrow.label(text=_("Time Remapping:"))
+        subrow.label(text="Time Remapping:")
         subrow = sub.row(align=True)
-        subrow.prop(rd, "frame_map_old", text=_("Old"))
-        subrow.prop(rd, "frame_map_new", text=_("New"))
+        subrow.prop(rd, "frame_map_old", text="Old")
+        subrow.prop(rd, "frame_map_new", text="New")
 
 
 class RENDER_PT_antialiasing(RenderButtonsPanel, Panel):
@@ -697,7 +696,7 @@ class RENDER_PT_antialiasing(RenderButtonsPanel, Panel):
 
         col = split.column()
         col.prop(rd, "pixel_filter_type", text="")
-        col.prop(rd, "filter_size", text=_("Size"))
+        col.prop(rd, "filter_size", text="Size")
 
 
 class RENDER_PT_motion_blur(RenderButtonsPanel, Panel):
@@ -739,15 +738,15 @@ class RENDER_PT_shading(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "use_textures", text=_("Textures"))
-        col.prop(rd, "use_shadows", text=_("Shadows"))
-        col.prop(rd, "use_sss", text=_("Subsurface Scattering"))
-        col.prop(rd, "use_envmaps", text=_("Environment Map"))
+        col.prop(rd, "use_textures", text="Textures")
+        col.prop(rd, "use_shadows", text="Shadows")
+        col.prop(rd, "use_sss", text="Subsurface Scattering")
+        col.prop(rd, "use_envmaps", text="Environment Map")
 
         col = split.column()
-        col.prop(rd, "use_raytrace", text=_("Ray Tracing"))
+        col.prop(rd, "use_raytrace", text="Ray Tracing")
         col.prop(rd, "use_color_management")
-        col.prop(rd, "alpha_mode", text=_("Alpha"))
+        col.prop(rd, "alpha_mode", text="Alpha")
 
 
 class RENDER_PT_performance(RenderButtonsPanel, Panel):
@@ -763,18 +762,18 @@ class RENDER_PT_performance(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Threads:"))
+        col.label(text="Threads:")
         col.row().prop(rd, "threads_mode", expand=True)
         sub = col.column()
         sub.enabled = rd.threads_mode == 'FIXED'
         sub.prop(rd, "threads")
         sub = col.column(align=True)
-        sub.label(text=_("Tiles:"))
+        sub.label(text="Tiles:")
         sub.prop(rd, "parts_x", text="X")
         sub.prop(rd, "parts_y", text="Y")
 
         col = split.column()
-        col.label(text=_("Memory:"))
+        col.label(text="Memory:")
         sub = col.column()
         sub.enabled = not (rd.use_border or rd.use_full_sample)
         sub.prop(rd, "use_save_buffers")
@@ -784,13 +783,13 @@ class RENDER_PT_performance(RenderButtonsPanel, Panel):
         sub.prop(rd, "use_free_unused_nodes")
         sub = col.column()
         sub.active = rd.use_raytrace
-        sub.label(text=_("Acceleration structure:"))
+        sub.label(text="Acceleration structure:")
         sub.prop(rd, "raytrace_method", text="")
         if rd.raytrace_method == 'OCTREE':
-            sub.prop(rd, "octree_resolution", text=_("Resolution"))
+            sub.prop(rd, "octree_resolution", text="Resolution")
         else:
-            sub.prop(rd, "use_instances", text=_("Instances"))
-        sub.prop(rd, "use_local_coords", text=_("Local Coordinates"))
+            sub.prop(rd, "use_instances", text="Instances")
+        sub.prop(rd, "use_local_coords", text="Local Coordinates")
 
 
 class RENDER_PT_post_processing(RenderButtonsPanel, Panel):
@@ -809,24 +808,24 @@ class RENDER_PT_post_processing(RenderButtonsPanel, Panel):
         col.prop(rd, "use_compositing")
         col.prop(rd, "use_sequencer")
 
-        split.prop(rd, "dither_intensity", text=_("Dither"), slider=True)
+        split.prop(rd, "dither_intensity", text="Dither", slider=True)
 
         layout.separator()
 
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "use_fields", text=_("Fields"))
+        col.prop(rd, "use_fields", text="Fields")
         sub = col.column()
         sub.active = rd.use_fields
         sub.row().prop(rd, "field_order", expand=True)
-        sub.prop(rd, "use_fields_still", text=_("Still"))
+        sub.prop(rd, "use_fields_still", text="Still")
 
         col = split.column()
         col.prop(rd, "use_edge_enhance")
         sub = col.column()
         sub.active = rd.use_edge_enhance
-        sub.prop(rd, "edge_threshold", text=_("Threshold"), slider=True)
+        sub.prop(rd, "edge_threshold", text="Threshold", slider=True)
         sub.prop(rd, "edge_color", text="")
 
         layout.separator()
@@ -855,26 +854,26 @@ class RENDER_PT_stamp(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "use_stamp_time", text=_("Time"))
-        col.prop(rd, "use_stamp_date", text=_("Date"))
-        col.prop(rd, "use_stamp_render_time", text=_("RenderTime"))
-        col.prop(rd, "use_stamp_frame", text=_("Frame"))
-        col.prop(rd, "use_stamp_scene", text=_("Scene"))
-        col.prop(rd, "use_stamp_camera", text=_("Camera"))
-        col.prop(rd, "use_stamp_lens", text=_("Lens"))
-        col.prop(rd, "use_stamp_filename", text=_("Filename"))
-        col.prop(rd, "use_stamp_marker", text=_("Marker"))
-        col.prop(rd, "use_stamp_sequencer_strip", text=_("Seq. Strip"))
+        col.prop(rd, "use_stamp_time", text="Time")
+        col.prop(rd, "use_stamp_date", text="Date")
+        col.prop(rd, "use_stamp_render_time", text="RenderTime")
+        col.prop(rd, "use_stamp_frame", text="Frame")
+        col.prop(rd, "use_stamp_scene", text="Scene")
+        col.prop(rd, "use_stamp_camera", text="Camera")
+        col.prop(rd, "use_stamp_lens", text="Lens")
+        col.prop(rd, "use_stamp_filename", text="Filename")
+        col.prop(rd, "use_stamp_marker", text="Marker")
+        col.prop(rd, "use_stamp_sequencer_strip", text="Seq. Strip")
 
         col = split.column()
         col.active = rd.use_stamp
         col.prop(rd, "stamp_foreground", slider=True)
         col.prop(rd, "stamp_background", slider=True)
         col.separator()
-        col.prop(rd, "stamp_font_size", text=_("Font Size"))
+        col.prop(rd, "stamp_font_size", text="Font Size")
 
         row = layout.split(percentage=0.2)
-        row.prop(rd, "use_stamp_note", text=_("Note"))
+        row.prop(rd, "use_stamp_note", text="Note")
         sub = row.row()
         sub.active = rd.use_stamp_note
         sub.prop(rd, "stamp_note_text", text="")
@@ -896,7 +895,7 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
 
         col = split.column()
         col.prop(rd, "file_format", text="")
-        col.row().prop(rd, "color_mode", text=_("Color"), expand=True)
+        col.row().prop(rd, "color_mode", text="Color", expand=True)
 
         col = split.column()
         col.prop(rd, "use_file_extension")
@@ -907,11 +906,11 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
             layout.prop(rd, "file_quality", slider=True)
 
         if file_format == 'PNG':
-            layout.prop(rd, "file_quality", slider=True, text=_("Compression"))
+            layout.prop(rd, "file_quality", slider=True, text="Compression")
 
         if file_format in {'OPEN_EXR', 'MULTILAYER'}:
             row = layout.row()
-            row.prop(rd, "exr_codec", text=_("Codec"))
+            row.prop(rd, "exr_codec", text="Codec")
 
             if file_format == 'OPEN_EXR':
                 row = layout.row()
@@ -922,7 +921,7 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
         elif file_format == 'JPEG2000':
             split = layout.split()
             col = split.column()
-            col.label(text=_("Depth:"))
+            col.label(text="Depth:")
             col.row().prop(rd, "jpeg2k_depth", expand=True)
 
             col = split.column()
@@ -935,13 +934,13 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
             split.label("FIXME: hard coded Non-Linear, Gamma:1.0")
             '''
             col = split.column()
-            col.prop(rd, "use_cineon_log", text=_("Convert to Log"))
+            col.prop(rd, "use_cineon_log", text="Convert to Log")
 
             col = split.column(align=True)
             col.active = rd.use_cineon_log
-            col.prop(rd, "cineon_black", text=_("Black"))
-            col.prop(rd, "cineon_white", text=_("White"))
-            col.prop(rd, "cineon_gamma", text=_("Gamma"))
+            col.prop(rd, "cineon_black", text="Black")
+            col.prop(rd, "cineon_white", text="White")
+            col.prop(rd, "cineon_gamma", text="Gamma")
             '''
 
         elif file_format == 'TIFF':
@@ -953,11 +952,11 @@ class RENDER_PT_output(RenderButtonsPanel, Panel):
         elif file_format == 'QUICKTIME_QTKIT':
             split = layout.split()
             col = split.column()
-            col.prop(rd, "quicktime_codec_type", text=_("Video Codec"))
-            col.prop(rd, "quicktime_codec_spatial_quality", text=_("Quality"))
+            col.prop(rd, "quicktime_codec_type", text="Video Codec")
+            col.prop(rd, "quicktime_codec_spatial_quality", text="Quality")
 
             # Audio
-            col.prop(rd, "quicktime_audiocodec_type", text=_("Audio Codec"))
+            col.prop(rd, "quicktime_audiocodec_type", text="Audio Codec")
             if rd.quicktime_audiocodec_type != 'No audio':
                 split = layout.split()
                 if rd.quicktime_audiocodec_type == 'LPCM':
@@ -995,7 +994,7 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
 
         rd = context.scene.render
 
-        layout.menu("RENDER_MT_ffmpeg_presets", text=_("Presets"))
+        layout.menu("RENDER_MT_ffmpeg_presets", text="Presets")
 
         split = layout.split()
         split.prop(rd, "ffmpeg_format")
@@ -1011,22 +1010,22 @@ class RENDER_PT_encoding(RenderButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Rate:"))
-        col.prop(rd, "ffmpeg_minrate", text=_("Minimum"))
-        col.prop(rd, "ffmpeg_maxrate", text=_("Maximum"))
-        col.prop(rd, "ffmpeg_buffersize", text=_("Buffer"))
+        col.label(text="Rate:")
+        col.prop(rd, "ffmpeg_minrate", text="Minimum")
+        col.prop(rd, "ffmpeg_maxrate", text="Maximum")
+        col.prop(rd, "ffmpeg_buffersize", text="Buffer")
 
         col = split.column()
         col.prop(rd, "ffmpeg_autosplit")
-        col.label(text=_("Mux:"))
-        col.prop(rd, "ffmpeg_muxrate", text=_("Rate"))
-        col.prop(rd, "ffmpeg_packetsize", text=_("Packet Size"))
+        col.label(text="Mux:")
+        col.prop(rd, "ffmpeg_muxrate", text="Rate")
+        col.prop(rd, "ffmpeg_packetsize", text="Packet Size")
 
         layout.separator()
 
         # Audio:
         if rd.ffmpeg_format not in {'MP3'}:
-            layout.prop(rd, "ffmpeg_audio_codec", text=_("Audio Codec"))
+            layout.prop(rd, "ffmpeg_audio_codec", text="Audio Codec")
 
         row = layout.row()
         row.prop(rd, "ffmpeg_audio_bitrate")
@@ -1068,7 +1067,7 @@ class RENDER_PT_bake(RenderButtonsPanel, Panel):
             col = split.column()
             col.prop(rd, "use_bake_clear")
             col.prop(rd, "bake_margin")
-            col.prop(rd, "bake_quad_split", text=_("Split"))
+            col.prop(rd, "bake_quad_split", text="Split")
 
             col = split.column()
             col.prop(rd, "use_bake_selected_to_active")

release/scripts/startup/bl_ui/properties_scene.py

@@ -18,9 +18,8 @@
 
 # <pep8 compliant>
 import bpy
-from bpy.types import Operator, Panel
+from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class SceneButtonsPanel():
@@ -42,7 +41,7 @@ class SCENE_PT_scene(SceneButtonsPanel, Panel):
         scene = context.scene
 
         layout.prop(scene, "camera")
-        layout.prop(scene, "background_set", text=_("Background"))
+        layout.prop(scene, "background_set", text="Background")
 
 
 class SCENE_PT_audio(SceneButtonsPanel, Panel):
@@ -60,15 +59,15 @@ class SCENE_PT_audio(SceneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(_("Listener:"))
+        col.label("Listener:")
         col.prop(scene, "audio_distance_model", text="")
-        col.prop(scene, "audio_doppler_speed", text=_("Speed"))
-        col.prop(scene, "audio_doppler_factor", text=_("Doppler"))
+        col.prop(scene, "audio_doppler_speed", text="Speed")
+        col.prop(scene, "audio_doppler_factor", text="Doppler")
 
         col = split.column()
-        col.label(_("Format:"))
+        col.label("Format:")
         col.prop(rd, "ffmpeg_audio_channels", text="")
-        col.prop(rd, "ffmpeg_audio_mixrate", text=_("Rate"))
+        col.prop(rd, "ffmpeg_audio_mixrate", text="Rate")
 
         layout.operator("sound.mixdown")
 
@@ -87,7 +86,7 @@ class SCENE_PT_unit(SceneButtonsPanel, Panel):
 
         row = layout.row()
         row.active = (unit.system != 'NONE')
-        row.prop(unit, "scale_length", text=_("Scale"))
+        row.prop(unit, "scale_length", text="Scale")
         row.prop(unit, "use_separate")
 
 
@@ -116,11 +115,11 @@ class SCENE_PT_keying_sets(SceneButtonsPanel, Panel):
 
             subcol = col.column()
             subcol.operator_context = 'INVOKE_DEFAULT'
-            op = subcol.operator("anim.keying_set_export", text=_("Export to File"))
+            op = subcol.operator("anim.keying_set_export", text="Export to File")
             op.filepath = "keyingset.py"
 
             col = row.column()
-            col.label(text=_("Keyframing Settings:"))
+            col.label(text="Keyframing Settings:")
             col.prop(ks, "bl_options")
 
 
@@ -139,7 +138,7 @@ class SCENE_PT_keying_set_paths(SceneButtonsPanel, Panel):
         ks = scene.keying_sets.active
 
         row = layout.row()
-        row.label(text=_("Paths:"))
+        row.label(text="Paths:")
 
         row = layout.row()
 
@@ -153,20 +152,20 @@ class SCENE_PT_keying_set_paths(SceneButtonsPanel, Panel):
         ksp = ks.paths.active
         if ksp:
             col = layout.column()
-            col.label(text=_("Target:"))
+            col.label(text="Target:")
             col.template_any_ID(ksp, "id", "id_type")
             col.template_path_builder(ksp, "data_path", ksp.id)
 
             row = layout.row()
 
             col = row.column()
-            col.label(text=_("Array Target:"))
+            col.label(text="Array Target:")
             col.prop(ksp, "use_entire_array")
             if ksp.use_entire_array is False:
                 col.prop(ksp, "array_index")
 
             col = row.column()
-            col.label(text=_("F-Curve Grouping:"))
+            col.label(text="F-Curve Grouping:")
             col.prop(ksp, "group_method")
             if ksp.group_method == 'NAMED':
                 col.prop(ksp, "group")
@@ -210,14 +209,14 @@ class SCENE_PT_simplify(SceneButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(rd, "simplify_subdivision", text=_("Subdivision"))
-        col.prop(rd, "simplify_child_particles", text=_("Child Particles"))
+        col.prop(rd, "simplify_subdivision", text="Subdivision")
+        col.prop(rd, "simplify_child_particles", text="Child Particles")
 
         col.prop(rd, "use_simplify_triangulate")
 
         col = split.column()
-        col.prop(rd, "simplify_shadow_samples", text=_("Shadow Samples"))
-        col.prop(rd, "simplify_ao_sss", text=_("AO and SSS"))
+        col.prop(rd, "simplify_shadow_samples", text="Shadow Samples")
+        col.prop(rd, "simplify_ao_sss", text="AO and SSS")
 
 
 class SCENE_PT_custom_props(SceneButtonsPanel, PropertyPanel, Panel):
@@ -225,112 +224,5 @@ class SCENE_PT_custom_props(SceneButtonsPanel, PropertyPanel, Panel):
     _context_path = "scene"
     _property_type = bpy.types.Scene
 
-#  XXX, move operator to op/ dir
-
-
-class ANIM_OT_keying_set_export(Operator):
-    "Export Keying Set to a python script"
-    bl_idname = "anim.keying_set_export"
-    bl_label = "Export Keying Set..."
-
-    filepath = bpy.props.StringProperty(name="File Path", description="Filepath to write file to")
-    filter_folder = bpy.props.BoolProperty(name="Filter folders", description="", default=True, options={'HIDDEN'})
-    filter_text = bpy.props.BoolProperty(name="Filter text", description="", default=True, options={'HIDDEN'})
-    filter_python = bpy.props.BoolProperty(name="Filter python", description="", default=True, options={'HIDDEN'})
-
-    def execute(self, context):
-        if not self.filepath:
-            raise Exception("Filepath not set")
-
-        f = open(self.filepath, "w")
-        if not f:
-            raise Exception("Could not open file")
-
-        scene = context.scene
-        ks = scene.keying_sets.active
-
-        f.write("# Keying Set: %s\n" % ks.name)
-
-        f.write("import bpy\n\n")
-        f.write("scene= bpy.data.scenes[0]\n\n")  # XXX, why not use the current scene?
-
-        # Add KeyingSet and set general settings
-        f.write("# Keying Set Level declarations\n")
-        f.write("ks= scene.keying_sets.new(name=\"%s\")\n" % ks.name)
-
-        if not ks.is_path_absolute:
-            f.write("ks.is_path_absolute = False\n")
-        f.write("\n")
-
-        f.write("ks.bl_options = %r\n" % ks.bl_options)
-        f.write("\n")
-
-        # generate and write set of lookups for id's used in paths
-        id_to_paths_cache = {}  # cache for syncing ID-blocks to bpy paths + shorthands
-
-        for ksp in ks.paths:
-            if ksp.id is None:
-                continue
-            if ksp.id in id_to_paths_cache:
-                continue
-
-            # - idtype_list is used to get the list of id-datablocks from bpy.data.*
-            #   since this info isn't available elsewhere
-            # - id.bl_rna.name gives a name suitable for UI,
-            #   with a capitalised first letter, but we need
-            #   the plural form that's all lower case
-            idtype_list = ksp.id.bl_rna.name.lower() + "s"
-            id_bpy_path = "bpy.data.%s[\"%s\"]" % (idtype_list, ksp.id.name)
-
-            # shorthand ID for the ID-block (as used in the script)
-            short_id = "id_%d" % len(id_to_paths_cache)
-
-            # store this in the cache now
-            id_to_paths_cache[ksp.id] = [short_id, id_bpy_path]
-
-        f.write("# ID's that are commonly used\n")
-        for id_pair in id_to_paths_cache.values():
-            f.write("%s = %s\n" % (id_pair[0], id_pair[1]))
-        f.write("\n")
-
-        # write paths
-        f.write("# Path Definitions\n")
-        for ksp in ks.paths:
-            f.write("ksp = ks.paths.add(")
-
-            # id-block + data_path
-            if ksp.id:
-                # find the relevant shorthand from the cache
-                id_bpy_path = id_to_paths_cache[ksp.id][0]
-            else:
-                id_bpy_path = "None"  # XXX...
-            f.write("%s, '%s'" % (id_bpy_path, ksp.data_path))
-
-            # array index settings (if applicable)
-            if ksp.use_entire_array:
-                f.write(", index=-1")
-            else:
-                f.write(", index=%d" % ksp.array_index)
-
-            # grouping settings (if applicable)
-            # NOTE: the current default is KEYINGSET, but if this changes, change this code too
-            if ksp.group_method == 'NAMED':
-                f.write(", group_method='%s', group_name=\"%s\"" % (ksp.group_method, ksp.group))
-            elif ksp.group_method != 'KEYINGSET':
-                f.write(", group_method='%s'" % ksp.group_method)
-
-            # finish off
-            f.write(")\n")
-
-        f.write("\n")
-        f.close()
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        wm.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/properties_texture.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Menu, Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class TEXTURE_MT_specials(Menu):
@@ -144,11 +143,11 @@ class TEXTURE_PT_context_texture(TextureButtonsPanel, Panel):
             if tex.use_nodes:
 
                 if slot:
-                    split.label(text=_("Output:"))
+                    split.label(text="Output:")
                     split.prop(slot, "output_node", text="")
 
             else:
-                split.label(text=_("Type:"))
+                split.label(text="Type:")
                 split.prop(tex, "type", text="")
 
 
@@ -179,21 +178,21 @@ class TEXTURE_PT_colors(TextureButtonsPanel, Panel):
 
         tex = context.texture
 
-        layout.prop(tex, "use_color_ramp", text=_("Ramp"))
+        layout.prop(tex, "use_color_ramp", text="Ramp")
         if tex.use_color_ramp:
             layout.template_color_ramp(tex, "color_ramp", expand=True)
 
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("RGB Multiply:"))
+        col.label(text="RGB Multiply:")
         sub = col.column(align=True)
         sub.prop(tex, "factor_red", text="R")
         sub.prop(tex, "factor_green", text="G")
         sub.prop(tex, "factor_blue", text="B")
 
         col = split.column()
-        col.label(text=_("Adjust:"))
+        col.label(text="Adjust:")
         col.prop(tex, "intensity")
         col.prop(tex, "contrast")
         col.prop(tex, "saturation")
@@ -236,17 +235,17 @@ class TEXTURE_PT_clouds(TextureTypePanel, Panel):
         tex = context.texture
 
         layout.prop(tex, "cloud_type", expand=True)
-        layout.label(text=_("Noise:"))
-        layout.prop(tex, "noise_type", text=_("Type"), expand=True)
-        layout.prop(tex, "noise_basis", text=_("Basis"))
+        layout.label(text="Noise:")
+        layout.prop(tex, "noise_type", text="Type", expand=True)
+        layout.prop(tex, "noise_basis", text="Basis")
 
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "noise_scale", text=_("Size"))
-        col.prop(tex, "noise_depth", text=_("Depth"))
+        col.prop(tex, "noise_scale", text="Size")
+        col.prop(tex, "noise_depth", text="Depth")
 
-        split.prop(tex, "nabla", text=_("Nabla"))
+        split.prop(tex, "nabla", text="Nabla")
 
 
 class TEXTURE_PT_wood(TextureTypePanel, Panel):
@@ -264,15 +263,15 @@ class TEXTURE_PT_wood(TextureTypePanel, Panel):
 
         col = layout.column()
         col.active = tex.wood_type in {'RINGNOISE', 'BANDNOISE'}
-        col.label(text=_("Noise:"))
-        col.row().prop(tex, "noise_type", text=_("Type"), expand=True)
-        layout.prop(tex, "noise_basis", text=_("Basis"))
+        col.label(text="Noise:")
+        col.row().prop(tex, "noise_type", text="Type", expand=True)
+        layout.prop(tex, "noise_basis", text="Basis")
 
         split = layout.split()
         split.active = tex.wood_type in {'RINGNOISE', 'BANDNOISE'}
 
         col = split.column()
-        col.prop(tex, "noise_scale", text=_("Size"))
+        col.prop(tex, "noise_scale", text="Size")
         col.prop(tex, "turbulence")
 
         split.prop(tex, "nabla")
@@ -290,15 +289,15 @@ class TEXTURE_PT_marble(TextureTypePanel, Panel):
 
         layout.prop(tex, "marble_type", expand=True)
         layout.prop(tex, "noise_basis_2", expand=True)
-        layout.label(text=_("Noise:"))
-        layout.prop(tex, "noise_type", text=_("Type"), expand=True)
-        layout.prop(tex, "noise_basis", text=_("Basis"))
+        layout.label(text="Noise:")
+        layout.prop(tex, "noise_type", text="Type", expand=True)
+        layout.prop(tex, "noise_basis", text="Basis")
 
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "noise_scale", text=_("Size"))
-        col.prop(tex, "noise_depth", text=_("Depth"))
+        col.prop(tex, "noise_scale", text="Size")
+        col.prop(tex, "noise_depth", text="Depth")
 
         col = split.column()
         col.prop(tex, "turbulence")
@@ -316,7 +315,7 @@ class TEXTURE_PT_magic(TextureTypePanel, Panel):
         tex = context.texture
 
         row = layout.row()
-        row.prop(tex, "noise_depth", text=_("Depth"))
+        row.prop(tex, "noise_depth", text="Depth")
         row.prop(tex, "turbulence")
 
 
@@ -349,12 +348,12 @@ class TEXTURE_PT_stucci(TextureTypePanel, Panel):
         tex = context.texture
 
         layout.prop(tex, "stucci_type", expand=True)
-        layout.label(text=_("Noise:"))
-        layout.prop(tex, "noise_type", text=_("Type"), expand=True)
-        layout.prop(tex, "noise_basis", text=_("Basis"))
+        layout.label(text="Noise:")
+        layout.prop(tex, "noise_type", text="Type", expand=True)
+        layout.prop(tex, "noise_basis", text="Basis")
 
         row = layout.row()
-        row.prop(tex, "noise_scale", text=_("Size"))
+        row.prop(tex, "noise_scale", text="Size")
         row.prop(tex, "turbulence")
 
 
@@ -372,13 +371,13 @@ class TEXTURE_PT_image(TextureTypePanel, Panel):
 
 
 def texture_filter_common(tex, layout):
-    layout.label(text=_("Filter:"))
+    layout.label(text="Filter:")
     layout.prop(tex, "filter_type", text="")
     if tex.use_mipmap and tex.filter_type in {'AREA', 'EWA', 'FELINE'}:
         if tex.filter_type == 'FELINE':
-            layout.prop(tex, "filter_probes", text=_("Probes"))
+            layout.prop(tex, "filter_probes", text="Probes")
         else:
-            layout.prop(tex, "filter_eccentricity", text=_("Eccentricity"))
+            layout.prop(tex, "filter_eccentricity", text="Eccentricity")
 
     layout.prop(tex, "filter_size")
     layout.prop(tex, "use_filter_size_min")
@@ -400,12 +399,12 @@ class TEXTURE_PT_image_sampling(TextureTypePanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Alpha:"))
-        col.prop(tex, "use_alpha", text=_("Use"))
-        col.prop(tex, "use_calculate_alpha", text=_("Calculate"))
-        col.prop(tex, "invert_alpha", text=_("Invert"))
+        col.label(text="Alpha:")
+        col.prop(tex, "use_alpha", text="Use")
+        col.prop(tex, "use_calculate_alpha", text="Calculate")
+        col.prop(tex, "invert_alpha", text="Invert")
         col.separator()
-        col.prop(tex, "use_flip_axis", text=_("Flip X/Y Axis"))
+        col.prop(tex, "use_flip_axis", text="Flip X/Y Axis")
 
         col = split.column()
 
@@ -446,12 +445,12 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, Panel):
 
         if tex.extension == 'REPEAT':
             col = split.column(align=True)
-            col.label(text=_("Repeat:"))
+            col.label(text="Repeat:")
             col.prop(tex, "repeat_x", text="X")
             col.prop(tex, "repeat_y", text="Y")
 
             col = split.column(align=True)
-            col.label(text=_("Mirror:"))
+            col.label(text="Mirror:")
             row = col.row()
             row.prop(tex, "use_mirror_x", text="X")
             row.active = (tex.repeat_x > 1)
@@ -463,11 +462,11 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, Panel):
         elif tex.extension == 'CHECKER':
             col = split.column(align=True)
             row = col.row()
-            row.prop(tex, "use_checker_even", text=_("Even"))
-            row.prop(tex, "use_checker_odd", text=_("Odd"))
+            row.prop(tex, "use_checker_even", text="Even")
+            row.prop(tex, "use_checker_odd", text="Odd")
 
             col = split.column()
-            col.prop(tex, "checker_distance", text=_("Distance"))
+            col.prop(tex, "checker_distance", text="Distance")
 
             layout.separator()
 
@@ -475,12 +474,12 @@ class TEXTURE_PT_image_mapping(TextureTypePanel, Panel):
 
         col = split.column(align=True)
         #col.prop(tex, "crop_rectangle")
-        col.label(text=_("Crop Minimum:"))
+        col.label(text="Crop Minimum:")
         col.prop(tex, "crop_min_x", text="X")
         col.prop(tex, "crop_min_y", text="Y")
 
         col = split.column(align=True)
-        col.label(text=_("Crop Maximum:"))
+        col.label(text="Crop Maximum:")
         col.prop(tex, "crop_max_x", text="X")
         col.prop(tex, "crop_max_y", text="Y")
 
@@ -518,9 +517,9 @@ class TEXTURE_PT_envmap(TextureTypePanel, Panel):
 
             col = split.column(align=True)
 
-            col.label(text=_("Clipping:"))
-            col.prop(env, "clip_start", text=_("Start"))
-            col.prop(env, "clip_end", text=_("End"))
+            col.label(text="Clipping:")
+            col.prop(env, "clip_start", text="Start")
+            col.prop(env, "clip_end", text="End")
 
 
 class TEXTURE_PT_envmap_sampling(TextureTypePanel, Panel):
@@ -552,7 +551,7 @@ class TEXTURE_PT_musgrave(TextureTypePanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "dimension_max", text=_("Dimension"))
+        col.prop(tex, "dimension_max", text="Dimension")
         col.prop(tex, "lacunarity")
         col.prop(tex, "octaves")
 
@@ -561,16 +560,16 @@ class TEXTURE_PT_musgrave(TextureTypePanel, Panel):
         if musgrave_type in {'HETERO_TERRAIN', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL'}:
             col.prop(tex, "offset")
         if musgrave_type in {'MULTIFRACTAL', 'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL'}:
-            col.prop(tex, "noise_intensity", text=_("Intensity"))
+            col.prop(tex, "noise_intensity", text="Intensity")
         if musgrave_type in {'RIDGED_MULTIFRACTAL', 'HYBRID_MULTIFRACTAL'}:
             col.prop(tex, "gain")
 
-        layout.label(text=_("Noise:"))
+        layout.label(text="Noise:")
 
-        layout.prop(tex, "noise_basis", text=_("Basis"))
+        layout.prop(tex, "noise_basis", text="Basis")
 
         row = layout.row()
-        row.prop(tex, "noise_scale", text=_("Size"))
+        row.prop(tex, "noise_scale", text="Size")
         row.prop(tex, "nabla")
 
 
@@ -587,26 +586,26 @@ class TEXTURE_PT_voronoi(TextureTypePanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Distance Metric:"))
+        col.label(text="Distance Metric:")
         col.prop(tex, "distance_metric", text="")
         sub = col.column()
         sub.active = tex.distance_metric == 'MINKOVSKY'
-        sub.prop(tex, "minkovsky_exponent", text=_("Exponent"))
-        col.label(text=_("Coloring:"))
+        sub.prop(tex, "minkovsky_exponent", text="Exponent")
+        col.label(text="Coloring:")
         col.prop(tex, "color_mode", text="")
-        col.prop(tex, "noise_intensity", text=_("Intensity"))
+        col.prop(tex, "noise_intensity", text="Intensity")
 
         col = split.column()
         sub = col.column(align=True)
-        sub.label(text=_("Feature Weights:"))
+        sub.label(text="Feature Weights:")
         sub.prop(tex, "weight_1", text="1", slider=True)
         sub.prop(tex, "weight_2", text="2", slider=True)
         sub.prop(tex, "weight_3", text="3", slider=True)
         sub.prop(tex, "weight_4", text="4", slider=True)
 
-        layout.label(text=_("Noise:"))
+        layout.label(text="Noise:")
         row = layout.row()
-        row.prop(tex, "noise_scale", text=_("Size"))
+        row.prop(tex, "noise_scale", text="Size")
         row.prop(tex, "nabla")
 
 
@@ -621,13 +620,13 @@ class TEXTURE_PT_distortednoise(TextureTypePanel, Panel):
         tex = context.texture
 
         layout.prop(tex, "noise_distortion")
-        layout.prop(tex, "noise_basis", text=_("Basis"))
+        layout.prop(tex, "noise_basis", text="Basis")
 
         split = layout.split()
 
         col = split.column()
-        col.prop(tex, "distortion", text=_("Distortion"))
-        col.prop(tex, "noise_scale", text=_("Size"))
+        col.prop(tex, "distortion", text="Distortion")
+        col.prop(tex, "noise_scale", text="Size")
 
         split.prop(tex, "nabla")
 
@@ -694,26 +693,26 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, Panel):
 
         col = split.column()
         if pd.point_source == 'PARTICLE_SYSTEM':
-            col.label(text=_("Object:"))
+            col.label(text="Object:")
             col.prop(pd, "object", text="")
 
             sub = col.column()
             sub.enabled = bool(pd.object)
             if pd.object:
-                sub.label(text=_("System:"))
+                sub.label(text="System:")
                 sub.prop_search(pd, "particle_system", pd.object, "particle_systems", text="")
-            sub.label(text=_("Cache:"))
+            sub.label(text="Cache:")
             sub.prop(pd, "particle_cache_space", text="")
         else:
-            col.label(text=_("Object:"))
+            col.label(text="Object:")
             col.prop(pd, "object", text="")
-            col.label(text=_("Cache:"))
+            col.label(text="Cache:")
             col.prop(pd, "vertex_cache_space", text="")
 
         col.separator()
 
         if pd.point_source == 'PARTICLE_SYSTEM':
-            col.label(text=_("Color Source:"))
+            col.label(text="Color Source:")
             col.prop(pd, "color_source", text="")
             if pd.color_source in {'PARTICLE_SPEED', 'PARTICLE_VELOCITY'}:
                 col.prop(pd, "speed_scale")
@@ -723,7 +722,7 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, Panel):
         col = split.column()
         col.label()
         col.prop(pd, "radius")
-        col.label(text=_("Falloff:"))
+        col.label(text="Falloff:")
         col.prop(pd, "falloff", text="")
         if pd.falloff == 'SOFT':
             col.prop(pd, "falloff_soft")
@@ -734,7 +733,7 @@ class TEXTURE_PT_pointdensity(TextureButtonsPanel, Panel):
 
         if pd.use_falloff_curve:
             col = layout.column()
-            col.label(text=_("Falloff Curve"))
+            col.label(text="Falloff Curve")
             col.template_curve_mapping(pd, "falloff_curve", brush=False)
 
 
@@ -763,9 +762,9 @@ class TEXTURE_PT_pointdensity_turbulence(TextureButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Influence:"))
+        col.label(text="Influence:")
         col.prop(pd, "turbulence_influence", text="")
-        col.label(text=_("Noise Basis:"))
+        col.label(text="Noise Basis:")
         col.prop(pd, "noise_basis", text="")
 
         col = split.column()
@@ -802,7 +801,7 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
         if not isinstance(idblock, bpy.types.Brush):
             split = layout.split(percentage=0.3)
             col = split.column()
-            col.label(text=_("Coordinates:"))
+            col.label(text="Coordinates:")
             col = split.column()
             col.prop(tex, "texture_coords", text="")
 
@@ -811,12 +810,12 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
                 ob = context.object
                 if ob and ob.type == 'MESH':
                     split = layout.split(percentage=0.3)
-                    split.label(text=_("Mesh:"))
+                    split.label(text="Mesh:")
                     split.prop(ob.data, "texco_mesh", text="")
                 """
             elif tex.texture_coords == 'UV':
                 split = layout.split(percentage=0.3)
-                split.label(text=_("Layer:"))
+                split.label(text="Layer:")
                 ob = context.object
                 if ob and ob.type == 'MESH':
                     split.prop_search(tex, "uv_layer", ob.data, "uv_textures", text="")
@@ -825,12 +824,12 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
 
             elif tex.texture_coords == 'OBJECT':
                 split = layout.split(percentage=0.3)
-                split.label(text=_("Object:"))
+                split.label(text="Object:")
                 split.prop(tex, "object", text="")
 
         if isinstance(idblock, bpy.types.Brush):
             if context.sculpt_object:
-                layout.label(text=_("Brush Mapping:"))
+                layout.label(text="Brush Mapping:")
                 layout.prop(tex, "map_mode", expand=True)
 
                 row = layout.row()
@@ -839,7 +838,7 @@ class TEXTURE_PT_mapping(TextureSlotPanel, Panel):
         else:
             if isinstance(idblock, bpy.types.Material):
                 split = layout.split(percentage=0.3)
-                split.label(text=_("Projection:"))
+                split.label(text="Projection:")
                 split.prop(tex, "mapping", text="")
 
                 split = layout.split()
@@ -901,111 +900,111 @@ class TEXTURE_PT_influence(TextureSlotPanel, Panel):
                 split = layout.split()
 
                 col = split.column()
-                col.label(text=_("Diffuse:"))
-                factor_but(col, "use_map_diffuse", "diffuse_factor", _("Intensity"))
-                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", _("Color"))
-                factor_but(col, "use_map_alpha", "alpha_factor", _("Alpha"))
-                factor_but(col, "use_map_translucency", "translucency_factor", _("Translucency"))
+                col.label(text="Diffuse:")
+                factor_but(col, "use_map_diffuse", "diffuse_factor", "Intensity")
+                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", "Color")
+                factor_but(col, "use_map_alpha", "alpha_factor", "Alpha")
+                factor_but(col, "use_map_translucency", "translucency_factor", "Translucency")
 
-                col.label(text=_("Specular:"))
-                factor_but(col, "use_map_specular", "specular_factor", _("Intensity"))
-                factor_but(col, "use_map_color_spec", "specular_color_factor", _("Color"))
-                factor_but(col, "use_map_hardness", "hardness_factor", _("Hardness"))
+                col.label(text="Specular:")
+                factor_but(col, "use_map_specular", "specular_factor", "Intensity")
+                factor_but(col, "use_map_color_spec", "specular_color_factor", "Color")
+                factor_but(col, "use_map_hardness", "hardness_factor", "Hardness")
 
                 col = split.column()
-                col.label(text=_("Shading:"))
-                factor_but(col, "use_map_ambient", "ambient_factor", _("Ambient"))
-                factor_but(col, "use_map_emit", "emit_factor", _("Emit"))
-                factor_but(col, "use_map_mirror", "mirror_factor", _("Mirror"))
-                factor_but(col, "use_map_raymir", "raymir_factor", _("Ray Mirror"))
+                col.label(text="Shading:")
+                factor_but(col, "use_map_ambient", "ambient_factor", "Ambient")
+                factor_but(col, "use_map_emit", "emit_factor", "Emit")
+                factor_but(col, "use_map_mirror", "mirror_factor", "Mirror")
+                factor_but(col, "use_map_raymir", "raymir_factor", "Ray Mirror")
 
-                col.label(text=_("Geometry:"))
+                col.label(text="Geometry:")
                 # XXX replace 'or' when displacement is fixed to not rely on normal influence value.
-                sub_tmp = factor_but(col, "use_map_normal", "normal_factor", _("Normal"))
+                sub_tmp = factor_but(col, "use_map_normal", "normal_factor", "Normal")
                 sub_tmp.active = (tex.use_map_normal or tex.use_map_displacement)
                 # END XXX
 
-                factor_but(col, "use_map_warp", "warp_factor", _("Warp"))
-                factor_but(col, "use_map_displacement", "displacement_factor", _("Displace"))
+                factor_but(col, "use_map_warp", "warp_factor", "Warp")
+                factor_but(col, "use_map_displacement", "displacement_factor", "Displace")
 
                 #sub = col.column()
                 #sub.active = tex.use_map_translucency or tex.map_emit or tex.map_alpha or tex.map_raymir or tex.map_hardness or tex.map_ambient or tex.map_specularity or tex.map_reflection or tex.map_mirror
-                #sub.prop(tex, "default_value", text=_("Amount"), slider=True)
+                #sub.prop(tex, "default_value", text="Amount", slider=True)
             elif idblock.type == 'HALO':
-                layout.label(text=_("Halo:"))
+                layout.label(text="Halo:")
 
                 split = layout.split()
 
                 col = split.column()
-                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", _("Color"))
-                factor_but(col, "use_map_alpha", "alpha_factor", _("Alpha"))
+                factor_but(col, "use_map_color_diffuse", "diffuse_color_factor", "Color")
+                factor_but(col, "use_map_alpha", "alpha_factor", "Alpha")
 
                 col = split.column()
-                factor_but(col, "use_map_raymir", "raymir_factor", _("Size"))
-                factor_but(col, "use_map_hardness", "hardness_factor", _("Hardness"))
-                factor_but(col, "use_map_translucency", "translucency_factor", _("Add"))
+                factor_but(col, "use_map_raymir", "raymir_factor", "Size")
+                factor_but(col, "use_map_hardness", "hardness_factor", "Hardness")
+                factor_but(col, "use_map_translucency", "translucency_factor", "Add")
             elif idblock.type == 'VOLUME':
                 split = layout.split()
 
                 col = split.column()
-                factor_but(col, "use_map_density", "density_factor", _("Density"))
-                factor_but(col, "use_map_emission", "emission_factor", _("Emission"))
-                factor_but(col, "use_map_scatter", "scattering_factor", _("Scattering"))
-                factor_but(col, "use_map_reflect", "reflection_factor", _("Reflection"))
+                factor_but(col, "use_map_density", "density_factor", "Density")
+                factor_but(col, "use_map_emission", "emission_factor", "Emission")
+                factor_but(col, "use_map_scatter", "scattering_factor", "Scattering")
+                factor_but(col, "use_map_reflect", "reflection_factor", "Reflection")
 
                 col = split.column()
                 col.label(text=" ")
-                factor_but(col, "use_map_color_emission", "emission_color_factor", _("Emission Color"))
-                factor_but(col, "use_map_color_transmission", "transmission_color_factor", _("Transmission Color"))
-                factor_but(col, "use_map_color_reflection", "reflection_color_factor", _("Reflection Color"))
+                factor_but(col, "use_map_color_emission", "emission_color_factor", "Emission Color")
+                factor_but(col, "use_map_color_transmission", "transmission_color_factor", "Transmission Color")
+                factor_but(col, "use_map_color_reflection", "reflection_color_factor", "Reflection Color")
 
         elif isinstance(idblock, bpy.types.Lamp):
             split = layout.split()
 
             col = split.column()
-            factor_but(col, "use_map_color", "color_factor", _("Color"))
+            factor_but(col, "use_map_color", "color_factor", "Color")
 
             col = split.column()
-            factor_but(col, "use_map_shadow", "shadow_factor", _("Shadow"))
+            factor_but(col, "use_map_shadow", "shadow_factor", "Shadow")
 
         elif isinstance(idblock, bpy.types.World):
             split = layout.split()
 
             col = split.column()
-            factor_but(col, "use_map_blend", "blend_factor", _("Blend"))
-            factor_but(col, "use_map_horizon", "horizon_factor", _("Horizon"))
+            factor_but(col, "use_map_blend", "blend_factor", "Blend")
+            factor_but(col, "use_map_horizon", "horizon_factor", "Horizon")
 
             col = split.column()
-            factor_but(col, "use_map_zenith_up", "zenith_up_factor", _("Zenith Up"))
-            factor_but(col, "use_map_zenith_down", "zenith_down_factor", _("Zenith Down"))
+            factor_but(col, "use_map_zenith_up", "zenith_up_factor", "Zenith Up")
+            factor_but(col, "use_map_zenith_down", "zenith_down_factor", "Zenith Down")
         elif isinstance(idblock, bpy.types.ParticleSettings):
             split = layout.split()
 
             col = split.column()
-            col.label(text=_("General:"))
-            factor_but(col, "use_map_time", "time_factor", _("Time"))
-            factor_but(col, "use_map_life", "life_factor", _("Lifetime"))
-            factor_but(col, "use_map_density", "density_factor", _("Density"))
-            factor_but(col, "use_map_size", "size_factor", _("Size"))
+            col.label(text="General:")
+            factor_but(col, "use_map_time", "time_factor", "Time")
+            factor_but(col, "use_map_life", "life_factor", "Lifetime")
+            factor_but(col, "use_map_density", "density_factor", "Density")
+            factor_but(col, "use_map_size", "size_factor", "Size")
 
             col = split.column()
-            col.label(text=_("Physics:"))
-            factor_but(col, "use_map_velocity", "velocity_factor", _("Velocity"))
-            factor_but(col, "use_map_damp", "damp_factor", _("Damp"))
-            factor_but(col, "use_map_gravity", "gravity_factor", _("Gravity"))
-            factor_but(col, "use_map_field", "field_factor", _("Force Fields"))
+            col.label(text="Physics:")
+            factor_but(col, "use_map_velocity", "velocity_factor", "Velocity")
+            factor_but(col, "use_map_damp", "damp_factor", "Damp")
+            factor_but(col, "use_map_gravity", "gravity_factor", "Gravity")
+            factor_but(col, "use_map_field", "field_factor", "Force Fields")
 
-            layout.label(text=_("Hair:"))
+            layout.label(text="Hair:")
 
             split = layout.split()
 
             col = split.column()
-            factor_but(col, "use_map_length", "length_factor", _("Length"))
-            factor_but(col, "use_map_clump", "clump_factor", _("Clump"))
+            factor_but(col, "use_map_length", "length_factor", "Length")
+            factor_but(col, "use_map_clump", "clump_factor", "Clump")
 
             col = split.column()
-            factor_but(col, "use_map_kink", "kink_factor", _("Kink"))
-            factor_but(col, "use_map_rough", "rough_factor", _("Rough"))
+            factor_but(col, "use_map_kink", "kink_factor", "Kink")
+            factor_but(col, "use_map_rough", "rough_factor", "Rough")
 
         layout.separator()
 
@@ -1013,32 +1012,32 @@ class TEXTURE_PT_influence(TextureSlotPanel, Panel):
             split = layout.split()
 
             col = split.column()
-            col.prop(tex, "blend_type", text=_("Blend"))
+            col.prop(tex, "blend_type", text="Blend")
             col.prop(tex, "use_rgb_to_intensity")
             # color is used on grayscale textures even when use_rgb_to_intensity is disabled.
             col.prop(tex, "color", text="")
 
             col = split.column()
-            col.prop(tex, "invert", text=_("Negative"))
+            col.prop(tex, "invert", text="Negative")
             col.prop(tex, "use_stencil")
 
         if isinstance(idblock, bpy.types.Material) or isinstance(idblock, bpy.types.World):
-            col.prop(tex, "default_value", text=_("DVar"), slider=True)
+            col.prop(tex, "default_value", text="DVar", slider=True)
 
         if isinstance(idblock, bpy.types.Material):
-            layout.label(text=_("Bump Mapping:"))
+            layout.label(text="Bump Mapping:")
 
             # only show bump settings if activated but not for normalmap images
             row = layout.row()
 
             sub = row.row()
             sub.active = (tex.use_map_normal or tex.use_map_warp) and not (tex.texture.type == 'IMAGE' and (tex.texture.use_normal_map or tex.texture.use_derivative_map))
-            sub.prop(tex, "bump_method", text=_("Method"))
+            sub.prop(tex, "bump_method", text="Method")
 
             # the space setting is supported for: derivmaps + bumpmaps (DEFAULT,BEST_QUALITY), not for normalmaps
             sub = row.row()
             sub.active = (tex.use_map_normal or tex.use_map_warp) and not (tex.texture.type == 'IMAGE' and tex.texture.use_normal_map) and ((tex.bump_method in {'BUMP_DEFAULT', 'BUMP_BEST_QUALITY'}) or (tex.texture.type == 'IMAGE' and tex.texture.use_derivative_map))
-            sub.prop(tex, "bump_objectspace", text=_("Space"))
+            sub.prop(tex, "bump_objectspace", text="Space")
 
 
 class TEXTURE_PT_custom_props(TextureButtonsPanel, PropertyPanel, Panel):

release/scripts/startup/bl_ui/properties_world.py

@@ -20,7 +20,6 @@
 import bpy
 from bpy.types import Panel
 from rna_prop_ui import PropertyPanel
-from blf import gettext as _
 
 
 class WorldButtonsPanel():
@@ -116,12 +115,12 @@ class WORLD_PT_ambient_occlusion(WorldButtonsPanel, Panel):
         layout.active = light.use_ambient_occlusion
 
         split = layout.split()
-        split.prop(light, "ao_factor", text=_("Factor"))
+        split.prop(light, "ao_factor", text="Factor")
         split.prop(light, "ao_blend_type", text="")
 
 
 class WORLD_PT_environment_lighting(WorldButtonsPanel, Panel):
-    bl_label = _("Environment Lighting")
+    bl_label = "Environment Lighting"
     COMPAT_ENGINES = {'BLENDER_RENDER'}
 
     def draw_header(self, context):
@@ -135,7 +134,7 @@ class WORLD_PT_environment_lighting(WorldButtonsPanel, Panel):
         layout.active = light.use_environment_light
 
         split = layout.split()
-        split.prop(light, "environment_energy", text=_("Energy"))
+        split.prop(light, "environment_energy", text="Energy")
         split.prop(light, "environment_color", text="")
 
 
@@ -154,11 +153,11 @@ class WORLD_PT_indirect_lighting(WorldButtonsPanel, Panel):
         layout.active = light.use_indirect_light and light.gather_method == 'APPROXIMATE'
 
         split = layout.split()
-        split.prop(light, "indirect_factor", text=_("Factor"))
-        split.prop(light, "indirect_bounces", text=_("Bounces"))
+        split.prop(light, "indirect_factor", text="Factor")
+        split.prop(light, "indirect_bounces", text="Bounces")
 
         if light.gather_method == 'RAYTRACE':
-            layout.label(text=_("Only works with Approximate gather method"))
+            layout.label(text="Only works with Approximate gather method")
 
 
 class WORLD_PT_gather(WorldButtonsPanel, Panel):
@@ -176,18 +175,18 @@ class WORLD_PT_gather(WorldButtonsPanel, Panel):
         split = layout.split()
 
         col = split.column()
-        col.label(text=_("Attenuation:"))
+        col.label(text="Attenuation:")
         if light.gather_method == 'RAYTRACE':
             col.prop(light, "distance")
         col.prop(light, "use_falloff")
         sub = col.row()
         sub.active = light.use_falloff
-        sub.prop(light, "falloff_strength", text=_("Strength"))
+        sub.prop(light, "falloff_strength", text="Strength")
 
         if light.gather_method == 'RAYTRACE':
             col = split.column()
 
-            col.label(text=_("Sampling:"))
+            col.label(text="Sampling:")
             col.prop(light, "sample_method", text="")
 
             sub = col.column()
@@ -202,9 +201,9 @@ class WORLD_PT_gather(WorldButtonsPanel, Panel):
         if light.gather_method == 'APPROXIMATE':
             col = split.column()
 
-            col.label(text=_("Sampling:"))
+            col.label(text="Sampling:")
             col.prop(light, "passes")
-            col.prop(light, "error_threshold", text=_("Error"))
+            col.prop(light, "error_threshold", text="Error")
             col.prop(light, "use_cache")
             col.prop(light, "correction")
 
@@ -258,11 +257,11 @@ class WORLD_PT_stars(WorldButtonsPanel, Panel):
 
         col = split.column()
         col.prop(world.star_settings, "size")
-        col.prop(world.star_settings, "color_random", text=_("Colors"))
+        col.prop(world.star_settings, "color_random", text="Colors")
 
         col = split.column()
-        col.prop(world.star_settings, "distance_min", text=_("Min. Dist"))
-        col.prop(world.star_settings, "average_separation", text=_("Separation"))
+        col.prop(world.star_settings, "distance_min", text="Min. Dist")
+        col.prop(world.star_settings, "average_separation", text="Separation")
 
 
 class WORLD_PT_custom_props(WorldButtonsPanel, PropertyPanel, Panel):

release/scripts/startup/bl_ui/space_console.py

@@ -18,9 +18,7 @@
 
 # <pep8 compliant>
 import bpy
-from bpy.types import Header, Menu, Operator
-from bpy.props import StringProperty
-from blf import gettext as _
+from bpy.types import Header, Menu
 
 
 class CONSOLE_HT_header(Header):
@@ -34,7 +32,7 @@ class CONSOLE_HT_header(Header):
         if context.area.show_menus:
             layout.menu("CONSOLE_MT_console")
 
-        layout.operator("console.autocomplete", text=_("Autocomplete"))
+        layout.operator("console.autocomplete", text="Autocomplete")
 
 
 class CONSOLE_MT_console(Menu):
@@ -80,87 +78,5 @@ def add_scrollback(text, text_type):
         bpy.ops.console.scrollback_append(text=l.replace('\t', '    '),
             type=text_type)
 
-
-class ConsoleExec(Operator):
-    '''Execute the current console line as a python expression'''
-    bl_idname = "console.execute"
-    bl_label = "Console Execute"
-
-    def execute(self, context):
-        sc = context.space_data
-
-        module = __import__("console_" + sc.language)
-        execute = getattr(module, "execute", None)
-
-        if execute:
-            return execute(context)
-        else:
-            print("Error: bpy.ops.console.execute_" + sc.language + " - not found")
-            return {'FINISHED'}
-
-
-class ConsoleAutocomplete(Operator):
-    '''Evaluate the namespace up until the cursor and give a list of options or complete the name if there is only one'''
-    bl_idname = "console.autocomplete"
-    bl_label = "Console Autocomplete"
-
-    def execute(self, context):
-        sc = context.space_data
-        module = __import__("console_" + sc.language)
-        autocomplete = getattr(module, "autocomplete", None)
-
-        if autocomplete:
-            return autocomplete(context)
-        else:
-            print("Error: bpy.ops.console.autocomplete_" + sc.language + " - not found")
-            return {'FINISHED'}
-
-
-class ConsoleBanner(Operator):
-    '''Print a message whem the terminal initializes'''
-    bl_idname = "console.banner"
-    bl_label = "Console Banner"
-
-    def execute(self, context):
-        sc = context.space_data
-
-        # default to python
-        if not sc.language:
-            sc.language = 'python'
-
-        module = __import__("console_" + sc.language)
-        banner = getattr(module, "banner", None)
-
-        if banner:
-            return banner(context)
-        else:
-            print("Error: bpy.ops.console.banner_" + sc.language + " - not found")
-            return {'FINISHED'}
-
-
-class ConsoleLanguage(Operator):
-    '''Set the current language for this console'''
-    bl_idname = "console.language"
-    bl_label = "Console Language"
-
-    language = StringProperty(
-            name="Language",
-            maxlen=32,
-            )
-
-    def execute(self, context):
-        sc = context.space_data
-
-        # defailt to python
-        sc.language = self.language
-
-        bpy.ops.console.banner()
-
-        # insert a new blank line
-        bpy.ops.console.history_append(text="", current_character=0,
-            remove_duplicates=True)
-
-        return {'FINISHED'}
-
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_dopesheet.py

@@ -20,7 +20,6 @@
 
 import bpy
 from bpy.types import Header, Menu
-from blf import gettext as _
 
 
 #######################################
@@ -118,7 +117,7 @@ class DOPESHEET_HT_header(Header):
                 row.menu("DOPESHEET_MT_gpencil_frame")
 
         layout.prop(st, "mode", text="")
-        layout.prop(st.dopesheet, "show_summary", text=_("Summary"))
+        layout.prop(st.dopesheet, "show_summary", text="Summary")
 
         if st.mode == 'DOPESHEET':
             dopesheet_filter(layout, context)
@@ -154,9 +153,9 @@ class DOPESHEET_MT_view(Menu):
         layout.prop(st, "use_marker_sync")
 
         if st.show_seconds:
-            layout.operator("anim.time_toggle", text=_("Show Frames"))
+            layout.operator("anim.time_toggle", text="Show Frames")
         else:
-            layout.operator("anim.time_toggle", text=_("Show Seconds"))
+            layout.operator("anim.time_toggle", text="Show Seconds")
 
         layout.separator()
         layout.operator("anim.previewrange_set")
@@ -181,22 +180,22 @@ class DOPESHEET_MT_select(Menu):
 
         # This is a bit misleading as the operator's default text is "Select All" while it actually *toggles* All/None
         layout.operator("action.select_all_toggle")
-        layout.operator("action.select_all_toggle", text=_("Invert Selection")).invert = True
+        layout.operator("action.select_all_toggle", text="Invert Selection").invert = True
 
         layout.separator()
         layout.operator("action.select_border")
-        layout.operator("action.select_border", text=_("Border Axis Range")).axis_range = True
+        layout.operator("action.select_border", text="Border Axis Range").axis_range = True
 
         layout.separator()
-        layout.operator("action.select_column", text=_("Columns on Selected Keys")).mode = 'KEYS'
-        layout.operator("action.select_column", text=_("Column on Current Frame")).mode = 'CFRA'
+        layout.operator("action.select_column", text="Columns on Selected Keys").mode = 'KEYS'
+        layout.operator("action.select_column", text="Column on Current Frame").mode = 'CFRA'
 
-        layout.operator("action.select_column", text=_("Columns on Selected Markers")).mode = 'MARKERS_COLUMN'
-        layout.operator("action.select_column", text=_("Between Selected Markers")).mode = 'MARKERS_BETWEEN'
+        layout.operator("action.select_column", text="Columns on Selected Markers").mode = 'MARKERS_COLUMN'
+        layout.operator("action.select_column", text="Between Selected Markers").mode = 'MARKERS_BETWEEN'
 
         layout.separator()
-        layout.operator("action.select_leftright", text=_("Before Current Frame")).mode = 'LEFT'
-        layout.operator("action.select_leftright", text=_("After Current Frame")).mode = 'RIGHT'
+        layout.operator("action.select_leftright", text="Before Current Frame").mode = 'LEFT'
+        layout.operator("action.select_leftright", text="After Current Frame").mode = 'RIGHT'
 
         # FIXME: grease pencil mode isn't supported for these yet, so skip for that mode only
         if context.space_data.mode != 'GPENCIL':
@@ -218,14 +217,14 @@ class DOPESHEET_MT_marker(Menu):
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", _("Add Marker"))
-        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
-        layout.operator("marker.delete", text=_("Delete Marker"))
+        layout.operator("marker.add", "Add Marker")
+        layout.operator("marker.duplicate", text="Duplicate Marker")
+        layout.operator("marker.delete", text="Delete Marker")
 
         layout.separator()
 
-        layout.operator("marker.rename", text=_("Rename Marker"))
-        layout.operator("marker.move", text=_("Grab/Move Marker"))
+        layout.operator("marker.rename", text="Rename Marker")
+        layout.operator("marker.move", text="Grab/Move Marker")
 
         if st.mode in {'ACTION', 'SHAPEKEY'} and st.action:
             layout.separator()
@@ -255,14 +254,14 @@ class DOPESHEET_MT_channel(Menu):
 
         layout.separator()
         layout.operator("anim.channels_editable_toggle")
-        layout.operator_menu_enum("action.extrapolation_type", "type", text=_("Extrapolation Mode"))
+        layout.operator_menu_enum("action.extrapolation_type", "type", text="Extrapolation Mode")
 
         layout.separator()
         layout.operator("anim.channels_expand")
         layout.operator("anim.channels_collapse")
 
         layout.separator()
-        layout.operator_menu_enum("anim.channels_move", "direction", text=_("Move..."))
+        layout.operator_menu_enum("anim.channels_move", "direction", text="Move...")
 
         layout.separator()
         layout.operator("anim.channels_fcurves_enable")
@@ -274,10 +273,10 @@ class DOPESHEET_MT_key(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.menu("DOPESHEET_MT_key_transform", text=_("Transform"))
+        layout.menu("DOPESHEET_MT_key_transform", text="Transform")
 
-        layout.operator_menu_enum("action.snap", "type", text=_("Snap"))
-        layout.operator_menu_enum("action.mirror", "type", text=_("Mirror"))
+        layout.operator_menu_enum("action.snap", "type", text="Snap")
+        layout.operator_menu_enum("action.mirror", "type", text="Mirror")
 
         layout.separator()
         layout.operator("action.keyframe_insert")
@@ -287,9 +286,9 @@ class DOPESHEET_MT_key(Menu):
         layout.operator("action.delete")
 
         layout.separator()
-        layout.operator_menu_enum("action.keyframe_type", "type", text=_("Keyframe Type"))
-        layout.operator_menu_enum("action.handle_type", "type", text=_("Handle Type"))
-        layout.operator_menu_enum("action.interpolation_type", "type", text=_("Interpolation Mode"))
+        layout.operator_menu_enum("action.keyframe_type", "type", text="Keyframe Type")
+        layout.operator_menu_enum("action.handle_type", "type", text="Handle Type")
+        layout.operator_menu_enum("action.interpolation_type", "type", text="Interpolation Mode")
 
         layout.separator()
         layout.operator("action.clean")
@@ -306,10 +305,10 @@ class DOPESHEET_MT_key_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.transform", text=_("Grab/Move")).mode = 'TIME_TRANSLATE'
-        layout.operator("transform.transform", text=_("Extend")).mode = 'TIME_EXTEND'
-        layout.operator("transform.transform", text=_("Slide")).mode = 'TIME_SLIDE'
-        layout.operator("transform.transform", text=_("Scale")).mode = 'TIME_SCALE'
+        layout.operator("transform.transform", text="Grab/Move").mode = 'TIME_TRANSLATE'
+        layout.operator("transform.transform", text="Extend").mode = 'TIME_EXTEND'
+        layout.operator("transform.transform", text="Slide").mode = 'TIME_SLIDE'
+        layout.operator("transform.transform", text="Scale").mode = 'TIME_SCALE'
 
 
 #######################################
@@ -348,7 +347,7 @@ class DOPESHEET_MT_gpencil_frame(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.menu("DOPESHEET_MT_key_transform", text=_("Transform"))
+        layout.menu("DOPESHEET_MT_key_transform", text="Transform")
 
         #layout.operator_menu_enum("action.snap", "type", text="Snap")
         #layout.operator_menu_enum("action.mirror", "type", text="Mirror")

release/scripts/startup/bl_ui/space_graph.py

@@ -20,7 +20,6 @@
 
 import bpy
 from bpy.types import Header, Menu
-from blf import gettext as _
 
 
 class GRAPH_HT_header(Header):
@@ -83,9 +82,9 @@ class GRAPH_MT_view(Menu):
 
         layout.separator()
         if st.show_handles:
-            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_HLT', text=_("Show All Handles"))
+            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_HLT', text="Show All Handles")
         else:
-            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_DEHLT', text=_("Show All Handles"))
+            layout.operator("graph.handles_view_toggle", icon='CHECKBOX_DEHLT', text="Show All Handles")
         layout.prop(st, "use_only_selected_curves_handles")
         layout.prop(st, "use_only_selected_keyframe_handles")
         layout.operator("anim.time_toggle")
@@ -113,23 +112,23 @@ class GRAPH_MT_select(Menu):
 
         # This is a bit misleading as the operator's default text is "Select All" while it actually *toggles* All/None
         layout.operator("graph.select_all_toggle")
-        layout.operator("graph.select_all_toggle", text=_("Invert Selection")).invert = True
+        layout.operator("graph.select_all_toggle", text="Invert Selection").invert = True
 
         layout.separator()
         layout.operator("graph.select_border")
-        layout.operator("graph.select_border", text=_("Border Axis Range")).axis_range = True
-        layout.operator("graph.select_border", text=_("Border (Include Handles)")).include_handles = True
+        layout.operator("graph.select_border", text="Border Axis Range").axis_range = True
+        layout.operator("graph.select_border", text="Border (Include Handles)").include_handles = True
 
         layout.separator()
-        layout.operator("graph.select_column", text=_("Columns on Selected Keys")).mode = 'KEYS'
-        layout.operator("graph.select_column", text=_("Column on Current Frame")).mode = 'CFRA'
+        layout.operator("graph.select_column", text="Columns on Selected Keys").mode = 'KEYS'
+        layout.operator("graph.select_column", text="Column on Current Frame").mode = 'CFRA'
 
-        layout.operator("graph.select_column", text=_("Columns on Selected Markers")).mode = 'MARKERS_COLUMN'
-        layout.operator("graph.select_column", text=_("Between Selected Markers")).mode = 'MARKERS_BETWEEN'
+        layout.operator("graph.select_column", text="Columns on Selected Markers").mode = 'MARKERS_COLUMN'
+        layout.operator("graph.select_column", text="Between Selected Markers").mode = 'MARKERS_BETWEEN'
 
         layout.separator()
-        layout.operator("graph.select_leftright", text=_("Before Current Frame")).mode = 'LEFT'
-        layout.operator("graph.select_leftright", text=_("After Current Frame")).mode = 'RIGHT'
+        layout.operator("graph.select_leftright", text="Before Current Frame").mode = 'LEFT'
+        layout.operator("graph.select_leftright", text="After Current Frame").mode = 'RIGHT'
 
         layout.separator()
         layout.operator("graph.select_more")
@@ -147,14 +146,14 @@ class GRAPH_MT_marker(Menu):
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", _("Add Marker"))
-        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
-        layout.operator("marker.delete", text=_("Delete Marker"))
+        layout.operator("marker.add", "Add Marker")
+        layout.operator("marker.duplicate", text="Duplicate Marker")
+        layout.operator("marker.delete", text="Delete Marker")
 
         layout.separator()
 
-        layout.operator("marker.rename", text=_("Rename Marker"))
-        layout.operator("marker.move", text=_("Grab/Move Marker"))
+        layout.operator("marker.rename", text="Rename Marker")
+        layout.operator("marker.move", text="Grab/Move Marker")
 
         # TODO: pose markers for action edit mode only?
 
@@ -177,14 +176,14 @@ class GRAPH_MT_channel(Menu):
         layout.separator()
         layout.operator("anim.channels_editable_toggle")
         layout.operator("anim.channels_visibility_set")
-        layout.operator_menu_enum("graph.extrapolation_type", "type", text=_("Extrapolation Mode"))
+        layout.operator_menu_enum("graph.extrapolation_type", "type", text="Extrapolation Mode")
 
         layout.separator()
         layout.operator("anim.channels_expand")
         layout.operator("anim.channels_collapse")
 
         layout.separator()
-        layout.operator_menu_enum("anim.channels_move", "direction", text=_("Move..."))
+        layout.operator_menu_enum("anim.channels_move", "direction", text="Move...")
 
         layout.separator()
         layout.operator("anim.channels_fcurves_enable")
@@ -196,10 +195,10 @@ class GRAPH_MT_key(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.menu("GRAPH_MT_key_transform", text=_("Transform"))
+        layout.menu("GRAPH_MT_key_transform", text="Transform")
 
-        layout.operator_menu_enum("graph.snap", "type", text=_("Snap"))
-        layout.operator_menu_enum("graph.mirror", "type", text=_("Mirror"))
+        layout.operator_menu_enum("graph.snap", "type", text="Snap")
+        layout.operator_menu_enum("graph.mirror", "type", text="Mirror")
 
         layout.separator()
         layout.operator("graph.keyframe_insert")
@@ -211,8 +210,8 @@ class GRAPH_MT_key(Menu):
         layout.operator("graph.delete")
 
         layout.separator()
-        layout.operator_menu_enum("graph.handle_type", "type", text=_("Handle Type"))
-        layout.operator_menu_enum("graph.interpolation_type", "type", text=_("Interpolation Mode"))
+        layout.operator_menu_enum("graph.handle_type", "type", text="Handle Type")
+        layout.operator_menu_enum("graph.interpolation_type", "type", text="Interpolation Mode")
 
         layout.separator()
         layout.operator("graph.clean")
@@ -225,7 +224,7 @@ class GRAPH_MT_key(Menu):
         layout.operator("graph.paste")
 
         layout.separator()
-        layout.operator("graph.euler_filter", text=_("Discontinuity (Euler) Filter"))
+        layout.operator("graph.euler_filter", text="Discontinuity (Euler) Filter")
 
 
 class GRAPH_MT_key_transform(Menu):
@@ -234,10 +233,10 @@ class GRAPH_MT_key_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.translate", text=_("Grab/Move"))
-        layout.operator("transform.transform", text=_("Extend")).mode = 'TIME_EXTEND'
-        layout.operator("transform.rotate", text=_("Rotate"))
-        layout.operator("transform.resize", text=_("Scale"))
+        layout.operator("transform.translate", text="Grab/Move")
+        layout.operator("transform.transform", text="Extend").mode = 'TIME_EXTEND'
+        layout.operator("transform.rotate", text="Rotate")
+        layout.operator("transform.resize", text="Scale")
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_image.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
-from blf import gettext as _
 
 
 class BrushButtonsPanel():
@@ -65,8 +64,7 @@ class IMAGE_MT_view(Menu):
         ratios = [[1, 8], [1, 4], [1, 2], [1, 1], [2, 1], [4, 1], [8, 1]]
 
         for a, b in ratios:
-            text = _("Zoom") + " %d:%d" % (a, b)
-            layout.operator("image.view_zoom_ratio", text=text).ratio = a / b
+            layout.operator("image.view_zoom_ratio", text="Zoom" + " %d:%d" % (a, b)).ratio = a / b
 
         layout.separator()
 
@@ -93,7 +91,7 @@ class IMAGE_MT_select(Menu):
         layout.separator()
 
         layout.operator("uv.select_all")
-        layout.operator("uv.select_all", text=_("Inverse")).action = 'INVERT'
+        layout.operator("uv.select_all", text="Inverse").action = 'INVERT'
         layout.operator("uv.unlink_selected")
 
         layout.separator()
@@ -123,12 +121,12 @@ class IMAGE_MT_image(Menu):
 
             layout.operator("image.save")
             layout.operator("image.save_as")
-            layout.operator("image.save_as", text=_("Save a Copy")).copy = True
+            layout.operator("image.save_as", text="Save a Copy").copy = True
 
             if ima.source == 'SEQUENCE':
                 layout.operator("image.save_sequence")
 
-            layout.operator("image.external_edit", _("Edit Externally"))
+            layout.operator("image.external_edit", "Edit Externally")
 
             layout.separator()
 
@@ -146,7 +144,7 @@ class IMAGE_MT_image(Menu):
                 # this could be done in operator poll too
                 if ima.is_dirty:
                     if ima.source in {'FILE', 'GENERATED'} and ima.type != 'MULTILAYER':
-                        layout.operator("image.pack", text=_("Pack As PNG")).as_png = True
+                        layout.operator("image.pack", text="Pack As PNG").as_png = True
 
             layout.separator()
 
@@ -159,23 +157,23 @@ class IMAGE_MT_image_invert(Menu):
     def draw(self, context):
         layout = self.layout
 
-        op = layout.operator("image.invert", text=_("Invert Image Colors"))
+        op = layout.operator("image.invert", text="Invert Image Colors")
         op.invert_r = True
         op.invert_g = True
         op.invert_b = True
 
         layout.separator()
 
-        op = layout.operator("image.invert", text=_("Invert Red Channel"))
+        op = layout.operator("image.invert", text="Invert Red Channel")
         op.invert_r = True
 
-        op = layout.operator("image.invert", text=_("Invert Green Channel"))
+        op = layout.operator("image.invert", text="Invert Green Channel")
         op.invert_g = True
 
-        op = layout.operator("image.invert", text=_("Invert Blue Channel"))
+        op = layout.operator("image.invert", text="Invert Blue Channel")
         op.invert_b = True
 
-        op = layout.operator("image.invert", text=_("Invert Alpha Channel"))
+        op = layout.operator("image.invert", text="Invert Alpha Channel")
         op.invert_a = True
 
 
@@ -186,8 +184,8 @@ class IMAGE_MT_uvs_showhide(Menu):
         layout = self.layout
 
         layout.operator("uv.reveal")
-        layout.operator("uv.hide", text=_("Hide Selected"))
-        layout.operator("uv.hide", text=_("Hide Unselected")).unselected = True
+        layout.operator("uv.hide", text="Hide Selected")
+        layout.operator("uv.hide", text="Hide Unselected").unselected = True
 
 
 class IMAGE_MT_uvs_transform(Menu):
@@ -212,14 +210,14 @@ class IMAGE_MT_uvs_snap(Menu):
         layout = self.layout
         layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("uv.snap_selected", text=_("Selected to Pixels")).target = 'PIXELS'
-        layout.operator("uv.snap_selected", text=_("Selected to Cursor")).target = 'CURSOR'
-        layout.operator("uv.snap_selected", text=_("Selected to Adjacent Unselected")).target = 'ADJACENT_UNSELECTED'
+        layout.operator("uv.snap_selected", text="Selected to Pixels").target = 'PIXELS'
+        layout.operator("uv.snap_selected", text="Selected to Cursor").target = 'CURSOR'
+        layout.operator("uv.snap_selected", text="Selected to Adjacent Unselected").target = 'ADJACENT_UNSELECTED'
 
         layout.separator()
 
-        layout.operator("uv.snap_cursor", text=_("Cursor to Pixels")).target = 'PIXELS'
-        layout.operator("uv.snap_cursor", text=_("Cursor to Selected")).target = 'SELECTED'
+        layout.operator("uv.snap_cursor", text="Cursor to Pixels").target = 'PIXELS'
+        layout.operator("uv.snap_cursor", text="Cursor to Selected").target = 'SELECTED'
 
 
 class IMAGE_MT_uvs_mirror(Menu):
@@ -229,8 +227,8 @@ class IMAGE_MT_uvs_mirror(Menu):
         layout = self.layout
         layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("transform.mirror", text=_("X Axis")).constraint_axis[0] = True
-        layout.operator("transform.mirror", text=_("Y Axis")).constraint_axis[1] = True
+        layout.operator("transform.mirror", text="X Axis").constraint_axis[0] = True
+        layout.operator("transform.mirror", text="Y Axis").constraint_axis[1] = True
 
 
 class IMAGE_MT_uvs_weldalign(Menu):
@@ -260,7 +258,7 @@ class IMAGE_MT_uvs(Menu):
 
         layout.prop(uv, "use_live_unwrap")
         layout.operator("uv.unwrap")
-        layout.operator("uv.pin", text=_("Unpin")).clear = True
+        layout.operator("uv.pin", text="Unpin").clear = True
         layout.operator("uv.pin")
 
         layout.separator()
@@ -300,32 +298,32 @@ class IMAGE_MT_uvs_select_mode(Menu):
         # do smart things depending on whether uv_select_sync is on
 
         if toolsettings.use_uv_select_sync:
-            prop = layout.operator("wm.context_set_value", text=_("Vertex"), icon='VERTEXSEL')
+            prop = layout.operator("wm.context_set_value", text="Vertex", icon='VERTEXSEL')
             prop.value = "(True, False, False)"
             prop.data_path = "tool_settings.mesh_select_mode"
 
-            prop = layout.operator("wm.context_set_value", text=_("Edge"), icon='EDGESEL')
+            prop = layout.operator("wm.context_set_value", text="Edge", icon='EDGESEL')
             prop.value = "(False, True, False)"
             prop.data_path = "tool_settings.mesh_select_mode"
 
-            prop = layout.operator("wm.context_set_value", text=_("Face"), icon='FACESEL')
+            prop = layout.operator("wm.context_set_value", text="Face", icon='FACESEL')
             prop.value = "(False, False, True)"
             prop.data_path = "tool_settings.mesh_select_mode"
 
         else:
-            prop = layout.operator("wm.context_set_string", text=_("Vertex"), icon='UV_VERTEXSEL')
+            prop = layout.operator("wm.context_set_string", text="Vertex", icon='UV_VERTEXSEL')
             prop.value = "VERTEX"
             prop.data_path = "tool_settings.uv_select_mode"
 
-            prop = layout.operator("wm.context_set_string", text=_("Edge"), icon='UV_EDGESEL')
+            prop = layout.operator("wm.context_set_string", text="Edge", icon='UV_EDGESEL')
             prop.value = "EDGE"
             prop.data_path = "tool_settings.uv_select_mode"
 
-            prop = layout.operator("wm.context_set_string", text=_("Face"), icon='UV_FACESEL')
+            prop = layout.operator("wm.context_set_string", text="Face", icon='UV_FACESEL')
             prop.value = "FACE"
             prop.data_path = "tool_settings.uv_select_mode"
 
-            prop = layout.operator("wm.context_set_string", text=_("Island"), icon='UV_ISLANDSEL')
+            prop = layout.operator("wm.context_set_string", text="Island", icon='UV_ISLANDSEL')
             prop.value = "ISLAND"
             prop.data_path = "tool_settings.uv_select_mode"
 
@@ -357,9 +355,9 @@ class IMAGE_HT_header(Header):
                 sub.menu("IMAGE_MT_select")
 
             if ima and ima.is_dirty:
-                sub.menu("IMAGE_MT_image", text=_("Image*"))
+                sub.menu("IMAGE_MT_image", text="Image*")
             else:
-                sub.menu("IMAGE_MT_image", text=_("Image"))
+                sub.menu("IMAGE_MT_image", text="Image")
 
             if show_uvedit:
                 sub.menu("IMAGE_MT_uvs")
@@ -597,22 +595,22 @@ class IMAGE_PT_view_properties(Panel):
 
         col = split.column()
         if ima:
-            col.prop(ima, "display_aspect", text=_("Aspect Ratio"))
+            col.prop(ima, "display_aspect", text="Aspect Ratio")
 
             col = split.column()
-            col.label(text=_("Coordinates:"))
-            col.prop(sima, "show_repeat", text=_("Repeat"))
+            col.label(text="Coordinates:")
+            col.prop(sima, "show_repeat", text="Repeat")
             if show_uvedit:
-                col.prop(uvedit, "show_normalized_coords", text=_("Normalized"))
+                col.prop(uvedit, "show_normalized_coords", text="Normalized")
 
         elif show_uvedit:
-            col.label(text=_("Coordinates:"))
-            col.prop(uvedit, "show_normalized_coords", text=_("Normalized"))
+            col.label(text="Coordinates:")
+            col.prop(uvedit, "show_normalized_coords", text="Normalized")
 
         if show_uvedit:
 
             col = layout.column()
-            col.label(_("Cursor Location:"))
+            col.label("Cursor Location:")
             col.row().prop(uvedit, "cursor_location", text="")
 
             col.separator()
@@ -624,11 +622,11 @@ class IMAGE_PT_view_properties(Panel):
 
             col = split.column()
             col.prop(uvedit, "show_faces")
-            col.prop(uvedit, "show_smooth_edges", text=_("Smooth"))
-            col.prop(uvedit, "show_modified_edges", text=_("Modified"))
+            col.prop(uvedit, "show_smooth_edges", text="Smooth")
+            col.prop(uvedit, "show_modified_edges", text="Modified")
 
             col = split.column()
-            col.prop(uvedit, "show_stretch", text=_("Stretch"))
+            col.prop(uvedit, "show_stretch", text="Stretch")
             sub = col.column()
             sub.active = uvedit.show_stretch
             sub.row().prop(uvedit, "draw_stretch_type", expand=True)
@@ -670,12 +668,12 @@ class IMAGE_PT_paint(Panel):
             row.prop(brush, "jitter", slider=True)
             row.prop(brush, "use_pressure_jitter", toggle=True, text="")
 
-            col.prop(brush, "blend", text=_("Blend"))
+            col.prop(brush, "blend", text="Blend")
 
             if brush.image_tool == 'CLONE':
                 col.separator()
-                col.prop(brush, "clone_image", text=_("Image"))
-                col.prop(brush, "clone_alpha", text=_("Alpha"))
+                col.prop(brush, "clone_image", text="Image")
+                col.prop(brush, "clone_alpha", text="Alpha")
 
 
 class IMAGE_PT_tools_brush_texture(BrushButtonsPanel, Panel):
@@ -729,7 +727,7 @@ class IMAGE_PT_paint_stroke(BrushButtonsPanel, Panel):
         layout.prop(brush, "use_space")
         row = layout.row(align=True)
         row.active = brush.use_space
-        row.prop(brush, "spacing", text=_("Distance"), slider=True)
+        row.prop(brush, "spacing", text="Distance", slider=True)
         row.prop(brush, "use_pressure_spacing", toggle=True, text="")
 
         layout.prop(brush, "use_wrap")

release/scripts/startup/bl_ui/space_info.py

@@ -18,8 +18,7 @@
 
 # <pep8 compliant>
 import bpy
-from bpy.types import Header, Menu, Operator
-from blf import gettext as _
+from bpy.types import Header, Menu
 
 
 class INFO_HT_header(Header):
@@ -46,7 +45,7 @@ class INFO_HT_header(Header):
             sub.menu("INFO_MT_help")
 
         if window.screen.show_fullscreen:
-            layout.operator("screen.back_to_previous", icon='SCREEN_BACK', text=_("Back to Previous"))
+            layout.operator("screen.back_to_previous", icon='SCREEN_BACK', text="Back to Previous")
             layout.separator()
         else:
             layout.template_ID(context.window, "screen", new="screen.new", unlink="screen.delete")
@@ -74,11 +73,11 @@ class INFO_HT_header(Header):
         """
         sinfo = context.space_data
         row = layout.row(align=True)
-        row.prop(sinfo, "show_report_debug", text=_("Debug"))
-        row.prop(sinfo, "show_report_info", text=_("Info"))
-        row.prop(sinfo, "show_report_operator", text=_("Operators"))
-        row.prop(sinfo, "show_report_warning", text=_("Warnings"))
-        row.prop(sinfo, "show_report_error", text=_("Errors"))
+        row.prop(sinfo, "show_report_debug", text="Debug")
+        row.prop(sinfo, "show_report_info", text="Info")
+        row.prop(sinfo, "show_report_operator", text="Operators")
+        row.prop(sinfo, "show_report_warning", text="Warnings")
+        row.prop(sinfo, "show_report_error", text="Errors")
 
         row = layout.row()
         row.enabled = sinfo.show_report_operator
@@ -107,25 +106,25 @@ class INFO_MT_file(Menu):
         layout = self.layout
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("wm.read_homefile", text=_("New"), icon='NEW')
+        layout.operator("wm.read_homefile", text="New", icon='NEW')
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.open_mainfile", text=_("Open..."), icon='FILE_FOLDER')
+        layout.operator("wm.open_mainfile", text="Open...", icon='FILE_FOLDER')
         layout.menu("INFO_MT_file_open_recent")
         layout.operator("wm.recover_last_session", icon='RECOVER_LAST')
-        layout.operator("wm.recover_auto_save", text=_("Recover Auto Save..."))
+        layout.operator("wm.recover_auto_save", text="Recover Auto Save...")
 
         layout.separator()
 
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.save_mainfile", text=_("Save"), icon='FILE_TICK').check_existing = False
+        layout.operator("wm.save_mainfile", text="Save", icon='FILE_TICK').check_existing = False
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.save_as_mainfile", text=_("Save As..."))
+        layout.operator("wm.save_as_mainfile", text="Save As...")
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.save_as_mainfile", text=_("Save Copy...")).copy = True
+        layout.operator("wm.save_as_mainfile", text="Save Copy...").copy = True
 
         layout.separator()
 
-        layout.operator("screen.userpref_show", text=_("User Preferences..."), icon='PREFERENCES')
+        layout.operator("screen.userpref_show", text="User Preferences...", icon='PREFERENCES')
 
         layout.operator_context = 'EXEC_AREA'
         layout.operator("wm.save_homefile")
@@ -134,8 +133,8 @@ class INFO_MT_file(Menu):
         layout.separator()
 
         layout.operator_context = 'INVOKE_AREA'
-        layout.operator("wm.link_append", text=_("Link"))
-        props = layout.operator("wm.link_append", text=_("Append"))
+        layout.operator("wm.link_append", text="Link")
+        props = layout.operator("wm.link_append", text="Append")
         props.link = False
         props.instance_groups = False
 
@@ -151,7 +150,7 @@ class INFO_MT_file(Menu):
         layout.separator()
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("wm.quit_blender", text=_("Quit"), icon='QUIT')
+        layout.operator("wm.quit_blender", text="Quit", icon='QUIT')
 
 
 class INFO_MT_file_import(Menu):
@@ -178,8 +177,8 @@ class INFO_MT_file_external_data(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("file.pack_all", text=_("Pack into .blend file"))
-        layout.operator("file.unpack_all", text=_("Unpack into Files"))
+        layout.operator("file.pack_all", text="Pack into .blend file")
+        layout.operator("file.unpack_all", text="Unpack into Files")
 
         layout.separator()
 
@@ -197,17 +196,17 @@ class INFO_MT_mesh_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("mesh.primitive_plane_add", icon='MESH_PLANE', text=_("Plane"))
-        layout.operator("mesh.primitive_cube_add", icon='MESH_CUBE', text=_("Cube"))
-        layout.operator("mesh.primitive_circle_add", icon='MESH_CIRCLE', text=_("Circle"))
-        layout.operator("mesh.primitive_uv_sphere_add", icon='MESH_UVSPHERE', text=_("UV Sphere"))
-        layout.operator("mesh.primitive_ico_sphere_add", icon='MESH_ICOSPHERE', text=_("Icosphere"))
-        layout.operator("mesh.primitive_cylinder_add", icon='MESH_CYLINDER', text=_("Cylinder"))
-        layout.operator("mesh.primitive_cone_add", icon='MESH_CONE', text=_("Cone"))
+        layout.operator("mesh.primitive_plane_add", icon='MESH_PLANE', text="Plane")
+        layout.operator("mesh.primitive_cube_add", icon='MESH_CUBE', text="Cube")
+        layout.operator("mesh.primitive_circle_add", icon='MESH_CIRCLE', text="Circle")
+        layout.operator("mesh.primitive_uv_sphere_add", icon='MESH_UVSPHERE', text="UV Sphere")
+        layout.operator("mesh.primitive_ico_sphere_add", icon='MESH_ICOSPHERE', text="Icosphere")
+        layout.operator("mesh.primitive_cylinder_add", icon='MESH_CYLINDER', text="Cylinder")
+        layout.operator("mesh.primitive_cone_add", icon='MESH_CONE', text="Cone")
         layout.separator()
-        layout.operator("mesh.primitive_grid_add", icon='MESH_GRID', text=_("Grid"))
-        layout.operator("mesh.primitive_monkey_add", icon='MESH_MONKEY', text=_("Monkey"))
-        layout.operator("mesh.primitive_torus_add", text=_("Torus"), icon='MESH_TORUS')
+        layout.operator("mesh.primitive_grid_add", icon='MESH_GRID', text="Grid")
+        layout.operator("mesh.primitive_monkey_add", icon='MESH_MONKEY', text="Monkey")
+        layout.operator("mesh.primitive_torus_add", text="Torus", icon='MESH_TORUS')
 
 
 class INFO_MT_curve_add(Menu):
@@ -218,11 +217,11 @@ class INFO_MT_curve_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("curve.primitive_bezier_curve_add", icon='CURVE_BEZCURVE', text=_("Bezier"))
-        layout.operator("curve.primitive_bezier_circle_add", icon='CURVE_BEZCIRCLE', text=_("Circle"))
-        layout.operator("curve.primitive_nurbs_curve_add", icon='CURVE_NCURVE', text=_("Nurbs Curve"))
-        layout.operator("curve.primitive_nurbs_circle_add", icon='CURVE_NCIRCLE', text=_("Nurbs Circle"))
-        layout.operator("curve.primitive_nurbs_path_add", icon='CURVE_PATH', text=_("Path"))
+        layout.operator("curve.primitive_bezier_curve_add", icon='CURVE_BEZCURVE', text="Bezier")
+        layout.operator("curve.primitive_bezier_circle_add", icon='CURVE_BEZCIRCLE', text="Circle")
+        layout.operator("curve.primitive_nurbs_curve_add", icon='CURVE_NCURVE', text="Nurbs Curve")
+        layout.operator("curve.primitive_nurbs_circle_add", icon='CURVE_NCIRCLE', text="Nurbs Circle")
+        layout.operator("curve.primitive_nurbs_path_add", icon='CURVE_PATH', text="Path")
 
 
 class INFO_MT_edit_curve_add(Menu):
@@ -249,12 +248,12 @@ class INFO_MT_surface_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("surface.primitive_nurbs_surface_curve_add", icon='SURFACE_NCURVE', text=_("NURBS Curve"))
-        layout.operator("surface.primitive_nurbs_surface_circle_add", icon='SURFACE_NCIRCLE', text=_("NURBS Circle"))
-        layout.operator("surface.primitive_nurbs_surface_surface_add", icon='SURFACE_NSURFACE', text=_("NURBS Surface"))
-        layout.operator("surface.primitive_nurbs_surface_cylinder_add", icon='SURFACE_NCYLINDER', text=_("NURBS Cylinder"))
-        layout.operator("surface.primitive_nurbs_surface_sphere_add", icon='SURFACE_NSPHERE', text=_("NURBS Sphere"))
-        layout.operator("surface.primitive_nurbs_surface_torus_add", icon='SURFACE_NTORUS', text=_("NURBS Torus"))
+        layout.operator("surface.primitive_nurbs_surface_curve_add", icon='SURFACE_NCURVE', text="NURBS Curve")
+        layout.operator("surface.primitive_nurbs_surface_circle_add", icon='SURFACE_NCIRCLE', text="NURBS Circle")
+        layout.operator("surface.primitive_nurbs_surface_surface_add", icon='SURFACE_NSURFACE', text="NURBS Surface")
+        layout.operator("surface.primitive_nurbs_surface_cylinder_add", icon='SURFACE_NCYLINDER', text="NURBS Cylinder")
+        layout.operator("surface.primitive_nurbs_surface_sphere_add", icon='SURFACE_NSPHERE', text="NURBS Sphere")
+        layout.operator("surface.primitive_nurbs_surface_torus_add", icon='SURFACE_NTORUS', text="NURBS Torus")
 
 
 class INFO_MT_armature_add(Menu):
@@ -265,7 +264,7 @@ class INFO_MT_armature_add(Menu):
         layout = self.layout
 
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("object.armature_add", text=_("Single Bone"), icon='BONE_DATA')
+        layout.operator("object.armature_add", text="Single Bone", icon='BONE_DATA')
 
 
 class INFO_MT_add(Menu):
@@ -276,39 +275,39 @@ class INFO_MT_add(Menu):
 
         layout.operator_context = 'EXEC_SCREEN'
 
-        #layout.operator_menu_enum("object.mesh_add", "type", text=_("Mesh"), icon='OUTLINER_OB_MESH')
+        #layout.operator_menu_enum("object.mesh_add", "type", text="Mesh", icon='OUTLINER_OB_MESH')
         layout.menu("INFO_MT_mesh_add", icon='OUTLINER_OB_MESH')
 
-        #layout.operator_menu_enum("object.curve_add", "type", text=_("Curve"), icon='OUTLINER_OB_CURVE')
+        #layout.operator_menu_enum("object.curve_add", "type", text="Curve", icon='OUTLINER_OB_CURVE')
         layout.menu("INFO_MT_curve_add", icon='OUTLINER_OB_CURVE')
-        #layout.operator_menu_enum("object.surface_add", "type", text=_("Surface"), icon='OUTLINER_OB_SURFACE')
+        #layout.operator_menu_enum("object.surface_add", "type", text="Surface", icon='OUTLINER_OB_SURFACE')
         layout.menu("INFO_MT_surface_add", icon='OUTLINER_OB_SURFACE')
-        layout.operator_menu_enum("object.metaball_add", "type", text=_("Metaball"), icon='OUTLINER_OB_META')
+        layout.operator_menu_enum("object.metaball_add", "type", text="Metaball", icon='OUTLINER_OB_META')
         layout.operator_context = 'INVOKE_REGION_WIN'
-        layout.operator("object.text_add", text=_("Text"), icon='OUTLINER_OB_FONT')
+        layout.operator("object.text_add", text="Text", icon='OUTLINER_OB_FONT')
         layout.separator()
 
         layout.menu("INFO_MT_armature_add", icon='OUTLINER_OB_ARMATURE')
-        layout.operator("object.add", text=_("Lattice"), icon='OUTLINER_OB_LATTICE').type = 'LATTICE'
-        layout.operator("object.add", text=_("Empty"), icon='OUTLINER_OB_EMPTY').type = 'EMPTY'
+        layout.operator("object.add", text="Lattice", icon='OUTLINER_OB_LATTICE').type = 'LATTICE'
+        layout.operator("object.add", text="Empty", icon='OUTLINER_OB_EMPTY').type = 'EMPTY'
         layout.separator()
 
-        layout.operator("object.speaker_add", text=_("Speaker"), icon='OUTLINER_OB_SPEAKER')
+        layout.operator("object.speaker_add", text="Speaker", icon='OUTLINER_OB_SPEAKER')
         layout.separator()
 
-        layout.operator("object.camera_add", text=_("Camera"), icon='OUTLINER_OB_CAMERA')
+        layout.operator("object.camera_add", text="Camera", icon='OUTLINER_OB_CAMERA')
         layout.operator_context = 'EXEC_SCREEN'
-        layout.operator_menu_enum("object.lamp_add", "type", text=_("Lamp"), icon='OUTLINER_OB_LAMP')
+        layout.operator_menu_enum("object.lamp_add", "type", text="Lamp", icon='OUTLINER_OB_LAMP')
         layout.separator()
 
-        layout.operator_menu_enum("object.effector_add", "type", text=_("Force Field"), icon='OUTLINER_OB_EMPTY')
+        layout.operator_menu_enum("object.effector_add", "type", text="Force Field", icon='OUTLINER_OB_EMPTY')
         layout.separator()
 
         if(len(bpy.data.groups) > 10):
             layout.operator_context = 'INVOKE_DEFAULT'
-            layout.operator("object.group_instance_add", text=_("Group Instance..."), icon='OUTLINER_OB_EMPTY')
+            layout.operator("object.group_instance_add", text="Group Instance...", icon='OUTLINER_OB_EMPTY')
         else:
-            layout.operator_menu_enum("object.group_instance_add", "group", text=_("Group Instance"), icon='OUTLINER_OB_EMPTY')
+            layout.operator_menu_enum("object.group_instance_add", "group", text="Group Instance", icon='OUTLINER_OB_EMPTY')
 
 
 class INFO_MT_game(Menu):
@@ -338,13 +337,13 @@ class INFO_MT_render(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("render.render", text=_("Render Image"), icon='RENDER_STILL')
-        layout.operator("render.render", text=_("Render Animation"), icon='RENDER_ANIMATION').animation = True
+        layout.operator("render.render", text="Render Image", icon='RENDER_STILL')
+        layout.operator("render.render", text="Render Animation", icon='RENDER_ANIMATION').animation = True
 
         layout.separator()
 
-        layout.operator("render.opengl", text=_("OpenGL Render Image"))
-        layout.operator("render.opengl", text=_("OpenGL Render Animation")).animation = True
+        layout.operator("render.opengl", text="OpenGL Render Image")
+        layout.operator("render.opengl", text="OpenGL Render Animation").animation = True
 
         layout.separator()
 
@@ -360,58 +359,30 @@ class INFO_MT_help(Menu):
 
         layout = self.layout
 
-        layout.operator("wm.url_open", text=_("Manual"), icon='HELP').url = 'http://wiki.blender.org/index.php/Doc:Manual'
-        layout.operator("wm.url_open", text=_("Release Log"), icon='URL').url = 'http://www.blender.org/development/release-logs/blender-259/'
+        layout.operator("wm.url_open", text="Manual", icon='HELP').url = 'http://wiki.blender.org/index.php/Doc:Manual'
+        layout.operator("wm.url_open", text="Release Log", icon='URL').url = 'http://www.blender.org/development/release-logs/blender-259/'
 
         layout.separator()
 
-        layout.operator("wm.url_open", text=_("Blender Website"), icon='URL').url = 'http://www.blender.org/'
-        layout.operator("wm.url_open", text=_("Blender e-Shop"), icon='URL').url = 'http://www.blender.org/e-shop'
-        layout.operator("wm.url_open", text=_("Developer Community"), icon='URL').url = 'http://www.blender.org/community/get-involved/'
-        layout.operator("wm.url_open", text=_("User Community"), icon='URL').url = 'http://www.blender.org/community/user-community/'
+        layout.operator("wm.url_open", text="Blender Website", icon='URL').url = 'http://www.blender.org/'
+        layout.operator("wm.url_open", text="Blender e-Shop", icon='URL').url = 'http://www.blender.org/e-shop'
+        layout.operator("wm.url_open", text="Developer Community", icon='URL').url = 'http://www.blender.org/community/get-involved/'
+        layout.operator("wm.url_open", text="User Community", icon='URL').url = 'http://www.blender.org/community/user-community/'
         layout.separator()
-        layout.operator("wm.url_open", text=_("Report a Bug"), icon='URL').url = 'http://projects.blender.org/tracker/?atid=498&group_id=9&func=browse'
+        layout.operator("wm.url_open", text="Report a Bug", icon='URL').url = 'http://projects.blender.org/tracker/?atid=498&group_id=9&func=browse'
         layout.separator()
 
-        layout.operator("wm.url_open", text=_("Python API Reference"), icon='URL').url = bpy.types.WM_OT_doc_view._prefix
-        layout.operator("help.operator_cheat_sheet", icon='TEXT')
+        layout.operator("wm.url_open", text="Python API Reference", icon='URL').url = bpy.types.WM_OT_doc_view._prefix
+        layout.operator("wm.operator_cheat_sheet", icon='TEXT')
         layout.operator("wm.sysinfo", icon='TEXT')
         layout.separator()
         if sys.platform[:3] == "win":
             layout.operator("wm.console_toggle", icon='CONSOLE')
             layout.separator()
-        layout.operator("anim.update_data_paths", text=_("FCurve/Driver Version fix"), icon='HELP')
+        layout.operator("anim.update_data_paths", text="FCurve/Driver Version fix", icon='HELP')
         layout.operator("logic.texface_convert", text="TexFace to Material Convert", icon='GAME')
         layout.separator()
         layout.operator("wm.splash", icon='BLENDER')
 
-
-# Help operators
-
-
-class HELP_OT_operator_cheat_sheet(Operator):
-    bl_idname = "help.operator_cheat_sheet"
-    bl_label = "Operator Cheat Sheet"
-
-    def execute(self, context):
-        op_strings = []
-        tot = 0
-        for op_module_name in dir(bpy.ops):
-            op_module = getattr(bpy.ops, op_module_name)
-            for op_submodule_name in dir(op_module):
-                op = getattr(op_module, op_submodule_name)
-                text = repr(op)
-                if text.split("\n")[-1].startswith('bpy.ops.'):
-                    op_strings.append(text)
-                    tot += 1
-
-            op_strings.append('')
-
-        textblock = bpy.data.texts.new("OperatorList.txt")
-        textblock.write('# %d Operators\n\n' % tot)
-        textblock.write('\n'.join(op_strings))
-        self.report({'INFO'}, "See OperatorList.txt textblock")
-        return {'FINISHED'}
-
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_logic.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
-from blf import gettext as _
 
 
 class LOGIC_PT_properties(Panel):
@@ -38,7 +37,7 @@ class LOGIC_PT_properties(Panel):
         ob = context.active_object
         game = ob.game
 
-        layout.operator("object.game_property_new", text=_("Add Game Property"), icon='ZOOMIN')
+        layout.operator("object.game_property_new", text="Add Game Property", icon='ZOOMIN')
 
         for i, prop in enumerate(game.properties):
 
@@ -57,9 +56,9 @@ class LOGIC_MT_logicbricks_add(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator_menu_enum("logic.sensor_add", "type", text=_("Sensor"))
-        layout.operator_menu_enum("logic.controller_add", "type", text=_("Controller"))
-        layout.operator_menu_enum("logic.actuator_add", "type", text=_("Actuator"))
+        layout.operator_menu_enum("logic.sensor_add", "type", text="Sensor")
+        layout.operator_menu_enum("logic.controller_add", "type", text="Controller")
+        layout.operator_menu_enum("logic.actuator_add", "type", text="Actuator")
 
 
 class LOGIC_HT_header(Header):

release/scripts/startup/bl_ui/space_nla.py

@@ -20,7 +20,6 @@
 
 import bpy
 from bpy.types import Header, Menu
-from blf import gettext as _
 
 
 class NLA_HT_header(Header):
@@ -63,7 +62,7 @@ class NLA_MT_view(Menu):
         layout.prop(st, "use_realtime_update")
         layout.prop(st, "show_frame_indicator")
 
-        layout.operator("anim.time_toggle", text=_("Show Frames") if st.show_seconds else _("Show Seconds"))
+        layout.operator("anim.time_toggle", text="Show Frames" if st.show_seconds else "Show Seconds")
 
         layout.prop(st, "show_strip_curves")
 
@@ -88,33 +87,33 @@ class NLA_MT_select(Menu):
 
         # This is a bit misleading as the operator's default text is "Select All" while it actually *toggles* All/None
         layout.operator("nla.select_all_toggle")
-        layout.operator("nla.select_all_toggle", text=_("Invert Selection")).invert = True
+        layout.operator("nla.select_all_toggle", text="Invert Selection").invert = True
 
         layout.separator()
         layout.operator("nla.select_border")
-        layout.operator("nla.select_border", text=_("Border Axis Range")).axis_range = True
+        layout.operator("nla.select_border", text="Border Axis Range").axis_range = True
 
         layout.separator()
-        layout.operator("nla.select_leftright", text=_("Before Current Frame")).mode = 'LEFT'
-        layout.operator("nla.select_leftright", text=_("After Current Frame")).mode = 'RIGHT'
+        layout.operator("nla.select_leftright", text="Before Current Frame").mode = 'LEFT'
+        layout.operator("nla.select_leftright", text="After Current Frame").mode = 'RIGHT'
 
 
 class NLA_MT_marker(Menu):
-    bl_label = _("Marker")
+    bl_label = "Marker"
 
     def draw(self, context):
         layout = self.layout
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", _("Add Marker"))
-        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
-        layout.operator("marker.delete", text=_("Delete Marker"))
+        layout.operator("marker.add", "Add Marker")
+        layout.operator("marker.duplicate", text="Duplicate Marker")
+        layout.operator("marker.delete", text="Delete Marker")
 
         layout.separator()
 
-        layout.operator("marker.rename", text=_("Rename Marker"))
-        layout.operator("marker.move", text=_("Grab/Move Marker"))
+        layout.operator("marker.rename", text="Rename Marker")
+        layout.operator("marker.move", text="Grab/Move Marker")
 
 
 class NLA_MT_edit(Menu):
@@ -125,9 +124,9 @@ class NLA_MT_edit(Menu):
 
         scene = context.scene
 
-        layout.menu("NLA_MT_edit_transform", text=_("Transform"))
+        layout.menu("NLA_MT_edit_transform", text="Transform")
 
-        layout.operator_menu_enum("nla.snap", "type", text=_("Snap"))
+        layout.operator_menu_enum("nla.snap", "type", text="Snap")
 
         layout.separator()
         layout.operator("nla.duplicate")
@@ -149,14 +148,14 @@ class NLA_MT_edit(Menu):
 
         # TODO: this really belongs more in a "channel" (or better, "track") menu
         layout.separator()
-        layout.operator_menu_enum("anim.channels_move", "direction", text=_("Track Ordering..."))
+        layout.operator_menu_enum("anim.channels_move", "direction", text="Track Ordering...")
 
         layout.separator()
         # TODO: names of these tools for 'tweakmode' need changing?
         if scene.is_nla_tweakmode:
-            layout.operator("nla.tweakmode_exit", text=_("Stop Tweaking Strip Actions"))
+            layout.operator("nla.tweakmode_exit", text="Stop Tweaking Strip Actions")
         else:
-            layout.operator("nla.tweakmode_enter", text=_("Start Tweaking Strip Actions"))
+            layout.operator("nla.tweakmode_enter", text="Start Tweaking Strip Actions")
 
 
 class NLA_MT_add(Menu):
@@ -175,7 +174,7 @@ class NLA_MT_add(Menu):
 
         layout.separator()
         layout.operator("nla.tracks_add")
-        layout.operator("nla.tracks_add", text=_("Add Tracks Above Selected")).above_selected = True
+        layout.operator("nla.tracks_add", text="Add Tracks Above Selected").above_selected = True
 
 
 class NLA_MT_edit_transform(Menu):
@@ -184,9 +183,9 @@ class NLA_MT_edit_transform(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("transform.translate", text=_("Grab/Move"))
-        layout.operator("transform.transform", text=_("Extend")).mode = 'TIME_EXTEND'
-        layout.operator("transform.transform", text=_("Scale")).mode = 'TIME_SCALE'
+        layout.operator("transform.translate", text="Grab/Move")
+        layout.operator("transform.transform", text="Extend").mode = 'TIME_EXTEND'
+        layout.operator("transform.transform", text="Scale").mode = 'TIME_SCALE'
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_node.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
-from blf import gettext as _
 
 
 class NODE_HT_header(Header):
@@ -62,7 +61,7 @@ class NODE_HT_header(Header):
 
         elif snode.tree_type == 'COMPOSITING':
             layout.prop(snode_id, "use_nodes")
-            layout.prop(snode_id.render, "use_free_unused_nodes", text=_("Free Unused"))
+            layout.prop(snode_id.render, "use_free_unused_nodes", text="Free Unused")
             layout.prop(snode, "show_backdrop")
             if snode.show_backdrop:
                 row = layout.row(align=True)
@@ -93,9 +92,9 @@ class NODE_MT_view(Menu):
         if context.space_data.show_backdrop:
             layout.separator()
 
-            layout.operator("node.backimage_move", text=_("Backdrop move"))
-            layout.operator("node.backimage_zoom", text=_("Backdrop zoom in")).factor = 1.2
-            layout.operator("node.backimage_zoom", text=_("Backdrop zoom out")).factor = 0.833
+            layout.operator("node.backimage_move", text="Backdrop move")
+            layout.operator("node.backimage_zoom", text="Backdrop zoom in").factor = 1.2
+            layout.operator("node.backimage_zoom", text="Backdrop zoom out").factor = 0.833
 
         layout.separator()
 
@@ -138,7 +137,7 @@ class NODE_MT_node(Menu):
 
         layout.separator()
         layout.operator("node.link_make")
-        layout.operator("node.link_make", text=_("Make and Replace Links")).replace = True
+        layout.operator("node.link_make", text="Make and Replace Links").replace = True
         layout.operator("node.links_cut")
 
         layout.separator()
@@ -181,13 +180,13 @@ class NODE_PT_properties(Panel):
         snode = context.space_data
         layout.active = snode.show_backdrop
         layout.prop(snode, "backdrop_channels", text="")
-        layout.prop(snode, "backdrop_zoom", text=_("Zoom"))
+        layout.prop(snode, "backdrop_zoom", text="Zoom")
 
         col = layout.column(align=True)
-        col.label(text=_("Offset:"))
+        col.label(text="Offset:")
         col.prop(snode, "backdrop_x", text="X")
         col.prop(snode, "backdrop_y", text="Y")
-        col.operator("node.backimage_move", text=_("Move"))
+        col.operator("node.backimage_move", text="Move")
 
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_sequencer.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
-from blf import gettext as _
 
 
 def act_strip(context):
@@ -65,9 +64,9 @@ class SEQUENCER_HT_header(Header):
         elif st.view_type == 'SEQUENCER_PREVIEW':
             layout.separator()
             layout.operator("sequencer.refresh_all")
-            layout.prop(st, "display_channel", text=_("Channel"))
+            layout.prop(st, "display_channel", text="Channel")
         else:
-            layout.prop(st, "display_channel", text=_("Channel"))
+            layout.prop(st, "display_channel", text="Channel")
 
             ed = context.scene.sequence_editor
             if ed:
@@ -102,11 +101,11 @@ class SEQUENCER_MT_view(Menu):
         layout.separator()
 
         if st.view_type in {'SEQUENCER', 'SEQUENCER_PREVIEW'}:
-            layout.operator("sequencer.view_all", text=_('View all Sequences'))
+            layout.operator("sequencer.view_all", text="View all Sequences")
         if st.view_type in {'PREVIEW', 'SEQUENCER_PREVIEW'}:
             layout.operator_context = 'INVOKE_REGION_PREVIEW'
-            layout.operator("sequencer.view_all_preview", text=_('Fit preview in window'))
-            layout.operator("sequencer.view_zoom_ratio", text=_('Show preview 1:1')).ratio = 1.0
+            layout.operator("sequencer.view_all_preview", text="Fit preview in window")
+            layout.operator("sequencer.view_zoom_ratio", text="Show preview 1:1").ratio = 1.0
             layout.operator_context = 'INVOKE_DEFAULT'
 
             # # XXX, invokes in the header view
@@ -115,9 +114,9 @@ class SEQUENCER_MT_view(Menu):
         layout.operator("sequencer.view_selected")
 
         if st.show_frames:
-            layout.operator("anim.time_toggle", text=_("Show Seconds"))
+            layout.operator("anim.time_toggle", text="Show Seconds")
         else:
-            layout.operator("anim.time_toggle", text=_("Show Frames"))
+            layout.operator("anim.time_toggle", text="Show Frames")
 
         layout.prop(st, "show_frame_indicator")
         if st.display_mode == 'IMAGE':
@@ -139,12 +138,12 @@ class SEQUENCER_MT_select(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("sequencer.select_active_side", text=_("Strips to the Left")).side = 'LEFT'
-        layout.operator("sequencer.select_active_side", text=_("Strips to the Right")).side = 'RIGHT'
+        layout.operator("sequencer.select_active_side", text="Strips to the Left").side = 'LEFT'
+        layout.operator("sequencer.select_active_side", text="Strips to the Right").side = 'RIGHT'
         layout.separator()
-        layout.operator("sequencer.select_handles", text=_("Surrounding Handles")).side = 'BOTH'
-        layout.operator("sequencer.select_handles", text=_("Left Handle")).side = 'LEFT'
-        layout.operator("sequencer.select_handles", text=_("Right Handle")).side = 'RIGHT'
+        layout.operator("sequencer.select_handles", text="Surrounding Handles").side = 'BOTH'
+        layout.operator("sequencer.select_handles", text="Left Handle").side = 'LEFT'
+        layout.operator("sequencer.select_handles", text="Right Handle").side = 'RIGHT'
         layout.separator()
         layout.operator("sequencer.select_linked")
         layout.operator("sequencer.select_all_toggle")
@@ -159,14 +158,14 @@ class SEQUENCER_MT_marker(Menu):
 
         #layout.operator_context = 'EXEC_REGION_WIN'
 
-        layout.operator("marker.add", _("Add Marker"))
-        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
-        layout.operator("marker.delete", text=_("Delete Marker"))
+        layout.operator("marker.add", "Add Marker")
+        layout.operator("marker.duplicate", text="Duplicate Marker")
+        layout.operator("marker.delete", text="Delete Marker")
 
         layout.separator()
 
-        layout.operator("marker.rename", text=_("Rename Marker"))
-        layout.operator("marker.move", text=_("Grab/Move Marker"))
+        layout.operator("marker.rename", text="Rename Marker")
+        layout.operator("marker.move", text="Grab/Move Marker")
 
         #layout.operator("sequencer.sound_strip_add", text="Transform Markers") # toggle, will be rna - (sseq->flag & SEQ_MARKER_TRANS)
 
@@ -181,7 +180,7 @@ class SEQUENCER_MT_change(Menu):
 
         layout.operator_menu_enum("sequencer.change_effect_input", "swap")
         layout.operator_menu_enum("sequencer.change_effect_type", "type")
-        layout.operator("sequencer.change_path", text=_("Path/Files"))
+        layout.operator("sequencer.change_path", text="Path/Files")
 
 
 class SEQUENCER_MT_add(Menu):
@@ -193,13 +192,13 @@ class SEQUENCER_MT_add(Menu):
 
         if len(bpy.data.scenes) > 10:
             layout.operator_context = 'INVOKE_DEFAULT'
-            layout.operator("sequencer.scene_strip_add", text=_("Scene..."))
+            layout.operator("sequencer.scene_strip_add", text="Scene...")
         else:
-            layout.operator_menu_enum("sequencer.scene_strip_add", "scene", text=_("Scene..."))
+            layout.operator_menu_enum("sequencer.scene_strip_add", "scene", text="Scene...")
 
-        layout.operator("sequencer.movie_strip_add", text=_("Movie"))
-        layout.operator("sequencer.image_strip_add", text=_("Image"))
-        layout.operator("sequencer.sound_strip_add", text=_("Sound"))
+        layout.operator("sequencer.movie_strip_add", text="Movie")
+        layout.operator("sequencer.image_strip_add", text="Image")
+        layout.operator("sequencer.sound_strip_add", text="Sound")
 
         layout.menu("SEQUENCER_MT_add_effect")
 
@@ -211,22 +210,22 @@ class SEQUENCER_MT_add_effect(Menu):
         layout = self.layout
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("sequencer.effect_strip_add", text=_("Add")).type = 'ADD'
-        layout.operator("sequencer.effect_strip_add", text=_("Subtract")).type = 'SUBTRACT'
-        layout.operator("sequencer.effect_strip_add", text=_("Alpha Over")).type = 'ALPHA_OVER'
-        layout.operator("sequencer.effect_strip_add", text=_("Alpha Under")).type = 'ALPHA_UNDER'
-        layout.operator("sequencer.effect_strip_add", text=_("Cross")).type = 'CROSS'
-        layout.operator("sequencer.effect_strip_add", text=_("Gamma Cross")).type = 'GAMMA_CROSS'
-        layout.operator("sequencer.effect_strip_add", text=_("Multiply")).type = 'MULTIPLY'
-        layout.operator("sequencer.effect_strip_add", text=_("Over Drop")).type = 'OVER_DROP'
-        layout.operator("sequencer.effect_strip_add", text=_("Plugin")).type = 'PLUGIN'
-        layout.operator("sequencer.effect_strip_add", text=_("Wipe")).type = 'WIPE'
-        layout.operator("sequencer.effect_strip_add", text=_("Glow")).type = 'GLOW'
-        layout.operator("sequencer.effect_strip_add", text=_("Transform")).type = 'TRANSFORM'
-        layout.operator("sequencer.effect_strip_add", text=_("Color")).type = 'COLOR'
-        layout.operator("sequencer.effect_strip_add", text=_("Speed Control")).type = 'SPEED'
-        layout.operator("sequencer.effect_strip_add", text=_("Multicam Selector")).type = 'MULTICAM'
-        layout.operator("sequencer.effect_strip_add", text=_("Adjustment Layer")).type = 'ADJUSTMENT'
+        layout.operator("sequencer.effect_strip_add", text="Add").type = 'ADD'
+        layout.operator("sequencer.effect_strip_add", text="Subtract").type = 'SUBTRACT'
+        layout.operator("sequencer.effect_strip_add", text="Alpha Over").type = 'ALPHA_OVER'
+        layout.operator("sequencer.effect_strip_add", text="Alpha Under").type = 'ALPHA_UNDER'
+        layout.operator("sequencer.effect_strip_add", text="Cross").type = 'CROSS'
+        layout.operator("sequencer.effect_strip_add", text="Gamma Cross").type = 'GAMMA_CROSS'
+        layout.operator("sequencer.effect_strip_add", text="Multiply").type = 'MULTIPLY'
+        layout.operator("sequencer.effect_strip_add", text="Over Drop").type = 'OVER_DROP'
+        layout.operator("sequencer.effect_strip_add", text="Plugin").type = 'PLUGIN'
+        layout.operator("sequencer.effect_strip_add", text="Wipe").type = 'WIPE'
+        layout.operator("sequencer.effect_strip_add", text="Glow").type = 'GLOW'
+        layout.operator("sequencer.effect_strip_add", text="Transform").type = 'TRANSFORM'
+        layout.operator("sequencer.effect_strip_add", text="Color").type = 'COLOR'
+        layout.operator("sequencer.effect_strip_add", text="Speed Control").type = 'SPEED'
+        layout.operator("sequencer.effect_strip_add", text="Multicam Selector").type = 'MULTICAM'
+        layout.operator("sequencer.effect_strip_add", text="Adjustment Layer").type = 'ADJUSTMENT'
 
 
 class SEQUENCER_MT_strip(Menu):
@@ -237,13 +236,13 @@ class SEQUENCER_MT_strip(Menu):
 
         layout.operator_context = 'INVOKE_REGION_WIN'
 
-        layout.operator("transform.transform", text=_("Grab/Move")).mode = 'TRANSLATION'
-        layout.operator("transform.transform", text=_("Grab/Extend from frame")).mode = 'TIME_EXTEND'
+        layout.operator("transform.transform", text="Grab/Move").mode = 'TRANSLATION'
+        layout.operator("transform.transform", text="Grab/Extend from frame").mode = 'TIME_EXTEND'
         #  uiItemO(layout, NULL, 0, "sequencer.strip_snap"); // TODO - add this operator
         layout.separator()
 
-        layout.operator("sequencer.cut", text=_("Cut (hard) at frame")).type = 'HARD'
-        layout.operator("sequencer.cut", text=_("Cut (soft) at frame")).type = 'SOFT'
+        layout.operator("sequencer.cut", text="Cut (hard) at frame").type = 'HARD'
+        layout.operator("sequencer.cut", text="Cut (soft) at frame").type = 'SOFT'
         layout.operator("sequencer.images_separate")
         layout.operator("sequencer.offset_clear")
         layout.operator("sequencer.deinterlace_selected_movies")
@@ -297,7 +296,7 @@ class SEQUENCER_MT_strip(Menu):
         layout.operator("sequencer.mute")
         layout.operator("sequencer.unmute")
 
-        layout.operator("sequencer.mute", text=_("Mute Deselected Strips")).unselected = True
+        layout.operator("sequencer.mute", text="Mute Deselected Strips").unselected = True
 
         layout.operator("sequencer.snap")
 
@@ -345,21 +344,21 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, Panel):
         strip = act_strip(context)
 
         split = layout.split(percentage=0.3)
-        split.label(text=_("Name:"))
+        split.label(text="Name:")
         split.prop(strip, "name", text="")
 
         split = layout.split(percentage=0.3)
-        split.label(text=_("Type:"))
+        split.label(text="Type:")
         split.prop(strip, "type", text="")
 
         split = layout.split(percentage=0.3)
-        split.label(text=_("Blend:"))
+        split.label(text="Blend:")
         split.prop(strip, "blend_type", text="")
 
         row = layout.row(align=True)
         sub = row.row()
         sub.active = (not strip.mute)
-        sub.prop(strip, "blend_alpha", text=_("Opacity"), slider=True)
+        sub.prop(strip, "blend_alpha", text="Opacity", slider=True)
         row.prop(strip, "mute", toggle=True, icon='RESTRICT_VIEW_ON' if strip.mute else 'RESTRICT_VIEW_OFF', text="")
         row.prop(strip, "lock", toggle=True, icon='LOCKED' if strip.lock else 'UNLOCKED', text="")
 
@@ -372,13 +371,13 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, Panel):
 
         col = layout.column(align=True)
         row = col.row()
-        row.label(text=_("Final Length") + ": %s" % bpy.utils.smpte_from_frame(strip.frame_final_duration))
+        row.label(text="Final Length" + ": %s" % bpy.utils.smpte_from_frame(strip.frame_final_duration))
         row = col.row()
         row.active = (frame_current >= strip.frame_start and frame_current <= strip.frame_start + strip.frame_duration)
-        row.label(text=_("Playhead") + ": %d" % (frame_current - strip.frame_start))
+        row.label(text="Playhead" + ": %d" % (frame_current - strip.frame_start))
 
-        col.label(text=_("Frame Offset") + " %d:%d" % (strip.frame_offset_start, strip.frame_offset_end))
-        col.label(text=_("Frame Still") + " %d:%d" % (strip.frame_still_start, strip.frame_still_end))
+        col.label(text="Frame Offset" + " %d:%d" % (strip.frame_offset_start, strip.frame_offset_end))
+        col.label(text="Frame Still" + " %d:%d" % (strip.frame_still_start, strip.frame_still_end))
 
         elem = False
 
@@ -388,9 +387,9 @@ class SEQUENCER_PT_edit(SequencerButtonsPanel, Panel):
             elem = strip.elements[0]
 
         if elem and elem.orig_width > 0 and elem.orig_height > 0:
-            col.label(text=_("Orig Dim") + ": %dx%d" % (elem.orig_width, elem.orig_height))
+            col.label(text="Orig Dim" + ": %dx%d" % (elem.orig_width, elem.orig_height))
         else:
-            col.label(text=_("Orig Dim: None"))
+            col.label(text="Orig Dim: None")
 
 
 class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
@@ -430,7 +429,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
 
             col = layout.column()
             col.prop(strip, "transition_type")
-            col.label(text=_("Direction:"))
+            col.label(text="Direction:")
             col.row().prop(strip, "direction", expand=True)
 
             col = layout.column()
@@ -450,13 +449,13 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
             row.prop(strip, "use_only_boost")
 
         elif strip.type == 'SPEED':
-            layout.prop(strip, "use_default_fade", _("Stretch to input strip length"))
+            layout.prop(strip, "use_default_fade", "Stretch to input strip length")
             if not strip.use_default_fade:
                 layout.prop(strip, "use_as_speed")
                 if strip.use_as_speed:
                     layout.prop(strip, "speed_factor")
                 else:
-                    layout.prop(strip, "speed_factor", text=_("Frame number"))
+                    layout.prop(strip, "speed_factor", text="Frame number")
                     layout.prop(strip, "scale_to_length")
 
             #doesn't work currently
@@ -474,7 +473,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
 
             sub.operator("screen.animation_play", text="", icon='PAUSE' if context.screen.is_animation_playing else 'PLAY')
 
-            row.label(_("Cut To"))
+            row.label("Cut To")
             for i in range(1, strip.channel):
                 row.operator("sequencer.cut_multicam", text=str(i)).camera = i
 
@@ -482,17 +481,17 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
         if strip.type == 'SPEED':
             col.prop(strip, "multiply_speed")
         elif strip.type in {'CROSS', 'GAMMA_CROSS', 'PLUGIN', 'WIPE'}:
-                col.prop(strip, "use_default_fade", _("Default fade"))
+                col.prop(strip, "use_default_fade", "Default fade")
                 if not strip.use_default_fade:
-                    col.prop(strip, "effect_fader", text=_("Effect fader"))
+                    col.prop(strip, "effect_fader", text="Effect fader")
 
-        layout.prop(strip, "use_translation", text=_("Image Offset:"))
+        layout.prop(strip, "use_translation", text="Image Offset:")
         if strip.use_translation:
             col = layout.column(align=True)
             col.prop(strip.transform, "offset_x", text="X")
             col.prop(strip.transform, "offset_y", text="Y")
 
-        layout.prop(strip, "use_crop", text=_("Image Crop:"))
+        layout.prop(strip, "use_crop", text="Image Crop:")
         if strip.use_crop:
             col = layout.column(align=True)
             col.prop(strip.crop, "max_y")
@@ -507,7 +506,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
         col.prop(strip, "interpolation")
         col.prop(strip, "translation_unit")
         col = layout.column(align=True)
-        col.label(text=_("Position:"))
+        col.label(text="Position:")
         col.prop(strip, "translate_start_x", text="X")
         col.prop(strip, "translate_start_y", text="Y")
 
@@ -517,18 +516,18 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
         col.prop(strip, "use_uniform_scale")
         if (strip.use_uniform_scale):
             col = layout.column(align=True)
-            col.prop(strip, "scale_start_x", text=_("Scale"))
+            col.prop(strip, "scale_start_x", text="Scale")
         else:
             col = layout.column(align=True)
-            col.label(text=_("Scale:"))
+            col.label(text="Scale:")
             col.prop(strip, "scale_start_x", text="X")
             col.prop(strip, "scale_start_y", text="Y")
 
         layout.separator()
 
         col = layout.column(align=True)
-        col.label(text=_("Rotation:"))
-        col.prop(strip, "rotation_start", text=_("Rotation"))
+        col.label(text="Rotation:")
+        col.prop(strip, "rotation_start", text="Rotation")
 
 
 class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
@@ -561,7 +560,7 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
         if seq_type == 'IMAGE':
             split = layout.split(percentage=0.2)
             col = split.column()
-            col.label(text=_("Path:"))
+            col.label(text="Path:")
             col = split.column()
             col.prop(strip, "directory", text="")
 
@@ -571,7 +570,7 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
             if elem:
                 split = layout.split(percentage=0.2)
                 col = split.column()
-                col.label(text=_("File:"))
+                col.label(text="File:")
                 col = split.column()
                 col.prop(elem, "filename", text="")  # strip.elements[0] could be a fallback
 
@@ -581,22 +580,22 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
         elif seq_type == 'MOVIE':
             split = layout.split(percentage=0.2)
             col = split.column()
-            col.label(text=_("Path:"))
+            col.label(text="Path:")
             col = split.column()
             col.prop(strip, "filepath", text="")
-            col.prop(strip, "mpeg_preseek", text=_("MPEG Preseek"))
-            col.prop(strip, "streamindex", text=_("Stream Index"))
+            col.prop(strip, "mpeg_preseek", text="MPEG Preseek")
+            col.prop(strip, "streamindex", text="Stream Index")
 
         # TODO, sound???
         # end drawing filename
 
-        layout.prop(strip, "use_translation", text=_("Image Offset:"))
+        layout.prop(strip, "use_translation", text="Image Offset:")
         if strip.use_translation:
             col = layout.column(align=True)
             col.prop(strip.transform, "offset_x", text="X")
             col.prop(strip.transform, "offset_y", text="Y")
 
-        layout.prop(strip, "use_crop", text=_("Image Crop:"))
+        layout.prop(strip, "use_crop", text="Image Crop:")
         if strip.use_crop:
             col = layout.column(align=True)
             col.prop(strip.crop, "max_y")
@@ -606,14 +605,14 @@ class SEQUENCER_PT_input(SequencerButtonsPanel, Panel):
 
         if not isinstance(strip, bpy.types.EffectSequence):
             col = layout.column(align=True)
-            col.label(text=_("Trim Duration (hard):"))
-            col.prop(strip, "animation_offset_start", text=_("Start"))
-            col.prop(strip, "animation_offset_end", text=_("End"))
+            col.label(text="Trim Duration (hard):")
+            col.prop(strip, "animation_offset_start", text="Start")
+            col.prop(strip, "animation_offset_end", text="End")
 
         col = layout.column(align=True)
-        col.label(text=_("Trim Duration (soft):"))
-        col.prop(strip, "frame_offset_start", text=_("Start"))
-        col.prop(strip, "frame_offset_end", text=_("End"))
+        col.label(text="Trim Duration (soft):")
+        col.prop(strip, "frame_offset_start", text="Start")
+        col.prop(strip, "frame_offset_end", text="End")
 
 
 class SEQUENCER_PT_sound(SequencerButtonsPanel, Panel):
@@ -642,9 +641,9 @@ class SEQUENCER_PT_sound(SequencerButtonsPanel, Panel):
 
         row = layout.row()
         if strip.sound.packed_file:
-            row.operator("sound.unpack", icon='PACKAGE', text=_("Unpack"))
+            row.operator("sound.unpack", icon='PACKAGE', text="Unpack")
         else:
-            row.operator("sound.pack", icon='UGLYPACKAGE', text=_("Pack"))
+            row.operator("sound.pack", icon='UGLYPACKAGE', text="Pack")
 
         row.prop(strip.sound, "use_memory_cache")
 
@@ -655,8 +654,8 @@ class SEQUENCER_PT_sound(SequencerButtonsPanel, Panel):
 
         col = layout.column(align=True)
         col.label(text="Trim Duration:")
-        col.prop(strip, "animation_offset_start", text=_("Start"))
-        col.prop(strip, "animation_offset_end", text=_("End"))
+        col.prop(strip, "animation_offset_start", text="Start")
+        col.prop(strip, "animation_offset_end", text="End")
 
 
 class SEQUENCER_PT_scene(SequencerButtonsPanel, Panel):
@@ -684,13 +683,13 @@ class SEQUENCER_PT_scene(SequencerButtonsPanel, Panel):
         if scene:
             layout.prop(scene.render, "use_sequencer")
 
-        layout.label(text=_("Camera Override"))
+        layout.label(text="Camera Override")
         layout.template_ID(strip, "scene_camera")
 
         if scene:
             sta = scene.frame_start
             end = scene.frame_end
-            layout.label(text=_("Original frame range") + ": %d-%d (%d)" % (sta, end, end - sta + 1))
+            layout.label(text="Original frame range" + ": %d-%d (%d)" % (sta, end, end - sta + 1))
 
 
 class SEQUENCER_PT_filter(SequencerButtonsPanel, Panel):
@@ -718,22 +717,22 @@ class SEQUENCER_PT_filter(SequencerButtonsPanel, Panel):
         strip = act_strip(context)
 
         col = layout.column()
-        col.label(text=_("Video:"))
+        col.label(text="Video:")
         col.prop(strip, "strobe")
 
         row = layout.row()
-        row.label(text=_("Flip:"))
+        row.label(text="Flip:")
         row.prop(strip, "use_flip_x", text="X")
         row.prop(strip, "use_flip_y", text="Y")
 
         col = layout.column()
-        col.prop(strip, "use_reverse_frames", text=_("Backwards"))
+        col.prop(strip, "use_reverse_frames", text="Backwards")
         col.prop(strip, "use_deinterlace")
 
         col = layout.column()
-        col.label(text=_("Colors:"))
-        col.prop(strip, "color_saturation", text=_("Saturation"))
-        col.prop(strip, "color_multiply", text=_("Multiply"))
+        col.label(text="Colors:")
+        col.prop(strip, "color_saturation", text="Saturation")
+        col.prop(strip, "color_multiply", text="Multiply")
         col.prop(strip, "use_premultiply")
         col.prop(strip, "use_float")
 
@@ -744,15 +743,15 @@ class SEQUENCER_PT_filter(SequencerButtonsPanel, Panel):
             col = row.column()
             col.template_color_wheel(strip.color_balance, "lift", value_slider=False, cubic=True)
             col.row().prop(strip.color_balance, "lift")
-            col.prop(strip.color_balance, "invert_lift", text=_("Inverse"))
+            col.prop(strip.color_balance, "invert_lift", text="Inverse")
             col = row.column()
             col.template_color_wheel(strip.color_balance, "gamma", value_slider=False, lock_luminosity=True, cubic=True)
             col.row().prop(strip.color_balance, "gamma")
-            col.prop(strip.color_balance, "invert_gamma", text=_("Inverse"))
+            col.prop(strip.color_balance, "invert_gamma", text="Inverse")
             col = row.column()
             col.template_color_wheel(strip.color_balance, "gain", value_slider=False, lock_luminosity=True, cubic=True)
             col.row().prop(strip.color_balance, "gain")
-            col.prop(strip.color_balance, "invert_gain", text=_("Inverse"))
+            col.prop(strip.color_balance, "invert_gain", text="Inverse")
 
 
 class SEQUENCER_PT_proxy(SequencerButtonsPanel, Panel):
@@ -795,18 +794,18 @@ class SEQUENCER_PT_proxy(SequencerButtonsPanel, Panel):
             row.prop(strip.proxy, "build_100")
 
             col = layout.column()
-            col.label(text=_("Build JPEG quality"))
+            col.label(text="Build JPEG quality")
             col.prop(strip.proxy, "quality")
 
             if strip.type == "MOVIE":
                 col = layout.column()
-                col.label(text=_("Use timecode index:"))
+                col.label(text="Use timecode index:")
 
                 col.prop(strip.proxy, "timecode")
 
 
 class SEQUENCER_PT_preview(SequencerButtonsPanel_Output, Panel):
-    bl_label = _("Scene Preview/Render")
+    bl_label = "Scene Preview/Render"
     bl_space_type = 'SEQUENCE_EDITOR'
     bl_region_type = 'UI'
 
@@ -816,7 +815,7 @@ class SEQUENCER_PT_preview(SequencerButtonsPanel_Output, Panel):
 
         col = layout.column()
         col.active = False  # Currently only opengl preview works!
-        col.prop(render, "use_sequencer_gl_preview", text=_("Open GL Preview"))
+        col.prop(render, "use_sequencer_gl_preview", text="Open GL Preview")
         col = layout.column()
         #col.active = render.use_sequencer_gl_preview
         col.prop(render, "sequencer_gl_preview", text="")

release/scripts/startup/bl_ui/space_text.py

@@ -19,7 +19,6 @@
 # <pep8-80 compliant>
 import bpy
 from bpy.types import Header, Menu, Panel
-from blf import gettext as _
 
 
 class TEXT_HT_header(Header):
@@ -67,13 +66,13 @@ class TEXT_HT_header(Header):
             row = layout.row()
             if text.filepath:
                 if text.is_dirty:
-                    row.label(text=_("File") + ": *%r " % text.filepath + _("(unsaved)"))
+                    row.label(text="File" + ": *%r " % text.filepath + "(unsaved)")
                 else:
-                    row.label(text=_("File") + ": %r" % text.filepath)
+                    row.label(text="File" + ": %r" % text.filepath)
             else:
-                row.label(text=_("Text: External")
+                row.label(text="Text: External"
                           if text.library
-                          else _("Text: Internal"))
+                          else "Text: Internal")
 
 
 class TEXT_PT_properties(Panel):
@@ -137,8 +136,8 @@ class TEXT_PT_find(Panel):
         # settings
         layout.prop(st, "use_match_case")
         row = layout.row()
-        row.prop(st, "use_find_wrap", text=_("Wrap"))
-        row.prop(st, "use_find_all", text=_("All"))
+        row.prop(st, "use_find_wrap", text="Wrap")
+        row.prop(st, "use_find_all", text="All")
 
 
 class TEXT_MT_view(Menu):
@@ -157,10 +156,10 @@ class TEXT_MT_view(Menu):
         layout.separator()
 
         layout.operator("text.move",
-                        text=_("Top of File"),
+                        text="Top of File",
                         ).type = 'FILE_TOP'
         layout.operator("text.move",
-                        text=_("Bottom of File"),
+                        text="Bottom of File",
                         ).type = 'FILE_BOTTOM'
 
 
@@ -249,10 +248,10 @@ class TEXT_MT_edit_to3d(Menu):
         layout = self.layout
 
         layout.operator("text.to_3d_object",
-                        text=_("One Object"),
+                        text="One Object",
                         ).split_lines = False
         layout.operator("text.to_3d_object",
-                        text=_("One Object Per Line"),
+                        text="One Object Per Line",
                         ).split_lines = True
 
 
@@ -283,7 +282,7 @@ class TEXT_MT_edit(Menu):
         layout.separator()
 
         layout.operator("text.jump")
-        layout.operator("text.properties", text=_("Find..."))
+        layout.operator("text.properties", text="Find...")
 
         layout.separator()
 

release/scripts/startup/bl_ui/space_time.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Header, Menu
-from blf import gettext as _
 
 
 class TIME_HT_header(Header):
@@ -44,11 +43,11 @@ class TIME_HT_header(Header):
 
         row = layout.row(align=True)
         if not scene.use_preview_range:
-            row.prop(scene, "frame_start", text=_("Start"))
-            row.prop(scene, "frame_end", text=_("End"))
+            row.prop(scene, "frame_start", text="Start")
+            row.prop(scene, "frame_end", text="End")
         else:
-            row.prop(scene, "frame_preview_start", text=_("Start"))
-            row.prop(scene, "frame_preview_end", text=_("End"))
+            row.prop(scene, "frame_preview_start", text="Start")
+            row.prop(scene, "frame_preview_end", text="End")
 
         layout.prop(scene, "frame_current", text="")
 
@@ -143,14 +142,14 @@ class TIME_MT_frame(Menu):
     def draw(self, context):
         layout = self.layout
 
-        layout.operator("marker.add", text=_("Add Marker"))
-        layout.operator("marker.duplicate", text=_("Duplicate Marker"))
-        layout.operator("marker.delete", text=_("Delete Marker"))
+        layout.operator("marker.add", text="Add Marker")
+        layout.operator("marker.duplicate", text="Duplicate Marker")
+        layout.operator("marker.delete", text="Delete Marker")
 
         layout.separator()
 
-        layout.operator("marker.rename", text=_("Rename Marker"))
-        layout.operator("marker.move", text=_("Grab/Move Marker"))
+        layout.operator("marker.rename", text="Rename Marker")
+        layout.operator("marker.move", text="Grab/Move Marker")
 
         layout.separator()
 
@@ -182,8 +181,8 @@ class TIME_MT_playback(Menu):
 
         layout.separator()
 
-        layout.prop(scene, "use_frame_drop", text=_("Frame Dropping"))
-        layout.prop(scene, "use_audio_sync", text=_("AV-sync"), icon='SPEAKER')
+        layout.prop(scene, "use_frame_drop", text="Frame Dropping")
+        layout.prop(scene, "use_audio_sync", text="AV-sync", icon='SPEAKER')
         layout.prop(scene, "use_audio")
         layout.prop(scene, "use_audio_scrub")
 

release/scripts/startup/bl_ui/space_userpref.py

@@ -18,12 +18,11 @@
 
 # <pep8 compliant>
 import bpy
-from bpy.types import Header, Menu, Operator, Panel
+from bpy.types import Header, Menu, Panel
 import os
 import addon_utils
 
 from bpy.props import StringProperty, BoolProperty, EnumProperty
-from blf import gettext as _
 
 
 def ui_items_general(col, context):
@@ -66,10 +65,10 @@ def opengl_lamp_buttons(column, lamp):
     col = split.column()
     col.active = lamp.use
     row = col.row()
-    row.label(text=_("Diffuse:"))
+    row.label(text="Diffuse:")
     row.prop(lamp, "diffuse_color", text="")
     row = col.row()
-    row.label(text=_("Specular:"))
+    row.label(text="Specular:")
     row.prop(lamp, "specular_color", text="")
 
     col = split.column()
@@ -87,7 +86,7 @@ class USERPREF_HT_header(Header):
         userpref = context.user_preferences
 
         layout.operator_context = 'EXEC_AREA'
-        layout.operator("wm.save_homefile", text=_("Save As Default"))
+        layout.operator("wm.save_homefile", text="Save As Default")
 
         layout.operator_context = 'INVOKE_DEFAULT'
 
@@ -128,7 +127,7 @@ class USERPREF_MT_appconfigs(Menu):
     preset_operator = "wm.appconfig_activate"
 
     def draw(self, context):
-        self.layout.operator("wm.appconfig_default", text=_("Blender (default)"))
+        self.layout.operator("wm.appconfig_default", text="Blender (default)")
 
         # now draw the presets
         Menu.draw_preset(self, context)
@@ -143,12 +142,12 @@ class USERPREF_MT_splash(Menu):
         row = split.row()
         row.label("")
         row = split.row()
-        row.label(_("Interaction:"))
+        row.label("Interaction:")
         # XXX, no redraws
         # text = bpy.path.display_name(context.window_manager.keyconfigs.active.name)
         # if not text:
         #     text = "Blender (default)"
-        row.menu("USERPREF_MT_appconfigs", text=_("Preset"))
+        row.menu("USERPREF_MT_appconfigs", text="Preset")
 
 
 class USERPREF_PT_interface(Panel):
@@ -171,13 +170,13 @@ class USERPREF_PT_interface(Panel):
         row = layout.row()
 
         col = row.column()
-        col.label(text=_("Display:"))
+        col.label(text="Display:")
         col.prop(view, "show_tooltips")
         col.prop(view, "show_tooltips_python")
-        col.prop(view, "show_object_info", text=_("Object Info"))
+        col.prop(view, "show_object_info", text="Object Info")
         col.prop(view, "show_large_cursors")
-        col.prop(view, "show_view_name", text=_("View Name"))
-        col.prop(view, "show_playback_fps", text=_("Playback FPS"))
+        col.prop(view, "show_view_name", text="View Name")
+        col.prop(view, "show_playback_fps", text="Playback FPS")
         col.prop(view, "use_global_scene")
         col.prop(view, "object_origin_size")
 
@@ -185,18 +184,18 @@ class USERPREF_PT_interface(Panel):
         col.separator()
         col.separator()
 
-        col.prop(view, "show_mini_axis", text=_("Display Mini Axis"))
+        col.prop(view, "show_mini_axis", text="Display Mini Axis")
         sub = col.column()
         sub.active = view.show_mini_axis
-        sub.prop(view, "mini_axis_size", text=_("Size"))
-        sub.prop(view, "mini_axis_brightness", text=_("Brightness"))
+        sub.prop(view, "mini_axis_size", text="Size")
+        sub.prop(view, "mini_axis_brightness", text="Brightness")
 
         col.separator()
         row.separator()
         row.separator()
 
         col = row.column()
-        col.label(text=_("View Manipulation:"))
+        col.label(text="View Manipulation:")
         col.prop(view, "use_mouse_auto_depth")
         col.prop(view, "use_zoom_to_mouse")
         col.prop(view, "use_rotate_around_active")
@@ -212,8 +211,8 @@ class USERPREF_PT_interface(Panel):
         col.separator()
         col.separator()
 
-        col.label(text=_("2D Viewports:"))
-        col.prop(view, "view2d_grid_spacing_min", text=_("Minimum Grid Spacing"))
+        col.label(text="2D Viewports:")
+        col.prop(view, "view2d_grid_spacing_min", text="Minimum Grid Spacing")
         col.prop(view, "timecode_style")
 
         row.separator()
@@ -229,19 +228,19 @@ class USERPREF_PT_interface(Panel):
         col.prop(view, "show_manipulator")
         sub = col.column()
         sub.active = view.show_manipulator
-        sub.prop(view, "manipulator_size", text=_("Size"))
-        sub.prop(view, "manipulator_handle_size", text=_("Handle Size"))
-        sub.prop(view, "manipulator_hotspot", text=_("Hotspot"))
+        sub.prop(view, "manipulator_size", text="Size")
+        sub.prop(view, "manipulator_handle_size", text="Handle Size")
+        sub.prop(view, "manipulator_hotspot", text="Hotspot")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("Menus:"))
+        col.label(text="Menus:")
         col.prop(view, "use_mouse_over_open")
-        col.label(text=_("Menu Open Delay:"))
-        col.prop(view, "open_toplevel_delay", text=_("Top Level"))
-        col.prop(view, "open_sublevel_delay", text=_("Sub Level"))
+        col.label(text="Menu Open Delay:")
+        col.prop(view, "open_toplevel_delay", text="Top Level")
+        col.prop(view, "open_sublevel_delay", text="Sub Level")
 
         col.separator()
 
@@ -268,97 +267,97 @@ class USERPREF_PT_edit(Panel):
         row = layout.row()
 
         col = row.column()
-        col.label(text=_("Link Materials To:"))
+        col.label(text="Link Materials To:")
         col.prop(edit, "material_link", text="")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("New Objects:"))
+        col.label(text="New Objects:")
         col.prop(edit, "use_enter_edit_mode")
-        col.label(text=_("Align To:"))
+        col.label(text="Align To:")
         col.prop(edit, "object_align", text="")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("Undo:"))
+        col.label(text="Undo:")
         col.prop(edit, "use_global_undo")
-        col.prop(edit, "undo_steps", text=_("Steps"))
-        col.prop(edit, "undo_memory_limit", text=_("Memory Limit"))
+        col.prop(edit, "undo_steps", text="Steps")
+        col.prop(edit, "undo_memory_limit", text="Memory Limit")
 
         row.separator()
         row.separator()
 
         col = row.column()
-        col.label(text=_("Grease Pencil:"))
-        col.prop(edit, "grease_pencil_manhattan_distance", text=_("Manhattan Distance"))
-        col.prop(edit, "grease_pencil_euclidean_distance", text=_("Euclidean Distance"))
+        col.label(text="Grease Pencil:")
+        col.prop(edit, "grease_pencil_manhattan_distance", text="Manhattan Distance")
+        col.prop(edit, "grease_pencil_euclidean_distance", text="Euclidean Distance")
         #col.prop(edit, "use_grease_pencil_simplify_stroke", text="Simplify Stroke")
-        col.prop(edit, "grease_pencil_eraser_radius", text=_("Eraser Radius"))
-        col.prop(edit, "use_grease_pencil_smooth_stroke", text=_("Smooth Stroke"))
+        col.prop(edit, "grease_pencil_eraser_radius", text="Eraser Radius")
+        col.prop(edit, "use_grease_pencil_smooth_stroke", text="Smooth Stroke")
         col.separator()
         col.separator()
         col.separator()
-        col.label(text=_("Playback:"))
+        col.label(text="Playback:")
         col.prop(edit, "use_negative_frames")
 
         row.separator()
         row.separator()
 
         col = row.column()
-        col.label(text=_("Keyframing:"))
+        col.label(text="Keyframing:")
         col.prop(edit, "use_visual_keying")
-        col.prop(edit, "use_keyframe_insert_needed", text=_("Only Insert Needed"))
+        col.prop(edit, "use_keyframe_insert_needed", text="Only Insert Needed")
 
         col.separator()
 
-        col.prop(edit, "use_auto_keying", text=_("Auto Keyframing:"))
+        col.prop(edit, "use_auto_keying", text="Auto Keyframing:")
 
         sub = col.column()
 
         # sub.active = edit.use_keyframe_insert_auto # incorrect, timeline can enable
-        sub.prop(edit, "use_keyframe_insert_available", text=_("Only Insert Available"))
+        sub.prop(edit, "use_keyframe_insert_available", text="Only Insert Available")
 
         col.separator()
 
-        col.label(text=_("New F-Curve Defaults:"))
-        col.prop(edit, "keyframe_new_interpolation_type", text=_("Interpolation"))
-        col.prop(edit, "keyframe_new_handle_type", text=_("Handles"))
-        col.prop(edit, "use_insertkey_xyz_to_rgb", text=_("XYZ to RGB"))
+        col.label(text="New F-Curve Defaults:")
+        col.prop(edit, "keyframe_new_interpolation_type", text="Interpolation")
+        col.prop(edit, "keyframe_new_handle_type", text="Handles")
+        col.prop(edit, "use_insertkey_xyz_to_rgb", text="XYZ to RGB")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("Transform:"))
+        col.label(text="Transform:")
         col.prop(edit, "use_drag_immediately")
 
         row.separator()
         row.separator()
 
         col = row.column()
-        col.prop(edit, "sculpt_paint_overlay_color", text=_("Sculpt Overlay Color"))
+        col.prop(edit, "sculpt_paint_overlay_color", text="Sculpt Overlay Color")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("Duplicate Data:"))
-        col.prop(edit, "use_duplicate_mesh", text=_("Mesh"))
-        col.prop(edit, "use_duplicate_surface", text=_("Surface"))
-        col.prop(edit, "use_duplicate_curve", text=_("Curve"))
-        col.prop(edit, "use_duplicate_text", text=_("Text"))
-        col.prop(edit, "use_duplicate_metaball", text=_("Metaball"))
-        col.prop(edit, "use_duplicate_armature", text=_("Armature"))
-        col.prop(edit, "use_duplicate_lamp", text=_("Lamp"))
-        col.prop(edit, "use_duplicate_material", text=_("Material"))
-        col.prop(edit, "use_duplicate_texture", text=_("Texture"))
-        #col.prop(edit, "use_duplicate_fcurve", text=_("F-Curve"))
-        col.prop(edit, "use_duplicate_action", text=_("Action"))
-        col.prop(edit, "use_duplicate_particle", text=_("Particle"))
+        col.label(text="Duplicate Data:")
+        col.prop(edit, "use_duplicate_mesh", text="Mesh")
+        col.prop(edit, "use_duplicate_surface", text="Surface")
+        col.prop(edit, "use_duplicate_curve", text="Curve")
+        col.prop(edit, "use_duplicate_text", text="Text")
+        col.prop(edit, "use_duplicate_metaball", text="Metaball")
+        col.prop(edit, "use_duplicate_armature", text="Armature")
+        col.prop(edit, "use_duplicate_lamp", text="Lamp")
+        col.prop(edit, "use_duplicate_material", text="Material")
+        col.prop(edit, "use_duplicate_texture", text="Texture")
+        #col.prop(edit, "use_duplicate_fcurve", text="F-Curve")
+        col.prop(edit, "use_duplicate_action", text="Action")
+        col.prop(edit, "use_duplicate_particle", text="Particle")
 
 
 class USERPREF_PT_system(Panel):
@@ -385,11 +384,11 @@ class USERPREF_PT_system(Panel):
         colsplit = column.split(percentage=0.85)
 
         col = colsplit.column()
-        col.label(text=_("General:"))
+        col.label(text="General:")
         col.prop(system, "dpi")
         col.prop(system, "frame_server_port")
-        col.prop(system, "scrollback", text=_("Console Scrollback"))
-        col.prop(system, "author", text=_("Author"))
+        col.prop(system, "scrollback", text="Console Scrollback")
+        col.prop(system, "author", text="Author")
         col.prop(system, "use_scripts_auto_execute")
         col.prop(system, "use_tabs_as_spaces")
 
@@ -397,21 +396,21 @@ class USERPREF_PT_system(Panel):
         col.separator()
         col.separator()
 
-        col.label(text=_("Sound:"))
+        col.label(text="Sound:")
         col.row().prop(system, "audio_device", expand=True)
         sub = col.column()
         sub.active = system.audio_device != 'NONE'
         #sub.prop(system, "use_preview_images")
-        sub.prop(system, "audio_channels", text=_("Channels"))
-        sub.prop(system, "audio_mixing_buffer", text=_("Mixing Buffer"))
-        sub.prop(system, "audio_sample_rate", text=_("Sample Rate"))
-        sub.prop(system, "audio_sample_format", text=_("Sample Format"))
+        sub.prop(system, "audio_channels", text="Channels")
+        sub.prop(system, "audio_mixing_buffer", text="Mixing Buffer")
+        sub.prop(system, "audio_sample_rate", text="Sample Rate")
+        sub.prop(system, "audio_sample_format", text="Sample Format")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("Screencast:"))
+        col.label(text="Screencast:")
         col.prop(system, "screencast_fps")
         col.prop(system, "screencast_wait_time")
         col.separator()
@@ -423,40 +422,40 @@ class USERPREF_PT_system(Panel):
         colsplit = column.split(percentage=0.85)
 
         col = colsplit.column()
-        col.label(text=_("OpenGL:"))
+        col.label(text="OpenGL:")
         col.prop(system, "gl_clip_alpha", slider=True)
         col.prop(system, "use_mipmaps")
-        col.label(text=_("Anisotropic Filtering"))
+        col.label(text="Anisotropic Filtering")
         col.prop(system, "anisotropic_filter", text="")
         col.prop(system, "use_vertex_buffer_objects")
         #Anti-aliasing is disabled as it breaks broder/lasso select
         #col.prop(system, "use_antialiasing")
-        col.label(text=_("Window Draw Method:"))
+        col.label(text="Window Draw Method:")
         col.prop(system, "window_draw_method", text="")
-        col.label(text=_("Text Draw Options:"))
+        col.label(text="Text Draw Options:")
         col.prop(system, "use_text_antialiasing")
-        col.label(text=_("Textures:"))
-        col.prop(system, "gl_texture_limit", text=_("Limit Size"))
-        col.prop(system, "texture_time_out", text=_("Time Out"))
-        col.prop(system, "texture_collection_rate", text=_("Collection Rate"))
+        col.label(text="Textures:")
+        col.prop(system, "gl_texture_limit", text="Limit Size")
+        col.prop(system, "texture_time_out", text="Time Out")
+        col.prop(system, "texture_collection_rate", text="Collection Rate")
 
         col.separator()
         col.separator()
         col.separator()
 
-        col.label(text=_("Sequencer:"))
+        col.label(text="Sequencer:")
         col.prop(system, "prefetch_frames")
         col.prop(system, "memory_cache_limit")
 
         # 3. Column
         column = split.column()
 
-        column.label(text=_("Solid OpenGL lights:"))
+        column.label(text="Solid OpenGL lights:")
 
         split = column.split(percentage=0.1)
         split.label()
-        split.label(text=_("Colors:"))
-        split.label(text=_("Direction:"))
+        split.label(text="Colors:")
+        split.label(text="Direction:")
 
         lamp = system.solid_lights[0]
         opengl_lamp_buttons(column, lamp)
@@ -469,12 +468,12 @@ class USERPREF_PT_system(Panel):
 
         column.separator()
 
-        column.label(text=_("Color Picker Type:"))
+        column.label(text="Color Picker Type:")
         column.row().prop(system, "color_picker_type", text="")
 
         column.separator()
 
-        column.prop(system, "use_weight_color_range", text=_("Custom Weight Paint Range"))
+        column.prop(system, "use_weight_color_range", text="Custom Weight Paint Range")
         sub = column.column()
         sub.active = system.use_weight_color_range
         sub.template_color_ramp(system, "weight_color_range", expand=True)
@@ -550,71 +549,71 @@ class USERPREF_PT_theme(Panel):
             col = split.column()
 
             ui = theme.user_interface.wcol_regular
-            col.label(text=_("Regular:"))
+            col.label(text="Regular:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_tool
-            col.label(text=_("Tool:"))
+            col.label(text="Tool:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_radio
-            col.label(text=_("Radio Buttons:"))
+            col.label(text="Radio Buttons:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_text
-            col.label(text=_("Text:"))
+            col.label(text="Text:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_option
-            col.label(text=_("Option:"))
+            col.label(text="Option:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_toggle
-            col.label(text=_("Toggle:"))
+            col.label(text="Toggle:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_num
-            col.label(text=_("Number Field:"))
+            col.label(text="Number Field:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_numslider
-            col.label(text=_("Value Slider:"))
+            col.label(text="Value Slider:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_box
-            col.label(text=_("Box:"))
+            col.label(text="Box:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_menu
-            col.label(text=_("Menu:"))
+            col.label(text="Menu:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_pulldown
-            col.label(text=_("Pulldown:"))
+            col.label(text="Pulldown:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_menu_back
-            col.label(text=_("Menu Back:"))
+            col.label(text="Menu Back:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_menu_item
-            col.label(text=_("Menu Item:"))
+            col.label(text="Menu Item:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_scroll
-            col.label(text=_("Scroll Bar:"))
+            col.label(text="Scroll Bar:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_progress
-            col.label(text=_("Progress Bar:"))
+            col.label(text="Progress Bar:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_list_item
-            col.label(text=_("List Item:"))
+            col.label(text="List Item:")
             ui_items_general(col, ui)
 
             ui = theme.user_interface.wcol_state
-            col.label(text=_("State:"))
+            col.label(text="State:")
 
             row = col.row()
 
@@ -650,7 +649,7 @@ class USERPREF_PT_theme(Panel):
             col = split.column()
 
             for i, ui in enumerate(theme.bone_color_sets):
-                col.label(text=_("Color Set") + " %d:" % (i + 1))  # i starts from 0
+                col.label(text="Color Set" + " %d:" % (i + 1))  # i starts from 0
 
                 row = col.row()
 
@@ -693,22 +692,22 @@ class USERPREF_PT_file(Panel):
         split = layout.split(percentage=0.7)
 
         col = split.column()
-        col.label(text=_("File Paths:"))
+        col.label(text="File Paths:")
 
         colsplit = col.split(percentage=0.95)
         col1 = colsplit.split(percentage=0.3)
 
         sub = col1.column()
-        sub.label(text=_("Fonts:"))
-        sub.label(text=_("Textures:"))
-        sub.label(text=_("Texture Plugins:"))
-        sub.label(text=_("Sequence Plugins:"))
-        sub.label(text=_("Render Output:"))
-        sub.label(text=_("Scripts:"))
-        sub.label(text=_("Sounds:"))
-        sub.label(text=_("Temp:"))
-        sub.label(text=_("Image Editor:"))
-        sub.label(text=_("Animation Player:"))
+        sub.label(text="Fonts:")
+        sub.label(text="Textures:")
+        sub.label(text="Texture Plugins:")
+        sub.label(text="Sequence Plugins:")
+        sub.label(text="Render Output:")
+        sub.label(text="Scripts:")
+        sub.label(text="Sounds:")
+        sub.label(text="Temp:")
+        sub.label(text="Image Editor:")
+        sub.label(text="Animation Player:")
 
         sub = col1.column()
         sub.prop(paths, "font_directory", text="")
@@ -725,7 +724,7 @@ class USERPREF_PT_file(Panel):
         subsplit.prop(paths, "animation_player", text="")
 
         col = split.column()
-        col.label(text=_("Save & Load:"))
+        col.label(text="Save & Load:")
         col.prop(paths, "use_relative_paths")
         col.prop(paths, "use_file_compression")
         col.prop(paths, "use_load_ui")
@@ -740,11 +739,11 @@ class USERPREF_PT_file(Panel):
         col.prop(paths, "save_version")
         col.prop(paths, "recent_files")
         col.prop(paths, "use_save_preview_images")
-        col.label(text=_("Auto Save:"))
+        col.label(text="Auto Save:")
         col.prop(paths, "use_auto_save_temporary_files")
         sub = col.column()
         sub.active = paths.use_auto_save_temporary_files
-        sub.prop(paths, "auto_save_time", text=_("Timer (mins)"))
+        sub.prop(paths, "auto_save_time", text="Timer (mins)")
 
 from bl_ui.space_userpref_keymap import InputKeyMapPanel
 
@@ -800,7 +799,7 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
         col = row.column()
 
         sub = col.column()
-        sub.label(text=_("Presets:"))
+        sub.label(text="Presets:")
         subrow = sub.row(align=True)
 
         subrow.menu("USERPREF_MT_interaction_presets", text=bpy.types.USERPREF_MT_interaction_presets.bl_label)
@@ -808,19 +807,19 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
         subrow.operator("wm.interaction_preset_add", text="", icon='ZOOMOUT').remove_active = True
         sub.separator()
 
-        sub.label(text=_("Mouse:"))
+        sub.label(text="Mouse:")
         sub1 = sub.column()
         sub1.active = (inputs.select_mouse == 'RIGHT')
         sub1.prop(inputs, "use_mouse_emulate_3_button")
         sub.prop(inputs, "use_mouse_continuous")
         sub.prop(inputs, "drag_threshold")
 
-        sub.label(text=_("Select With:"))
+        sub.label(text="Select With:")
         sub.row().prop(inputs, "select_mouse", expand=True)
 
         sub = col.column()
-        sub.label(text=_("Double Click:"))
-        sub.prop(inputs, "mouse_double_click_time", text=_("Speed"))
+        sub.label(text="Double Click:")
+        sub.prop(inputs, "mouse_double_click_time", text="Speed")
 
         sub.separator()
 
@@ -828,10 +827,10 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
 
         sub.separator()
 
-        sub.label(text=_("Orbit Style:"))
+        sub.label(text="Orbit Style:")
         sub.row().prop(inputs, "view_rotate_method", expand=True)
 
-        sub.label(text=_("Zoom Style:"))
+        sub.label(text="Zoom Style:")
         sub.row().prop(inputs, "view_zoom_method", text="")
         if inputs.view_zoom_method in {'DOLLY', 'CONTINUE'}:
             sub.row().prop(inputs, "view_zoom_axis", expand=True)
@@ -842,8 +841,8 @@ class USERPREF_PT_input(Panel, InputKeyMapPanel):
         #col.separator()
 
         sub = col.column()
-        sub.label(text=_("Mouse Wheel:"))
-        sub.prop(inputs, "invert_zoom_wheel", text=_("Invert Wheel Zoom Direction"))
+        sub.label(text="Mouse Wheel:")
+        sub.prop(inputs, "invert_zoom_wheel", text="Invert Wheel Zoom Direction")
         #sub.prop(view, "wheel_scroll_lines", text="Scroll Lines")
 
         col.separator()
@@ -881,9 +880,9 @@ class USERPREF_MT_addons_dev_guides(Menu):
     # menu to open webpages with addons development guides
     def draw(self, context):
         layout = self.layout
-        layout.operator('wm.url_open', text=_('API Concepts'), icon='URL').url = 'http://wiki.blender.org/index.php/Dev:2.5/Py/API/Intro'
-        layout.operator('wm.url_open', text=_('Addon Guidelines'), icon='URL').url = 'http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Guidelines/Addons'
-        layout.operator('wm.url_open', text=_('How to share your addon'), icon='URL').url = 'http://wiki.blender.org/index.php/Dev:Py/Sharing'
+        layout.operator("wm.url_open", text="API Concepts", icon='URL').url = "http://wiki.blender.org/index.php/Dev:2.5/Py/API/Intro"
+        layout.operator("wm.url_open", text="Addon Guidelines", icon='URL').url = "http://wiki.blender.org/index.php/Dev:2.5/Py/Scripts/Guidelines/Addons"
+        layout.operator("wm.url_open", text="How to share your addon", icon='URL').url = "http://wiki.blender.org/index.php/Dev:Py/Sharing"
 
 
 class USERPREF_PT_addons(Panel):
@@ -892,17 +891,11 @@ class USERPREF_PT_addons(Panel):
     bl_region_type = 'WINDOW'
     bl_options = {'HIDE_HEADER'}
 
-    _addons_fake_modules = {}
-
     @classmethod
     def poll(cls, context):
         userpref = context.user_preferences
         return (userpref.active_section == 'ADDONS')
 
-    @staticmethod
-    def module_get(mod_name):
-        return USERPREF_PT_addons._addons_fake_modules[mod_name]
-
     @staticmethod
     def is_user_addon(mod, user_addon_paths):
         if not user_addon_paths:
@@ -933,15 +926,15 @@ class USERPREF_PT_addons(Panel):
         used_ext = {ext.module for ext in userpref.addons}
 
         # collect the categories that can be filtered on
-        addons = [(mod, addon_utils.module_bl_info(mod)) for mod in addon_utils.modules(USERPREF_PT_addons._addons_fake_modules)]
+        addons = [(mod, addon_utils.module_bl_info(mod)) for mod in addon_utils.modules(addon_utils.addons_fake_modules)]
 
         split = layout.split(percentage=0.2)
         col = split.column()
         col.prop(context.window_manager, "addon_search", text="", icon='VIEWZOOM')
-        col.label(text=_("Categories"))
+        col.label(text="Categories")
         col.prop(context.window_manager, "addon_filter", expand=True)
 
-        col.label(text=_("Supported Level"))
+        col.label(text="Supported Level")
         col.prop(context.window_manager, "addon_support", expand=True)
 
         col = split.column()
@@ -1018,23 +1011,23 @@ class USERPREF_PT_addons(Panel):
                 if info["show_expanded"]:
                     if info["description"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text=_('Description:'))
+                        split.label(text="Description:")
                         split.label(text=info["description"])
                     if info["location"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text=_('Location:'))
+                        split.label(text="Location:")
                         split.label(text=info["location"])
                     if info["author"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text=_('Author:'))
+                        split.label(text="Author:")
                         split.label(text=info["author"])
                     if info["version"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text=_('Version:'))
+                        split.label(text="Version:")
                         split.label(text='.'.join(str(x) for x in info["version"]))
                     if info["warning"]:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text=_("Warning:"))
+                        split.label(text="Warning:")
                         split.label(text='  ' + info["warning"], icon='ERROR')
 
                     user_addon = USERPREF_PT_addons.is_user_addon(mod, user_addon_paths)
@@ -1042,13 +1035,13 @@ class USERPREF_PT_addons(Panel):
 
                     if tot_row:
                         split = colsub.row().split(percentage=0.15)
-                        split.label(text=_("Internet:"))
+                        split.label(text="Internet:")
                         if info["wiki_url"]:
-                            split.operator("wm.url_open", text=_("Link to the Wiki"), icon='HELP').url = info["wiki_url"]
+                            split.operator("wm.url_open", text="Link to the Wiki", icon='HELP').url = info["wiki_url"]
                         if info["tracker_url"]:
-                            split.operator("wm.url_open", text=_("Report a Bug"), icon='URL').url = info["tracker_url"]
+                            split.operator("wm.url_open", text="Report a Bug", icon='URL').url = info["tracker_url"]
                         if user_addon:
-                            split.operator("wm.addon_remove", text=_("Remove"), icon='CANCEL').module = mod.__name__
+                            split.operator("wm.addon_remove", text="Remove", icon='CANCEL').module = mod.__name__
 
                         for i in range(4 - tot_row):
                             split.separator()
@@ -1060,7 +1053,7 @@ class USERPREF_PT_addons(Panel):
 
         if missing_modules and filter in {"All", "Enabled"}:
             col.column().separator()
-            col.column().label(text=_("Missing script files"))
+            col.column().label(text="Missing script files")
 
             module_names = {mod.__name__ for mod, info in addons}
             for module_name in sorted(missing_modules):
@@ -1075,292 +1068,5 @@ class USERPREF_PT_addons(Panel):
                 if is_enabled:
                     row.operator("wm.addon_disable", icon='CHECKBOX_HLT', text="", emboss=False).module = module_name
 
-
-class WM_OT_addon_enable(Operator):
-    "Enable an addon"
-    bl_idname = "wm.addon_enable"
-    bl_label = "Enable Add-On"
-
-    module = StringProperty(
-            name="Module",
-            description="Module name of the addon to enable",
-            )
-
-    def execute(self, context):
-        mod = addon_utils.enable(self.module)
-
-        if mod:
-            info = addon_utils.module_bl_info(mod)
-
-            info_ver = info.get("blender", (0, 0, 0))
-
-            if info_ver > bpy.app.version:
-                self.report({'WARNING'}, ("This script was written Blender "
-                                          "version %d.%d.%d and might not "
-                                          "function (correctly), "
-                                          "though it is enabled") %
-                                         info_ver)
-            return {'FINISHED'}
-        else:
-            return {'CANCELLED'}
-
-
-class WM_OT_addon_disable(Operator):
-    "Disable an addon"
-    bl_idname = "wm.addon_disable"
-    bl_label = "Disable Add-On"
-
-    module = StringProperty(
-            name="Module",
-            description="Module name of the addon to disable",
-            )
-
-    def execute(self, context):
-        addon_utils.disable(self.module)
-        return {'FINISHED'}
-
-
-class WM_OT_addon_install(Operator):
-    "Install an addon"
-    bl_idname = "wm.addon_install"
-    bl_label = "Install Add-On..."
-
-    overwrite = BoolProperty(
-            name="Overwrite",
-            description="Remove existing addons with the same ID",
-            default=True,
-            )
-    target = EnumProperty(
-            name="Target Path",
-            items=(('DEFAULT', "Default", ""),
-                   ('PREFS', "User Prefs", "")),
-            )
-
-    filepath = StringProperty(
-            name="File Path",
-            description="File path to write file to",
-            )
-    filter_folder = BoolProperty(
-            name="Filter folders",
-            default=True,
-            options={'HIDDEN'},
-            )
-    filter_python = BoolProperty(
-            name="Filter python",
-            default=True,
-            options={'HIDDEN'},
-            )
-    filter_glob = StringProperty(
-            default="*.py;*.zip",
-            options={'HIDDEN'},
-            )
-
-    @staticmethod
-    def _module_remove(path_addons, module):
-        module = os.path.splitext(module)[0]
-        for f in os.listdir(path_addons):
-            f_base = os.path.splitext(f)[0]
-            if f_base == module:
-                f_full = os.path.join(path_addons, f)
-
-                if os.path.isdir(f_full):
-                    os.rmdir(f_full)
-                else:
-                    os.remove(f_full)
-
-    def execute(self, context):
-        import traceback
-        import zipfile
-        import shutil
-
-        pyfile = self.filepath
-
-        if self.target == 'DEFAULT':
-            # dont use bpy.utils.script_paths("addons") because we may not be able to write to it.
-            path_addons = bpy.utils.user_resource('SCRIPTS', "addons", create=True)
-        else:
-            path_addons = bpy.context.user_preferences.filepaths.script_directory
-            if path_addons:
-                path_addons = os.path.join(path_addons, "addons")
-
-        if not path_addons:
-            self.report({'ERROR'}, "Failed to get addons path")
-            return {'CANCELLED'}
-
-        # create dir is if missing.
-        if not os.path.exists(path_addons):
-            os.makedirs(path_addons)
-
-        # Check if we are installing from a target path,
-        # doing so causes 2+ addons of same name or when the same from/to
-        # location is used, removal of the file!
-        addon_path = ""
-        pyfile_dir = os.path.dirname(pyfile)
-        for addon_path in addon_utils.paths():
-            if os.path.samefile(pyfile_dir, addon_path):
-                self.report({'ERROR'}, "Source file is in the addon search path: %r" % addon_path)
-                return {'CANCELLED'}
-        del addon_path
-        del pyfile_dir
-        # done checking for exceptional case
-
-        addons_old = {mod.__name__ for mod in addon_utils.modules(USERPREF_PT_addons._addons_fake_modules)}
-
-        #check to see if the file is in compressed format (.zip)
-        if zipfile.is_zipfile(pyfile):
-            try:
-                file_to_extract = zipfile.ZipFile(pyfile, 'r')
-            except:
-                traceback.print_exc()
-                return {'CANCELLED'}
-
-            if self.overwrite:
-                for f in file_to_extract.namelist():
-                    WM_OT_addon_install._module_remove(path_addons, f)
-            else:
-                for f in file_to_extract.namelist():
-                    path_dest = os.path.join(path_addons, os.path.basename(f))
-                    if os.path.exists(path_dest):
-                        self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
-                        return {'CANCELLED'}
-
-            try:  # extract the file to "addons"
-                file_to_extract.extractall(path_addons)
-
-                # zip files can create this dir with metadata, don't need it
-                macosx_dir = os.path.join(path_addons, '__MACOSX')
-                if os.path.isdir(macosx_dir):
-                    shutil.rmtree(macosx_dir)
-
-            except:
-                traceback.print_exc()
-                return {'CANCELLED'}
-
-        else:
-            path_dest = os.path.join(path_addons, os.path.basename(pyfile))
-
-            if self.overwrite:
-                WM_OT_addon_install._module_remove(path_addons, os.path.basename(pyfile))
-            elif os.path.exists(path_dest):
-                self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
-                return {'CANCELLED'}
-
-            #if not compressed file just copy into the addon path
-            try:
-                shutil.copyfile(pyfile, path_dest)
-
-            except:
-                traceback.print_exc()
-                return {'CANCELLED'}
-
-        addons_new = {mod.__name__ for mod in addon_utils.modules(USERPREF_PT_addons._addons_fake_modules)} - addons_old
-        addons_new.discard("modules")
-
-        # disable any addons we may have enabled previously and removed.
-        # this is unlikely but do just incase. bug [#23978]
-        for new_addon in addons_new:
-            addon_utils.disable(new_addon)
-
-        # possible the zip contains multiple addons, we could disallow this
-        # but for now just use the first
-        for mod in addon_utils.modules(USERPREF_PT_addons._addons_fake_modules):
-            if mod.__name__ in addons_new:
-                info = addon_utils.module_bl_info(mod)
-
-                # show the newly installed addon.
-                context.window_manager.addon_filter = 'All'
-                context.window_manager.addon_search = info["name"]
-                break
-
-        # incase a new module path was created to install this addon.
-        bpy.utils.refresh_script_paths()
-
-        # TODO, should not be a warning.
-        # self.report({'WARNING'}, "File installed to '%s'\n" % path_dest)
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        wm.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-
-class WM_OT_addon_remove(Operator):
-    "Disable an addon"
-    bl_idname = "wm.addon_remove"
-    bl_label = "Remove Add-On"
-
-    module = StringProperty(
-            name="Module",
-            description="Module name of the addon to remove",
-            )
-
-    @staticmethod
-    def path_from_addon(module):
-        for mod in addon_utils.modules(USERPREF_PT_addons._addons_fake_modules):
-            if mod.__name__ == module:
-                filepath = mod.__file__
-                if os.path.exists(filepath):
-                    if os.path.splitext(os.path.basename(filepath))[0] == "__init__":
-                        return os.path.dirname(filepath), True
-                    else:
-                        return filepath, False
-        return None, False
-
-    def execute(self, context):
-        path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
-        if path is None:
-            self.report('WARNING', "Addon path %r could not be found" % path)
-            return {'CANCELLED'}
-
-        # incase its enabled
-        addon_utils.disable(self.module)
-
-        import shutil
-        if isdir:
-            shutil.rmtree(path)
-        else:
-            os.remove(path)
-
-        context.area.tag_redraw()
-        return {'FINISHED'}
-
-    # lame confirmation check
-    def draw(self, context):
-        self.layout.label(text="Remove Addon: %r?" % self.module)
-        path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
-        self.layout.label(text="Path: %r" % path)
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self, width=600)
-
-
-class WM_OT_addon_expand(Operator):
-    "Display more information on this add-on"
-    bl_idname = "wm.addon_expand"
-    bl_label = ""
-
-    module = StringProperty(
-            name="Module",
-            description="Module name of the addon to expand",
-            )
-
-    def execute(self, context):
-        module_name = self.module
-
-        # unlikely to fail, module should have already been imported
-        try:
-            # mod = __import__(module_name)
-            mod = USERPREF_PT_addons.module_get(module_name)
-        except:
-            import traceback
-            traceback.print_exc()
-            return {'CANCELLED'}
-
-        info = addon_utils.module_bl_info(mod)
-        info["show_expanded"] = not info["show_expanded"]
-        return {'FINISHED'}
-
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_userpref_keymap.py

@@ -18,9 +18,8 @@
 
 # <pep8 compliant>
 import bpy
-from bpy.types import Menu, Operator, OperatorProperties
+from bpy.types import Menu, OperatorProperties
 import os
-from blf import gettext as _
 
 
 KM_HIERARCHY = [
@@ -132,7 +131,7 @@ class USERPREF_MT_keyconfigs(Menu):
     preset_operator = "wm.keyconfig_activate"
 
     def draw(self, context):
-        props = self.layout.operator("wm.context_set_value", text=_("Blender (default)"))
+        props = self.layout.operator("wm.context_set_value", text="Blender (default)")
         props.data_path = "window_manager.keyconfigs.active"
         props.value = "context.window_manager.keyconfigs.default"
 
@@ -183,7 +182,7 @@ class InputKeyMapPanel:
 
         row = col.row()
         row.prop(km, "show_expanded_children", text="", emboss=False)
-        row.label(text=_(km.name))
+        row.label(text=km.name)
 
         row.label()
         row.label()
@@ -191,7 +190,7 @@ class InputKeyMapPanel:
         if km.is_modal:
             row.label(text="", icon='LINKED')
         if km.is_user_modified:
-            row.operator("wm.keymap_restore", text=_("Restore"))
+            row.operator("wm.keymap_restore", text="Restore")
         else:
             row.label()
 
@@ -202,7 +201,7 @@ class InputKeyMapPanel:
                 subcol = self.indented_layout(col, level + 1)
                 subrow = subcol.row()
                 subrow.prop(km, "show_expanded_items", text="", emboss=False)
-                subrow.label(text="%s " % _(km.name) + _("(Global)"))
+                subrow.label(text="%s " % km.name + "(Global)")
             else:
                 km.show_expanded_items = True
 
@@ -214,7 +213,7 @@ class InputKeyMapPanel:
                 # "Add New" at end of keymap item list
                 col = self.indented_layout(col, level + 1)
                 subcol = col.split(percentage=0.2).column()
-                subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
+                subcol.operator("wm.keyitem_add", text="Add New", icon='ZOOMIN')
 
             col.separator()
 
@@ -262,7 +261,7 @@ class InputKeyMapPanel:
         if km.is_modal:
             row.prop(kmi, "propvalue", text="")
         else:
-            row.label(text=_(kmi.name))
+            row.label(text=kmi.name)
 
         row = split.row()
         row.prop(kmi, "map_type", text="")
@@ -351,7 +350,7 @@ class InputKeyMapPanel:
                 row.label()
 
                 if km.is_user_modified:
-                    row.operator("wm.keymap_restore", text=_("Restore"))
+                    row.operator("wm.keymap_restore", text="Restore")
                 else:
                     row.label()
 
@@ -361,7 +360,7 @@ class InputKeyMapPanel:
                 # "Add New" at end of keymap item list
                 col = self.indented_layout(layout, 1)
                 subcol = col.split(percentage=0.2).column()
-                subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
+                subcol.operator("wm.keyitem_add", text="Add New", icon='ZOOMIN')
 
     def draw_hierarchy(self, display_keymaps, layout):
         for entry in KM_HIERARCHY:
@@ -382,7 +381,7 @@ class InputKeyMapPanel:
         #row.prop_search(wm.keyconfigs, "active", wm, "keyconfigs", text="Key Config:")
         text = bpy.path.display_name(context.window_manager.keyconfigs.active.name)
         if not text:
-            text = _("Blender (default)")
+            text = "Blender (default)"
         row.menu("USERPREF_MT_keyconfigs", text=text)
         row.operator("wm.keyconfig_preset_add", text="", icon="ZOOMIN")
         row.operator("wm.keyconfig_preset_add", text="", icon="ZOOMOUT").remove_active = True
@@ -402,9 +401,6 @@ class InputKeyMapPanel:
             self.draw_hierarchy(display_keymaps, col)
 
 
-from bpy.props import StringProperty, BoolProperty, IntProperty
-
-
 def export_properties(prefix, properties, lines=None):
     if lines is None:
         lines = []
@@ -420,397 +416,5 @@ def export_properties(prefix, properties, lines=None):
                     lines.append("%s.%s = %s\n" % (prefix, pname, value))
     return lines
 
-
-class WM_OT_keyconfig_test(Operator):
-    "Test keyconfig for conflicts"
-    bl_idname = "wm.keyconfig_test"
-    bl_label = _("Test Key Configuration for Conflicts")
-
-    def testEntry(self, kc, entry, src=None, parent=None):
-        result = False
-
-        def kmistr(kmi):
-            if km.is_modal:
-                s = ["kmi = km.keymap_items.new_modal(\'%s\', \'%s\', \'%s\'" % (kmi.propvalue, kmi.type, kmi.value)]
-            else:
-                s = ["kmi = km.keymap_items.new(\'%s\', \'%s\', \'%s\'" % (kmi.idname, kmi.type, kmi.value)]
-
-            if kmi.any:
-                s.append(", any=True")
-            else:
-                if kmi.shift:
-                    s.append(", shift=True")
-                if kmi.ctrl:
-                    s.append(", ctrl=True")
-                if kmi.alt:
-                    s.append(", alt=True")
-                if kmi.oskey:
-                    s.append(", oskey=True")
-            if kmi.key_modifier and kmi.key_modifier != 'NONE':
-                s.append(", key_modifier=\'%s\'" % kmi.key_modifier)
-
-            s.append(")\n")
-
-            props = kmi.properties
-
-            if props is not None:
-                export_properties("kmi.properties", props, s)
-
-            return "".join(s).strip()
-
-        idname, spaceid, regionid, children = entry
-
-        km = kc.keymaps.find(idname, space_type=spaceid, region_type=regionid)
-
-        if km:
-            km = km.active()
-
-            if src:
-                for item in km.keymap_items:
-                    if src.compare(item):
-                        print("===========")
-                        print(parent.name)
-                        print(kmistr(src))
-                        print(km.name)
-                        print(kmistr(item))
-                        result = True
-
-                for child in children:
-                    if self.testEntry(kc, child, src, parent):
-                        result = True
-            else:
-                for i in range(len(km.keymap_items)):
-                    src = km.keymap_items[i]
-
-                    for child in children:
-                        if self.testEntry(kc, child, src, km):
-                            result = True
-
-                    for j in range(len(km.keymap_items) - i - 1):
-                        item = km.keymap_items[j + i + 1]
-                        if src.compare(item):
-                            print("===========")
-                            print(km.name)
-                            print(kmistr(src))
-                            print(kmistr(item))
-                            result = True
-
-                for child in children:
-                    if self.testEntry(kc, child):
-                        result = True
-
-        return result
-
-    def testConfig(self, kc):
-        result = False
-        for entry in KM_HIERARCHY:
-            if self.testEntry(kc, entry):
-                result = True
-        return result
-
-    def execute(self, context):
-        wm = context.window_manager
-        kc = wm.keyconfigs.default
-
-        if self.testConfig(kc):
-            print("CONFLICT")
-
-        return {'FINISHED'}
-
-
-def _string_value(value):
-    if isinstance(value, str) or isinstance(value, bool) or isinstance(value, float) or isinstance(value, int):
-        result = repr(value)
-    elif getattr(value, '__len__', False):
-        return repr(list(value))
-    else:
-        print("Export key configuration: can't write ", value)
-
-    return result
-
-
-class WM_OT_keyconfig_import(Operator):
-    "Import key configuration from a python script"
-    bl_idname = "wm.keyconfig_import"
-    bl_label = "Import Key Configuration..."
-
-    filepath = StringProperty(
-            name="File Path",
-            description="Filepath to write file to",
-            default="keymap.py",
-            )
-    filter_folder = BoolProperty(
-            name="Filter folders",
-            default=True,
-            options={'HIDDEN'},
-            )
-    filter_text = BoolProperty(
-            name="Filter text",
-            default=True,
-            options={'HIDDEN'},
-            )
-    filter_python = BoolProperty(
-            name="Filter python",
-            default=True,
-            options={'HIDDEN'},
-            )
-    keep_original = BoolProperty(
-            name="Keep original",
-            description="Keep original file after copying to configuration folder",
-            default=True,
-            )
-
-    def execute(self, context):
-        from os.path import basename
-        import shutil
-
-        if not self.filepath:
-            self.report({'ERROR'}, "Filepath not set")
-            return {'CANCELLED'}
-
-        config_name = basename(self.filepath)
-
-        path = bpy.utils.user_resource('SCRIPTS', os.path.join("presets", "keyconfig"), create=True)
-        path = os.path.join(path, config_name)
-
-        try:
-            if self.keep_original:
-                shutil.copy(self.filepath, path)
-            else:
-                shutil.move(self.filepath, path)
-        except Exception as e:
-            self.report({'ERROR'}, "Installing keymap failed: %s" % e)
-            return {'CANCELLED'}
-
-        # sneaky way to check we're actually running the code.
-        bpy.utils.keyconfig_set(path)
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        wm.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-# This operator is also used by interaction presets saving - AddPresetBase
-
-
-class WM_OT_keyconfig_export(Operator):
-    "Export key configuration to a python script"
-    bl_idname = "wm.keyconfig_export"
-    bl_label = _("Export Key Configuration...")
-
-    filepath = StringProperty(
-            name="File Path",
-            description="Filepath to write file to",
-            default="keymap.py",
-            )
-    filter_folder = BoolProperty(
-            name="Filter folders",
-            default=True,
-            options={'HIDDEN'},
-            )
-    filter_text = BoolProperty(
-            name="Filter text",
-            default=True,
-            options={'HIDDEN'},
-            )
-    filter_python = BoolProperty(
-            name="Filter python",
-            default=True,
-            options={'HIDDEN'},
-            )
-
-    def execute(self, context):
-        if not self.filepath:
-            raise Exception("Filepath not set")
-
-        if not self.filepath.endswith('.py'):
-            self.filepath += '.py'
-
-        f = open(self.filepath, "w")
-        if not f:
-            raise Exception("Could not open file")
-
-        wm = context.window_manager
-        kc = wm.keyconfigs.active
-
-        f.write("import bpy\n")
-        f.write("import os\n\n")
-        f.write("wm = bpy.context.window_manager\n")
-        f.write("kc = wm.keyconfigs.new(os.path.splitext(os.path.basename(__file__))[0])\n\n")  # keymap must be created by caller
-
-        # Generate a list of keymaps to export:
-        #
-        # First add all user_modified keymaps (found in keyconfigs.user.keymaps list),
-        # then add all remaining keymaps from the currently active custom keyconfig.
-        #
-        # This will create a final list of keymaps that can be used as a 'diff' against
-        # the default blender keyconfig, recreating the current setup from a fresh blender
-        # without needing to export keymaps which haven't been edited.
-
-        class FakeKeyConfig():
-            keymaps = []
-        edited_kc = FakeKeyConfig()
-        for km in wm.keyconfigs.user.keymaps:
-            if km.is_user_modified:
-                edited_kc.keymaps.append(km)
-        # merge edited keymaps with non-default keyconfig, if it exists
-        if kc != wm.keyconfigs.default:
-            export_keymaps = _merge_keymaps(edited_kc, kc)
-        else:
-            export_keymaps = _merge_keymaps(edited_kc, edited_kc)
-
-        for km, kc_x in export_keymaps:
-
-            km = km.active()
-
-            f.write("# Map %s\n" % km.name)
-            f.write("km = kc.keymaps.new('%s', space_type='%s', region_type='%s', modal=%s)\n\n" % (km.name, km.space_type, km.region_type, km.is_modal))
-            for kmi in km.keymap_items:
-                if km.is_modal:
-                    f.write("kmi = km.keymap_items.new_modal('%s', '%s', '%s'" % (kmi.propvalue, kmi.type, kmi.value))
-                else:
-                    f.write("kmi = km.keymap_items.new('%s', '%s', '%s'" % (kmi.idname, kmi.type, kmi.value))
-                if kmi.any:
-                    f.write(", any=True")
-                else:
-                    if kmi.shift:
-                        f.write(", shift=True")
-                    if kmi.ctrl:
-                        f.write(", ctrl=True")
-                    if kmi.alt:
-                        f.write(", alt=True")
-                    if kmi.oskey:
-                        f.write(", oskey=True")
-                if kmi.key_modifier and kmi.key_modifier != 'NONE':
-                    f.write(", key_modifier='%s'" % kmi.key_modifier)
-                f.write(")\n")
-
-                props = kmi.properties
-
-                if props is not None:
-                    f.write("".join(export_properties("kmi.properties", props)))
-
-            f.write("\n")
-
-        f.close()
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        wm = context.window_manager
-        wm.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-
-class WM_OT_keymap_restore(Operator):
-    "Restore key map(s)"
-    bl_idname = "wm.keymap_restore"
-    bl_label = "Restore Key Map(s)"
-
-    all = BoolProperty(
-            name="All Keymaps",
-            description="Restore all keymaps to default",
-            )
-
-    def execute(self, context):
-        wm = context.window_manager
-
-        if self.all:
-            for km in wm.keyconfigs.user.keymaps:
-                km.restore_to_default()
-        else:
-            km = context.keymap
-            km.restore_to_default()
-
-        return {'FINISHED'}
-
-
-class WM_OT_keyitem_restore(Operator):
-    "Restore key map item"
-    bl_idname = "wm.keyitem_restore"
-    bl_label = "Restore Key Map Item"
-
-    item_id = IntProperty(
-            name="Item Identifier",
-            description="Identifier of the item to remove",
-            )
-
-    @classmethod
-    def poll(cls, context):
-        keymap = getattr(context, "keymap", None)
-        return keymap
-
-    def execute(self, context):
-        km = context.keymap
-        kmi = km.keymap_items.from_id(self.item_id)
-
-        if (not kmi.is_user_defined) and kmi.is_user_modified:
-            km.restore_item_to_default(kmi)
-
-        return {'FINISHED'}
-
-
-class WM_OT_keyitem_add(Operator):
-    "Add key map item"
-    bl_idname = "wm.keyitem_add"
-    bl_label = "Add Key Map Item"
-
-    def execute(self, context):
-        km = context.keymap
-
-        if km.is_modal:
-            km.keymap_items.new_modal("", 'A', 'PRESS')  # kmi
-        else:
-            km.keymap_items.new("none", 'A', 'PRESS')  # kmi
-
-        # clear filter and expand keymap so we can see the newly added item
-        if context.space_data.filter_text != "":
-            context.space_data.filter_text = ""
-            km.show_expanded_items = True
-            km.show_expanded_children = True
-
-        return {'FINISHED'}
-
-
-class WM_OT_keyitem_remove(Operator):
-    "Remove key map item"
-    bl_idname = "wm.keyitem_remove"
-    bl_label = "Remove Key Map Item"
-
-    item_id = IntProperty(
-            name="Item Identifier",
-            description="Identifier of the item to remove",
-            )
-
-    @classmethod
-    def poll(cls, context):
-        return hasattr(context, "keymap")
-
-    def execute(self, context):
-        km = context.keymap
-        kmi = km.keymap_items.from_id(self.item_id)
-        km.keymap_items.remove(kmi)
-        return {'FINISHED'}
-
-
-class WM_OT_keyconfig_remove(Operator):
-    "Remove key config"
-    bl_idname = "wm.keyconfig_remove"
-    bl_label = "Remove Key Config"
-
-    @classmethod
-    def poll(cls, context):
-        wm = context.window_manager
-        keyconf = wm.keyconfigs.active
-        return keyconf and keyconf.is_user_defined
-
-    def execute(self, context):
-        wm = context.window_manager
-        keyconfig = wm.keyconfigs.active
-        wm.keyconfigs.remove(keyconfig)
-        return {'FINISHED'}
-
 if __name__ == "__main__":  # only for live edit.
     bpy.utils.register_module(__name__)

release/scripts/startup/bl_ui/space_view3d_toolbar.py

@@ -19,7 +19,6 @@
 # <pep8 compliant>
 import bpy
 from bpy.types import Menu, Panel
-from blf import gettext as _
 
 
 class View3DPanel():
@@ -32,33 +31,33 @@ class View3DPanel():
 # History/Repeat tools
 def draw_repeat_tools(context, layout):
     col = layout.column(align=True)
-    col.label(text=_("Repeat:"))
+    col.label(text="Repeat:")
     col.operator("screen.repeat_last")
-    col.operator("screen.repeat_history", text=_("History..."))
+    col.operator("screen.repeat_history", text="History...")
 
 
 # Keyframing tools
 def draw_keyframing_tools(context, layout):
     col = layout.column(align=True)
-    col.label(text=_("Keyframes:"))
+    col.label(text="Keyframes:")
     row = col.row()
-    row.operator("anim.keyframe_insert_menu", text=_("Insert"))
-    row.operator("anim.keyframe_delete_v3d", text=_("Remove"))
+    row.operator("anim.keyframe_insert_menu", text="Insert")
+    row.operator("anim.keyframe_delete_v3d", text="Remove")
 
 
 # Grease Pencil tools
 def draw_gpencil_tools(context, layout):
     col = layout.column(align=True)
 
-    col.label(text=_("Grease Pencil:"))
+    col.label(text="Grease Pencil:")
 
     row = col.row()
-    row.operator("gpencil.draw", text=_("Draw")).mode = 'DRAW'
-    row.operator("gpencil.draw", text=_("Line")).mode = 'DRAW_STRAIGHT'
+    row.operator("gpencil.draw", text="Draw").mode = 'DRAW'
+    row.operator("gpencil.draw", text="Line").mode = 'DRAW_STRAIGHT'
 
     row = col.row()
-    row.operator("gpencil.draw", text=_("Poly")).mode = 'DRAW_POLY'
-    row.operator("gpencil.draw", text=_("Erase")).mode = 'ERASER'
+    row.operator("gpencil.draw", text="Poly").mode = 'DRAW_POLY'
+    row.operator("gpencil.draw", text="Erase").mode = 'ERASER'
 
     row = col.row()
     row.prop(context.tool_settings, "use_grease_pencil_sessions")
@@ -74,16 +73,16 @@ class VIEW3D_PT_tools_objectmode(View3DPanel, Panel):
         layout = self.layout
 
         col = layout.column(align=True)
-        col.label(text=_("Transform:"))
+        col.label(text="Transform:")
         col.operator("transform.translate")
         col.operator("transform.rotate")
-        col.operator("transform.resize", text=_("Scale"))
+        col.operator("transform.resize", text="Scale")
 
         col = layout.column(align=True)
-        col.operator("object.origin_set", text=_("Origin"))
+        col.operator("object.origin_set", text="Origin")
 
         col = layout.column(align=True)
-        col.label(text=_("Object:"))
+        col.label(text="Object:")
         col.operator("object.duplicate_move")
         col.operator("object.delete")
         col.operator("object.join")
@@ -92,17 +91,17 @@ class VIEW3D_PT_tools_objectmode(View3DPanel, Panel):
         if active_object and active_object.type == 'MESH':
 
             col = layout.column(align=True)
-            col.label(text=_("Shading:"))
+            col.label(text="Shading:")
             row = col.row(align=True)
-            row.operator("object.shade_smooth", text=_("Smooth"))
-            row.operator("object.shade_flat", text=_("Flat"))
+            row.operator("object.shade_smooth", text="Smooth")
+            row.operator("object.shade_flat", text="Flat")
 
         draw_keyframing_tools(context, layout)
 
         col = layout.column(align=True)
-        col.label(text=_("Motion Paths:"))
-        col.operator("object.paths_calculate", text=_("Calculate Paths"))
-        col.operator("object.paths_clear", text=_("Clear Paths"))
+        col.label(text="Motion Paths:")
+        col.operator("object.paths_calculate", text="Calculate Paths")
+        col.operator("object.paths_clear", text="Clear Paths")
 
         draw_repeat_tools(context, layout)
 
@@ -123,8 +122,8 @@ class VIEW3D_PT_tools_meshedit(View3DPanel, Panel):
         col.operator("transform.translate")
         col.operator("transform.rotate")
         col.operator("transform.resize", text="Scale")
-        col.operator("transform.shrink_fatten", text=_("Shrink/Fatten"))
-        col.operator("transform.push_pull", text=_("Push/Pull"))
+        col.operator("transform.shrink_fatten", text="Shrink/Fatten")
+        col.operator("transform.push_pull", text="Push/Pull")
 
         col = layout.column(align=True)
         col.label(text="Deform:")
@@ -1017,7 +1016,7 @@ class VIEW3D_PT_tools_brush_appearance(PaintPanel, Panel):
         brush = settings.brush
 
         if brush is None:  # unlikely but can happen
-            layout.label(text=_("Brush Unset"))
+            layout.label(text="Brush Unset")
             return
 
         col = layout.column()