diff options
114 files changed, 8815 insertions, 2415 deletions
diff --git a/SConstruct b/SConstruct index 3432a7b71ba..01522b3ae29 100644 --- a/SConstruct +++ b/SConstruct @@ -512,8 +512,10 @@ datafilestargetlist = [] dottargetlist = [] scriptinstall = [] -if env['OURPLATFORM']!='darwin': - for dp, dn, df in os.walk('bin/.blender'): +if env['OURPLATFORM']!='darwin': + for dp, dn, df in os.walk('release/bin/.blender'): + dp = os.path.normpath(dp) + if '.svn' in dn: dn.remove('.svn') if '_svn' in dn: @@ -529,14 +531,14 @@ if env['OURPLATFORM']!='darwin': if f.endswith('.ttf'): continue - if 'locale' in dp: + if 'locale' in dp or 'fonts' in dp: datafileslist.append(os.path.join(dp,f)) - dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['datafiles'] + dp.split(os.sep)[1:])) # skip bin + dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['datafiles'] + dp.split(os.sep)[3:])) # skip bin datafilestargetlist.append(dir + os.sep + f) else: dotblendlist.append(os.path.join(dp, f)) - dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['config'] + dp.split(os.sep)[1:])) # skip bin + dir= os.path.join(*([env['BF_INSTALLDIR']] + [VERSION] + ['config'] + dp.split(os.sep)[3:])) # skip bin dottargetlist.append(dir + os.sep + f) dotblenderinstall = [] diff --git a/po/POTFILES.in b/po/POTFILES.in new file mode 100644 index 00000000000..4c791dd9369 --- /dev/null +++ b/po/POTFILES.in @@ -0,0 +1,222 @@ +release/scripts/modules/rna_prop_ui.py + +release/scripts/startup/bl_operators/animsys_update.py +release/scripts/startup/bl_operators/object.py +release/scripts/startup/bl_operators/object_align.py +release/scripts/startup/bl_operators/object_quick_effects.py +release/scripts/startup/bl_operators/object_randomize_transform.py +release/scripts/startup/bl_operators/presets.py +release/scripts/startup/bl_operators/screen_play_rendered_anim.py +release/scripts/startup/bl_operators/sequencer.py +release/scripts/startup/bl_operators/wm.py + +release/scripts/startup/bl_ui/properties_animviz.py +release/scripts/startup/bl_ui/properties_data_armature.py +release/scripts/startup/bl_ui/properties_data_bone.py +release/scripts/startup/bl_ui/properties_data_camera.py +release/scripts/startup/bl_ui/properties_data_curve.py +release/scripts/startup/bl_ui/properties_data_empty.py +release/scripts/startup/bl_ui/properties_data_lamp.py +release/scripts/startup/bl_ui/properties_data_lattice.py +release/scripts/startup/bl_ui/properties_data_mesh.py +release/scripts/startup/bl_ui/properties_data_metaball.py +release/scripts/startup/bl_ui/properties_data_modifier.py +release/scripts/startup/bl_ui/properties_game.py +release/scripts/startup/bl_ui/properties_material.py +release/scripts/startup/bl_ui/properties_object_constraint.py +release/scripts/startup/bl_ui/properties_object.py +release/scripts/startup/bl_ui/properties_particle.py +release/scripts/startup/bl_ui/properties_physics_cloth.py +release/scripts/startup/bl_ui/properties_physics_common.py +release/scripts/startup/bl_ui/properties_physics_field.py +release/scripts/startup/bl_ui/properties_physics_fluid.py +release/scripts/startup/bl_ui/properties_physics_smoke.py +release/scripts/startup/bl_ui/properties_physics_softbody.py +release/scripts/startup/bl_ui/properties_render.py +release/scripts/startup/bl_ui/properties_scene.py +release/scripts/startup/bl_ui/properties_texture.py +release/scripts/startup/bl_ui/properties_world.py + +release/scripts/startup/bl_ui/space_console.py +release/scripts/startup/bl_ui/space_dopesheet.py +release/scripts/startup/bl_ui/space_graph.py +release/scripts/startup/bl_ui/space_image.py +release/scripts/startup/bl_ui/space_info.py +release/scripts/startup/bl_ui/space_logic.py +release/scripts/startup/bl_ui/space_nla.py +release/scripts/startup/bl_ui/space_node.py +release/scripts/startup/bl_ui/space_outliner.py +release/scripts/startup/bl_ui/space_sequencer.py +release/scripts/startup/bl_ui/space_text.py +release/scripts/startup/bl_ui/space_time.py +release/scripts/startup/bl_ui/space_userpref.py +release/scripts/startup/bl_ui/space_userpref_keymap.py +release/scripts/startup/bl_ui/space_view3d.py +release/scripts/startup/bl_ui/space_view3d_toolbar.py + +source/blender/editors/animation/anim_channels_edit.c +source/blender/editors/animation/anim_markers.c +source/blender/editors/animation/anim_ops.c +source/blender/editors/animation/drivers.c +source/blender/editors/animation/keyframing.c +source/blender/editors/animation/keyingsets.c + +source/blender/editors/armature/armature_ops.c +source/blender/editors/armature/editarmature.c +source/blender/editors/armature/editarmature_sketch.c +source/blender/editors/armature/poselib.c +source/blender/editors/armature/poseobject.c +source/blender/editors/armature/poseSlide.c + +source/blender/editors/curve/editcurve.c +source/blender/editors/curve/editfont.c + +source/blender/editors/gpencil/gpencil_paint.c + +source/blender/editors/interface/interface_layout.c +source/blender/editors/interface/interface_ops.c +source/blender/editors/interface/interface_regions.c +source/blender/editors/interface/interface_templates.c +source/blender/editors/interface/interface_utils.c +source/blender/editors/interface/view2d_ops.c + +source/blender/editors/mesh/editmesh.c +source/blender/editors/mesh/editmesh_add.c +source/blender/editors/mesh/editmesh_loop.c +source/blender/editors/mesh/editmesh_mods.c +source/blender/editors/mesh/editmesh_tools.c +source/blender/editors/mesh/loopcut.c +source/blender/editors/mesh/mesh_data.c +source/blender/editors/mesh/mesh_ops.c + +source/blender/editors/metaball/mball_edit.c + +source/blender/editors/object/object_add.c +source/blender/editors/object/object_constraint.c +source/blender/editors/object/object_edit.c +source/blender/editors/object/object_group.c +source/blender/editors/object/object_lattice.c +source/blender/editors/object/object_modifier.c +source/blender/editors/object/object_ops.c +source/blender/editors/object/object_relations.c +source/blender/editors/object/object_select.c +source/blender/editors/object/object_shapekey.c +source/blender/editors/object/object_transform.c +source/blender/editors/object/object_vgroup.c + +source/blender/editors/physics/particle_edit.c +source/blender/editors/physics/particle_object.c +source/blender/editors/physics/physics_pointcache.c + +source/blender/editors/render/render_internal.c +source/blender/editors/render/render_opengl.c +source/blender/editors/render/render_shading.c +source/blender/editors/render/render_view.c + +source/blender/editors/screen/area.c +source/blender/editors/screen/screendump.c +source/blender/editors/screen/screen_ops.c + +source/blender/editors/sculpt_paint/paint_ops.c +source/blender/editors/sculpt_paint/paint_image.c +source/blender/editors/sculpt_paint/paint_utils.c +source/blender/editors/sculpt_paint/paint_vertex.c +source/blender/editors/sculpt_paint/sculpt.c + +source/blender/editors/sound/sound_ops.c + +source/blender/editors/space_action/action_edit.c +source/blender/editors/space_action/action_ops.c +source/blender/editors/space_action/action_select.c + +source/blender/editors/space_buttons/buttons_header.c +source/blender/editors/space_buttons/buttons_ops.c + +source/blender/editors/space_console/console_ops.c + +source/blender/editors/space_file/file_draw.c +source/blender/editors/space_file/file_ops.c +source/blender/editors/space_file/file_panels.c + +source/blender/editors/space_graph/graph_buttons.c +source/blender/editors/space_graph/graph_edit.c +source/blender/editors/space_graph/graph_ops.c +source/blender/editors/space_graph/graph_select.c + +source/blender/editors/space_image/image_buttons.c +source/blender/editors/space_image/image_ops.c + +source/blender/editors/space_info/info_ops.c +source/blender/editors/space_info/info_report.c +source/blender/editors/space_info/space_info.c + +source/blender/editors/space_logic/logic_buttons.c + +source/blender/editors/space_nla/nla_buttons.c +source/blender/editors/space_nla/nla_channels.c +source/blender/editors/space_nla/nla_edit.c +source/blender/editors/space_nla/nla_select.c + +source/blender/editors/space_node/node_buttons.c +source/blender/editors/space_node/node_edit.c +source/blender/editors/space_node/node_header.c +source/blender/editors/space_node/node_ops.c +source/blender/editors/space_node/node_select.c +source/blender/editors/space_node/node_state.c + +source/blender/editors/space_script/script_edit.c + +source/blender/editors/space_sequencer/sequencer_add.c +source/blender/editors/space_sequencer/sequencer_buttons.c +source/blender/editors/space_sequencer/sequencer_edit.c +source/blender/editors/space_sequencer/sequencer_select.c + +source/blender/editors/space_text/text_header.c +source/blender/editors/space_text/text_ops.c +source/blender/editors/space_time/time_ops.c + +source/blender/editors/space_view3d/view3d_buttons.c +source/blender/editors/space_view3d/view3d_draw.c +source/blender/editors/space_view3d/view3d_edit.c +source/blender/editors/space_view3d/view3d_fly.c +source/blender/editors/space_view3d/view3d_header.c +source/blender/editors/space_view3d/view3d_select.c +source/blender/editors/space_view3d/view3d_view.c +source/blender/editors/space_view3d/view3d_toolbar.c + +source/blender/editors/transform/transform.c +source/blender/editors/transform/transform_ops.c +source/blender/editors/transform/transform_orientations.c + +source/blender/editors/util/undo.c + +source/blender/editors/uvedit/uvedit_ops.c +source/blender/editors/uvedit/uvedit_unwrap_ops.c + +source/blender/makesrna/intern/rna_ID.c +source/blender/makesrna/intern/rna_action.c +source/blender/makesrna/intern/rna_color.c +source/blender/makesrna/intern/rna_constraint.c +source/blender/makesrna/intern/rna_curve.c +source/blender/makesrna/intern/rna_fcurve.c +source/blender/makesrna/intern/rna_material.c +source/blender/makesrna/intern/rna_mesh.c +source/blender/makesrna/intern/rna_modifier.c +source/blender/makesrna/intern/rna_object.c +source/blender/makesrna/intern/rna_object_force.c +source/blender/makesrna/intern/rna_particle.c +source/blender/makesrna/intern/rna_render.c +source/blender/makesrna/intern/rna_scene.c +source/blender/makesrna/intern/rna_space.c +source/blender/makesrna/intern/rna_texture.c +source/blender/makesrna/intern/rna_ui_api.c +source/blender/makesrna/intern/rna_userdef.c +source/blender/makesrna/intern/rna_wm.c +source/blender/makesrna/intern/rna_wm_api.c +source/blender/makesrna/intern/rna_world.c + +source/blender/windowmanager/intern/wm_files.c +source/blender/windowmanager/intern/wm_operators.c +source/blender/windowmanager/intern/wm_window.c + + diff --git a/po/messages.txt b/po/messages.txt new file mode 100644 index 00000000000..b491061cdc4 --- /dev/null +++ b/po/messages.txt @@ -0,0 +1,5433 @@ +The edited object +Bezier curve point with two handles defining a Keyframe on an F-Curve +Max Climb +Media Stop +System & OpenGL +Strips Selected +Active Keying Set +Action Blending +Bone is able to be selected +Defines where the color of the environment light comes from +Display files as short list +Build 75% proxy resolution +Right Mouse +Cubic Catmull-Rom +Particle system can be edited in particle mode +UV editor data for the image editor space +Editing hair +Zoom using opposite direction +Graph Editor space data +Create obstacle +Tiles +Align newly added objects to the world coordinates +Index of custom color set +Sample point for F-Curve +AVI Raw +Linear Drag +Color to display the marker with +Channels Region +Lower bound of envelope at this control-point +Fluid +Regions this area is subdivided in +Double Click +Disable simulation of linear motion along the X axis +Sequencer OpenGL +Child particles generated by the particle system +Point in a shape key for curves +Lock to Bone +Sun Size +Set modifier expanded in the user interface +Multiple Scattering +ID Name +Steering +Animation Visualisation +Keyed States +Fixed size vertex indices array +Normal Size +Track To +Time since last access of a GL texture in seconds after which it is freed. (Set to 0 to keep textures allocated.) +Collection of keymaps +Texture datablocks +Number of vertical pixels in the screen +Fluid Simulation +Zooms in and out like scaling the view, mouse movements relative to center +Lattice Edit +Snap onto its self (editmode) +Only render what's in front of the solid z values +True when multiple enums +Backdrop Zoom +Causes mesh data to be duplicated with the object +Automatic +Small Caps +UV Project +UV Sync Selection +Cloth dynamics for hair +File Browser Main +Sensitivity +Amount of rotation around side vector +Specify how many frames the Map Old will last +Start Still +Unique datablock ID name +Active pose marker for this Action +Draw Channels +Smoothens emitted smoke to avoid blockiness +Tool Settings +Text Line +Bone Constraints +Toggle whether the material is linked to object data or the object block +Falloff power for transmissivity filter effect (1.0 is linear) +Only use case sensitive matches of search string +Screw +Region Text +Representation of alpha information in the RGBA pixels +Edges receive a drag force from surrounding media +Sequence Transform +Over Drop +Domain Settings +New F-Curve Colors - XYZ to RGB +Space that owner is evaluated in +Frame Step +Enumeration +Value of the item +Parent of this pose bone +B-Bone Z size +Up Arrow +For reactor systems, the object that has the target particle system (empty if same object) +Shift key pressed +Auto Refresh +Bone Color Sets +Positive values make strands rounder, negative makes strands spiky +Collection of images +Show actuators of active object +interpolate a global timestamp using the record date and time written by recording device +Main Lattices +Variable from some source/target for driver relationship +Z Location +Auto-Clamped handle selected color +Fixed Alternate +Game engine sensor to detect events +Include the frame number in image metadata +Bone does not deform any geometry +UV Textures +Game +Minimal Spring length * Ball Size +16384 +Line in which the marker is located +Offset X +Rasterized cell height +Edge Threshold +-Z +Set audio channels to mono +Jump Speed +HuffYUV +Active Bone +View3D Fly Modal +Sets the audio channel count +Rotation Damping +Max Air Acceleration +Snap center onto target +Spring Damping +Compact with Milliseconds +Maintain speed, flight level or wander +Interpolation type +Type Info +SIMD QBVH +active +Armature +Match case +16 Bit +XZY Rotation Order. Prone to Gimbal Lock +Auto handle selected color +Theme File Browser +Bake the normals in object space +Enable color range used for weight visualization in weight painting mode +Vorticity +Open window +Shows sensors for this object in the user interface +Radius of head of bone (for Envelope deform only) +Plain diffuse energy (white.) +Elasticity +Cache Step +View Sliders +Hair +Filter Movies +Material datablock used by this material slot +Smooth Emitter +Catalan (Català ) +RVO (cells) +Home +Action Mouse +Show Debug Info +Loads a saved environment map image from disk +is_baking +Scene datablocks +Wire +Group +On Land +Group Objects +Time Step +Keep UI +Bone inherits rotation or scale from parent bone +Show Selected Object +Theme settings for the Outliner +Time of key over the simulation +Header Text +Health +Similar to SMPTE (Compact), except that instead of frames, milliseconds are shown instead +Blender Original +Deliver texture UV pass +Index number of the vertex +Stepped Interpolation +Adds diagonal springs on 4-gons +Shear +Tent +Strength of force field +Space that target is evaluated in +F11 +Star +Library datablocks +Line Input +Lighten +In Range +Use Blender units for widths instead of pixels +F17 +Node Socket +Quad-Buffer +Sets scaling for the texture's X, Y and Z sizes +F14 +Motion Path settings for animation visualisation +Make hairs longer +Set audio sample format to 32 bit float +Amount of anti-aliasing samples per pixel +type +Use optimized Bullet DBVT tree for view frustum and occlusion culling +Make this surface a closed loop in the V direction +Alpha Over +Media player for video & png/jpeg/sgi image sequences +Second input for the effect strip +Space Logic Editor +Snap during transform +Edit Methods +Left Handle +B-Bone Ease Out +Cyclic Offset +Subtype +Object Base +Vertex Group Clump +Letterbox +Set audio channels to 7.1 surround sound +V +Quaternion (WXYZ) +Image File +Preset configs for external animation players +Maximum Value +Make this nurbs curve or surface act like a Bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled) +uk_UA +3x3 bone matrix +Vertex Weight +Display Material +Use a custom transform orientation +GLSL Shaders +Text +Deliver shadow pass +From node +Keyframes +Main Brushes +Deliver diffuse pass +Header +Level detector, trigger controllers of new states(only applicable upon logic state transition) +Collision Compound +Increment +Trackball +Active Strip +Initial Rest Length +User defined layer of string text values +Edge Tag Mode +Invert tilt Axis +Deliver emission pass +Face Selected +Xor +Voronoi Crackle +Align the transformation axes to the window +Line sample +Default Goal (vertex target position) value, when no Vertex Group used +Type of raytrace accelerator structure +Area Spaces +Project individual elements on the surface of other objects +Use the angle between two bones +Aero +Zmask +Set audio sample format to 32 bit signed integer +Scene render size +Multiplier to convert blender units to physical distance +Free Image Textures +Metaball datablocks +DPI +Fill in Z values for solid faces in invisible layers, for masking +Active Action for this datablock +Use turntable style rotation in the viewport +Format +Use a Catmull-Rom filter for anti-aliasing +Link material to object or the object's data +Type of participation in the fluid simulation +face normal +Enable +Final 4x4 matrix after constraints and drivers are applied (object space) +Diameter of widget, in 10 pixel units +ID Property +Radius of tail of bone (for Envelope deform only) +Custom Shape Transform +Action FCurves +Envelope Deform Weight +A +Renders star shaped lines over halo +Fade-out Color +Syntax Built-in +Samples below this threshold will be considered fully shadowed/unshadowed and skipped (for Raytrace Adaptive QMC) +Camera datablocks +Bounding Box Center +Middle Mouse +Framerate base +Touch +Vortex +Manipulator Size +F-Curve Colors - XYZ to RGB +Invert Output +Calculate heights against unsubdivided low resolution mesh +Shrinkwrap +Window Deactivate +Y position of the sequence strip +The frame on which this sketch appears +Snap to increments of grid +Rest Length +All +Serbian (СÑпÑком ÑезикÑ) +Sample Method +Text Anti-aliasing +Only allows given density value in emitter area +Sequencer Preview Shading +Lower field first +File Name +Show timing in seconds not frames +Display the object as wire edges +Billboard with Z-axis constraint +Curves +Displays clock frequency of fullscreen display +X Rotation +Sphere +Select UVs that share mesh vertex, irrespective if they are in the same location +8 bit RAW +0.5 means no distance at all, 1.0 is maximum distance +Sequencer +Max Ghost Range +An object instance in a scene +User Interface +Alt +Vertex group name +PNG +Animated Selected +Blue +Damping of the spring force, when inside the physics distance area +Plugin Strip +Hide +Pose Matrix +Guide-free time from particle life's end +Frame is being edited (painted on) +Large Cursors +Limit Rotation +Draw only faces with the currently displayed image assigned +Record Run +Pixel width over which the reconstruction filter combines samples +Global Scene +Defines the structure of the header in the UI +Source List Text Highlight +User-editable keyframes +Scaling factor for action +Inner +Active Constraint +Side-by-side +Right Arrow +Causes the 1 to 0 keys to act as the numpad (useful for laptops) +A collection of pose channels, including settings for animating bones +Lennard-Jones +Use a maximum radial distance for the field to work +Location of tail end of the bone relative to armature +Edit All +estimate matrix .. split to COM , ROT ,SCALE +Use Coordinates +Theme User Preferences +Show line numbers next to the text +Minimum speed in air (relative to maximum speed) +Display keymap datablocks +, +Display Summary +Channel Driver (only set for Driver F-Curves) +Item +In/Out Node +Frame that modifier's influence ends (if Restrict Frame Range is in use) +Premultiplied +Number of frames cached +Description of the Struct's purpose +Tilt in 3D View +Show Debug +Offsets image horizontally from the world origin +region_data +Protect layer from further editing and/or frame changes +File Format +Retarget roll mode +IK rot control +Upper bound of envelope at this control-point +Interaction Radius +Syntax String +Vertex group to control density +Show Overexposed +Vertices +Kerning Style +IK X Minimum +Sets the factor by which the flare is larger than the halo +Absolute ball size or factor if not manual adjusted +Blend Opacity +Steps +Texture +Settings for the visualisation of motion +Group of vertices, used for armature deform and other purposes +Limit Distance +Minus +No interpolation, fast but blocky and low quality +Control +Full SMPTE timecode. Format is HH:MM:SS:FF +Open On Mouse Over +Show sensors of active object +Frame Server Port +Noise patterns will remain unchanged, faster and suitable for stills +Start +RLE (lossless) +True when the property is not saved in presets +Images are rendered in new Window +Theme Timeline +If this is set, the header gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_HT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_HT_hello" +The color that rays with no intersection within the Max Distance take (material color can be best for indoor scenes, sky color for outdoor) +Show Cursor +Goal Default +Shape Key Point +Object Origin Size +Orthographic +Invert y axis +Unit Scale +Collection of points for Bezier curves only +Mouse +Pivot Point +UV Layer to control billboard splitting +Only insert keyframes where they're needed in the relevant F-Curves +IK Z Minimum +Distance +Key rotation quaternion +Backscattered light +Texture effector weight +Volume rendering settings for a Material datablock +Which output node to use, for node-based textures +Handle 1 selection status +Always render a still frame from the voxel data sequence +Factor ++Z +Numpad 4 +Type +Action Groups +Styles +rv +Recast data for a Game datablock +Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method) +Description of the property for tooltips +Area in a subdivided screen, containing an editor +IK Z Maximum +Effect fader position +Particle System to render as points +Vertex Group Size Negate +Simplify Subdivision +Warp +3D View center is locked to this bone's position +Enable cluster collision between soft and rigid body +04 - Theme Color Set +Lamps +Color Picker Type +Location of the hair key in its internal coordinate system, relative to the emitting face +Properties Space +The view mode to use for displaying sequencer output +Hold +Prefetch Frames +Pose Tail Position +Amount of pixels to extend the baked result with, as post process filter +Dummy +Deliver full combined RGBA buffer +Long Key Selected +Extension +Complete Matches Only +Lines +The external source data file to use +The time (in minutes) to wait between automatic temporary saves +Undo Memory Size +Type of event mapping +Animation Data +Unique node identifier +Draw white edges +Show Menus +W +Inverse Kinematics +Number of times a map will be rendered recursively (mirror effects.) +Face Mask +Density is calculated as a factor of default density (depends on particle size) +Soft +Use a maximum distance for the field to work +Has IK +Power of Fresnel for transparency (Ray or ZTransp) +Name of PoseBone to use as target +Display files as thumbnails +Transparency blending mode +Multiple Engines +Bits +Active Boid Rule Index +Child Of +Metric +Proxy size 100% +Module name +Visible +NLA Strip references some Action +Average screen dimension of stars +Converter Node +Mirror +Method of calculating aerodynamic interaction +Curl +Main Objects +Only include channels relating to selected objects and data +Set audio mixing buffer size to 256 samples +Bake normals +Uses direction of strands as normal for tangent-shading +Textbox Width +Pose +Plasticity +Object scale factor +Boid effector weight +Mass Vertex Group +Fight +Adjust the offset to the beginning/end +Bone Solid +NLA Strip representing a sound event for speakers +Maximum contour edge length +Build free run time code index using Record Date/Time +End frame displayed in the sequence editor after offsets are applied +NLA Strip acts as a container for adjacent strips +Offsets image vertically from the world origin +Block anything else from using the cursor +Inverse Lift +Maximum for slider +Mode of automatic keyframe insertion for Objects and Bones (default setting used for new Scenes) +Render Solid faces in this Layer +Vertex Weight Edit +Rotation style in the viewport +Active Vertex Color Index +Show the active object's smoke cache +Action Extrapolation +Resolution X +Mesh +Progress Bar Widget Colors +Lock editing of rotation in the interface +Draw faces over the image +Press +Weight Color Range +Collection of vertex colors +Thickness of strokes (in pixels) +Resolution V +Particle Target +Object duplicate transformation matrix +Luma +Blend Out +B +B-Bone X size +Anti-Aliasing Level +Handle Vertex Size +IK Lin Weight +Negative +End Still +Y Offset +Edge +Amount of stickness to surface collision +Bone Matrix +Randomizes ring dimension and line location +Velocity +Respect the frame rate rather than rendering as many frames as possible +Distance to the view location +High res +Object to take point data from +Falloff type for proportional editing mode +Region width +Border Minimum Y +Flash Video +Active Section +Channel defining pose data for a bone in a Pose +Smoothed high quality interpolation, but slower +Sets the audio sample rate +Deliver raytraced refraction pass +Land Personal Space +Curve Splines +Operating system key pressed +14 - Theme Color Set +Grease pencil data for this space +Child particle interpolated from simulated or edited particles +Editor header containing UI elements +Select Head +Catmull-Rom +GLSL Nodes +Make edges 'sail' +Scattering +Wire Select +Unit +Bezier Points +Frame on which the simulation starts +Animation Player +Sequence Crop +Autoname +Dying +Floor +True when the property is hidden +Cache Compression +Keep Root +Render Output Directory +Multiple Caches +External Shadows +Points V +Show Debug Properties +White Level +Framing Color +Line Feed +Logarithmic dissolve +Circle +Show movie files +Maximum distance for the field to work +Vertex Group Kink +Enable anisotropic friction +Use color management for GLSL rendering +Exec Screen +Render Layer +Validity +Show sensors of all selected objects +Tessellation +- +F-Curve Modifier's effects will be tempered by a default factor +Paths Type +Cine-Scope 24fps 2048x858 +Use Mist +Object Duplicate Matrix +Repulsion force to apply on cloth when close to colliding +Marker is temporary +Collection of screens +Lock X Axis +Octree Resolution +Control how much mist density decreases with height +Custom Color Set +Texture Context +Active Vertex Group +Disallow movement around the Y axis +Edge Color +Datablocks +Channels of the image to draw +2D Cursor +Constant QMC +Shape Key Curve Point +Command output +turbulence_strength +Color used for active bones +3D View center is locked to this object's position +Vertex groups of the object +Weights for the vertex groups this vertex is member of +Invert Axes +Euler Rotation +Material to override all other materials in this render layer +Tag Sharp +Is part of an IK chain +Output image in JPEG format +Main Groups +Slider Min +Side +Bone +Square (HV + S) +Transforms include effects of parenting/restpose and constraints +Name of operator to call on input event +Particle Speed +Motion Blur +Nurb V-lines +Font size to use for displaying the text +Tools +Float +Dynamic +Scene +Color curve mapping to use for displaying the image +Set audio channels to 4 channels +Free handle color +16-bit Signed +Active object for this scene +Previous Angular Velocity +Material Link To +Solid Light +Property Value +Worldspace distance over which to blend in the surface normal +NLA Strip is active +Mini Axis Size +Multiply direct lighting with ambient occlusion, darkening the result +Moving things with a mouse drag confirms when releasing the button +Show Render +Camera this timeline sets to active +Update Automatically +Inwards component of the vortex force +Edit texture nodes from Brush +Current perspective matrix of the 3D region +Opaque +Goal (vertex target position) friction +All rules are averaged +Grease Pencil Stroke +Display Object Info +The maximum distance from which a boid can attack +Curve interpolation at this point: Bezier or vector +Both Z +Textbox Y Offset +Node group datablocks +Ogg Theora +Logic And +Identifier of operator to call on input event +Spaces contained in this area, the first being the active space. NOTE: Useful for example to restore a previously used 3d view space in a certain area to get the old view orientation +Set audio channels to stereo +Order V +View & Controls +Rec Run +Upward spring force, when inside the physics distance area +Mesh Texture Face Layer +Transformation orientation +Gives a radial field toward the center of object +layout +Extend +Collision margin for soft body. Small value makes the algorithm unstable +box radius +Cache Index +Free +Inbetween Move +Packed File +Capsule +UV projector used by the UV project modifier +F-Curve Modifier has invalid settings and will not be evaluated +Dopesheet +Only Selected +Replace Text +Freq +Sets maximum Y value for the render border +Compositing nodes +Waveform Opacity +Layers that contain something +Skip Save +Same Types +Include Missing NLA +Level +Free Unused Nodes +Maximum distance to apply repulsion force, must be greater then minimum distance +Display tooltips +Hold RMB Open Toolbox Delay +Random variation of friction +Proportional Editing Falloff +Object Modifiers +Logic Xnor +Move to center of neighbors and match their velocity +Stretch or squeeze the viewport to fill the display window +X +Show frame numbers of Keyframes on Motion Paths +Shaded +Enhance the resolution of smoke by this factor using noise +Backdrop +Selected +Refraction Exclude +Enable bitmap text on face +Button4 Mouse +The direction that the OpenGL light is shining +Images are rendered without forcing UI changes, optionally showing result +A circular Hue/Saturation color wheel, with Value slider +Input 3 +Input 2 +Input 1 +Engine to use for rendering +Active UV Texture Index +Include the render time in the stamp image +Disabled +Sets the amount mirror reflection for raytrace +Game Object Settings +Clear +Max Physics Steps +Find All +3D View far clipping distance +Activate or deactivate item +Blobby element in a MetaBall datablock +Only Render +Radius of the agent +Show Navigation Guide +Default Colors +Sets the dimension of the sub-flares, dots and circles +Dynamic Friction +fi_FI +Viewpoint Object +Display the object solid, lit with default OpenGL lights +Use Global Coordinates +Use the initial length as spring rest length instead of 2 * particle size +Priority +Render polygon transparent, depending on alpha channel of the texture +Active File +Manually determine the number of threads +User Defined +Vertex group to control clump +Enable/Disable Constraint +Object is detected by the Near and Radar sensor +VBOs +When false, this (sub)layout is greyed out +Select Mouse +The Drivers/Expressions for this datablock +Individual Centers +Enables automatic saving of preview images in the .blend file (Windows only) +Shape key in a shape keys datablock +Use left Mouse Button for selection +Pivot around the 3D cursor +Auto +Registered +Flares Sub +Short List +Sounds Directory +Interpolate +Game engine properties +Allow drawing multiple strokes at a time with Grease Pencil +Output image in (old!) SGI IRIS format +Left Alt +Sub Level Menu Open Delay +Number of frames at start of strip to fade in influence +Keyframe Points +Noise algorithm - Voronoi F3: Returns distance to the 3rd closest feature point +Display error text +Vertex group for fine control over structural stiffness +RNA Path (from ID-block) to property used +Info +User preferences space data +C +Emit Exclude +Thumbnails +Collision Sensor, detects static and dynamic objects but not the other collision sensor objects +Lamp Sky Settings +3D View center is locked to the cursor's position +Manoeuvre to avoid collisions with other boids and deflector objects in near future +Global gravity weight +Curve or Surface subdivisions per segment +The nominal number of game frames per second. Physics fixed timestep = 1/fps, independently of actual frame rate +Back scattering (-1.0) to Forward scattering (1.0) and the range in between +Library Path +Calculate shadows while rendering +Defines the strength of environment light +Mux packet size (byte) +Croatian (Hrvatski) +Separate Colors +Collider Friction +Goal minimum, vertex group weights are scaled to match this range +Gamma Cross +Driver for the value of a setting based on an external value +Unit System +Highlight Line +Constraint is the one being edited +Draw F-Curves using Anti-Aliasing and other fancy effects. Disable for better performance +Keying Set +UV Local View +Changing edges seam re-calculates UV unwrap +View3D Move Modal +Any Type +Image Paint +Set audio mixing buffer size to 16384 samples +Creates turbulence with a noise field +Active EditBone +Brush +Show only sensors connected to active states +Disable simulation of angular motion along the Z axis +3D View Generic +Shape used as a relative key +World Stars +Use Environment Lighting +X Location +Auto Save Temporary Files +Surface subdivisions per segment +Output image in OpenEXR format +Center +Air has normally some thickness which slows falling things down +Defines if the panel has to be open or collapsed at the time of its creation +Parameters for the function +Keep root keys unmodified +Interpolate new particles from the existing ones +Include visualization of Node related Animation data +25% +Sets the number of simulation substep per physic timestep, higher value give better physics precision +Space in which transforms are used +16x +Sets the number of images of a movie to use +Callback function defines for built-in Keying Sets +20 - Theme Color Set +How much heat effects smoke motion, higher value results in faster rising smoke +Display when not linked to a visible states controller +Collection of scenes +256 +Smooth View +Choose shading information to bake into the image +Sets the number of star shaped lines rendered over the halo +Textures +Active spline +Maximum bending stiffness value +Eye Separation +Window event timer +Armature EditBones +Game engine actuators to act on events +End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method) +Quad Split +Auto handles clamped to not overshoot +How much the spring has to be stretched/compressed in order to change it's rest length +Show Brush On Surface +. +Defines the structure of the panel in the UI +Handle 2 selected +Use lights for GLSL rendering +Groups +Textured +Camera rotation in horizontal axis +Blender RNA +Type of ID-block that can be used +Column number to show right margin at +Game Soft Body Settings +Activity Culling +Local Space +Sets the layer as active for rendering +Rotate From Normal +IK Y Lock +Amount of influence constraint will have on the final solution +The window relative horizontal location of the mouse +Set audio mixing buffer size to 2048 samples +Lighting Mode +Object to use as projector transform +Numpad - +Location to store the proxy files +Add directed noise to the density at render-time +Physics Sub Steps +Mesh Faces +Apply on spline +Armature Sketch +Render Halos in this Layer (on top of Solid) +Nla Strips +Weight used by the Bevel modifier +Color range used for weight visualization in weight painting mode +Boid Rules +Delay between repeated pulses(in logic tics, 0=no delay) +Billboard Time Index UV +Game Data +IK X Limit +Theora +Hook +Collection of materials +Lifetime mapped as 0.0 - 1.0 intensity +Property Editor +Vorbis +Allow Land +Tip select mode +Navigation Mesh +Limit the texture size to save graphics memory +Game engine user defined object property +Sticky vertex selection disabled +Display an isolated sub-set of objects, apart from the scene visibility +Straight Alpha +Wheel Out +Sequence Proxy +Text displayed and edited in this space +Custom Object +Numpad + +Menu +Active Point Cache Index +Starting frame of the stored range +Panel Style +Emphasize position of keyframes on Motion Paths +Libraries +Restrict Frame Range +Quadratic Drag +Display X Axis +Copy of the colors associated with the group's color set +Use a Mitchell-Netravali filter for anti-aliasing +ID of the item +Marker selection state +Good smoothness and speed +Use Onion Skinning +Draw type for drawing UV edges +id +Result strip replaces the accumulated results by amount specified by influence +Transform Space +Speed factor +Collection of group sockets +Highlight Keyframes +Hide files/datablocks that start with a dot(.*) +Use 3D transform manipulator +Value of shape key at the current frame +Python +Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample) +Perspective Matrix +Meta strip stack, last is currently edited meta strip +Noise algorithm - Voronoi F2: Returns distance to the 2nd closest feature point +Auto Keyframe Insert Keying Set +2D Cursor Location +Vertex Weight Mix +Group Index +Add hairs +Bake textures +Crop to Border +Initial boid health when born +When rendering animations, save JPG preview images in same directory +The number of grid lines to display in perspective view +Worlds +The distance between 3D View grid lines +Vector font datablocks +Tag Bevel +Negate the effect of the kink vertex group +Use viscoelastic springs instead of Hooke's springs +Frameserver Port for Frameserver Rendering +Shows actuators for this object in the user interface +Show Info +Grease Pencil Euclidean Distance +Pixels moved by mouse per axis when drawing stroke +Color balance parameters for a sequence strip +Collision Quality +Triple Buffer +Face is used for shadow +Include visualization of World related Animation data +Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory +Regular Widget Colors +Y +Bezier Curve Point +To node +Puff Mode +Root +Deliver Z values pass +Coordinates of the control point +Transforms don't include parenting/restpose or constraints +Keying Set Path +Friction force if a collision happened. (higher = less movement) +Theme settings defining draw style and colors in the user interface +MPEG-4(divx) +Display reference images behind objects in the 3D View +Collection of Node Links +Follow Leader +Hide objects on these layers when generating the Environment Map +Line Number +Fields per Frame +Harmonic Damping +Weight hair particles +Use the Blender internal rendering engine for rendering +Rotation/Scaling Pivot +Minimum radial distance for the field's fall-off +Duration +Causes curve data to be duplicated with the object +Absolute +pt_BR +Active Layer +YCbCr (ITU 601) +Average distance between any two stars +Multitexture materials +GLSL +Current Scene +How many keys to make new particles with +Hide element +Main Meshes +Text character formatting settings +Main Material +Collection of object modifiers +Maximal resolution used in the fluid domain +Amount of light that gets emitted by the volume +Grid +Use For Growing Hair +Parent edit bone (in same Armature) +Use a column layout for toolbox +Sort by time +When transforming strips, changes to the animation data are flushed to other views +Theme settings for widget color sets +Inner Thickness +Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info) +Constant Jittered +Weight to assign in vertex groups +Bone Armature-Relative Matrix +Rest length of the harmonic force +user_preferences +Gimbal +Alpha Under +RNA property definition +YXZ Euler +Use shadows for GLSL rendering +IOR +Gives the flare extra strength +Editor menu containing buttons +Right handle selection status +Minimum Value +Action referenced by this strip +Display and edit the grease pencil freehand annotations overlay +Path edit mode +Smooth falloff +Preferences related to viewing data +Max Edge Error +A square showing Hue/Value, with Saturation slider +D +Material slot in an object +Set audio sample format to 8 bit unsigned integer +User defined integer number value in an integer properties layer +Output image to a frameserver +Single Layer +Radius of boids personal space in air (% of particle size) +YCbCr (Jpeg) +Length +Specular +Proportional Editing using connected geometry only +Convex Hull +Mid-range quality and speed +Scale of the added turbulent noise +Only use complete matches of search string +Show Splash +Wind +Repulsion Force +Method used to convert stroke to bones +Show Pose Markers +Frame on which the simulation stops +Warp Data +Key angular velocity +select_start +Show Linked to Controller +Struct in which this struct is always nested, and to which it logically belongs +Include a custom note in image metadata +Log conversion gamma +Transform Orientation +Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems) +Which style to use for font kerning +Fall-Off +Render voxels from a Blender smoke simulation +Draw the points which make up the strokes (for debugging purposes) +Frames +Original image height +Use face for collision and ray-sensor detection +Around Frame +Image Strip +Bounding Box +Device up/down directly controls your Z position +The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed +Original image width +Show Margin +Transform Modal Map +Stiff Quads +System +Spherical Panoramic +Onion Skinning settings for animation visualisation +KeyMap Items +Valid +MP2 +Handle 2 Type +Italic +Material Raytrace Mirror +Object Grouped Active +Use Frame Rate +sv_SE +Samples +Name +Material mode to use for rendering +Cube +Result color of the volume, after other light has been scattered/absorbed +Use Min +Display the center and axis during rotation +Multiplier for intensity values +Render Edge-enhance in this Layer (only works for Solid faces) +Material datablocks +/ +Arabic (اÙعربÙØ©) +Most compact representation. Uses '+' as separator for sub-second frame numbers, with left and right truncation of the timecode as necessary +Filter 2D +Lift +Lighting for a World datablock +External +Collection of metaballs +Sets the hardness of the halo +General rotation damping +Constraint name +Hardness +Syntax highlight for scripting +Parameters and Settings for the Filebrowser +Edit Path +Rot Matrix +Global Time +Grease Pencil Manhattan Distance +Grouping Method +Lock view rotation in side views +Effector Group +Collection of armature edit bones +Flare +Control Point selected +Freehand curves defining the sketch on this frame +Make this nurbs surface act like a Bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled) +Operator +Near +Use the pinned context +Display files as a detailed list +On Selected Bones Only +Has Reports +Property +Collection of related sketches +Control point mass values +Chance that the particle will pass through the mesh +Sticky Selection Mode +Font +Key Modifier +Clip +Edit texture nodes from Object +resolution_y +Storage of an operator being executed, or registered after execution +Image +Density Scale +Active Render Layer +Space DopeSheet Editor +Maximal +Indirect Factor +Pixel Filter +Upper field first +Static +AVI +Internal Friction +Global Hair +Level height +Bake Specular colors +DopeSheet space data +Registered Optionally +Causes actions to be duplicated with the object +Enable collisions with other objects +Theme settings for the Properties +Region ID +Strength +Use nodes for GLSL rendering +General Mass value +Damping Factor +Show Paint +Weight of a particle dupliobject in a group +Shows controllers for this object in the user interface +Allow the use of colors indicating constraints/keyed status +Target Object +Texture Paint +Defines how AO mixes with material shading +Driver Variable +Wrap words if there is not enough horizontal space +Point in a shape key for Bezier curves +Directory/name to save animations, # characters defines the position and length of frame numbers +Follow Path +Use a cubic filter for anti-aliasing +Media First +Use so the operator grabs the mouse focus, enables wrapping when continuous grab is enabled +Draw Frames +Length of rays, defines how far away other faces give occlusion effect +Lock Scale +Method of attenuating density by distance from the point +8-bit Unsigned +File Paths +Point Source +cs_CZ +Pose Space +Sort the file list alphabetically +Provides an alternative access to loc/scale/rotation relative to the parent and own rest bone +Collision Type +Collection of node trees +Occlusion Resolution +Apply sun effect on sky +Stamp Note Text +Traditional Chinese (ç¹é«ä¸æ) +Scene layers included in this render layer +Weight used by the Bevel modifier 'Only Vertices' option +IK Y Stiffness +The default directory to search for texture plugins +Vertex Group Velocity Negate +Modifiers +Invoke Region Window +Auto Perspective +Module +The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions +Display Camera +Subdivisions +Blendfile Data +Location of custom proxy file +Solidify +Do a full redraw each time, slow, only use for reference or when all else fails +Horizon Spread +06 - Theme Color Set +Show a visualization of physics bounds and interactions +Z +Quick Cache +Show Error +Left +Property that stores arbitrary, user defined properties +UV 4 +Resolution % +Scattering color +UV 1 +UV 3 +UV 2 +Handle 2 +Display datablocks in visible layers +Handle 1 +Left handle selection status +Active Keying Set Index +SMPTE (Full) +Use textures to affect material properties +Draw Modified Edges +Maximum caused damage on attack per second +Shape Key +Enable file compression when saving .blend files +Script datablocks (DEPRECATED) +Frame rate for the screencast to be played back +MPEG-1 +Use Sketching Sessions +MP3 +Use ObColor instead of vertex colors +Lock X Rotation Axis +Envelope Tail Radius +Causes armature data to be duplicated with the object +The menu label +Allow Flight +Keyed timing +Free Run (rec date) +Use a 3D manipulator widget for controlling transforms +Insert Keyframes - Only Needed +Show handles of Bezier control points +Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes) +Inverse Quadratic +ru_RU +Use the value from some RNA property (Default) +Calculate point velocities automatically +Actions +Modifiers affecting all the F-Curves in the referenced Action +Enables automatic saving of preview images in the .blend file +Animation Player Preset +16 - Theme Color Set +Vector handle color +Proxy render size +Clip Max X +Clip Max Y +Open in thumbnail view for images and movies +Physics Engine +Description +Sort files by size +Particle Cache +Action Influence +Envelope +View Perspective +IK X Maximum +Boid States +Display datablocks of selected objects +Full Sample +Animation data for datablock +Channel +Interpolation mode used for first keyframe on newly added F-Curves. Subsequent keyframes take interpolation from preceeding keyframe +Order U +Timecode +Distance moved by mouse when drawing stroke (in pixels) to include +Calculate radiosity in a pre-process before rendering +Selected to Active +For RGB curves, the color that black is mapped to +Mesh Texture Face +E +For Pose-Mode drawing, only draw ghosts for selected bones +Landing Smoothness +Grease Pencil Frame +Shift +Mouse Move +Button 3 +Auto-detect +Space Timeline Editor +Only Selected Keyframes Handles +Use smoke density as texture data +Operator has a set of reports (warnings and errors) from last execution +Layered +Object Vertices +Set audio mixing buffer size to 512 samples +Duplicate Metaball +Saves this datablock even if it has no users +Cine-Scope 48fps 2048x858 +Ad-hoc correction for over-occlusion due to the approximation +Line Info +Filtering Group +Choose the method used to split a quad into 2 triangles for baking +Menu Item Colors +Blending factor for Fresnel +Constant +Mitchell-Netravali +Color +Button 8 +IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC +Include visualization of Camera related Animation data +Free Run +Opacity of the points +Button 9 +Collection of speakers +Adaptive QMC +Layers the object base is on +NLA Generic +Sort by size +Friend +Velocity Min +The brightness of the icon +Show the active object's cloth point cache +Invoke Default +Amplification +Display warnings +Realtime +Size of the font used when rendering stamp text +Refraction +Third input for the effect strip +Snap to vertices +Global child particles percentage +Faces collide too, can be very slow +Disable collision for this object +Disable the time difference between fields +The default directory to search for loading fonts +Automatic keyframe insertion in available curves +Bake the normals in camera space +Show Header +layers +Color for all strokes in this layer +Top Level Menu Open Delay +Exec Area +Auto Render +Type of periodic offset on the curve +Key location +Use scaled and grid-fitted kerning distances +Stars setting for a World data-block +Burn +Set audio sample format to 24 bit signed integer +Standard +0 +Tag Crease +Image Sequence +Function is registered as callback as part of type registration +UV Layer to control billboard normals +Auto-Keying Mode +Bitrate +Back scattering weight +Select where rendered images will be displayed +The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent +Gamma Corrected Color +AutoMerge Keyframes +Hold the first frame if no previous strips in track, and always hold last frame +Active PoseChannel constraint +Scene Bases +Vertex Colors +Collection of mesh faces +string +Live search filtering string +Sequencers active strip +Number of scene samples to take with motion blur +Vertex Group for pinning of vertices +Display libraries +The number of fields per rendered frame (2 fields is 1 image) +Allow any .blend file to run scripts automatically (unsafe with blend files from an untrusted source) +Frame of referenced Action to evaluate +Line Error +Plus +Coordinates +Roll CW +Envelope Control Point +Invert roll Axis +Source List Text +The file extension used for saving renders +Last selected element +Radial falloff power (real gravitational falloff = 2) +Face Normal +Fluid Simulation Settings +Disable or enable the render layer +Tap +Active Bone Group +Show render related properties +Number of vertical pixels in the rendered image +Child of this pose bone +Location of Center of mass +Show background image in back view +Max Land Acceleration +3D View +Snap to actual frames/seconds (nla-action time) +Two-side +Tag +Enables Anti-aliasing +Smoke domain settings +Tab +Default Closed +SPH Fluid Settings +Dome physical configurations +Theme settings for the User Preferences +Front-Truncated +Has the current session been saved to disk as a .blend file +12 - Theme Color Set +Box +Constraint modifying the transformation of objects and bones +Curve datablocks +Adjustment Layer +Velocity Scale +Field of View of the Dome - it only works in mode Fisheye and Truncated +Jitter +Audio Window +Use Grease Pencil +Filter Blender +Start frame displayed in the sequence editor after offsets are applied, setting this is equivalent to moving the handle, not the actual start frame +Create springs for this number of frames since particles birth (0 is always) +Label +Object this base links to +Apply channel rotation as IK constraint +PCM +Percentage +Render Sky in this Layer +Red +pl_PL +Datablock whose nodes are being edited +Draw user interface text anti-aliased +Head +Subdivide stroke in bones of specific length +Use the depth under the mouse to improve view pan/rotate/zoom functionality +Texture to use as force +RNA type definition +PIZ (lossless) +Bit depth per channel +Billboard Split UV +Pxr24 (lossy) +Region height +Heat +Particle select and display mode +Normalized +Mux Packet Size +Diameter in Pixels for Object/Lamp origin display +Distance between subsequent volume depth samples +Swap the Mouse Wheel zoom direction +Sequence editor space data +The context in which the panel belongs to. (TODO: explain the possible combinations bl_context/bl_region_type/bl_space_type) +Bake from Multires +Start size of strands in pixels or Blender units +Shape Key datablocks +Targa +Particle Instance +Bezier V +Multiplier to bring particle speed within an acceptable range +Collision Group +Limit effectors to this Group +Display datablocks of all objects of same type as selected object +The constraint is applied relative to the local coordinate system of the object, with the parent transformation added +Deliver normal pass +Location of tail end of the bone +The transformation of the target is evaluated relative to the world coordinate system +File Path +O +FLAC +UV Layer to control billboard time index (X-Y) +Blender Units +Vertex Group Tangent Negate +Set color of selected color stop +Pivot center for rotation/scaling +Set audio sample format to 16 bit signed integer +Zooms in and out based on horizontal mouse movement +Invert Zoom +Alpha Mode +bl_use_postprocess +Land Stick Force +Create empty placeholder files while rendering frames (similar to Unix 'touch') +Face Collision +Automatic keyframe insertion for Objects and Bones +Damp +Disable simulation of angular motion along the X axis +RNA Array Index +Unsigned Number +Output video in MPEG format +Dead +Text Widget Colors +Auto Save Time +Freehand curve defining part of a sketch +Header Text Highlight +Seed +True when the Ctrl key is held +Raytrace Acceleration Structure +Which direction is used to calculate the effector force +Addon Key Configuration +Data point for freehand stroke curve +Number of cone samples averaged for blurry reflections +F8 +Filter Sound +Mass of cloth material +Matrix +Action Group that this F-Curve belongs to +Subdivide stroke adaptively, with more subdivision in curvier parts +How many steps to draw the path with +Space Text Editor +Handle Vertex +Render face two-sided +Mist uses inverse quadratic progression +DV +Has Maximum +Skip Quad to Triangles +Number of times to repeat the action range +Maximum Distance +is_baked +Amount of damping during collision +F9 +8192 +X Offset +Image Pin +Accuracy of attack +Continuously unwrap the selected UV island while transforming pinned vertices +Collection of grease pencils +Gesture Border +Exclude raytraced reflection pass from combined +Choose normal space for baking +Boid state for boid physics +Occluder for optimizing scene rendering +Axis Angle +Field settings for an object in physics simulation +Rotation Mode +Active Spline +Buoyancy +Element of a curve, either Nurbs, Bezier or Polyline or a character with text objects +Start player with a visible mouse cursor +Bars +Armatures active edit bone +Breakdown +Color Mode +Diffuse +01 - Theme Color Set +Start position of the marker in the line +Consider objects as whole when finding volume center +Iris +Save Buffers +Time Scale +Split quads predictably (1,2,3) (1,3,0) +Constraint +Display Hidden +Receive shadows from sources outside the volume (temporary) +Required +Domain +Display Speaker +GLSL Ramps +Point data to use as renderable point density +Keyframe insertion only when keyframe needed +Audio Sample Rate +Area width +Time +Texture datablock used by this texture slot +Draw Waveform +DPX +Expression +Voxel data settings +Constraints +State Colors +Influence setting is controlled by an F-Curve rather than automatically determined +Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method) +Set audio sampling rate to 48000 samples per second +Order of video fields. Select which lines get rendered first, to create smooth motion for TV output +Surface Diffuse +Magnetic +Stamp Background +Radius of the activity bubble, in Manhattan length. Objects outside the box are activity-culled +Show Warn +When bone has a parent, bone's head is struck to the parent's tail +Timer 0 +Timer 1 +Timer 2 +Display Y Axis +Frame player from IRIDAS +Children +Zoom To Mouse Position +Shadows +Use High Quality Drawing +Exclude emission pass from combined +Invert rotation axis +Plane +Drivers +Particle system in an object +Shader Nodes +Z-Buffer +Soft to Soft Body +Expanded in the user interface +After Current +Mix +Object Color +Fresnel +Main Cameras +Atmosphere Extinction +Use Indirect Lighting +Elastic Limit +Material Slot +Resolution of raytrace accelerator. Use higher resolutions for larger scenes +Falloff Power +Mesh Deform +Show influence curves on strips +Tweak timing for physics to control frequency and speed +IK X Stiffness +Theme settings for the File Browser +Images are saved with RGB (color) data +1 +Textured Fonts +Data type of the property +Gain +Scale X +Is Perspective +Metaball +IK Z Stiffness +B-Bone Display X Width +Space Console +Handle type for handles of new keyframes +Left Mouse +Macro +Average +Curve +Sketches for this layer on different frames +User interface layout in a panel or header +Error Tolerance +Axis of mouse movement to zoom in or out on +Disable auto (de)activation in physics simulation +Softness +Inherit Scale +Graph Editor +Method of shading, attenuating, and scattering light through the volume +View +Position Iterations +H.264 +Romanian (Român) +Still Frame Number +Extension Filter +Vertex Group Roughness End Negate +Specular Colors +Minimal Info +Face selection mode +Reflection Color +Node Editor +Proportional distance over which the light is diffused +Use Local Coords +Zmask Negate +Property that gives the name of the struct +Rotation in quaternions (keep normalized) +On Keyframes +Pulse False Level +Animated +Main Grease Pencils +Alpha Sort +Factor for ambient occlusion blending +Active vertex color index +Generator +Author +Restrict Animation Updates +Lock editing of four component rotations by components (instead of as Eulers) +NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled) +The diffuse color of the OpenGL light +Do not calculate lighting and shadows +Max Sample Error +Cut +Starting distance of the mist, measured from the camera +Damping +Push an undo event (needed for operator redo) +White +Sets the strength of the add effect +Collection of lamps +Animation +Parent bone (in same Armature) +Environment Maps +Inputs +Direction +Max difference in heights of obstacles to enable their interaction +group +75% +Hide this curve in editmode +Deformed Location +Include visualization of Lattice related Animation data +Weighted result of strip is multiplied with the accumulated results +Cloth Settings +Sharp edge for the EdgeSplit modifier +Collection of groups +window +Preset +Theme Outliner +Fast Navigate +Draw Smooth Edges +Collection of curves +Star Tips +NLA Evaluation Enabled +3D Cursor Location +Spline Bezier Points +Stereo +Page Up +Negate the effect of the field vertex group +Collide All +Items Expanded +Marker for noting points in the timeline +Z Direction +Causes lamp data to be duplicated with the object +Scene Strip +Boid state name +Simulation value to be used as a texture +64-bit Float +Domain Object +Right +Shape of clumping +XZY Euler +Group Sockets +Individual pose bones for the armature +Min Step +Manipulator Scale +Main Armatures +Die Time +Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method) +Placeholders +name +Unfitted +Minimum regions size. Smaller regions will be merged +Mesh Selection Mode +Method to draw in the sequencer view +Mute +Down Arrow +Render Strands in this Layer +Child Particles +Duplicate Action +IK Param +Main Images +Weight for cloth simulation +Index number of the vertex group +Collection of NLA Tracks +Sequence strip data for a single frame +Sculpt/Paint Use Unified Strength +Audio Mixing Buffer +ID-block that the specific property used can be found from (id_type property must be set first) +Linear physics +Use Collision Bounds +Passes +Noise algorithm - Original Perlin: Smooth interpolated noise +Additive +Handle 2 selection status +Trigger controllers only for an instant, even while the sensor remains true +Loose edge +Edit animation/keyframes displayed as 2D curves +Sculpt/Paint Use Unified Radius +Index to the specific property affected by F-Curve if applicable +Main Window Managers +Unit to use for displaying/editing rotation values +Editmode bone in an Armature datablock +Bending Stiffness Maximum +Selection state of the curve point +Enable pinning of cloth vertices to other objects/positions +Shared +Zoom = Up/Down +NLA Strips +Text to search for with the find tool +Use a DCI Standard preset for saving jpeg2000 +Blend Mode +Space Sequence Editor +Textures Directory +Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes +Include the name of the active scene in image metadata +F-Curve Name Filter +Time in 1/10 seconds to hold the Right Mouse Button before opening the toolbox +pin_id +Fluid interaction radius +NLA Strip 'transitions' between adjacent strips +Editable +Emission +Template armature that will be retargeted to the stroke +Selection status +Texture slot defining the mapping and influence of a texture +Connected +Key +Align the transformation axes to world space +Transform parameters for a sequence strip +Layer Opacity +Use the Bullet physics engine +Method for generating shadow samples (for Raytrace) +Effect particles' dynamic rotation +Show options for whether channels related to certain types of data are included +G +Collection of group objects +Make hairs shorter +Show properties marked for debugging while the game runs +Invert x axis +Greek (Îλληνικά) +Smooth +Sync view position between side views +Used Layers +Active File Text +F18 +F19 +Force effector weight +The distance over which the mist effect fades in +Edge Select +F12 +F13 +F10 +Display Meshes +F16 +Options +Grease Pencil datablocks +F15 +Output video in AVI JPEG format +Sky Color +blend_data +Temporary Directory +Current rendering engine is a game engine +100% +Vertex Group Roughness 2 +IK Rot Weight +Handle Type +Bevel Weight +F-Curve Modifier Type +int +No Sleeping +Save TIFF with 16 bits per channel +ID Property Group +Island selection mode +Collection of texts +Edges collide too +512 +Sets minimum Y value for the render border +Mouse X Position +Active screen showing in the window +Stamp Note +Number of horizontal tiles to use while rendering +Tilt +Child Particle +Action Start Frame +Media Last +Pass in multilayer image +Back Space +Outflow +Active Boid State Index +Enable cluster collision between soft and soft body +Instance support leads to effective memory reduction when using duplicates +Xvid +Realtime display of a modifier +Sets the layer as active for display and editing +Wireframe +Grease Pencil Eraser Radius +Accurate, but slow when noise-free results are required +Syntax Special +Repeat +Global undo works by keeping a full copy of the file itself in memory, so takes extra memory +Strength of noise +Vertical +Separate +Self Friction +Snap median onto target +Area +Falloff +REC709 +Smooth the normals of the surface or beveled curve +2D View Minimum Grid Spacing +Font Style +Image datablocks +3D region in this space, in case of quad view the camera region +Sound datablocks +Auto Velocity +Data +Bake the normals in world space +Lock Camera and Layers +Vertex group to control rotation +Global +Sun Brightness +Optional custom node label +Align to Normal +Directory displayed in the file browser +Deliver speed vector pass +Enabled +Frame player from Tweak Software +Weighted result of strip is removed from the accumulated results +A animation layer containing Actions referenced as NLA strips +Key configuration that can be extended by addons, and is added to the active configuration when handling events +Dominant +Line Output +Seam edge for UV unwrapping +Options for this panel type +Menu Widget Colors +Main Worlds +Shadowed +11 +Atmosphere +Create representation for obstacle simulation +Estimated rotation matrix +16 +Pose +Sun size +NodeTree +RGB +2048 +Anaglyph +Active Object +Collection of curve splines +Marker highlighting a portion of text in a Text datablock +DopeSheet +Magnetic effector weight +Render face transparent and add color of face +Previous Rotation +Display Shapekeys +Aggression +en_US +Color space to use for internal XYZ->RGB color conversion +Numpad 7 +Sets the maximum number of physics step per game frame if graphics slows down the game, higher value allows physics to keep up with realtime +Keying Sets All +Boid +Numpad 6 +Snap Element +it_IT +Include the name of the foreground sequence strip in image metadata +Metaballs +Active particle system being displayed +Toggle between moving the viewpoint or moving the scene being viewed +Use a Gaussian filter for anti-aliasing +ChannelDriver Variables +MetaBall +Combined +FFmpeg video codec #1 +Use Default Fade +Numpad 3 +ZXY Rotation Order. Prone to Gimbal Lock +Index to the specific setting if applicable +Bake Mirror values +Use vBVH +Apply channel size as IK constraint if stretching is enabled +Invert Zoom Direction +Numpad 1 +Edge Sharp +Unit Settings +Stamp Frame +Brush datablocks +use global timestamp written by recording device +Mapping +Snap active onto target +Rigid Body Joint +Rate control: buffer size (kb) +Scale factor along the Y for items in this (sub)layout +RGBA +Half +Sets the number of rings rendered over the halo +Turbulence +Graph Editor instance has some ghost curves stored +Halo +No display +Stiffness Scaling +Use a custom falloff curve +Contents Follow Opening Direction +Off +Seam +Sculpt +Sequences +Stiff viscosity is a factor of normal viscosity +Curve Guide +Proportional Editing disabled +Rotate Around Selection +Key Maps +Minimum +Align newly added objects facing the active 3D View direction +Tool Properties +Amount of noise for the force strength +Amount of ray samples. Higher values give smoother results and longer rendering times +Numpad 8 +] +Exclude specular pass from combined +Stamp Scene +Collection of grease pencil layers +Choose Collision Type +Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption) +Particle system has been edited in particle mode +Stroke conversion method +Properties acting as inputs for this driver +Point Cache +Window Manager Event +Collection of brushes +Don't use a physics engine +Material Override +Temperature difference to ambient temperature +State determining which controllers are displayed +All Object Origins +Uses extreme alpha +Node Tree +Before Current +Array +Collision settings for object in physics simulation +Stretch To +F-Curves for controlling the strip's influence and timing +Field Order +Hide Dot Files/Datablocks +Loose +Use Game Engine +Onion Skinning (ghosting) settings for visualisation +Draw dashed black-white edges +Align handle selected color +Minimum number of pixels between each gridline in 2D Viewports +Sky +Spring Frames +Location of head end of the bone +Active key configuration (preset) +Width +Action Group is selected +Collection of Texture Nodes +Collection of add-ons +States which are being used by controllers +Gravity or external force vector +NLA Track is active +Ogg +Roll +Grless +Wheel Down +Amount of friction during particle collision +Search in all text datablocks, instead of only the active one +View pivot location +Draw image with RGB colors and alpha transparency +Resolution +Use the scene's active camera and layers in this view, rather than local layers +Every point is effected by multiple springs +Vertex +Include the filename of the .blend file in image metadata +Maximum distance error from contour to cells +Output video in H.264 format +Action displayed and edited in this space +History +Local View +Stamp Text Color +Translation +IK Y Maximum +File Select Parameters +Shared Vertex +Safe Margin +Tip Size +Edge color +Negate the effect of the size vertex group +Game engine controllers to process events, connecting sensor to actuators +Triangle Mesh +NLA Strip is played back in reverse order (only when timing is automatically determined) +Scale Y +H +Main Lamps +Approximate +Controllers +Deliver specular pass +The number of old versions to maintain in the current directory, when manually saving +Theme settings for the NLA Editor +Nearest Marker +Randomize star colors +Theme settings for the Sequence Editor +Index of refraction (higher values are denser) +Local Location +Default Key Configuration +Show background image while looking to the right +The space where the header is going to be used in +Max number of vertices per polygon +Quality of JPEG images, AVI Jpeg and SGI movies, Compression for PNG's +Averaged Value +Use a box filter for anti-aliasing +Spin CCW +Color to use for stamp text +Wheel Invert Zoom +Lock Camera to View +New Interpolation Type +Main data structure representing a .blend file and all its datablocks +Calculate bone paths from heads +Layer of vertex colors in a Mesh datablock +Is this keymap item user defined (doesn't just replace a builtin item) +Main Textures +Enable soft body shape matching goal +How many self collision iterations should be done. (higher is better quality but slower) +Collection of scene bases +Show right margin +Ambient Occlusion +Frame this control-point occurs on +Snap to edges +Turbulence effector weight +Build record run time code index +float +Use Edges as springs +Rings +Color Ramp Elements +Charge +Thickness +Zmask Layers +The panel label, shows up in the panel header at the right of the triangle used to collapse the panel +Spread +Cluster Iterations +Location +Weight Paint +15 - Theme Color Set +space_data +Vertex group to control kink +If this is set, the menu gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_MT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_MT_hello" +Path is being edited +ShapeKey Editor +AC3 +Set audio channels to 5.1 surround sound +Minimum Size +Path to a custom animation/frame sequence player +Smoke inherits it's velocity from the emitter particle +Display Lists +Maximum number of frames on either side of the active frame to show (0 = show the 'first' available sketch on either side) +Compress File +Bezier U +Displace +Velocity Max +Use Right Mouse Button for selection +Box Backdrop Colors +Exec Default +3 +Path point is selected for editing +Bone Group +When calculating Bone Paths, use Head or Tips +Project Individual Elements +Parameters for IK solver +Show the object origin center dot for all (selected and unselected) objects +BLI BVH +Realtime Updates +Shutter +How strongly the fluid tries to keep from clustering (factor of stiffness) +Target +Scrollbar +Show controllers of all selected objects +Instead of per brush radius, the radius is shared across brushes +screen +Use large mouse cursors when available +Keymap is defined by the user +Grease Pencil Stroke Point +48 kHz +Use the manipulator for rotation transformations +Bullet +Armature Bones +Directory +TimeCode Style +Identifier +Does full Sky texture render for diffuse energy +Items in the keymap, linking an operator to an input event +AvMinMax +Multiply the current speed of the sequence with this number or remap current frame to this frame +Apply force only in 2d +MPEG +Is this keymap item modified by the user +Zoom in towards the mouse pointer's position in the 3D view, rather than the 2D window center +How smoothly the boids land +region +Swedish (Svenska) +Region in a subdivided screen area +Add indirect light bouncing of surrounding objects +Factor Radius +Obstacle +Color used for selected bones +Line Numbers +Draw edges after modifiers are applied +Space Info +Multicam Selector +Reflection Exclude +Weight of scale constraint for IK +Node editor space data +Link between nodes in a node tree +Show the entire viewport in the display window, viewing more horizontally or vertically +Pixel distance around the handles to accept mouse clicks +Initial State +Sum Values +Channel Group +Tools can use this to tag data, (initial state is undefined) +The default directory to search for textures +Lin error +F-Curve is selected for editing +Keying Sets +Release confirms +64 +Title for the file browser +Sets the audio sample format +Invert y Axis +Include the name of the last marker in image metadata +Collection of keyframe points +3D View space data +Vortex effector weight +Object adds fluid to the simulation +Use smoke velocity as texture data +Maximum Radial Distance +The axis to display the image on +Keying set options +Horizon Brightness +Render Engine +Display Particle +Exclude AO pass from combined +Lights user to display objects in solid draw mode +Textbox Height +Point coordinates +Axis Angle (W+XYZ). Defines a rotation around some axis defined by 3D-Vector +Text Editor +Use display lists to speed up rendering by keeping geometry on the GPU +Actuators +Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled) +es_ES +Auto Run Python Scripts +Subtract +Screen Editing +Properties in the struct +Set audio sampling rate to 96000 samples per second +Scale to use when converting between blender units and dimensions +Mouse/Trackpad Zoom +X Ray +Maximum distance of reflected rays (reflections further than this range fade to sky color or material color) +True when this property is an output value from an RNA function +False when F-Curve could not be evaluated in past, so should be skipped when evaluating +Fresnel Factor +Minimum for slider +Use Goal +Sets how the texture is extrapolated past its original bounds +Minimum size of strands in pixels +Points +Motion Path +Emission Color +Global maximum shadow samples +Path +Action +Sets the number of sub-flares +Used State +Update other affected window spaces automatically to reflect changes during interactive operations such as transform +Filter Script +Method to interpolate/smooth values between voxel cells +Gives halo a texture +Show markers belonging to the active action instead of Scene markers (Action and Shape Key Editors only) +Divide +Proportional Editing mode, allows transforms with distance fall-off +Angular distortion between UV and 3D angles +Random variation of damping +Channels Selected +plugin +Spline IK +The frame on which the timeline marker appears +Snap to 1.0 frame/second intervals +Handle 1 selected +Free all image texture from memory after render, to save memory before compositing +Method used for combining Active Action's result with result of NLA stack +If enabled, stiffness can be scaled along a weight painted vertex group +Invert z Axis +Minimum regions size. Smaller regions will be deleted +Display Mode +Text bounding box for layout +Onion Skinning +Open +User Add-Ons +Output file format +Size +Backdrop X offset +Active Pose Marker Index +Text Marker +Number of preprocessing passes to reduce overocclusion +Modifiers affecting the shape of the F-Curve +Wheel In +Mesh Face +Rotation Angle +Path to a setting for use in a Keying Set +Sync Markers with keyframe edits +Whether to use minimum clipping value +Main Actions +Editing context being displayed +Raytraced refraction settings for a Material datablock +Enable image painting mode +Hidden +When adding objects from a 3D View menu, either align them to that view's direction or the world coordinates +Only show and edit handles of selected keyframes +Cinema 48fps 2048x1080 +Max Rate +Envelope Head Radius +Use old Octree structure +Global maximum subdivision level +Use this object's coordinate system instead of global coordinate system +Viscosity +Theme Properties +Boolean Property +UV Selection Mode +Force the curve view to fit a defined boundary +Objects +Default (Default) +Shade Down +Grease Pencil Layers +Current Keying Set index +Shadow Exclude +Root Size +Rest Shade Key +Framerate, expressed in frames per second +Scrollback +Overlay Lock +Duplicate Text +Russian (Ð ÑÑÑкий) +10 - Theme Color Set +Collection of texture slots +ID Materials +I +The distance from which particles are affected fully +Action Pose Markers +Clamp velocity to this maximum speed +English (English) +JPEG +L +Display only files with extensions in the image select window +Theme Sequence Editor +ID From +All Scenes +Make hairs longer or shorter +Handle Vertex Select +With displacement normalize to the distance, with ambient occlusion normalize without using material settings +Physics +ID +Mesh Vertex Color Layer +Use curve weights to influence the particle influence along the curve +Cached location on path +Motion +Node tree being displayed and edited +Tangent Shading +Mesh Vertex Color +B-Spline +Based on distance/falloff it adds a portion of the entire path +Theme settings for the Audio Window +Displacement +Coordinates of the second handle +Rendering settings for a Scene datablock +Radius of boids personal space on land (% of particle size) +Live Edit +The length of the contents of this strip before the handles are applied +Display Armature +Length Mode +Display datablocks of active object +SDL +Collection of Nla Strips +Amount the Active Action contributes to the result of the NLA stack +Show only actuators connected to active states +Vertex group for fine control over bending stiffness +4 Channels +Bake displacement +Acceleration +Angular Velocity +Boid Rule +Action Group +Split quads predictably (0,1,2) (0,2,3) +Struct definition this is derived from +Include the current date in image metadata +Action Group is expanded +Draw title safe margins in preview +Output image in DPX format +Include visualization of Object-level Animation data (mostly Transforms) +Proxy size 25% +16 bit color channels +The default directory to search for sounds +Log +Redraw all overlapping regions, minimal memory usage but more redraws +International Fonts +5.1 Surround +Linear +Settings that should be keyframed together +Factor Repulsion +Overlap Flip +The active face for this mesh +Turn on SB diagnose console prints +Dome +Brazilian Portuguese (Português do Brasil) +Make hairs stand up +Uses the vertex normal to specify the dimension of the halo +Key maps configured as part of this configuration +Active Space +4 +Theme Text Editor +Method to display/shade objects in the 3D View +Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled) +Normalized Coordinates +Glow +Diffusion +Enemy +Co-ordinate system to cache vertices in +Show state panel +Show ghosts on keyframes +Anti-Aliasing +Zoom Axis +Reactor Target Particle System +First input for the effect strip +Radians +Free Nodes that are not used while compositing, to save memory +Transform +Free handle selected color +Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled) +Button 10 +Amplitude +Show Active States +Space Nla Editor +Vertex group to control length +In text window, paste with middle mouse button instead of panning +Collection of object constraints +Transparent RGB pixels are multiplied by the alpha channel +Calculates environment map at each rendering +Deform +Choose BW for saving greyscale images, RGB for saving red, green and blue channels, AND RGBA for saving red, green, blue + alpha channels +Tweak Right +44.1 kHz +Include visualization of Texture related Animation data +Set layer Visibility +Deliver mist factor pass (0.0-1.0) +Sort files by modification time +Minimal # solver steps/frame +Have recent edits been saved to disk +Keying Set Paths to define settings that get keyframed together +Pressure of tablet at point when drawing it +Show background image while looking to the left +Sharp +Only include F-Curves with names containing search text +Number of spaces to display tabs with +Puff Volume +Video bitrate(kb/s) +Linear Stiffness +Vertex Group Tangent +Amount of dithering noise added to the rendered image to break up banding +Absorption +Find Wrap +Enable hair dynamics using cloth simulation +The type of the Sequencer view (sequencer, preview or both) +Number Widget Colors +File Extensions +Theme Node Editor +Object Duplicate +Goal Maximum +Size of element, use of components depends on element type +Word Wrap +Any +More than one rendering engine is available +Cached positions per frame +Control key pressed +Collection of armatures +Gloss Anisotropy +Tracking by taking the shortest path +Spherical falloff +Objects further than this are not visible to map +Driver could not be evaluated in past, so should be skipped +Insert Keyframes - Visual +Rule Evaluation +Negate the effect of the velocity vertex group +The frame number to always use +ca_AD +Visibility +Bone associated with this PoseBone +Envelope Deform Distance +Invoke Area +Theme Info +Current Keying Set index (negative for 'builtin' and positive for 'absolute') +Black +Lock editing of location in the interface +Interface +Auto Keying Enable +Save luminance-chrominance-chrominance channels instead of RGB colors +Left Ctrl +Multiplier to adjust velocity passed to smoke +Font size and resolution for display +Extreme +Show Controllers +Render engine +Render image to two fields per frame, for interlaced TV output +To socket +Activate TRUE level triggering (pulse mode) +Temp. Diff. +Expanded +Target particle system +Which part to snap onto the target +local space unit length normal vector for this face +Keying Set Name +Python Console +Show Hidden +The region relative horizontal location of the mouse +Nurb active V-lines +Set position of selected color stop +Fixed size UV coordinates array +Reactor Target Object +Node tree type to display and edit +Display datablocks in current scene +Color and Alpha +Causes texture data to be duplicated with the object +Item in a Key Map +3D View region data +Display face-assigned textures in solid view +Disable simulation of linear motion along the Z axis +Point of a curve used for a curve mapping +Include visualization of Metaball related Animation data +Structural Stiffness Maximum +Factor Density +Simple Deform +The default color for textures that don't return RGB or when RGB to intensity is enabled +Name of UV unwrapping layer +Outputs +Images +Message +Ray +Theme Bone Color Set +Redraw all overlapping regions, minimal memory usage but more redraws (for graphics drivers that do flipping) +IK stiffness around the Y axis +Edge spring stiffness when shorter than rest length +Menu Backdrop Colors +50% +Heads +Stereo Mode +Soft body simulation settings for an object in the game engine +Show Framerate and Profile +Right Shift +Direct conversion of frame numbers to seconds +Log conversion reference whitepoint +Radius +Linear stiffness of the soft body links +View3D Rotate Modal +SMPTE +Add +Show framerate and profiling information while the game runs +Degrees +Gather Method +Output +Set audio sampling rate to 192000 samples per second +End +Include visualization of Material related Animation data +Sets the layer as active for cloning +Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing +When bone doesn't have a parent, it receives cyclic offset effects +Enable self collisions +Property is registered as part of type registration +Syntax Comment +Draw Particles +area +Basis Matrix +Active vertex color layer +Image and UV editor space data +Set metaball as negative one +Collection +JPEG Quality of proxies to build +Zbuf +Show the Z axis line in perspective view +Tails +Show Active Object +Defines size of derivative offset used for calculating gradient and curl +Color Set +Integer +Output image in bitmap format +OpenAL +Particle Systems +Display the user preference datablocks +Size of packed file in bytes +Ukrainian (УкÑаÑнÑÑкий) +Mono +No proxy, full render +Fullscreen +Allow scaling of the bone for IK +Creates viscosity for expanding fluid) +J +Blend mode for combining sun sky with world sky +Global Undo +Quicktime +Draw frames rather than seconds +Bake shading on the surface of selected objects to the active object +Frame currently being displayed for this layer +Never None +alignment +Bulgarian (ÐÑлгаÑÑки) +Light +Maximal Spring length * Ball Size +Emulates Middle Mouse with Alt+Left Mouse (doesn't work with Left Mouse Select option) +Text datablocks +Welding +Heavy +Quick Sketching +Method used to determine color of F-Curve in Graph Editor +Show UV Editor +Cut hairs +Expand +Effect particles' location +View Matrix +Allow boids to climb goal objects +Sequence +Bone Name +Seed of the noise +Motion Path Cache Point +Use modifier while in the edit mode +Meshes +For reactor systems, index of particle system on the target object +Billboard +Automatically set based on graphics card and driver +Macro Operator +DopeSheet Channel +Render and combine multiple samples per pixel to prevent jagged edges +Render Z-Transparent faces in this Layer (On top of Solid and Halos) +Output image in uncompressed Targa format +Paths +Left Arrow +Collection of spline bezirt points +Layout +Show Physics Visualization +Number of bones in the subdivided stroke +Vertex Group Clump Negate +Negate the effect of the tangent vertex group +Base type for IK solver parameters +Active camera used in this view (when unlocked from the scene's active camera) +Re-render and composite changed layer on 3D edits +ISO 2 +Active Layer Index +Esc +Show Frame Number Indicator +End Offset +Use active Viewer Node output as backdrop for compositing nodes +Blender command line animation playback - path to Blender 2.4 +Frequency +Pivot around the median point of selected objects +Blend vertex colors across face when vertices are shared +Game engine logic brick to detect events +Causes the image to repeat horizontally and vertically +Bone location is set in local space +User Preferences +Show Operator +Max Logic Steps +Damping of the harmonic force +Vertex of a simulated fluid mesh +Graph Editor Generic +18 - Theme Color Set +Average Speed +Console +Total number points for the surface on the V direction +Use the manipulator for scale transformations +Disable +5 +13 - Theme Color Set +Vertex group to control field +12 +Shared Location +Transparent pixels are filled with sky color +Atmosphere Turbidity +Widget Style +RNA function definition +NLA Strip is not evaluated +Recast Data +4096 +Right Handle Selected +Cyclic +Color Ramp +Self Collision Quality +Index of active pose marker +Vertex Group Density Negate +Dome Mode +Image and settings for display in the 3d View background +Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist +FPS +Normals +SIMD SVBVH +Minimum distance between collision objects before collision response takes in +Color balance gamma (midtones) +Minimum distance for the field's fall-off +Limit fluid objects to this group +Load UI +Factor Stiff Viscosity +Draw preview using full resolution or different proxy resolutions +Paint Lock +Sets the number of samples used by the audio mixing buffer +Source List +Around Current Frame +Scroll Handle +Add light coming from the environment +Color of the F-Curve in the Graph Editor +Exclude indirect pass from combined +Selection of IK solver for IK chain, current choice is 0 for Legacy, 1 for iTaSC +Bias +Text Input +Pitch +2D +Braid +Modifier name +Use extra textures like normal or specular maps for GLSL rendering +Stamp Marker +ZXY Euler +Function does not pass its self as an argument (becomes a class method in python) +Sun Intensity +Fit +AO Exclude +Integer Property +Tube +ZYX Rotation Order. Prone to Gimbal Lock +Default paths for external files +Solid +Lock the same rotation/scaling pivot in all 3D Views +Groups of F-Curves +Display the object solid, with face-assigned textures +Quadratic +ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only) +Inaccurate, but faster and without noise +Unique ID for this region +Lock Y Axis +Logic Nor +Gaussian +Euler +Settings for filtering the channels shown in Animation Editors +Invoke Region Channels +Crop the rendered frame to the defined border size +Limit Location +Radius of the brush in pixels +Automatically select also UVs sharing the same vertex as the ones being selected +Title +Histogram +Display raw datablocks +Bone deformation distance (for Envelope deform only) +Forcefield based on the Lennard-Jones potential +Action Group is locked +XYZ Euler +Outline Width +Upper First +Subdivide stroke in fixed number of bones +Action Clip +Use 16 bit floats instead of 32 bit floats per channel +Stamp Camera +Texture Nodes +Falloff power (real gravitational falloff = 2) +3D View near clipping distance +Color Randomization +Snap Peel Object +Determine the amount of render threads used +Amount +F-Curve +Zmask scene layers for solid faces +Bone Group this pose channel belongs to (0=no group) +Constraint's panel is expanded in UI +Collection of Color Ramp Elements +Grease Pencil +Show controllers of active object +Instead of per brush strength, the strength is shared across brushes +Allow boids to move on land +Negate the effect of the clump vertex group +` +Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis +Highlight the current line +Simplify Child Particles +Lattice +Timeline Markers +Draw actual particles +XYZ +Collection of spaces +Bake Mode +Sub +Enable Stereo environment +F-Curve defining values of a period of time +Rules are gone through top to bottom. Only the first rule that effect above fuzziness threshold is evaluated +Constraint to stay within the image bounds while editing +Only Selected Curve Keyframes +Scroll Bar +Theme settings for Font +Allow Climbing +Syntax Highlight +ASCII +Properties space data +Lamp datablocks +Pivot around bounding box center of selected object(s) +Max Res +Mouse Previous X Position +Simplify the final stroke +Frame is selected for editing in the DopeSheet +OS Key +Function is optionally registered as callback part of type registration +Ease +Renders halo as a star +NLA Channels +Use the speed vector pass to reduce AO samples in fast moving pixels. Higher values result in more aggressive sample reduction. Requires Vec pass enabled (for Raytrace Adaptive QMC) +nl_NL +Alt key pressed +Limit movement around the Y axis +Z Scale +Actuator +Motion Path for this element +Slider Widget Colors +Name of Vertex color layer +Xnor +Bone Group this pose channel belongs to +Quad View Region +Edge Split +Noise algorithm - Voronoi Crackle: Voronoi tessellation with sharp edges +Max Air Angular Velocity +Use Bone Sketching +Automatic keyframe insertion using active Keying Set only +Colors +Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method) +Show script files +Cloth simulation settings for self collision and collision with other objects +Object to use as the environment map's viewpoint location +The interpolation type for this curve element +Vertically Open +Show the expanded in the user interface +Emit Object Location +Toggle Widget Colors +Rotation +Current Transformation orientation +Total number points for the curve or surface in the U direction +Active Particle System Index +Material Physics +Pull +List Item Colors +Show a small rotating 3D axis in the bottom left corner of the 3D View +Add-Ons +Render face with texture +Tilt Interpolation +K +Collection of particle systems +Text editor space data +Zoom +Goal minimum, vertex weights are scaled to match this range +When deforming bone, multiply effects of Vertex Group weights with Envelope influence +F-Curve Sample +Radius of eraser 'brush' +Finnish (Suomi) +Turbulent noise driven by the global current frame +Raytraced reflection settings for a Material datablock +Convert effector force into air flow velocity +True when the Shift key is held +Audio Sample Format +Bold +Vertex colors for a face in a Mesh +Cursor +Mouse/Trackpad Pan +Display Paths of poses within specified range +Info space data +Duplicate Armature +Settings for Bullet soft body simulation +Name of the theme +Collection of scene objects +B-Bone Display Z Width +Zoom using up/down on the device (otherwise forward/backward) +Enter Edit Mode automatically after adding a new object +Apply gravitation to point movement +Info on current cache status +Cone +Lock Z Rotation Axis +GLSL Extra Textures +Starts player in a new fullscreen display +Named Group +Samplerate +Children expanded in the user interface +Border +Armatures active bone +Active Path Index +Texture Type +Amount of clumping +Style +Collection of render layers +Show Restriction Columns +Soft Body +Drag effector weight +Layers visible in this 3D View +Top +Quality of the simulation in steps per frame. (higher is better quality but slower) +The constraint is applied in Pose Space, the object transformation is ignored +View Rotation +Gravitation +Cardinal +Dolly +8 bit greyscale binary data +Chroma Vectorscope +Active bone group for this pose +Repulsion Factor +Object Constraints +Filter Text +Vertex group to control tangent +Default builtin key configuration +Show folders +Page Down +Elements +View3D Zoom Modal +Show Actuators +Deletes smoke from simulation +Filter File Extensions +Control point selection status +Left Handle Selected +Draw Stretch +Align rotation with the snapping target +Cloth +Show the name of the view's direction in each 3D View +Display Filter +Object does not restitute collisions, like a ghost +Particle Velocity +Relative time of key over hair length +6 +Threshold for drawing outlines on geometry edges +Lighting +MPEG-4 +Delete +MPEG-2 +Curve Edit +Distance of the physics area +Boid Settings +Pixel resolution of the rendered environment map +Goal maximum, vertex group weights are scaled to match this range +Vertex Group Roughness 2 Negate +Manipulator Rotate +Limits +Current Frame +Project to Self +Sticky texture coordinate location +Transition +Duplicate Texture +Mask +Description of the Function's purpose +Generate voxels from a sequence of image slices +Theme settings for the Node Editor +Automatic time snapping settings for transformations +Banking +Texture Plugin Directory +Mass +Mist settings for a World data-block +Show column +Tool Widget Colors +Clip Alpha +Retarget +Drag component proportional to velocity +Blocking +Mirror Colors +Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method) +Bars Selected +Use a minimum radial distance for the field's fall-off +Edit Object +Cineon +Height +Texture Factor +Draw Wire +Manipulate object centers only +Custom color set to use +Negate the effect of the density vertex group +SL +Enable Self Collision +Correction +Self Minimum Distance +Keying set paths +Invoke Region Preview +Causes material data to be duplicated with the object +Sample Distance +Vertex Group Field +Multiplier to make out-scattered light brighter or darker (non-physically correct) +Object Selected +Keyframe Selected +Pose Bone +Set sensor expanded in the user interface +Theme Audio Window +Strip Time +Number of frames from start frame for influence to fade out +Codec +Speaker +Image Generic +3D Region +Copy Scale +Duplicate Surface +Particle key for hair particle system +Particle Edit +Number of cone samples averaged for blurry refractions +Keep from going through other boids +Output image in DDS format +Orig Height +In Air +Constraint was added in this proxy instance (i.e. did not belong to source Armature) +OpenGL shading language shaders +Render the stamp info text in the rendered image +read only area of the face +Exec Region Channels +Smoke collides with every side +Enable Collision +The mouse button used for selection +How strong a force must be to start effecting a boid on land +Imperial +Vertex Group Length +SDL device - simple direct media layer, recommended for sequencer usage +Pixel Aspect Y +Shadow +Show the active object's softbody point cache +ZIP (lossless) +Collection of Compositor Nodes +Viewport Shading +Mean red/green/blue scattering path length +Ball inflating pressure +Snap to nearest marker +Vertical aspect ratio - for anamorphic or non-square pixel output +Window Sliders +Color ramp mapping a scalar value to a color +Make hairs less puffy +Active UV texture index +Location of head end of the bone relative to its parent +Display Texture +Group Node +Collection of meshes +Continue +Grease Pencil Smooth Stroke +Set audio mixing buffer size to 4096 samples +Transparent RGB and alpha pixels are unmodified +Nearest Neighbor +Gives a constant force along the force objects local Z axis +Emit +Bake the normals in tangent space +Active Base +Active UV texture +Falloff Curve +Sun intensity +Collection of related sketches on a particular frame +Vector Fonts +Mesh Edit +String Property +Variables +3D View Space +Show the active object's particle point cache +Cinema 24fps 2048x1080 +The default directory for rendering output, for new scenes +Audio bitrate(kb/s) +Font Size +File +Automatically converts all new tabs into spaces for new and loaded text files +Search again from the start of the file when reaching the end +Driver variable type +Search term for filtering in the UI +Show UV editing related properties +Subdivision Surface +Mipmaps +Simplified Chinese (ç®ä½ä¸æ) +Edge Length Text +View2D +Step Size +All effector's weight +GOP Size +Bottom +Color balance lift (shadows) +True when this value can't be set to None +The color of the lights specular highlight +Free Run (Rec Date) +How much the spring rest length can change after the elastic limit is crossed +Nand +Background Images +Vertex Group Roughness 1 Negate +Follow a boid or assigned object +Collection of Shader Nodes +Show Brush +Save Preview Images +Use Influence +Add/Replace +Enable direct editing of modifier control cage +Overwrite characters when typing rather than inserting them +Multitexture +Full +Modifier affecting the geometry data of an object +Text to replace selected text with using the replace tool +Particle Age +Unique name used in the code and scripting +Movie Strip +Python Scripts Directory +Global user preferences +Proportional Size +Location of the hair key in object space +Window Manager +Selectable +Diffuse subsurface scattering settings for a Material datablock +Air Personal Space +Which axis to use for offset +Sound +Include Animation Data blocks with no NLA data. (NLA Editor only) +Tree Type +The index of particle system on the target object +Noise algorithm - Voronoi F1-F2 +Autosplit Output +Type of transition used to fade mist +Logic Nand +Enable this OpenGL light in solid draw mode +Explode +Tilt CW +ID-Block +Diffusion factor, the strength of the blurring effect +Rate control: min rate(kb/s) +Alter spring length to shrink/blow up (unit %) 0 to disable +Object is made a particle system to display particles generated by a fluidsim domain object +Alternate script path, matching the default layout with subdirs: startup, addons & modules (requires restart) +channels +Head Select +Nearest Frame +WPaint Auto-Normalize +View3D Gesture Circle +Active index in render layer array +True when the Cmd key is held +When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used +Poly +Name of the key map +Roll bones to face the view +Cycle the animated time within the action start & end +Metaball Edit +Use anti-aliasing for the 3D view (may impact redraw performance) +Key Configuration +NLA editor space data +Sounds +Noise formula used for turbulence +Show Thumbnails +Output video in AVI Raw format +Shape Keys +Cloth simulation settings for an object +Transparency along the width of the strand +Name of UV layer to override +Custom animation player executable path +Spring Vertex Group +Luma Waveform +Goal Damping +French (Française) +tool_settings +3D Cursor +Collection of lattices +Display +Center of mass +The type of radius interpolation for Bezier curves +Global approximate AA and SSS quality factor +Type of data to take texture from +Build +Logic Xor +Backdrop zoom factor +Collection of worlds +Python addons to be loaded automatically +Proxy size 50% +Intensity of the mist effect +UV Editor +Opacity +JPEG 2000 +ID Type +Wires +Texture Face +The default directory to search for sequence plugins +Physics settings for a Material datablock +Size of the turbulence +Plastic +Viscoelastic Springs +Keyframe Insert Needed +Threads Mode +Exclude environment pass from combined +Display an additional 'summary' line. (DopeSheet Editors only) +Blend factor with sky +BMP +Obstacle simulation +Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled +7 +Enable naive vertex ball self collision +Text Character Format +Particle System +Active section of the user preferences shown in the user interface +Outliner +Don't use any brush +Pulldown Widget Colors +Duplicate Lamp +Spring rest length (factor of particle radius) +Softens the edges of halos at intersections with other geometry +None +ko_KR +Only Matching F-Curves +Active Particle Target +TIFF +Keyboard +Strand settings for a Material datablock +" +Material Index +Targa Raw +Name that will be used in exported files when format supports such feature +F-Curve is not evaluated +Texture Collection Rate +Blend +Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy +rect +08 - Theme Color Set +Sharp falloff +Proxy Local +Repulsion Distance +Method used for combining strip's result with accumulated result +Particle speed (absolute magnitude of velocity) mapped as 0.0-1.0 intensity +Syntax Numbers +Images get saved in 8 bits grayscale (only PNG, JPEG, TGA, TIF) +Global Space +Save the z-depth per pixel (32 bit unsigned int z-buffer) +Curving of the noodle +View Type +Children Expanded +Shape +Background Image +Dash +Pass +Snap to Pixels +Engine +Vertex Select +Specular Exclude +Color 2 +Brush strength +Control point weight values +Maximum memory usage in megabytes (0 means unlimited) +Pivot around each object's own origin +Island +Softbody goal weight +Exclude shadow pass from combined +Method for driving added turbulent noise +Sampled colors along line +Offsets the number of the frame to use in the animation +Maximum angular velocity on land (relative to 180 degrees) +Start Frame +Middle Mouse Paste +Edge Seam +Display UV coordinates from 0.0 to 1.0 rather than in pixels +Find Text +Inverse Gamma +Smooth hairs +Graphics driver and operating system settings +How much density effects smoke motion, higher value results in faster rising smoke +passes +Boid rule name +Maximum number of recently opened files to remember +Path to property setting +Level of detail in the added turbulent noise +Screen +Billboard Normal UV +Selects the type of physical representation +Clip End +Creates a force along a curve object +Time delay in 1/10 seconds before automatically opening top level menus +Autosplit output at 2GB boundary +Resolution Y +Artificial buoyancy force in negative gravity direction based on pressure differences inside the fluid +Gamma +Light Cache +Offset +Voronoi F2-F1 +Hair keys are in global coordinate space +Structs +Particle system name +Don't adjust roll +Bevel +UI Layout +Movie Format +Fast but not so effective compression +Use linear workflow - gamma corrected imaging pipeline +Delta +Gravity +Mist uses linear progression +BSpline +Type of element to snap to +Set audio mixing buffer size to 32768 samples +Show the Y axis line in perspective view +Action End Frame +Settings for input devices +Joystick +Window manager datablocks +Left Handle Type +Points U +bl_description +Collection of mesh edges +Clip objects based on what's visible in other side views +Object Grouped +Backscattered Light +Active grease pencil layer +Animated Influence +Atmosphere Inscatter +Color of emitted light +Lock Location +Active Vertex Color Layer +Spaces +Properties of particle editing mode +Area height +Material nodes +Collection of armature bones +Resolution U +Click +Filter Files +Display general information +Bone Groups +Overlay +Muted +Movie +Auto Clamped +Individual Origins +Overlap +Custom +Particles +Use Max +Window +File browser space data +AVI JPEG +Friction Coefficients +Object base selection state +Bone Pose +Sequence strip in the sequence editor +Display Background Images +Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit) +User defined layer of floating pointer number values +96 kHz +Occlude +Images are rendered in Image Editor +States +Saturation +Location of this character in the text data (only for text curves) +Users +Scene Objects +Goal Stiffness +Audio Codec +Collection of objects +Type of NLA Strip +Minimum distance to the camera for stars +Main Scenes +Clips to image size and sets exterior pixels as transparent +Interpolation method to use for segment of the curve from this Keyframe until the next Keyframe +Radius from the shaded sample to look for points within +Layer of texture faces in a Mesh datablock +Tangent +Stamp Time +Comb hairs +24-bit Signed +Show Handles +Alpha +Difference +The frequency of the offset (1/total length) +Layer Membership +Render layer +ro_RO +Vector Coordinates +Spring force +Flare Boost +Scopes +Description of the item's purpose +Camera Parent Lock +Invert the axis of mouse movement for zooming +Socket name +M +Enable diffuse subsurface scatting effects in a material +Color Factor +Noise algorithm - Cell Noise: Square cell tessallation +For PoseBone paths, use the bone head location when calculating this path +Max Land Speed +Show linked objects to sensor/actuator +Edit drivers +F-Curve Modifier is the one being edited +Channel Matrix +Has Ghost Curves +Threshold for adaptive sampling (if a sample contributes less than this amount [as a percentage], sampling is stopped) +Selects which domain border will be treated as collision object +Object that defines custom draw type for this bone +Still Frame Only +Invert tilt axis +The name of the active key configuration +Apply sun effect on atmosphere +Spacebar +Limit effectors to this group +Keep paths from intersecting the emitter +Input or output socket of a node +Transform Channel +Storage of a macro operator being executed, or registered after execution +Sets the number of points on the star shaped halo +Display the object's local bounding boxes only +Goal (vertex target position) spring stiffness +Boolean +Cyclic U +Cinema 24fps 4096x2160 +Images are saved with RGB and Alpha data (if supported) +Cyclic V +Indirect +Show Points +Speed +Copy Location +GLSL Lights +resolution_x +All available keying sets +Specular Color +Convert to logarithmic color space +Show keyframes for active Object and/or its selected bones only +Use Visual keying automatically for constrained objects +Game Property +Merged Region Size +Material Halo +Flare Seed +No Gimbal Lock (default) +Bending Const +Null device - there will be no audio output +Main Fonts +Sensor +Output image in Cineon format +Set audio sample format to 64 bit float +Whether to use maximum clipping value +Display units in pairs +Form factor scales the inertia tensor +Filter Images +Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard +Draw UV edges anti-aliased +Search string is sensitive to uppercase and lowercase letters +Region Text Titles +Flow Settings +Texture Slot +Enable debug visualization for obstacle simulation +Wrinkle coefficient. (higher = less smaller but more big wrinkles) +Action to take for gaps past the Active Action's range (when evaluating with NLA) +Spring rest length is a factor of 2 * particle size +Mist uses quadratic progression +Base +Enter Edit Mode +Widget Label Style +For Zmask, only render what is behind solid z values instead of in front +Face Angle Text +8 +Face Dot Size +Grow +Strips +Vertex group to control roughness end +Texture Slots +Snap UVs to pixel locations while editing +Border Minimum X +Value +Button5 Mouse +Roll CCW +Deprecation Warnings +Source List Title +Collection of fonts +Effector weights for physics simulation +2 +Input line for the interactive console +; +Soft body +Display Lamp +Tail Select +Rotation in Quaternions +Main MetaBall +Right Alt +Waveform Mode +Audio samplerate(samples/s) +Random +Harmonic +hr_HR +Themes +Texture scatting blend factor +Selected File +Cache AO results in pixels and interpolate over neighbouring pixels for speedup +double +Negate +Mute this shape key +Fgon +RVO (rays) +External file packed into the .blend file +Causes text data to be duplicated with the object +Include visualization of Speaker related Animation data +Zoom factor +Tweak Select +Shape Match +Spherical forcefield based on the charge of particles, only influences other charge force fields +Active Boid Rule +Active index in bone groups array +IK stiffness around the X axis +Go to assigned object or loudest assigned signal source +Wait Timer (ms) +The region relative vertical location of the mouse +Mouse/Trackpad Rotate +02 - Theme Color Set +Show Control Curves +Time taken in frames between shutter open and close +Textured Solid +Tail +Lift Force +The type of event, only applies to some +Targets +Main Texts +Draw Axes +Space data type +Subsurface Scattering +Mesh Vertex +Max Slope +Specular Intensity +Smoke collision settings +Cubic +Set all state bits +Action to take for gaps past the strip extents +Neutral +UV mapping, texturing and game engine data for a face +Minimum value for clipping +zh_CN +Wheel Scroll Lines +Shadow color in grey value +The constraint is applied relative to the world coordinate system +Icon File +Theme Console +Step Calculation +Amount the strip contributes to the current result +Shape Key Bezier Point +Smoke doesn't collide with top and bottom sides +Fastest and gives the most noise +Source of input values for driver variables +Show Keyframe Numbers +Image opacity to blend the image against the background color +Outline +window_manager +DDS +Show key map event and property details in the user interface +Bake ambient occlusion +Long List +Manual +Kink +Display Metaball +View Location +Radio Widget Colors +Weights +Cache of the worldspace positions of an element over a frame range +Theme settings for the Text Editor +Number of frames for Blending In/Out is automatically determined from overlapping strips +Collection of Driver F-Curves +Use SIMD QBVH +UV/Image Editor +Use degrees for measuring rotation +Resolution of the voxel grid +Physics Gravity +bl_idname +Name of the key configuration +Agent Radius +Keyed particles target is valid +Use force fields when growing hair +Point in the lattice grid +The amplitude of the offset +End Frame +Lets halo receive light and shadows from external objects +Pivot +Maximum walkable slope angle in degrees +Permeability +User defined floating point number value in a float properties layer +Render Result +Objects nearer than this are not visible to map +Pivot around active object +Operator Node +Local With Parent +Blender RNA structure definitions +Radius of bounding sphere and material physics +Bezier +Blend Type +Original Perlin +Active UV Texture +Active Object constraint +Armature-Relative Head +F-Curve's settings cannot be edited +7.1 Surround +Fluid Mesh Vertex +Long Key +Do not show any ghosts +Frame for absolute keys +Wav +Preview +[ +ObData +Emulate Numpad +Theme settings for the Timeline +Cell Size +Clamp velocity to this minimum speed (except when totally still) +Specify old mapping value in frames +Type of texture data to display and edit +Show ghosts for the specified frame range +Radius for bevelling +Maximal # solver steps/frame +Copy Rotation +07 - Theme Color Set +Use object/global coordinates for texture +If set to True, the panel shows a header, which contains a clickable arrow to collapse the panel and the label (see bl_label) +Sequence Element +Use rule when boid is flying +Simplify Shadow Samples +Deliver indirect lighting pass +Particle Key +Time since last step in seconds +Properties +Y Scale +Minimum Radial Distance +Sampled Points +Theme Logic Editor +Use Stars +Manipulator Translate +Brush steps +Active Pose Marker +F-Modifier +N +True when the Alt/Option key is held +Decimate +Use multi-sampled 3D scene motion blur +Type of active data to display and edit +Permanent deform +Onion Skinning Settings +Mode of automatic keyframe insertion for Objects and Bones +Theme settings for bone color sets +Scopes for statistical view of an image +Push +Show Seconds +Logic Or +Buffer Resolution +Create a toon outline around the edges of geometry +Regions +Damped Track +Active Bone Group Index +Automatically select acceleration structure +Specify a collision bounds type other than the default +Auto-Clamped handle color +Vertex Group Roughness End +Sets the maximum number of logic frame per game frame if graphics slows down the game, higher value allows better synchronization with physics +Control Point +Particle count +Turntable +Use Weight Color Range +Octree +Environment Exclude +Fuzziness while on collision, high values make collision handling faster but less stable +Tweak +Marker +Shadeless +Align handle color +Mist +Scene Render Layer +Sequence editing data for a Scene datablock +Structural Stiffness Vertex Group +Meta Stack +Duplicate F-Curve +Show sound files +Render layer name +Index of active particle system slot +Roll bone to original joint plane offset +Filter Fonts +Material Subsurface Scattering +Tip +Invalid +Show Cache +Delay +Blend factor for SSS colors +Fluid Group +Causes F-curve data to be duplicated with the object +Stationary object +el_GR +Compression method to be used +Speaker datablocks +B-Bone Ease In +Relative Paths +Mesh Int Property Layer +Enable smoke to disappear over time +Double Click Timeout +Cell Noise +Particle system has multiple point caches +Human readable name +The object that has the target particle system (empty if same object) +Maximum acceleration on land (relative to maximum speed) +Legacy +Clip alpha below this threshold in the 3D textured view +Display a preset button with the operators settings +Force gets absorbed by collision objects +9 +Noise method which is used for creating the high resolution +Manipulator +Select UVs that are at the same location and share a mesh vertex +Shadow offset in pixels +Bake directly from multires object +Insert +Wind effector weight +DopeSheet Editor +Entire Array +Use smoke heat as texture data. Values from -2.0 to 2.0 are used +Sequence Color Balance +Disallow movement around the X axis +Scenes +Active KeyConfig +Distance between two bones or objects +Rate control: max rate(kb/s) +Active file in the file browser +Limit collisions to this group +Nurbs weight +Outline Selected +Extrapolate the curve or extend it horizontally +Right Handle +Collection of mesh vertices +Smooth the final stroke +Current Transform Orientation +F-Curve live filtering string +Softness of the 'soft' falloff option +Selection Mode +Proportional Editing +Collection of keying set paths +Build 25% proxy resolution +DBVT culling +Armature Edit +Show Datablock Filters +A valid edit mode exists +World Mist +Default Value +Full Screen +Text in the line +Quality +A container referencing an existing Action +Layer name +Auto Start +Visualization +Show text files +Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion) +Snap Align Rotation +Angle of Rotation for Axis-Angle rotation representation +192 kHz +From socket +Nurb active U-lines +Constraints that act on this PoseChannel +Cyclic Strip Time +Space Outliner +Constraint has valid settings and can be evaluated +Debug +Pose Bones +Show image files +Goal maximum, vertex weights are scaled to match this range +Puff +Right Handle Type +Include the name of the active cameras lens in image metadata +Sky Color Space +Include visualization of Armature related Animation data +Character Index +Pin (vertex target position) spring stiffness +Open source frame player: http://djv.sourceforge.net +Grab Pointer +Bone is not able to be transformed when in Edit Mode +Show linked objects to the controller +Blend Distance +Edited +The mode used to apply the texture +Locked Track +File Browser +Vertex weight group, to blend with basis shape +The type of keyframe (for visual purposes only +Obstacle Radius +Drawing method used by the window manager +Active Particle Target Index +Front +Enable starfield generation +Particle datablocks +Show an outline highlight around selected objects in non-wireframe views +Zooms in and out based on vertical mouse movement +Calculate sub-surface scattering in materials rendering +Parent this node is attached to +ar_EG +Include the render frame as HH:MM:SS.FF in image metadata +Line of text in a Text datablock +Detail mesh sample spacing +Active Theme Area +Theme Widget Color Set +Boid height relative to particle size +Using 1/x +Scene keying sets +Show Sliders +All Z +Environment Color +Position +Buffersize +Adapt To Speed +Or +World datablocks +Effect Strip +Group of ID properties +Proxy size 75% +Vertex Paint +Hair Dynamics +Stroke Points +NLA Track is locked +Which mesh elements selection works on +Weight of rotation constraint for IK +Always refresh image on frame changes +Use horizon and zenith color for diffuse energy +Extra margin around object for collision detection, small amount required for stability +Collection of vertex groups +Coordinates of the first handle +Sky Blend Mode +Mesh Edge +Adjust simulation speed +Bounding box of this object represents the computational domain of the fluid simulation +Color balance gain (highlights) +Normal Space +Layers +Spin CW +Mesh Float Property Layer +Buffer Resolution - decrease it to increase speed +12 bit color channels +Space Graph Editor +Directory Path +False when this property is an optional argument in an RNA function +Framing Types +Display Paths of poses within a fixed number of frames around the current frame +Last selected point +Cropping parameters for a sequence strip +Min Air Speed +Wavelet +Color used for the surface of bones +Window Managers +Occlude objects with the environment color as they are further away +Attenuation falloff strength, the higher, the less influence distant objects have +Driven Selected +Surface Edit +Causes metaball data to be duplicated with the object +Main Curves +Japanese (æ¥æ¬èª) +Vertex Group Field Negate +Collection of uv textures +Enable simplification of scene for quicker preview renders +String +Randomized +Retarget template bone chain to stroke +Use the manipulator for movement transformations +Command line prompt language +How the rules in the list are evaluated +Color of texture overlay +Text Box +Modifier for values of F-Curve +Specify the number of cluster iterations +Mass of the object +React to force field physics settings in materials +The window relative vertical location of the mouse +YCbCr (ITU 709) +Linear viscosity +8x +Nothing +IK Z Limit +Sensors +Child Seed +Tweak Middle +Object represents a volume of fluid in the simulation +Property is editable through RNA +Theme settings for the Console +Datablock from which the edited datablock is linked +Particle +Solo +Mark controller for execution before all non-marked controllers (good for startup scripts) +FFMpeg audio codec to use +ZTransp +Location (Object Space) +IK Z Lock +Display size for normals in the 3D view +Use a tent filter for anti-aliasing +Original IK solver +Use velocities for automagic step sizes +Multiplier +Constraint Target +Draw Repeated +For RGB curves, the color that white is mapped to +Noise algorithm - Voronoi F1: Returns distance to the closest feature point +IK Y Minimum +Pin Stiffness +Cache Info +No Ghosts +Duplicate Material +Nurbs order in the V direction (For surfaces only), Higher values let points influence a greater area +Spanish (Español) +Sets the dimension of the halo +Vertex in a Mesh datablock +Line Numbers Background +Shadow Size +Depth +Rest Density +Frame Server +alert +Meta Element +Show actuators of all selected objects +Calculate environment maps while rendering +Motion Path Settings +Interlaced +Space type +Display the operator log +Show background image in front view +Simple +Storage of a sub operator in a macro after it has been added +Collision Bounds +Maximum value for clipping +Transparency +Armature-Relative Tail +Display in the info window and support the redo toolbar panel +FFMpeg codec to use +Show frame numbers on Motion Paths +Maximum allowed number of light inter-refractions +Use a third buffer for minimal redraws at the cost of more memory +Game engine logic brick to process events, connecting sensors to actuators +Layer in multilayer image +Depth Cutoff +Mesh Edges +Max Edge Length +The number of lines scrolled at a time with the mouse wheel +Root Texture Coordinates +Tag Seam +Visibility status +Birth Time +Mini Axis Brightness +Environment +Accuracy +Driven +Air Damping +Use Vertex Buffer Objects (or Vertex Arrays, if unsupported) for viewport rendering +Normal +Keys +The axis icon's size +Spring Force +Brushes +Drag +Emulate 3 Button Mouse +Sculpt/Paint Overlay Color +Collection of keymap items +Shadow Y Offset +Fuzzy +Comb +Theme settings for the 3D View +End frame of the stored range +Grid Subdivisions +Layers bone exists in +Base type for datablocks, defining a unique name, linking from other libraries and garbage collection +Numpad 5 +face area +Clip Start +Numpad 2 +Tweak Action +Numpad 0 +Use this files path when library linked into another file +GL Texture Limit +Only keyframes of selected F-Curves are visible and editable +Numpad 9 +Crease +Filter +Minimum angles for IK Limit +Scatter contribution factor +Bones which are children of this bone +Main Particle Settings +Collection of particle settings +Use modifier during rendering +Numpad / +Numpad . +05 - Theme Color Set +Read Only +Include visualization of Particle related Animation data +Numpad * +Bone is not visible when in Edit Mode +Width Fade +Amount of rotation around velocity vector on turns +Czech (Äeský) +Display datablocks in all scenes +Turbulent noise driven by the particle's age between birth and death +Aerodynamics Type +Best quality +Use effector/global coordinates for turbulence +Target particle systems +Min Rate +Distance to keep particles away from the emitter +Type of information to display +Limit movement around the Z axis +NLA stack is evaluated when evaluating this block +Apply puff to unselected end-points, (helps maintain hair volume when puffing root) +Fgon edge +Perspective +Bone rotation around head-tail axis +Pan/Zoom +Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking +No Auto-Snap +Active Texture Face +Node Backdrop +Count +Amount of influence F-Curve Modifier will have when not fading in/out +Collection of points that make up this poly or nurbs spline +Enable All Codecs +Auto Blend In/Out +Show Python Tooltips +Show menus in the header +Action datablocks +Edit texture nodes from World +Cross +Particle target name +Frame Map Old +Collection of channel driver Variables +Lower First +Stamp Render Time +Groups of the bones +Vertex Group Velocity +Cine-Flat 48fps 1998x1080 +Snap +Extreme Alpha +2x +Group datablocks +Overall sensitivity of the 3D Mouse +Images are rendered in full Screen +Activity culling is enabled +2D cursor location for this view +Metaball types +F +Show Linked to Actuator +Square (HS + V) +Node Groups +Name Property +Dither Intensity +Reconstruction filter used for combining anti-aliasing samples +Minimal +Active Face +Scripts +Scale factor along the X for items in this (sub)layout +Image Axis +Orig Width +Pose Head Position +Cursor Y-Value +Property is optionally registered as part of type registration +IK stiffness around the Z axis +NLA Tracks +Constrain to Image Bounds +Arrangement of the panels +Length of second Bezier Handle (for B-Bones only) +Median +Indirect Exclude +AO +Node in a node tree +Cast +Save cache files to disk (.blend file must be saved first) +Simplify AO and SSS +Use key times +de_DE +Property has been dynamically created at runtime +Ball Size +Display sequence datablocks +Read-only matrix calculated from the roll (armature space) +Noise algorithm - Improved Perlin: Smooth interpolated noise +Automatically start game at load time +Generate point density from a particle system +How much of effector force gets lost during collision with this object (in percent) +Deliver AO pass +Group that included Object should be a member of +Cell Height +Shear Stiffness +Material Volume +Maximum number of lines to store for the console buffer +Include visualization of Mesh related Animation data +Object Non-modal +Maximum acceleration in air (relative to maximum speed) +Pin ID +Radar +Render color of textured face as color +Parts Y +Parts X +Collection of F-Curve Modifiers +Verts Per Poly +Lock to Cursor +Theme Image Editor +Graph Editor 2D-Value cursor - Y-Value component +Automatically merge vertices moved to the same location +Stencil +Lock strip so that it can't be transformed +Vertex Group Rotation +Djv +Use a quadratic filter for anti-aliasing +Calculates environment map only once +Node Links +The number of subdivisions between grid lines +Filter Folder +use images in the order as they are recorded +Collection of libraries +Use selection as the pivot point +Auto Snap +The original matrix of this object before it was duplicated +The unit system to use for button display +Limit selection to visible (clipped with depth buffer) +Type of field +float_array +Root falloff +The quality of the anisotropic filtering (values greater than 1.0 enable anisotropic filtering) +Dodge +Active Vertex Group Index +Method used for determining what ghosts get drawn +Proportional Editing Objects +Parent +Particle dupliobject name +Theme Widget State Color +Tilt CCW +Mirror Intensity +Object +Include visualization of Lamp related Animation data +Object Location +select_end +FrameCycler +Joint +Backdrop X +Backdrop Y +Use Instances +Y Rotation +Nor +Addon +Anti-Aliasing Samples +frames_skipped +Stamp Lens +Make hairs more puffy +Offsets image horizontally from the view center +Negate the effect of the roughness 2 vertex group +Invoke Screen +A square showing Hue/Saturation, with Value slider +NLA Track +Outer Thickness +Format of Time Codes displayed when not displaying timing in terms of frames +Display Node +Boid will fight this times stronger enemy +Custom Color +P +Negate the effect of the rotation vertex group +Select Tail +Settings for boid physics +Options for this operator type +Mouse Y Position +Input properties of an Operator +Fixed +Current windowmanager and data context +Collection of actions +Tab Width +Theme 3D View +Render +Auto Keyframe Insert Available +Grid Scale +Number of undo steps available (smaller values conserve memory) +Show background image in bottom view +Theme Graph Editor +Surface +Flash +Collision +Grid Lines +Pre Roll +Strand +The transformation of the target bone is evaluated relative its local coordinate system, with the parent transformation added +Disables non-planer quads being triangulated +Particle Brush +Smoke doesn't collide with any border +Ghost frames on either side of frame +Frame +Select +ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil) +Index +Functions +03 - Theme Color Set +Built-In Function +Display objects name and frame number in 3D view +Custom text to appear in the stamp note +Cameras +Noise algorithm - Voronoi F4: Returns distance to the 4th closest feature point +Estimated scale matrix +Overall stiffness of structure +State +Camera +Distance between key frames +Image Painting +Object is made a fluid control mesh, which influences the fluid +Draw image with RGB colors +Build 100% proxy resolution +Space Type +Transformation +Method of calculating the steps through the volume +Material slot name +Number of frames between cached frames +Repulsion is a factor of stiffness +Edge spring friction +Face Area Text +Frame Map New +Media Play/Pause +Mux Rate +Show background image in all views +Slider Max +Every Point +Stub RNA type used for pointers to unknown or internal data +Number of indirect diffuse light bounces +Clip Min X +Clip Min Y +Link +Record animation to fcurves +Object removes fluid from the simulation +The number of times this object is repeated with respect to other objects +Line +Method used to define which Group-name to use +Use Material Force Field +Multi constraint, stateful IK solver +Texture nodes +Locked +Filebrowser Parameter +Path to an image editor +Weights for the vertex groups this point is member of +Insert keyframes based on 'visual transforms' +Armatures +Nabla +Mesh String Property +Collection of action groups +Keep path lengths constant +The type of tilt interpolation for 3D, Bezier curves +Creates a force that dampens motion +Disable simulation of linear motion along the Y axis +Green +Layer is selected for editing in the DopeSheet +Voronoi F2 +Voronoi F3 +Active F-Curve Modifier +Cycles +Margin +Voronoi F4 +Theme settings for the Image Editor +Face Dot Selected +Damping of cloth velocity. (higher = more smooth, less jiggling) +GLSL Color Management +Prompt +Length of first Bezier Handle (for B-Bones only) +Theme settings for style sets +Ctrl +Show intermediate values for the driver calculations to allow debugging of drivers +Apply this and all preceding deformation modifiers on splines' points rather than on filled curve/surface +Vertex indices +Lens angle (mm) in perspective view +Back +German (Deutsch) +Color of light scattered out of the volume (does not affect transmission) +Build free run time code index +Extrapolation +Theme settings for Info +Collection of metaball elements +Use face normal to rotate object, so that it points away from the surface +Lens +Otherwise menus, etc will always be top to bottom, left to right, no matter opening direction +Particle Dupliobject Weight +Use textures for drawing international fonts +Use light for face +The edge flag to tag when selecting the shortest path +Vinterlace +Cycle the images in the movie +Display Z Axis +Reflectivity +Window Draw Method +Set audio sampling rate to 44100 samples per second +Causes particle systems to be duplicated with the object +Scripts Window +The space where the panel is going to be used in +SMPTE (Compact) +Automatically merge nearby keyframes +Fast in high-contrast areas +YCC +Deliver object index pass +Bake shadows +Continuous Grab +Alive State +Input +Adaptive +Single texture face materials +Color Ramp Element +Hue +Error tolerance (low values are slower and higher quality) +Transforms include effects of constraints but not parenting/restpose +Collision Settings +Collection of cameras +Command line prompt +Cache file path +Object Space +Driver +End size of strands in pixels or Blender units +Weighted result of strip is added to the accumulated results +NLA Track is selected +Quaternion +DOC BROKEN +19 - Theme Color Set +Debug State +Active Keying Set used to insert/delete keyframes +Lock Rotations (4D) +Sets the audio output device +Channels to display when drawing the histogram +Displays bit depth of full screen display +Sky Blend +Reflection +Vertex group to control roughness 1 +Bake Emit values (glow) +Language use for translation +Atmosphere Distance Factor +Emit Object Space +Motion Path Points +IK Solver +F-Curves +Semantic interpretation of the property +Partial overlay on top of the sequencer +Unborn +Effect in full or only positive/negative Z direction +Format of the source data set to render +Space UV Editor +Solid Lights +F1 +F2 +F3 +F4 +F5 +F6 +F7 +Fonts Directory +Single ASCII character for this event +Invert x Axis +Allow boids to move in air +Zoom Style +Library +Sky related settings for a sun lamp +Inherit Rotation +Disable Stereo and Dome environments +KeyConfigs +IK Stretch +Voronoi F1 +Rigid Body +operator_context +Rotation Units +Defines the structure of the menu in the UI +idp_array +XYZ velocity mapped to RGB colors +Editmode +Particle Location +Tabs as Spaces +Region Background +Render Layers +Stiff viscosity +Scale Matrix +Pinned +Sequence Editor +Vertex Normal +Display current image regardless of object selection +Display Lattices +Density +Exclude raytraced refraction pass from combined +Charge effector weight +Limit colliders to this Group +Square (SV + H) +Space currently being displayed in this area +Show frame number beside the current frame indicator line +Face +Normalized quaternion rotation +Proportional Editing enabled +Vector handle selected color +Scope region background color +Show font files +Wave +Stickness +Vertex Groups +The time to animate the view in milliseconds, zero to disable +Number of times this datablock is referenced +Source Path +Forcefield based on a texture +Lattices +Object used as the smoke simulation domain +Parameters defining which layer, pass and frame of the image is displayed +Vertex Size +Italian (Italiano) +Physics Type +Ghost +Audio Device +Display Scene +Limit Scale +Enable Dome environment +Vertex Group Kink Negate +Radial Falloff Power +Value Sliders +collection +Meta Elements +Q +Display Transforms +Texture Time Out +Output image in TIFF format +Key Map +Navigation mesh +Fade effect using the built-in default (usually make transition as long as effect strip) +Include visualization of ShapeKey related Animation data +Manual adjust +Space User Preferences +NLA Track is not evaluated +Use rule when boid is on land +Anisotropic Filter +Red Green Blue +Radiance HDR +Active object base in the scene +User defined layer of integer number values +Object Mode +Maximum height between grid cells the agent can climb +Texts +Sort the file list by extension +Settings for filtering animation data +Number of horizontal pixels in the screen +Path to the .blend file +Converts texture RGB values to intensity (gray) values +Different styles of displaying the color picker widget +Initial state when the game starts +Nurbs order in the U direction (For splines and surfaces), Higher values let points influence a greater area +Show sliders beside F-Curve channels +Fisheye +Show View Name +Sequencer and Image Preview +Fake User +Video Sequence Editor +Struct Definition +The directory for storing temporary save files +Record Animation +F-Curve Modifier will not be evaluated +Full Render +Only one side is rendered, with Z axis pointing in direction of image +Show ghosts from around the current frame +Display Channel +Automatically switch between orthographic and perspective when changing from top/front/side views +Print debug information for this property +Update simulation with cache steps +Relationship Lines +RNA Path to property affected by F-Curve +Median Point +Mesh datablocks +Sets angular index of refraction for raytraced refraction +Node Socket type +Outliner space data +Shadow X Offset +Amount of residual error in Blender space unit for constraints that work on position +Make diffuse shading more similar to shading the surface +Scale textures for the 3D View (looks nicer but uses more memory and slows image reloading) +Draw white edges with black outline +UV selection and display mode +No +Show linked objects to the actuator +Key Config +Pressure +Render Data +Quaternion Rotation +Multiply +Control point for envelope F-Modifier +Proportion of original image source pixel lines to sample +Avoid Collision +Snap to volume +Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method) +Automatically determine the number of threads, based on CPUs +Curve mapping to map color, vector and scalar values to other values using a user defined curve +Run python while editing +Selects the collision type +Active Vert/Edge/Face +Tessellation level - check the generated mesh in wireframe mode +Register +Transform Markers +Include visualization of Scene related Animation data +Index number of cache files +Text Highlight +Halo particle effect settings for a Material datablock +MPlayer +Previous Particle Location +Recent Files +Legacy tracking constraint prone to twisting artifacts +Edges receive a lift force when passing through surrounding media +Optional region type keymap is associated with +Output image in JPEG 2000 format +Self Collision +Enable bending constraints +Theme DopeSheet +Layer +Drag Threshold +Factor Rest Length +Which style to use for viewport scaling +Data to derive color results from +3D cursor location for this view (dependent on local view setting) +Nested +MultiLayer +Display Curve +Disk Cache +Transform markers as well as strips +mode +Target object for multi-target constraints +Multiplier for the material's density +FPS Base +Grease Pencil Simplify Stroke +Edit all markers of the same group as one +Harmonic effector weight +Location of head end of the bone relative to armature +Texture coordinates from root particle locations +Stereo Options +Disallow movement around the Z axis +Number of vertical tiles to use while rendering +Random Friction +Specifies an offset in the flare seed table +Horizon brightness +Language +Sound Clip +Light used for OpenGL lighting in solid draw mode +Screen datablocks +NLA Editor +Vertex group to control velocity +input_count +Only hold last frame +Elasticity of collisions +Sky Texture +Use SIMD SVBVH +Sort alphabetically +New Handles Type +Display only objects which will be rendered +Noise +The time (in ms) for a double click +matrix +channel_id +Only render the active layer +Material +Standard Modal Map +No TC in use +Output image in multilayer OpenEXR format +Empty +Always +Enable filtering of files +Template +When the camera is locked to the view and in fly mode, transform the parent rather than the camera +Show Sensors +Auto handle color +Custom Warp Mesh data file +Audio Channels +Available as GameObject attributes in the game engine's python API +Offset Y +Min Region Size +Pre-calculate the raytrace accelerator and render raytracing effects +For multires, show low resolution while navigating the view +Active curve spline +Strength of sky shading exponential exposure correction +Print Performance to Console +Power of Fresnel for mirror reflection +Default binary voxel file format +Copy Transforms +Draw alpha transparency channel +4x4 bone matrix relative to armature +Edge spring stiffness when longer than rest length +When true the format is a movie +Read cache from an external location +Object Index +Print warnings when using deprecated features in the python API +Option Widget Colors +Auto Depth +Goal Minimum +Display size for proportional editing circle +Point +NLA Strip +Strokes +Lock editing of scale in the interface +Sensor name +Point in a shape key +Dutch (Nederlandse taal) +Only Objects in Group +The shininess of the reflection (values < 1.0 give diffuse, blurry reflections) +Default relative path option for the file selector +Proportional editing object mode +Sampled animation data +Output image in PNG format +Owner Space +Align the transformation axes to the selected objects' local space +If this is set, the panel gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is "OBJECT_PT_hello", and bl_idname is not set by the script, then bl_idname = "OBJECT_PT_hello" +Lock Rotation (4D Angle) +Overdraw Sketching +Pause +Maximum speed in air +Backdrop Y offset +Ellipsoid +Separate Units +Object is a fixed obstacle +scene +Load user interface setup when loading .blend files +'Viscosity' inside collision target +Bake everything +Lamp +Negate the effect of the length vertex group +Invert z axis +Armature datablocks +Shadow size in pixels (0, 3 and 5 supported) +Rasterized cell size +Collection of timeline markers +Local +Old style zoom, continues while moving mouse up or down +Tooltips +Edge Collision +Fluid rest density +Blender Voxel +Bezier curve point with two handles +Runtime +Regular key pressed as a modifier +UV Layer +Initial Velocity +Sources of input data for evaluating this variable +Timeline +Game engine related settings for the object +Hide Recent Locations +Include the name of the active camera in image metadata +Colored Constraints +Particle Hair Key +Y Location +Exec Region Window +Stereographic techniques +UV editor settings +General movement damping +Estimate matrix +Global Pivot +IK X Lock +Keep UV and edit mode mesh selection in sync +Vector Handle +Number of frames from start frame for influence to take effect +int_array +Key velocity +Negate the effect of the roughness 1 vertex group +Output Path +Image User +AutoMerge Editing +Flare Subsize +Handle 2 Location +Edge UV Face Select +Clamp To +NDOF +The transformation of the target is only evaluated in the Pose Space, the target armature object transformation is ignored +Particle systems emitted from the object +Wheel Up +Linear falloff +Show the status of cached frames in the timeline +R +Keyframe +Blender Render +Noise Basis +How the texture effect is calculated (RGB & Curl need a RGB texture else Gradient will be used instead) +Display Grid Floor +Transmission Color +Parameters defining how an Image datablock is used by another datablock +Spline point without handles +8 bit color channels +Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only) +Draw Z-buffer associated with image (mapped from camera clip start to end) +Filter Size +Density is constant within lookup radius +Clear Images before baking +Animation Channels +Snap closest point onto target +Cloth Collision Settings +Sequence Plugin Directory +Size of widget handles as percentage of widget radius +Friction +Main Speakers +Offset in the random number table, to get a different randomized result +Keep Lengths +Vertex Group Element +Snap to faces +Case Sensitive Matches Only +Time delay in 1/10 seconds before automatically opening sub level menus +RNA structure definition +F-Curve Modifier is only applied for the specified frame range to help mask off effects in order to chain them +Collection of pose bone constraints +Angle +Gives a spiraling force that twists the force objects local Z axis +AAC +The constraint is applied relative to the local coordinate sytem of the object +Separate color channels in preview +Absolute Density +Target Particle System +When transforming keyframes, changes to the animation data are flushed to other views +Markers +Amount of pixels you have to drag before dragging UI items happens +Manipulator Hotspot +Nurb U-lines +Output video in Ogg format +double_array +Shape matching threshold +Drag component proportional to the square of velocity +Inner Selected +Show Playback FPS +Interpolation +Space File Browser +Hold LMB Open Toolbox Delay +Vertex Group Weight +Timeline editor space data +Main Screens +Improved Perlin +The value this event translates to in a modal keymap +Theme settings for widget state colors +Reversed +Mesh Float Property +Sky Exposure +Align each axis to the Euler rotation axis as used for input +Show Frame Numbers +Action Editor +17 - Theme Color Set +Soft body simulation settings for an object +Mesh Vertices +32-bit Float +Invisible +Number of horizontal pixels in the rendered image += +Handle types +Stricky texture coordinate +Max Land Angular Velocity +Struct definition used for properties assigned to this item +RGB to Intensity +Mapping settings +Name of Shape Key +Shadow Alpha +Radius Interpolation +Pulse True Level +Bounces +Exec Region Preview +Edge Draw Type +Color Management +Raytrace +Forcefield depends on the speed of the particles +Mode +Stiffness +Radial +Noise Method +Number of seconds between each run of the GL texture garbage collector +Gravitational constant used for physics simulation in the game engine +Logic Editor +Text Selected +Point Caches +No compression +Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed +Edge Crease +Invert rotation Axis +Use Ambient Occlusion to add shadowing based on distance between objects +Frame that modifier's influence starts (if Restrict Frame Range is in use) +active_strip +Lock +Collection of window managers +Cine-Flat 24fps 1998x1080 +Sort by extension +All Views +Enum Item Definition +Button 4 +Button 5 +Button 6 +Button 7 +Button 1 +Button 2 +Maximum angles for IK Limit +Render Pass +Selected Text +Whether to draw the sound's waveform +Data Path +Enum Flag +Soft Light +Define forces for vertices to stick to animated position +Sample every pixel of the image +Invert roll axis +Goal +Dissolve Speed +Textbox X Offset +Sky turbidity +A random rule is selected for each boid +OpenAL device - supports 3D audio, recommended for game engine usage +Console Input +Invert the level(output) of this sensor +Memory Cache Limit +Point Cache List +Motion Path settings for visualisation +Endpoint V +The rotation step for numerical pad keys (2 4 6 8) +Linear and angular physics +NLA Strip is selected +The channel number shown in the image preview. 0 is the result of all strips combined +Shrink +Limit movement around the X axis +Draw Action +Display debug reporting info +Collection of action fcurves +Bone inherits scaling from parent bone +Lock current frame displayed by layer +Type of stretch to draw +Friction/damping with self contact +Undo +ZYX Euler +Scaling factor for the background image +vBVH +Axis-Angle Rotation +Bone deformation weight (for Envelope deform only) +Interaction radius is a factor of 4 * particle size +Shape key to use the rest spring lengths from +Use this texture as a blending value on the next texture +Deliver environment lighting pass +Show Python references in tooltips +Theme NLA Editor +Above-Below +Transition Strip +NLA Strips on this NLA-track +Draw black edges +Removes the operator from search results +Light Override +Only include channels from Objects in the specified Group +Compositing +128 +Random Damping +Effector Weights +Location of tail of the channel's bone +Frame Number +Image displayed and edited in this space +Vertex group to control roughness 2 +Show background image in camera view +How incompressible the fluid is +Point select mode +Panel containing UI elements +Stamp Date +Inverts the values of the texture to reverse its effect +Smoke flow settings +Active Particle System +Channels +Type of this region +Intensity +Audio Strip +Blending +Enable this objects as a collider for physics systems +Tracking along a single axis +Weight used by the Subsurf modifier for creasing +Duplicate Mesh +Keying Set Info +Map Type +Use BLI K-Dop BVH.c +Amount of turbulence/rotation in fluid +Add light and shadow +Random falloff +Script +Edge selection mode +Auto Handle +Collection of bone groups +Vertex Group Roughness 1 +Sets minimum X value to for the render border +Coordinates of the left handle (before the control point) +Source +Output Node +Groups of Pose Channels (Bones) +Hide recent locations in the file selector +Particle editing brush +Show the ground plane grid in perspective view +Snap Target +Scripted Expression +Shadow Brightness +Noise algorithm - Blender original: Smooth interpolated noise +Rot error +Amount of damping during particle collision +Save Versions +Anti-aliasing +Endpoint U +Sub-Target +Settings +Use international fonts +Show Mini Axis +Previous Particle Velocity +Edge in a Mesh datablock +Function Definition +Physics engine used for physics simulation in the game engine +Softbody +Theme settings for the DopeSheet +Vertex Group Size +Add the file format extensions to the rendered file name (eg: filename + .jpg) +Collection of KeyConfigs +Active Element +Wipe +Deliver raytraced reflection pass +Fade paths and keys further away from current frame +Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped +Control point spring strength values +Extends by repeating edge pixels of the image +File is Saved +Region Type +OpenEXR +Auto Keying +S +Vector +Texture Mapping +Cache name +Smoke +Boid State +Space Node Editor +Multiresolution +No Preset +Maximum allowed number of light inter-reflections +Final key configuration that combines keymaps from the active and addon configurations, and can be edited by the user +Allow Negative Frames +Bending +Group to override all other lights in this render layer +Position solver iterations +Exists +Lock editing of 'angle' component of four-component rotations in the interface +Deliver shade-less color pass +Rear-Truncated +RNA +Has Minimum +Strip has no influence past its extents +Lennard-Jones effector weight +Screens +Window Background +current_character +Meta +Theme settings for the Logic Editor +Floating-Point Property +Structural Stiffness +Particle system settings +Codec settings for OpenEXR +Axis +Forces the current Scene to be displayed in all Screens +Indicates that a keymap is used for translate modal events for an operator +Environment map created by the renderer and cached for subsequent renders +Rotational Difference +Goal Vertex Group +Use shaders for GLSL rendering +Multiple Springs +Emitter Distance +Edit Bone +Indicates that a keyconfig was defined by the user +Include channels from objects/bone that aren't visible +Align dynamic game objects along the surface normal, when inside the physics distance area +Frames Per Second +Set the distance between the eyes - the camera focal length/30 should be fine +Draw Other Objects +Mouse Previous Y Position +Flare Size +Align the transformation axes to average normal of selected elements (bone Y axis for pose mode) +Maintain Volume +Display mode for the file list +Max Step +Activate FALSE level triggering (pulse mode) +Active Render +Size Y +Size X +Display splash screen on startup +Size Z +Grease Pencil Layer +X/Y coordinates of the curve point +Use a minimum distance for the field's fall-off +Show 2D cursor +Frame Locked +Active +Horizontal +Editing +Factor for how much surrounding objects contribute to light +Blend In +Sets the global starting frame of the movie/sequence, assuming first picture has a #1 +bg_BG +The size of the occlusion buffer in pixel, use higher value for better precision (slower) +Horizontal aspect ratio - for anamorphic or non-square pixel output +4x4 matrix, before constraints +Minimum Distance +End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method) +Particles generated by the particle system +Region Text Highlight +Align +zh_TW +Overwrite existing files while rendering +Cylinder +How many frames to fade +Driver type +World +Theme settings for user interface elements +Bending Stiffness +Draw other selected objects that share the same image +Show dashed lines indicating parent or constraint relationships +And +Bevel Radius +Extrapolated +Force +Active Brush +Distance will be used to attenuate shadows +Method used to adjust the roll of bones when retargeting +Form Factor +Scopes to visualize image statistics +Number +Shade Top +Number of frames to render ahead during playback +High quality interpolation, but slower +Current view matrix of the 3D region +Handle 1 Location +Vertex Group Density +Active Frame +IK Y Limit +Blending to inelastic collision +Enable high resolution (using amplification) +Simulation starts on this frame +Properties to set when the operator is called +Result of rendering, including all layers and passes +iTaSC +Mesh String Property Layer +Tweak Left +True if this map is ready for use, False if it needs rendering +X Scale +Bone in an Armature datablock +Output image in Targa format +Stamp Sequence Strip +F-Curve Modifier's panel is expanded in UI +Build 50% proxy resolution +An object duplicate +Start Offset +Items +Fluid simulation settings for an object taking part in the simulation +Set audio mixing buffer size to 8192 samples +Material Strand +Inflow +Sort +Relative Key +Motion Paths +Return +Stiffness defines how much of the element to fill +Detail mesh simplification max sample error +Meta Strip +Bake Alpha values (transparency) +Memory cache limit in sequencer (megabytes) +Input configuration, including keymaps +Select the type of Framing you want +Animation data for this datablock +Raytracing +Key Map Item +Split quads to give the least distortion while baking +Show overexposed areas with zebra stripes +1024 +Bias towards faces further away from the object (in blender units) +Strip time is controlled by an F-Curve rather than automatically determined +Bake Location +sr_RS +Panel +Main Libraries +Edit Edit +Get away from assigned object or loudest assigned signal source +Darken +Active index in vertex group array +Average Separation +F-Curve Modifiers +RNA type used for pointers to any possible data +Space Image Editor +UV Selected +Handle 1 Type +Choke +Use Simplify +Maximum +YZX Euler +No Self +Helicopter Mode +Rotation in Eulers +On Cage +Bone that defines the display transform of this custom shape +Main Node Trees +Undo Steps +Cube Map +Point cache for physics simulations +Interactive python console +Use environment map with six cube sides +Show .blend files +Kill Particles +Sets maximum X value for the render border +Only Seconds +NLA Tracks (i.e. Animation Layers) +Timer Property +Z Rotation +Ensure all bone-deforming vertex groups add up to 1.0 while weight painting +Rigid to Soft Body +Lock to Object +Threshold +Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible) +Occlude Geometry +Causes surface data to be duplicated with the object +Use the images alpha values clipped with no blending (binary alpha) +Hold Forward +Set Controller state index (1 to 30) +Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate +Lock Horizon +Ignore Layers +Object Matrix +Pixel Aspect X +Filename +Use Ambient Occlusion +The transformation of the target is evaluated relative to its local coordinate system +The region where the panel is going to be used in +BW +Bake Specular values +Tool +Margin Column +Maximum distance from active object to other object (in blender units +Final transformation value of object or bone +Group Name +Proxy parameters for a sequence strip +fr_FR +Kill collided particles +Disable simulation of angular motion along the Y axis +Collision Margin +SMPTE timecode showing minutes, seconds, and frames only. Hours are also shown if necessary, but not by default +bl_use_preview +Draw Faces +Vertex Group Rotation Negate +\ +New Window +Turbulent noise driven by particle velocity +Lock Rotation +Color Source +Print state debug info in the game engine +Location of head of the channel's bone +Timer +Output video in Xvid format +Enable raytraced reflections +Image Preview +Optional space type keymap is associated with +Use ramps for GLSL rendering +Motion Samples +Vectorscope Opacity +Element defining a color at a position in the color ramp +All Action Keyframes +Automatic keyframe insertion for Objects and Bones (default setting used for new Scenes) +Align Object To +Welding threshold: distance between nearby vertices to be considered equal => set to 0.0 to disable welding test and speed up scene loading (ok if the mesh has no duplicates) +Limit +T +Diffuse Color +Release +User defined string text value in a string properties layer +Histogram for viewing image statistics +Scroll Widget Colors +General media friction for point movements +Lock Y Rotation Axis +Set audio mixing buffer size to 1024 samples +Draw the image repeated outside of the main view +Mesh Int Property +Noodle curving +Unknown Type +Add & Replace +Border Collisions +Add children to form a compound collision object +Influence +Show high resolution (using amplification) +Collection of sounds +Use Bone Heads +Actuator to apply actions in the game engine +Mp3 +Go to closest enemy and attack when in range +Type of range to show for Motion Paths +Use trackball style rotation in the viewport +32768 +Overwrite +Duplicate Particle +32-bit Signed +Scale +Expression to use for Scripted Expression +Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy +Parameters +Material Mode +Avoid +Cache is outdated +File Browser Buttons +Actor +Bone Group Index +Toolbox Column Layout +Show the frames per second screen refresh rate, while animation is played back +Image Editor +Mesh Vertex Sticky Texture Coordinate +Vertex Weight Proximity +Average Spring length * Ball Size +Renders rings over halo +Offset in the random number table for child particles, to get a different randomized result +Auto Keying Mode +B-Bone Segments +Time in 1/10 seconds to hold the Left Mouse Button before opening the toolbox +Visible Layers +File format to save the rendered images as +Enable view navigation within the camera view +Show background image in top view +Sun brightness +Closest +Make this curve or surface a closed loop in the U direction +Command history +XYZ Rotation Order. Prone to Gimbal Lock +Draw Stretch Type +Percentage scale for render resolution +F-Curve and its keyframes are hidden in the Graph Editor graphs +F-Curve Editor +Area distortion between UV and 3D faces +YXZ Rotation Order. Prone to Gimbal Lock +Effective but slow compression +Fields +For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower) +Process the render result through the compositing pipeline, if compositing nodes are enabled +Co-ordinate system to cache particles in +Error Limit +Curve guide effector weight +Default +Black Level +ISO 1 +Fine tunes texture mapping X, Y and Z locations +Single Property +Korean (íêµ ì¸ì´) +DopeSheet Sub-Channel +Max Air Speed +Vertex Group Length Negate +Key location for a particle over time +Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample +Range +Materials +Show hidden dot files +Numpad Enter +Polish (Polski) +Automatic saving of temporary files in temp directory, uses process ID +Cubic B-Spline +Logic editor space data +Open menu buttons and pulldowns automatically when the mouse is hovering +Use to check if an operator is a macro +Display zoom level +Stamp Filename +Weight +Bias (in radians) to prevent smoothed faces from showing banding (for Raytrace Constant Jittered) +Auto XYZ to RGB +UV +Audio volume +Restrict the number of animation updates to the animation FPS. This is better for performance, but can cause issues with smooth playback +Replace +Show paint related properties +Target Space +Gloss Samples +UI +Keep horizon level while flying with 3D Mouse +Texture Mode +Shaded + Multiple Scattering +Lifetime +Settings for particle fluids physics +Type of units for this property +Pointer +Field Settings +PoseBone Constraints +Right Ctrl +User Key Configuration +Color 3 +Speakers +Color 1 +Spline Points +Color 4 +Gradient +Rule Fuzziness +YZX Rotation Order. Prone to Gimbal Lock +Amount of residual error in radiant for constraints that work on orientation +GLSL Shadows +Radius of object representation in obstacle simulation +Show the entire viewport in the display window, using bar horizontally or vertically +Dissolve Smoke +Internal +Library file the datablock is linked from +Outer face thickness +Any modifier keys pressed +Screen aligned billboard +Allow moving the mouse outside the view on some manipulations (transform, ui control drag) +NLA Strips that this strip acts as a container for (if it is of type Meta) +Pixel Cache +Texture slot name +Render Stamp +bl_label +Settings for interacting with Blender data +Ball +Active Clone +Editbone Matrix +ja_JP +Curve in a curve mapping +Auto Rainbow +Maximum angular velocity in air (relative to 180 degrees) +Operator Properties +Material Raytrace Transparency +Child +Modal Keymap +Color to use behind stamp text +Theme settings for the graph editor +Aligned +Border Maximum X +Border Maximum Y +Type of event +Set color of the bars +Collapse Summary +How many collision iterations should be done. (higher is better quality but slower) +Consant falloff +Fields Still +Main Sounds +Definition of a choice in an RNA enum property +Translate Tooltips +Sync Markers +Object being duplicated +Face in a Mesh datablock +Calculate bone paths from tails +Display World +UV Pinned +No Collision +Active Channel Group +Make face invisible +Number of subdivisions of bone (for B-Bones only) +Renders halo as a lens flare +Only Selected Channels +Minimum height where the agent can still walk +Stroke data points +Multiply Vertex Group with Envelope +Inner face thickness +Set actuator expanded in the user interface +Low values are slower and higher quality +Vertices Cache +Lattice datablocks +Current frame number can be manually set to a negative value +Set controller expanded in the user interface +Simulation used for obstacle avoidance in the game engine +Duplicate Curve +List of background images +Manipulator Handle Size +Alive +Lock Z Axis +Tex +A square showing Saturation/Value, with Hue slider +Deliver material index pass +XXX todo +Collection of spline points +Flock +Linear Light +Live Unwrap +Radiosity +Turbulence Influence +Object datablocks +Left Shift +The source of this force field is the zero point of a harmonic oscillator +Driver Target +CIE +Show High Resolution +Pin Cloth +Soft Body Settings +Threads +Negate the effect of the roughness end vertex group +Gloss Threshold +World Space +Game data for a Scene datablock +Blender 2.4 +Coordinates of the right handle (after the control point) +View2D Buttons List +F-Curves in this group +Point cache list +3D View Region +Show the X axis line in perspective view +Matroska +Node Generic +Extinction scattering contribution factor +Callback function defines for builtin Keying Sets +Generate point density from an object's vertices +Coulomb friction coefficient, when inside the physics distance area +Temporary +Vertex group to control size +Time in milliseconds between each frame recorded for screencast +Low Resolution Mesh +Maximum structural stiffness value +Maximum radial distance for the field to work +Collection of point caches +Volume +Asymmetry +Mux rate (bits/s(!)) +Weight value of a vertex in a vertex group +Log conversion reference blackpoint +Point density settings +Show Mouse +Name of Action Group to assign setting(s) for this path to +Rotate +Multiplier for multiple scattered light energy +09 - Theme Color Set +(Min+Max)/2 * Ball Size +Flow +Output image in Radiance HDR format +Show Expanded +11 - Theme Color Set +Front scattering weight +Maximum speed for jumping +Compositor Nodes +Particle in a particle system +Vertex Group +U +Bending Stiffness Vertex Group +Context +Vertex selection mode +Use scaled but un-grid-fitted kerning distances +Gloss Amount +3D region that defines the quad view settings +Display groups and their datablocks +Include visualization of Curve related Animation data +User Modified +Statistical view of the levels of color in an image +Anisotropic Friction +4x +Inverse Gain +Fade Time +Visual Keying +Agent Height +Underline +Translate Interface +Property Definition +Bake Mirror colors +Animated Strip Time +Friction Factor +Space data for a screen area +Maximum speed on land +Theme User Interface +Deflect Emitter +Use Edges +The base density of the volume diff --git a/po/update_mo.py b/po/update_mo.py new file mode 100755 index 00000000000..4effdc65541 --- /dev/null +++ b/po/update_mo.py @@ -0,0 +1,17 @@ +#!/usr/bin/python + +# update all mo files in the LANGS + +import os + +LOCALE_DIR="../release/bin/.blender/locale" +PO_DIR = "." +DOMAIN = "blender" + +for po in os.listdir( PO_DIR ): + if po.endswith(".po"): + lang = po[:-3] + # show stats + cmd = "msgfmt --statistics %s.po -o %s/%s/LC_MESSAGES/%s.mo" % ( lang, LOCALE_DIR, lang, DOMAIN ) + print cmd + os.system( cmd ) diff --git a/po/update_po.py b/po/update_po.py new file mode 100755 index 00000000000..50459c2b14b --- /dev/null +++ b/po/update_po.py @@ -0,0 +1,17 @@ +#!/usr/bin/python + +# update all po files in the LANGS + +import os + +PO_DIR = "." +DOMAIN = "blender" + +for po in os.listdir( PO_DIR ): + if po.endswith(".po"): + lang = po[:-3] + # update po file + cmd = "msgmerge --update --lang=%s %s.po %s.pot" % (lang, lang, DOMAIN) + print(cmd) + os.system( cmd ) + diff --git a/po/update_pot.py b/po/update_pot.py new file mode 100755 index 00000000000..616443edc4a --- /dev/null +++ b/po/update_pot.py @@ -0,0 +1,61 @@ +#!/usr/bin/python + +# update the pot file according the POTFILES.in + +import os + +GETTEXT_XGETTEXT_EXECUTABLE="xgettext" +SOURCE_DIR=".." +DOMAIN="blender" + +cmd = "%s --files-from=%s/po/POTFILES.in --keyword=_ --keyword=N_ --directory=%s --output=%s/po/%s.pot --from-code=utf-8" % ( + GETTEXT_XGETTEXT_EXECUTABLE, SOURCE_DIR, SOURCE_DIR, SOURCE_DIR, DOMAIN) + +os.system( cmd ) + +def stripeol(s): + if line.endswith("\n"): + s = s[:-1] + + if line.endswith("\r"): + s = s[:-1] + + return s + +pot_messages = {} +reading_message = False +message = "" +with open("blender.pot", 'r') as handle: + while True: + line = handle.readline() + + if not line: + break + + line = stripeol(line) + if line.startswith("msgid"): + reading_message = True + message = line[7:-1] + elif line.startswith("msgstr"): + reading_message = False + pot_messages[message] = True + elif reading_message: + message += line[1:-1] + +# add messages collected automatically from RNA +with open("blender.pot", "a") as pot_handle: + with open("messages.txt", 'r') as handle: + while True: + line = handle.readline() + + if not line: + break + + line = stripeol(line) + line = line.replace("\\", "\\\\") + line = line.replace("\"", "\\\"") + + if not pot_messages.get(line): + pot_handle.write("\n#: Automatically collected from RNA\n") + pot_handle.write("msgid \"%s\"\n" % (line)) + pot_handle.write("msgstr \"\"\n") diff --git a/release/bin/.blender/.Blanguages b/release/bin/.blender/.Blanguages index 9f3b3ef80dc..1a83c46039a 100644 --- a/release/bin/.blender/.Blanguages +++ b/release/bin/.blender/.Blanguages @@ -11,13 +11,14 @@ Catalan:ca_ES Czech:cs_CZ Brazilian Portuguese:pt_BR Simplified Chinese:zh_CN +Traditional Chinese:zh_TW Russian:ru_RU Croatian:hr_HR -Serbian:sr +Serbian:sr_RS Ukrainian:uk_UA Polish:pl_PL -Romanian:ro -Arabic:ar -Bulgarian:bg -Greek:el -Korean:ko +Romanian:ro_RO +Arabic:ar_SA +Bulgarian:bg_BG +Greek:el_GR +Korean:ko_KR diff --git a/release/bin/.blender/fonts/droidsans.ttf.gz b/release/bin/.blender/fonts/droidsans.ttf.gz Binary files differnew file mode 100644 index 00000000000..e83aff4e899 --- /dev/null +++ b/release/bin/.blender/fonts/droidsans.ttf.gz diff --git a/release/scripts/startup/bl_operators/wm.py b/release/scripts/startup/bl_operators/wm.py index 861255f167f..fae38eb1cef 100644 --- a/release/scripts/startup/bl_operators/wm.py +++ b/release/scripts/startup/bl_operators/wm.py @@ -1144,6 +1144,67 @@ class WM_OT_sysinfo(Operator): return {'FINISHED'} +class WM_OT_get_messages(Operator): + bl_idname = "wm.get_messages" + bl_label = "Get Messages" + + def _putMessage(self, messages, msg): + if len(msg): + messages[msg] = True + + def _walkProperties(self, properties, messages): + for prop in properties: + self._putMessage(messages, prop.name) + self._putMessage(messages, prop.description) + + if isinstance(prop, bpy.types.EnumProperty): + for item in prop.enum_items: + self._putMessage(messages, item.name) + self._putMessage(messages, item.description) + + def _walkRNA(self, bl_rna, messages): + if bl_rna.name and bl_rna.name != bl_rna.identifier: + self._putMessage(messages, bl_rna.name) + + if bl_rna.description: + self._putMessage(messages, bl_rna.description) + + self._walkProperties(bl_rna.properties, messages) + + def _walkClass(self, cls, messages): + self._walkRNA(cls.bl_rna, messages) + + def _walk_keymap_hierarchy(self, hier, messages): + for lvl in hier: + self._putMessage(messages, lvl[0]) + + if lvl[3]: + self._walk_keymap_hierarchy(lvl[3], messages) + + def execute(self, context): + messages = {} + + for cls in type(bpy.context).__base__.__subclasses__(): + self._walkClass(cls, messages) + + for cls in bpy.types.Space.__subclasses__(): + self._walkClass(cls, messages) + + for cls in bpy.types.Operator.__subclasses__(): + self._walkClass(cls, messages) + + from bl_ui.space_userpref_keymap import KM_HIERARCHY + + self._walk_keymap_hierarchy(KM_HIERARCHY, messages) + + text = bpy.data.texts.new(name="messages.txt") + for message in messages: + text.write(message + "\n") + self._walkClass(bpy.types.SpaceDopeSheetEditor, messages) + + return {'FINISHED'} + + class WM_OT_copy_prev_settings(Operator): '''Copy settings from previous version''' bl_idname = "wm.copy_prev_settings" diff --git a/release/scripts/startup/bl_ui/properties_animviz.py b/release/scripts/startup/bl_ui/properties_animviz.py index 3b33a7ccc61..499ea4c95d4 100644 --- a/release/scripts/startup/bl_ui/properties_animviz.py +++ b/release/scripts/startup/bl_ui/properties_animviz.py @@ -23,7 +23,7 @@ # 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(): bl_space_type = 'PROPERTIES' @@ -43,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 @@ -82,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 diff --git a/release/scripts/startup/bl_ui/properties_data_armature.py b/release/scripts/startup/bl_ui/properties_data_armature.py index 61093abe814..e5729a24b91 100644 --- a/release/scripts/startup/bl_ui/properties_data_armature.py +++ b/release/scripts/startup/bl_ui/properties_data_armature.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Panel, Menu from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class ArmatureButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -60,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) @@ -89,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): @@ -161,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): @@ -230,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): @@ -263,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() @@ -275,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") @@ -286,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 ( @@ -314,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 diff --git a/release/scripts/startup/bl_ui/properties_data_bone.py b/release/scripts/startup/bl_ui/properties_data_bone.py index b3eaf88d5bf..2c9b31fd88d 100644 --- a/release/scripts/startup/bl_ui/properties_data_bone.py +++ b/release/scripts/startup/bl_ui/properties_data_bone.py @@ -21,7 +21,7 @@ import bpy from bpy.types import Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class BoneButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -76,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") @@ -97,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") @@ -126,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") @@ -155,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: @@ -174,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): @@ -206,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): @@ -241,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="") @@ -258,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) @@ -276,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="") @@ -290,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 @@ -298,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): @@ -334,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") diff --git a/release/scripts/startup/bl_ui/properties_data_camera.py b/release/scripts/startup/bl_ui/properties_data_camera.py index 5255af40951..0d79ec99789 100644 --- a/release/scripts/startup/bl_ui/properties_data_camera.py +++ b/release/scripts/startup/bl_ui/properties_data_camera.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class CameraButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -91,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="") @@ -109,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): @@ -124,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): diff --git a/release/scripts/startup/bl_ui/properties_data_curve.py b/release/scripts/startup/bl_ui/properties_data_curve.py index 2e0b36a7a75..861359fbed4 100644 --- a/release/scripts/startup/bl_ui/properties_data_curve.py +++ b/release/scripts/startup/bl_ui/properties_data_curve.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class CurveButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -67,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 @@ -85,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() @@ -103,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): @@ -129,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): @@ -152,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="") @@ -182,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() @@ -194,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): @@ -215,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") @@ -261,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") @@ -282,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") @@ -299,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") @@ -344,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") @@ -388,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") diff --git a/release/scripts/startup/bl_ui/properties_data_empty.py b/release/scripts/startup/bl_ui/properties_data_empty.py index c781873e16c..b6fa6d8e839 100644 --- a/release/scripts/startup/bl_ui/properties_data_empty.py +++ b/release/scripts/startup/bl_ui/properties_data_empty.py @@ -19,7 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Panel - +from blf import gettext as _ class DataButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -39,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__) diff --git a/release/scripts/startup/bl_ui/properties_data_lamp.py b/release/scripts/startup/bl_ui/properties_data_lamp.py index 4ff180f74fb..93ed8ca369b 100644 --- a/release/scripts/startup/bl_ui/properties_data_lamp.py +++ b/release/scripts/startup/bl_ui/properties_data_lamp.py @@ -20,10 +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'} @@ -93,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") @@ -111,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") @@ -139,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() @@ -176,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): @@ -209,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() @@ -226,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() @@ -263,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): @@ -325,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): @@ -348,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") @@ -358,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): diff --git a/release/scripts/startup/bl_ui/properties_data_mesh.py b/release/scripts/startup/bl_ui/properties_data_mesh.py index ff19ece8f94..37c91370979 100644 --- a/release/scripts/startup/bl_ui/properties_data_mesh.py +++ b/release/scripts/startup/bl_ui/properties_data_mesh.py @@ -20,10 +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): @@ -34,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' @@ -51,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 @@ -99,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") @@ -120,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): @@ -163,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): @@ -250,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="") diff --git a/release/scripts/startup/bl_ui/properties_data_metaball.py b/release/scripts/startup/bl_ui/properties_data_metaball.py index cd894e60dbb..693cb697544 100644 --- a/release/scripts/startup/bl_ui/properties_data_metaball.py +++ b/release/scripts/startup/bl_ui/properties_data_metaball.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class DataButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -60,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) @@ -86,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): @@ -107,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") diff --git a/release/scripts/startup/bl_ui/properties_data_modifier.py b/release/scripts/startup/bl_ui/properties_data_modifier.py index f0904ca8976..32324411669 100644 --- a/release/scripts/startup/bl_ui/properties_data_modifier.py +++ b/release/scripts/startup/bl_ui/properties_data_modifier.py @@ -19,7 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Panel - +from blf import gettext as _ class ModifierButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -51,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() @@ -92,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") @@ -122,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") @@ -133,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): @@ -156,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) @@ -175,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: %s" % str(md.face_count)) + layout.label(text=_("Face Count")+": %s" % str(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") @@ -234,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() @@ -260,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() @@ -287,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() @@ -330,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() @@ -344,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") @@ -356,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") @@ -376,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): @@ -388,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") @@ -407,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 @@ -444,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") @@ -473,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() @@ -486,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': @@ -517,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'}: @@ -542,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") @@ -556,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() @@ -569,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") @@ -592,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="") @@ -668,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") @@ -684,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") @@ -700,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() @@ -719,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") diff --git a/release/scripts/startup/bl_ui/properties_game.py b/release/scripts/startup/bl_ui/properties_game.py index 26b95484b28..95ae54c4597 100644 --- a/release/scripts/startup/bl_ui/properties_game.py +++ b/release/scripts/startup/bl_ui/properties_game.py @@ -19,7 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Panel - +from blf import gettext as _ class PhysicsButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -54,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") @@ -66,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") @@ -81,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") @@ -112,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") @@ -136,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() @@ -165,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): @@ -189,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): @@ -242,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() @@ -260,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="") @@ -299,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 @@ -310,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() @@ -348,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): @@ -384,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(): @@ -546,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): diff --git a/release/scripts/startup/bl_ui/properties_material.py b/release/scripts/startup/bl_ui/properties_material.py index 68d7d5d4615..7b04c990c6a 100644 --- a/release/scripts/startup/bl_ui/properties_material.py +++ b/release/scripts/startup/bl_ui/properties_material.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Menu, Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ def active_node_mat(mat): # TODO, 2.4x has a pipeline section, for 2.5 we need to communicate @@ -114,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) @@ -142,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): @@ -197,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") @@ -225,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) @@ -240,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() @@ -255,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): @@ -282,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() @@ -308,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): @@ -384,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() @@ -406,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): @@ -448,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): @@ -510,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): @@ -561,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() @@ -603,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): @@ -660,7 +660,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") @@ -692,10 +692,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) @@ -703,7 +703,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': @@ -713,9 +713,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): @@ -748,11 +748,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") @@ -787,12 +787,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="") @@ -802,11 +802,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") @@ -919,7 +919,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) @@ -958,7 +958,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") @@ -993,11 +993,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): diff --git a/release/scripts/startup/bl_ui/properties_object.py b/release/scripts/startup/bl_ui/properties_object.py index 0779debb102..a099189eed6 100644 --- a/release/scripts/startup/bl_ui/properties_object.py +++ b/release/scripts/startup/bl_ui/properties_object.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class ObjectButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -55,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") @@ -82,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") @@ -107,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): @@ -137,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() @@ -157,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 @@ -176,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 @@ -197,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="") @@ -209,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): @@ -235,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 @@ -271,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 ( @@ -312,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 diff --git a/release/scripts/startup/bl_ui/properties_object_constraint.py b/release/scripts/startup/bl_ui/properties_object_constraint.py index 05fac2026a0..e7385d3926b 100644 --- a/release/scripts/startup/bl_ui/properties_object_constraint.py +++ b/release/scripts/startup/bl_ui/properties_object_constraint.py @@ -19,7 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Panel - +from blf import gettext as _ class ConstraintButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -43,7 +43,7 @@ class ConstraintButtonsPanel(): split = layout.split(percentage=0.2) - split.label(text="Space:") + split.label(text=_("Space:")) row = split.row() if target: @@ -60,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() @@ -96,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") @@ -121,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) @@ -140,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() @@ -152,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") @@ -170,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") @@ -189,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") @@ -207,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) @@ -222,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): @@ -241,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): @@ -302,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): @@ -343,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): @@ -355,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") @@ -382,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") @@ -415,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") @@ -439,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): @@ -471,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() @@ -482,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): @@ -504,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) @@ -516,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") @@ -630,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. @@ -674,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() @@ -683,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) @@ -718,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") @@ -741,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): @@ -773,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") diff --git a/release/scripts/startup/bl_ui/properties_particle.py b/release/scripts/startup/bl_ui/properties_particle.py index d4378b0d094..6424f6dca44 100644 --- a/release/scripts/startup/bl_ui/properties_particle.py +++ b/release/scripts/startup/bl_ui/properties_particle.py @@ -20,6 +20,7 @@ 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, @@ -108,17 +109,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="") @@ -128,10 +129,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="") @@ -141,8 +142,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") @@ -157,7 +158,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) @@ -174,7 +175,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): @@ -221,7 +222,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() @@ -239,11 +240,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): @@ -284,22 +285,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): @@ -355,17 +356,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") @@ -406,21 +407,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': @@ -461,19 +462,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") @@ -488,13 +489,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) @@ -515,8 +516,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 @@ -524,7 +525,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="") @@ -532,7 +533,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() @@ -541,11 +542,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 @@ -581,7 +582,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") @@ -589,16 +590,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") @@ -621,7 +622,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") @@ -631,7 +632,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': @@ -639,7 +640,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): @@ -678,7 +679,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") @@ -721,7 +722,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") @@ -800,14 +801,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() @@ -864,30 +865,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() @@ -895,8 +896,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() @@ -904,9 +905,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': @@ -914,10 +915,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="") @@ -965,11 +966,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() @@ -980,11 +981,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") @@ -1013,24 +1014,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) @@ -1042,38 +1043,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() @@ -1082,7 +1083,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) @@ -1123,25 +1124,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) @@ -1163,56 +1164,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="") diff --git a/release/scripts/startup/bl_ui/properties_physics_cloth.py b/release/scripts/startup/bl_ui/properties_physics_cloth.py index d5427d8bae8..de74d1473c8 100644 --- a/release/scripts/startup/bl_ui/properties_physics_cloth.py +++ b/release/scripts/startup/bl_ui/properties_physics_cloth.py @@ -19,7 +19,7 @@ # <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 +71,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 +156,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 +198,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): diff --git a/release/scripts/startup/bl_ui/properties_physics_common.py b/release/scripts/startup/bl_ui/properties_physics_common.py index 204e25d9f01..20b76ec0a84 100644 --- a/release/scripts/startup/bl_ui/properties_physics_common.py +++ b/release/scripts/startup/bl_ui/properties_physics_common.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Panel - +from blf import gettext as _ class PhysicButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -53,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 @@ -95,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="") @@ -108,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) @@ -142,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() @@ -152,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): @@ -215,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") @@ -223,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") @@ -237,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") @@ -265,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() @@ -273,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__) diff --git a/release/scripts/startup/bl_ui/properties_physics_field.py b/release/scripts/startup/bl_ui/properties_physics_field.py index e1dc4d04378..937df5c0ad9 100644 --- a/release/scripts/startup/bl_ui/properties_physics_field.py +++ b/release/scripts/startup/bl_ui/properties_physics_field.py @@ -19,7 +19,7 @@ # <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 +54,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 +76,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 +117,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 +128,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 +149,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 +192,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__) diff --git a/release/scripts/startup/bl_ui/properties_physics_fluid.py b/release/scripts/startup/bl_ui/properties_physics_fluid.py index 55629e6c6b9..c89d7ec9755 100644 --- a/release/scripts/startup/bl_ui/properties_physics_fluid.py +++ b/release/scripts/startup/bl_ui/properties_physics_fluid.py @@ -19,7 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Panel - +from blf import gettext as _ class PhysicButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -46,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") @@ -58,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() @@ -92,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() @@ -129,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") @@ -146,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") @@ -167,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): @@ -206,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) @@ -254,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): diff --git a/release/scripts/startup/bl_ui/properties_physics_smoke.py b/release/scripts/startup/bl_ui/properties_physics_smoke.py index 771a778380d..61c477b6d49 100644 --- a/release/scripts/startup/bl_ui/properties_physics_smoke.py +++ b/release/scripts/startup/bl_ui/properties_physics_smoke.py @@ -19,7 +19,7 @@ # <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 +59,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 +85,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 +121,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 +157,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 +184,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') diff --git a/release/scripts/startup/bl_ui/properties_physics_softbody.py b/release/scripts/startup/bl_ui/properties_physics_softbody.py index 0b55ccf9516..5449e54c6e6 100644 --- a/release/scripts/startup/bl_ui/properties_physics_softbody.py +++ b/release/scripts/startup/bl_ui/properties_physics_softbody.py @@ -19,7 +19,7 @@ # <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 +62,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 +114,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 +154,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 +169,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 +203,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 +233,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") diff --git a/release/scripts/startup/bl_ui/properties_render.py b/release/scripts/startup/bl_ui/properties_render.py index 395cfc6934e..1e9c15eedae 100644 --- a/release/scripts/startup/bl_ui/properties_render.py +++ b/release/scripts/startup/bl_ui/properties_render.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Menu, Panel +from blf import gettext as _ class RENDER_MT_presets(Menu): @@ -64,10 +65,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): @@ -97,25 +98,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") @@ -134,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") @@ -193,29 +194,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.prop(scene, "frame_start", text="Start") - sub.prop(scene, "frame_end", text="End") - sub.prop(scene, "frame_step", text="Step") + 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: @@ -225,7 +226,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" @@ -235,10 +236,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): @@ -266,7 +267,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): @@ -308,15 +309,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): @@ -332,18 +333,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") @@ -353,13 +354,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): @@ -378,24 +379,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="") @@ -419,26 +420,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="") @@ -460,7 +461,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") @@ -471,11 +472,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() @@ -486,7 +487,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() @@ -499,13 +500,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': @@ -517,11 +518,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': @@ -559,7 +560,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") @@ -575,22 +576,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") @@ -632,7 +633,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") diff --git a/release/scripts/startup/bl_ui/properties_scene.py b/release/scripts/startup/bl_ui/properties_scene.py index 5a25e608a39..c82b4ac69dc 100644 --- a/release/scripts/startup/bl_ui/properties_scene.py +++ b/release/scripts/startup/bl_ui/properties_scene.py @@ -20,7 +20,7 @@ import bpy from bpy.types import Operator, Panel from rna_prop_ui import PropertyPanel - +from blf import gettext as _ class SceneButtonsPanel(): bl_space_type = 'PROPERTIES' @@ -41,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): @@ -59,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") @@ -86,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") @@ -115,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") @@ -138,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() @@ -152,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") @@ -209,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): diff --git a/release/scripts/startup/bl_ui/properties_texture.py b/release/scripts/startup/bl_ui/properties_texture.py index 34f5a948ee7..c5f8708040f 100644 --- a/release/scripts/startup/bl_ui/properties_texture.py +++ b/release/scripts/startup/bl_ui/properties_texture.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Menu, Panel from rna_prop_ui import PropertyPanel +from blf import gettext as _ class TEXTURE_MT_specials(Menu): @@ -143,11 +144,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="") @@ -178,21 +179,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") @@ -235,17 +236,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): @@ -263,15 +264,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") @@ -289,15 +290,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") @@ -315,7 +316,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") @@ -348,12 +349,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") @@ -371,13 +372,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") @@ -399,12 +400,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() @@ -445,12 +446,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) @@ -462,11 +463,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() @@ -474,12 +475,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") @@ -517,9 +518,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): @@ -551,7 +552,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") @@ -560,16 +561,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") @@ -586,26 +587,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") @@ -620,13 +621,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") @@ -693,26 +694,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") @@ -722,7 +723,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") @@ -733,7 +734,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) @@ -762,9 +763,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() @@ -801,7 +802,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="") @@ -810,12 +811,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="") @@ -824,12 +825,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() @@ -838,7 +839,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() @@ -900,111 +901,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() @@ -1012,32 +1013,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): diff --git a/release/scripts/startup/bl_ui/properties_world.py b/release/scripts/startup/bl_ui/properties_world.py index 71ee03296a0..916667ea400 100644 --- a/release/scripts/startup/bl_ui/properties_world.py +++ b/release/scripts/startup/bl_ui/properties_world.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Panel from rna_prop_ui import PropertyPanel +from blf import gettext as _ class WorldButtonsPanel(): @@ -115,12 +116,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): @@ -134,7 +135,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="") @@ -153,11 +154,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): @@ -175,18 +176,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() @@ -201,9 +202,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") @@ -257,11 +258,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): diff --git a/release/scripts/startup/bl_ui/space_console.py b/release/scripts/startup/bl_ui/space_console.py index cbbefa01a3c..bb0cf6eda2c 100644 --- a/release/scripts/startup/bl_ui/space_console.py +++ b/release/scripts/startup/bl_ui/space_console.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Header, Menu, Operator from bpy.props import StringProperty +from blf import gettext as _ class CONSOLE_HT_header(Header): @@ -33,7 +34,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): diff --git a/release/scripts/startup/bl_ui/space_dopesheet.py b/release/scripts/startup/bl_ui/space_dopesheet.py index 90dcc99e6d7..580a4e7f1b6 100644 --- a/release/scripts/startup/bl_ui/space_dopesheet.py +++ b/release/scripts/startup/bl_ui/space_dopesheet.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Header, Menu +from blf import gettext as _ ####################################### @@ -117,7 +118,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) @@ -153,9 +154,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") @@ -180,22 +181,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': @@ -217,14 +218,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() @@ -254,14 +255,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") @@ -273,10 +274,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") @@ -286,9 +287,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") @@ -305,10 +306,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' ####################################### @@ -347,7 +348,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") diff --git a/release/scripts/startup/bl_ui/space_graph.py b/release/scripts/startup/bl_ui/space_graph.py index d4b8c415a7f..fd50d60bd45 100644 --- a/release/scripts/startup/bl_ui/space_graph.py +++ b/release/scripts/startup/bl_ui/space_graph.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Header, Menu +from blf import gettext as _ class GRAPH_HT_header(Header): @@ -82,9 +83,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") @@ -112,23 +113,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") @@ -146,14 +147,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? @@ -176,14 +177,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") @@ -195,10 +196,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") @@ -210,8 +211,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") @@ -224,7 +225,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): @@ -233,10 +234,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__) diff --git a/release/scripts/startup/bl_ui/space_image.py b/release/scripts/startup/bl_ui/space_image.py index 97b5d8457e0..f5be25d14f6 100644 --- a/release/scripts/startup/bl_ui/space_image.py +++ b/release/scripts/startup/bl_ui/space_image.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu, Panel +from blf import gettext as _ class BrushButtonsPanel(): @@ -64,7 +65,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) + text = _("Zoom") + " %d:%d" % (a, b) layout.operator("image.view_zoom_ratio", text=text).ratio = a / b layout.separator() @@ -92,7 +93,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() @@ -122,12 +123,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() @@ -145,7 +146,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() @@ -158,23 +159,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 @@ -185,8 +186,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): @@ -211,14 +212,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): @@ -228,8 +229,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): @@ -259,7 +260,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() @@ -299,32 +300,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" @@ -356,9 +357,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") @@ -596,22 +597,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() @@ -623,11 +624,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) @@ -669,12 +670,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): @@ -728,7 +729,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") diff --git a/release/scripts/startup/bl_ui/space_info.py b/release/scripts/startup/bl_ui/space_info.py index debe82e7ab2..3e6abaa8ea3 100644 --- a/release/scripts/startup/bl_ui/space_info.py +++ b/release/scripts/startup/bl_ui/space_info.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu, Operator +from blf import gettext as _ class INFO_HT_header(Header): @@ -45,7 +46,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") @@ -73,11 +74,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 @@ -106,25 +107,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") @@ -133,8 +134,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 @@ -150,7 +151,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): @@ -177,8 +178,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() @@ -196,17 +197,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): @@ -217,11 +218,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): @@ -248,12 +249,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): @@ -264,7 +265,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): @@ -275,39 +276,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): @@ -337,13 +338,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() @@ -359,27 +360,27 @@ 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("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.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') diff --git a/release/scripts/startup/bl_ui/space_logic.py b/release/scripts/startup/bl_ui/space_logic.py index 869a91124d3..b1149913d17 100644 --- a/release/scripts/startup/bl_ui/space_logic.py +++ b/release/scripts/startup/bl_ui/space_logic.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu, Panel +from blf import gettext as _ class LOGIC_PT_properties(Panel): @@ -37,7 +38,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): @@ -56,9 +57,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): diff --git a/release/scripts/startup/bl_ui/space_nla.py b/release/scripts/startup/bl_ui/space_nla.py index ffead81c507..8a4b0a61291 100644 --- a/release/scripts/startup/bl_ui/space_nla.py +++ b/release/scripts/startup/bl_ui/space_nla.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Header, Menu +from blf import gettext as _ class NLA_HT_header(Header): @@ -62,7 +63,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") @@ -87,33 +88,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): @@ -124,9 +125,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") @@ -148,14 +149,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): @@ -174,7 +175,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): @@ -183,9 +184,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__) diff --git a/release/scripts/startup/bl_ui/space_node.py b/release/scripts/startup/bl_ui/space_node.py index 708017ba749..0808ddf769a 100644 --- a/release/scripts/startup/bl_ui/space_node.py +++ b/release/scripts/startup/bl_ui/space_node.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu, Panel +from blf import gettext as _ class NODE_HT_header(Header): @@ -61,7 +62,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) @@ -92,9 +93,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() @@ -137,7 +138,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() @@ -180,13 +181,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__) diff --git a/release/scripts/startup/bl_ui/space_sequencer.py b/release/scripts/startup/bl_ui/space_sequencer.py index 36f606da635..a9a5eae3179 100644 --- a/release/scripts/startup/bl_ui/space_sequencer.py +++ b/release/scripts/startup/bl_ui/space_sequencer.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu, Panel +from blf import gettext as _ def act_strip(context): @@ -64,9 +65,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: @@ -101,11 +102,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 @@ -114,9 +115,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': @@ -138,12 +139,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") @@ -158,14 +159,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) @@ -180,7 +181,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): @@ -192,13 +193,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") @@ -210,22 +211,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): @@ -236,13 +237,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") @@ -296,7 +297,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") @@ -344,21 +345,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="") @@ -371,13 +372,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 @@ -387,9 +388,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): @@ -429,7 +430,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() @@ -449,13 +450,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 @@ -473,7 +474,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 @@ -481,17 +482,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") @@ -506,7 +507,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") @@ -516,18 +517,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): @@ -560,7 +561,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="") @@ -570,7 +571,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 @@ -580,22 +581,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") @@ -605,14 +606,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): @@ -641,9 +642,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") @@ -654,8 +655,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): @@ -683,13 +684,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): @@ -717,22 +718,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") @@ -743,15 +744,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): @@ -794,18 +795,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' @@ -815,7 +816,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="") diff --git a/release/scripts/startup/bl_ui/space_text.py b/release/scripts/startup/bl_ui/space_text.py index 12e07c19ca1..cd72d42857b 100644 --- a/release/scripts/startup/bl_ui/space_text.py +++ b/release/scripts/startup/bl_ui/space_text.py @@ -19,6 +19,7 @@ # <pep8-80 compliant> import bpy from bpy.types import Header, Menu, Panel +from blf import gettext as _ class TEXT_HT_header(Header): @@ -66,13 +67,13 @@ class TEXT_HT_header(Header): row = layout.row() if text.filepath: if text.is_dirty: - row.label(text="File: *%r (unsaved)" % text.filepath) + 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): @@ -136,8 +137,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): @@ -156,10 +157,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' @@ -248,10 +249,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 @@ -282,7 +283,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() diff --git a/release/scripts/startup/bl_ui/space_time.py b/release/scripts/startup/bl_ui/space_time.py index db009fe43c2..d654c1e4d8b 100644 --- a/release/scripts/startup/bl_ui/space_time.py +++ b/release/scripts/startup/bl_ui/space_time.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu +from blf import gettext as _ class TIME_HT_header(Header): @@ -43,11 +44,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="") @@ -142,14 +143,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() @@ -181,8 +182,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") diff --git a/release/scripts/startup/bl_ui/space_userpref.py b/release/scripts/startup/bl_ui/space_userpref.py index 3e3ca913e88..d0e7ae5e609 100644 --- a/release/scripts/startup/bl_ui/space_userpref.py +++ b/release/scripts/startup/bl_ui/space_userpref.py @@ -23,6 +23,7 @@ import os import addon_utils from bpy.props import StringProperty, BoolProperty, EnumProperty +from blf import gettext as _ def ui_items_general(col, context): @@ -65,10 +66,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() @@ -86,7 +87,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' @@ -127,7 +128,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) @@ -142,12 +143,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): @@ -170,13 +171,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") @@ -184,18 +185,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") @@ -211,8 +212,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() @@ -228,19 +229,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() @@ -267,97 +268,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): @@ -384,11 +385,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") @@ -396,80 +397,66 @@ 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() col.separator() col.separator() - #column = split.column() - #colsplit = column.split(percentage=0.85) - - # No translation in 2.5 yet - #col.prop(system, "language") - #col.label(text="Translate:") - #col.prop(system, "use_translate_tooltips", text="Tooltips") - #col.prop(system, "use_translate_buttons", text="Labels") - #col.prop(system, "use_translate_toolbox", text="Toolbox") - - #col.separator() - - #col.prop(system, "use_textured_fonts") - # 2. Column column = split.column() 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) @@ -481,21 +468,27 @@ class USERPREF_PT_system(Panel): opengl_lamp_buttons(column, lamp) column.separator() - column.separator() - 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.separator() - 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) + column.separator() + + column.prop(system, "use_international_fonts") + if system.use_international_fonts: + column.prop(system, "language") + row = column.row() + row.label(text="Translate:") + row.prop(system, "use_translate_interface", text="Interface") + row.prop(system, "use_translate_tooltips", text="Tooltips") + class USERPREF_PT_theme(Panel): bl_space_type = 'USER_PREFERENCES' @@ -557,71 +550,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() @@ -657,7 +650,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() @@ -700,22 +693,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="") @@ -732,7 +725,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") @@ -747,11 +740,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 @@ -807,7 +800,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) @@ -815,19 +808,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() @@ -835,10 +828,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) @@ -849,8 +842,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() @@ -888,9 +881,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): @@ -945,10 +938,10 @@ class USERPREF_PT_addons(Panel): 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() @@ -1025,23 +1018,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) @@ -1049,13 +1042,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() @@ -1067,7 +1060,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): diff --git a/release/scripts/startup/bl_ui/space_userpref_keymap.py b/release/scripts/startup/bl_ui/space_userpref_keymap.py index 9ed1591cbf3..f8d77a1604b 100644 --- a/release/scripts/startup/bl_ui/space_userpref_keymap.py +++ b/release/scripts/startup/bl_ui/space_userpref_keymap.py @@ -20,6 +20,7 @@ import bpy from bpy.types import Menu, Operator, OperatorProperties import os +from blf import gettext as _ KM_HIERARCHY = [ @@ -131,7 +132,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" @@ -182,7 +183,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() @@ -190,7 +191,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() @@ -201,7 +202,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 (Global)" % km.name) + subrow.label(text="%s " % _(km.name) + _("(Global)") ) else: km.show_expanded_items = True @@ -213,7 +214,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() @@ -261,7 +262,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="") @@ -350,7 +351,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() @@ -360,7 +361,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: @@ -381,7 +382,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 @@ -423,7 +424,7 @@ def export_properties(prefix, properties, lines=None): class WM_OT_keyconfig_test(Operator): "Test keyconfig for conflicts" bl_idname = "wm.keyconfig_test" - bl_label = "Test Key Configuration for Conflicts" + bl_label = _("Test Key Configuration for Conflicts") def testEntry(self, kc, entry, src=None, parent=None): result = False @@ -597,7 +598,7 @@ class WM_OT_keyconfig_import(Operator): class WM_OT_keyconfig_export(Operator): "Export key configuration to a python script" bl_idname = "wm.keyconfig_export" - bl_label = "Export Key Configuration..." + bl_label = _("Export Key Configuration...") filepath = StringProperty( name="File Path", diff --git a/release/scripts/startup/bl_ui/space_view3d.py b/release/scripts/startup/bl_ui/space_view3d.py index 357c673edbd..2e86e875bab 100644 --- a/release/scripts/startup/bl_ui/space_view3d.py +++ b/release/scripts/startup/bl_ui/space_view3d.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Header, Menu, Operator, Panel +from blf import gettext as _ class VIEW3D_HT_header(Header): @@ -124,9 +125,9 @@ class ShowHideMenu(): def draw(self, context): layout = self.layout - layout.operator("%s.reveal" % self._operator_name, text="Show Hidden") - layout.operator("%s.hide" % self._operator_name, text="Hide Selected") - layout.operator("%s.hide" % self._operator_name, text="Hide Unselected").unselected = True + layout.operator("%s.reveal" % self._operator_name, text=_("Show Hidden")) + layout.operator("%s.hide" % self._operator_name, text=_("Hide Selected")) + layout.operator("%s.hide" % self._operator_name, text=_("Hide Unselected")).unselected = True class VIEW3D_MT_transform(Menu): @@ -145,35 +146,35 @@ class VIEW3D_MT_transform(Menu): layout.separator() - layout.operator("transform.tosphere", text="To Sphere") - layout.operator("transform.shear", text="Shear") - layout.operator("transform.warp", text="Warp") - layout.operator("transform.push_pull", text="Push/Pull") + layout.operator("transform.tosphere", text=_("To Sphere")) + layout.operator("transform.shear", text=_("Shear")) + layout.operator("transform.warp", text=_("Warp")) + layout.operator("transform.push_pull", text=_("Push/Pull")) layout.separator() - layout.operator("transform.translate", text="Move Texture Space").texture_space = True - layout.operator("transform.resize", text="Scale Texture Space").texture_space = True + layout.operator("transform.translate", text=_("Move Texture Space")).texture_space = True + layout.operator("transform.resize", text=_("Scale Texture Space")).texture_space = True layout.separator() obj = context.object if obj.type == 'ARMATURE' and obj.mode in {'EDIT', 'POSE'} and obj.data.draw_type in {'BBONE', 'ENVELOPE'}: - layout.operator("transform.transform", text="Scale Envelope/BBone").mode = 'BONE_SIZE' + layout.operator("transform.transform", text=_("Scale Envelope/BBone")).mode = 'BONE_SIZE' if context.edit_object and context.edit_object.type == 'ARMATURE': layout.operator("armature.align") else: layout.operator_context = 'EXEC_REGION_WIN' - layout.operator("transform.transform", text="Align to Transform Orientation").mode = 'ALIGN' # XXX see alignmenu() in edit.c of b2.4x to get this working + layout.operator("transform.transform", text=_("Align to Transform Orientation")).mode = 'ALIGN' # XXX see alignmenu() in edit.c of b2.4x to get this working layout.separator() layout.operator_context = 'EXEC_AREA' - layout.operator("object.origin_set", text="Geometry to Origin").type = 'GEOMETRY_ORIGIN' - layout.operator("object.origin_set", text="Origin to Geometry").type = 'ORIGIN_GEOMETRY' - layout.operator("object.origin_set", text="Origin to 3D Cursor").type = 'ORIGIN_CURSOR' + layout.operator("object.origin_set", text=_("Geometry to Origin")).type = 'GEOMETRY_ORIGIN' + layout.operator("object.origin_set", text=_("Origin to Geometry")).type = 'ORIGIN_GEOMETRY' + layout.operator("object.origin_set", text=_("Origin to 3D Cursor")).type = 'ORIGIN_CURSOR' layout.separator() @@ -191,32 +192,32 @@ class VIEW3D_MT_mirror(Menu): def draw(self, context): layout = self.layout - layout.operator("transform.mirror", text="Interactive Mirror") + layout.operator("transform.mirror", text=_("Interactive Mirror")) layout.separator() layout.operator_context = 'INVOKE_REGION_WIN' - props = layout.operator("transform.mirror", text="X Global") + props = layout.operator("transform.mirror", text=_("X Global")) props.constraint_axis = (True, False, False) props.constraint_orientation = 'GLOBAL' - props = layout.operator("transform.mirror", text="Y Global") + props = layout.operator("transform.mirror", text=_("Y Global")) props.constraint_axis = (False, True, False) props.constraint_orientation = 'GLOBAL' - props = layout.operator("transform.mirror", text="Z Global") + props = layout.operator("transform.mirror", text=_("Z Global")) props.constraint_axis = (False, False, True) props.constraint_orientation = 'GLOBAL' if context.edit_object: layout.separator() - props = layout.operator("transform.mirror", text="X Local") + props = layout.operator("transform.mirror", text=_("X Local")) props.constraint_axis = (True, False, False) props.constraint_orientation = 'LOCAL' - props = layout.operator("transform.mirror", text="Y Local") + props = layout.operator("transform.mirror", text=_("Y Local")) props.constraint_axis = (False, True, False) props.constraint_orientation = 'LOCAL' - props = layout.operator("transform.mirror", text="Z Local") + props = layout.operator("transform.mirror", text=_("Z Local")) props.constraint_axis = (False, False, True) props.constraint_orientation = 'LOCAL' @@ -229,15 +230,15 @@ class VIEW3D_MT_snap(Menu): def draw(self, context): layout = self.layout - layout.operator("view3d.snap_selected_to_grid", text="Selection to Grid") - layout.operator("view3d.snap_selected_to_cursor", text="Selection to Cursor") + layout.operator("view3d.snap_selected_to_grid", text=_("Selection to Grid")) + layout.operator("view3d.snap_selected_to_cursor", text=_("Selection to Cursor")) layout.separator() - layout.operator("view3d.snap_cursor_to_selected", text="Cursor to Selected") - layout.operator("view3d.snap_cursor_to_center", text="Cursor to Center") - layout.operator("view3d.snap_cursor_to_grid", text="Cursor to Grid") - layout.operator("view3d.snap_cursor_to_active", text="Cursor to Active") + layout.operator("view3d.snap_cursor_to_selected", text=_("Cursor to Selected")) + layout.operator("view3d.snap_cursor_to_center", text=_("Cursor to Center")) + layout.operator("view3d.snap_cursor_to_grid", text=_("Cursor to Grid")) + layout.operator("view3d.snap_cursor_to_active", text=_("Cursor to Active")) class VIEW3D_MT_uv_map(Menu): @@ -263,7 +264,7 @@ class VIEW3D_MT_uv_map(Menu): layout.separator() layout.operator("uv.project_from_view") - layout.operator("uv.project_from_view", text="Project from View (Bounds)").scale_to_bounds = True + layout.operator("uv.project_from_view", text=_("Project from View (Bounds)")).scale_to_bounds = True layout.separator() @@ -284,15 +285,15 @@ class VIEW3D_MT_view(Menu): layout.separator() - layout.operator("view3d.viewnumpad", text="Camera").type = 'CAMERA' - layout.operator("view3d.viewnumpad", text="Top").type = 'TOP' - layout.operator("view3d.viewnumpad", text="Bottom").type = 'BOTTOM' - layout.operator("view3d.viewnumpad", text="Front").type = 'FRONT' - layout.operator("view3d.viewnumpad", text="Back").type = 'BACK' - layout.operator("view3d.viewnumpad", text="Right").type = 'RIGHT' - layout.operator("view3d.viewnumpad", text="Left").type = 'LEFT' + layout.operator("view3d.viewnumpad", text=_("Camera")).type = 'CAMERA' + layout.operator("view3d.viewnumpad", text=_("Top")).type = 'TOP' + layout.operator("view3d.viewnumpad", text=_("Bottom")).type = 'BOTTOM' + layout.operator("view3d.viewnumpad", text=_("Front")).type = 'FRONT' + layout.operator("view3d.viewnumpad", text=_("Back")).type = 'BACK' + layout.operator("view3d.viewnumpad", text=_("Right")).type = 'RIGHT' + layout.operator("view3d.viewnumpad", text=_("Left")).type = 'LEFT' - layout.menu("VIEW3D_MT_view_cameras", text="Cameras") + layout.menu("VIEW3D_MT_view_cameras", text=_("Cameras")) layout.separator() @@ -307,22 +308,22 @@ class VIEW3D_MT_view(Menu): layout.operator_context = 'INVOKE_REGION_WIN' - layout.operator("view3d.clip_border", text="Clipping Border...") - layout.operator("view3d.zoom_border", text="Zoom Border...") + layout.operator("view3d.clip_border", text=_("Clipping Border...")) + layout.operator("view3d.zoom_border", text=_("Zoom Border...")) layout.separator() - layout.operator("view3d.layers", text="Show All Layers").nr = 0 + layout.operator("view3d.layers", text=_("Show All Layers")).nr = 0 layout.separator() - layout.operator("view3d.localview", text="View Global/Local") + layout.operator("view3d.localview", text=_("View Global/Local")) layout.operator("view3d.view_selected") layout.operator("view3d.view_all") layout.separator() - layout.operator("screen.animation_play", text="Playback Animation") + layout.operator("screen.animation_play", text=_("Playback Animation")) layout.separator() @@ -345,9 +346,9 @@ class VIEW3D_MT_view_navigation(Menu): layout.separator() - layout.operator("view3d.zoom", text="Zoom In").delta = 1 - layout.operator("view3d.zoom", text="Zoom Out").delta = -1 - layout.operator("view3d.zoom_camera_1_to_1", text="Zoom Camera 1:1") + layout.operator("view3d.zoom", text=_("Zoom In")).delta = 1 + layout.operator("view3d.zoom", text=_("Zoom Out")).delta = -1 + layout.operator("view3d.zoom_camera_1_to_1", text=_("Zoom Camera 1:1")) layout.separator() @@ -364,8 +365,8 @@ class VIEW3D_MT_view_align(Menu): layout.separator() - layout.operator("view3d.view_all", text="Center Cursor and View All").center = True - layout.operator("view3d.camera_to_view", text="Align Active Camera to View") + layout.operator("view3d.view_all", text=_("Center Cursor and View All")).center = True + layout.operator("view3d.camera_to_view", text=_("Align Active Camera to View")) layout.operator("view3d.view_selected") layout.operator("view3d.view_center_cursor") @@ -376,22 +377,22 @@ class VIEW3D_MT_view_align_selected(Menu): def draw(self, context): layout = self.layout - props = layout.operator("view3d.viewnumpad", text="Top") + props = layout.operator("view3d.viewnumpad", text=_("Top")) props.align_active = True props.type = 'TOP' - props = layout.operator("view3d.viewnumpad", text="Bottom") + props = layout.operator("view3d.viewnumpad", text=_("Bottom")) props.align_active = True props.type = 'BOTTOM' - props = layout.operator("view3d.viewnumpad", text="Front") + props = layout.operator("view3d.viewnumpad", text=_("Front")) props.align_active = True props.type = 'FRONT' - props = layout.operator("view3d.viewnumpad", text="Back") + props = layout.operator("view3d.viewnumpad", text=_("Back")) props.align_active = True props.type = 'BACK' - props = layout.operator("view3d.viewnumpad", text="Right") + props = layout.operator("view3d.viewnumpad", text=_("Right")) props.align_active = True props.type = 'RIGHT' - props = layout.operator("view3d.viewnumpad", text="Left") + props = layout.operator("view3d.viewnumpad", text=_("Left")) props.align_active = True props.type = 'LEFT' @@ -403,7 +404,7 @@ class VIEW3D_MT_view_cameras(Menu): layout = self.layout layout.operator("view3d.object_as_camera") - layout.operator("view3d.viewnumpad", text="Active Camera").type = 'CAMERA' + layout.operator("view3d.viewnumpad", text=_("Active Camera")).type = 'CAMERA' # ********** Select menus, suffix from context.mode ********** @@ -419,19 +420,19 @@ class VIEW3D_MT_select_object(Menu): layout.separator() - layout.operator("object.select_all", text="Select/Deselect All") - layout.operator("object.select_inverse", text="Inverse") - layout.operator("object.select_random", text="Random") - layout.operator("object.select_mirror", text="Mirror") - layout.operator("object.select_by_layer", text="Select All by Layer") - layout.operator_menu_enum("object.select_by_type", "type", text="Select All by Type...") - layout.operator("object.select_camera", text="Select Camera") + layout.operator("object.select_all", text=_("Select/Deselect All")) + layout.operator("object.select_inverse", text=_("Inverse")) + layout.operator("object.select_random", text=_("Random")) + layout.operator("object.select_mirror", text=_("Mirror")) + layout.operator("object.select_by_layer", text=_("Select All by Layer")) + layout.operator_menu_enum("object.select_by_type", "type", text=_("Select All by Type...")) + layout.operator("object.select_camera", text=_("Select Camera")) layout.separator() - layout.operator_menu_enum("object.select_grouped", "type", text="Grouped") - layout.operator_menu_enum("object.select_linked", "type", text="Linked") - layout.operator("object.select_pattern", text="Select Pattern...") + layout.operator_menu_enum("object.select_grouped", "type", text=_("Grouped")) + layout.operator_menu_enum("object.select_linked", "type", text=_("Linked")) + layout.operator("object.select_pattern", text=_("Select Pattern...")) class VIEW3D_MT_select_pose(Menu): @@ -444,31 +445,31 @@ class VIEW3D_MT_select_pose(Menu): layout.separator() - layout.operator("pose.select_all", text="Select/Deselect All") - layout.operator("pose.select_inverse", text="Inverse") - layout.operator("pose.select_flip_active", text="Flip Active") - layout.operator("pose.select_constraint_target", text="Constraint Target") - layout.operator("pose.select_linked", text="Linked") + layout.operator("pose.select_all", text=_("Select/Deselect All")) + layout.operator("pose.select_inverse", text=_("Inverse")) + layout.operator("pose.select_flip_active", text=_("Flip Active")) + layout.operator("pose.select_constraint_target", text=_("Constraint Target")) + layout.operator("pose.select_linked", text=_("Linked")) layout.separator() - layout.operator("pose.select_hierarchy", text="Parent").direction = 'PARENT' - layout.operator("pose.select_hierarchy", text="Child").direction = 'CHILD' + layout.operator("pose.select_hierarchy", text=_("Parent")).direction = 'PARENT' + layout.operator("pose.select_hierarchy", text=_("Child")).direction = 'CHILD' layout.separator() - props = layout.operator("pose.select_hierarchy", text="Extend Parent") + props = layout.operator("pose.select_hierarchy", text=_("Extend Parent")) props.extend = True props.direction = 'PARENT' - props = layout.operator("pose.select_hierarchy", text="Extend Child") + props = layout.operator("pose.select_hierarchy", text=_("Extend Child")) props.extend = True props.direction = 'CHILD' layout.separator() - layout.operator_menu_enum("pose.select_grouped", "type", text="Grouped") - layout.operator("object.select_pattern", text="Select Pattern...") + layout.operator_menu_enum("pose.select_grouped", "type", text=_("Grouped")) + layout.operator("object.select_pattern", text=_("Select Pattern...")) class VIEW3D_MT_select_particle(Menu): @@ -481,7 +482,7 @@ class VIEW3D_MT_select_particle(Menu): layout.separator() - layout.operator("particle.select_all", text="Select/Deselect All") + layout.operator("particle.select_all", text=_("Select/Deselect All")) layout.operator("particle.select_linked") layout.operator("particle.select_inverse") @@ -492,8 +493,8 @@ class VIEW3D_MT_select_particle(Menu): layout.separator() - layout.operator("particle.select_roots", text="Roots") - layout.operator("particle.select_tips", text="Tips") + layout.operator("particle.select_roots", text=_("Roots")) + layout.operator("particle.select_tips", text=_("Tips")) class VIEW3D_MT_select_edit_mesh(Menu): @@ -507,40 +508,40 @@ class VIEW3D_MT_select_edit_mesh(Menu): layout.separator() - layout.operator("mesh.select_all", text="Select/Deselect All") - layout.operator("mesh.select_inverse", text="Inverse") + layout.operator("mesh.select_all", text=_("Select/Deselect All")) + layout.operator("mesh.select_inverse", text=_("Inverse")) layout.separator() - layout.operator("mesh.select_random", text="Random") - layout.operator("mesh.select_nth", text="Every N Number of Verts") - layout.operator("mesh.edges_select_sharp", text="Sharp Edges") - layout.operator("mesh.faces_select_linked_flat", text="Linked Flat Faces") - layout.operator("mesh.faces_select_interior", text="Interior Faces") - layout.operator("mesh.select_axis", text="Side of Active") + layout.operator("mesh.select_random", text=_("Random")) + layout.operator("mesh.select_nth", text=_("Every N Number of Verts")) + layout.operator("mesh.edges_select_sharp", text=_("Sharp Edges")) + layout.operator("mesh.faces_select_linked_flat", text=_("Linked Flat Faces")) + layout.operator("mesh.faces_select_interior", text=_("Interior Faces")) + layout.operator("mesh.select_axis", text=_("Side of Active")) layout.separator() - layout.operator("mesh.select_by_number_vertices", text="Triangles").type = 'TRIANGLES' - layout.operator("mesh.select_by_number_vertices", text="Quads").type = 'QUADS' + layout.operator("mesh.select_by_number_vertices", text=_("Triangles")).type = 'TRIANGLES' + layout.operator("mesh.select_by_number_vertices", text=_("Quads")).type = 'QUADS' if context.scene.tool_settings.mesh_select_mode[2] == False: - layout.operator("mesh.select_non_manifold", text="Non Manifold") - layout.operator("mesh.select_by_number_vertices", text="Loose Verts/Edges").type = 'OTHER' - layout.operator("mesh.select_similar", text="Similar") + layout.operator("mesh.select_non_manifold", text=_("Non Manifold")) + layout.operator("mesh.select_by_number_vertices", text=_("Loose Verts/Edges")).type = 'OTHER' + layout.operator("mesh.select_similar", text=_("Similar")) layout.separator() - layout.operator("mesh.select_less", text="Less") - layout.operator("mesh.select_more", text="More") + layout.operator("mesh.select_less", text=_("Less")) + layout.operator("mesh.select_more", text=_("More")) layout.separator() - layout.operator("mesh.select_mirror", text="Mirror") + layout.operator("mesh.select_mirror", text=_("Mirror")) - layout.operator("mesh.select_linked", text="Linked") - layout.operator("mesh.select_vertex_path", text="Vertex Path") - layout.operator("mesh.loop_multi_select", text="Edge Loop") - layout.operator("mesh.loop_multi_select", text="Edge Ring").ring = True + layout.operator("mesh.select_linked", text=_("Linked")) + layout.operator("mesh.select_vertex_path", text=_("Vertex Path")) + layout.operator("mesh.loop_multi_select", text=_("Edge Loop")) + layout.operator("mesh.loop_multi_select", text=_("Edge Ring")).ring = True layout.separator() @@ -559,10 +560,10 @@ class VIEW3D_MT_select_edit_curve(Menu): layout.separator() - layout.operator("curve.select_all", text="Select/Deselect All") + layout.operator("curve.select_all", text=_("Select/Deselect All")) layout.operator("curve.select_inverse") layout.operator("curve.select_random") - layout.operator("curve.select_nth", text="Every Nth Number of Points") + layout.operator("curve.select_nth", text=_("Every Nth Number of Points")) layout.separator() @@ -588,10 +589,10 @@ class VIEW3D_MT_select_edit_surface(Menu): layout.separator() - layout.operator("curve.select_all", text="Select/Deselect All") + layout.operator("curve.select_all", text=_("Select/Deselect All")) layout.operator("curve.select_inverse") layout.operator("curve.select_random") - layout.operator("curve.select_nth", text="Every Nth Number of Points") + layout.operator("curve.select_nth", text=_("Every Nth Number of Points")) layout.separator() @@ -631,7 +632,7 @@ class VIEW3D_MT_select_edit_lattice(Menu): layout.separator() - layout.operator("lattice.select_all", text="Select/Deselect All") + layout.operator("lattice.select_all", text=_("Select/Deselect All")) class VIEW3D_MT_select_edit_armature(Menu): @@ -644,25 +645,25 @@ class VIEW3D_MT_select_edit_armature(Menu): layout.separator() - layout.operator("armature.select_all", text="Select/Deselect All") - layout.operator("armature.select_inverse", text="Inverse") + layout.operator("armature.select_all", text=_("Select/Deselect All")) + layout.operator("armature.select_inverse", text=_("Inverse")) layout.separator() - layout.operator("armature.select_hierarchy", text="Parent").direction = 'PARENT' - layout.operator("armature.select_hierarchy", text="Child").direction = 'CHILD' + layout.operator("armature.select_hierarchy", text=_("Parent")).direction = 'PARENT' + layout.operator("armature.select_hierarchy", text=_("Child")).direction = 'CHILD' layout.separator() - props = layout.operator("armature.select_hierarchy", text="Extend Parent") + props = layout.operator("armature.select_hierarchy", text=_("Extend Parent")) props.extend = True props.direction = 'PARENT' - props = layout.operator("armature.select_hierarchy", text="Extend Child") + props = layout.operator("armature.select_hierarchy", text=_("Extend Child")) props.extend = True props.direction = 'CHILD' - layout.operator("object.select_pattern", text="Select Pattern...") + layout.operator("object.select_pattern", text=_("Select Pattern...")) class VIEW3D_MT_select_face(Menu): # XXX no matching enum @@ -705,11 +706,11 @@ class VIEW3D_MT_object(Menu): layout.operator("object.duplicate_move") layout.operator("object.duplicate_move_linked") - layout.operator("object.delete", text="Delete...") - layout.operator("object.proxy_make", text="Make Proxy...") - layout.menu("VIEW3D_MT_make_links", text="Make Links...") + layout.operator("object.delete", text=_("Delete...")) + layout.operator("object.proxy_make", text=_("Make Proxy...")) + layout.menu("VIEW3D_MT_make_links", text=_("Make Links...")) layout.operator("object.make_dupli_face") - layout.operator_menu_enum("object.make_local", "type", text="Make Local...") + layout.operator_menu_enum("object.make_local", "type", text=_("Make Local...")) layout.menu("VIEW3D_MT_make_single_user") layout.separator() @@ -730,7 +731,7 @@ class VIEW3D_MT_object(Menu): layout.separator() - layout.operator("object.move_to_layer", text="Move to Layer...") + layout.operator("object.move_to_layer", text=_("Move to Layer...")) layout.menu("VIEW3D_MT_object_showhide") layout.operator_menu_enum("object.convert", "target") @@ -742,9 +743,9 @@ class VIEW3D_MT_object_animation(Menu): def draw(self, context): layout = self.layout - layout.operator("anim.keyframe_insert_menu", text="Insert Keyframe...") - layout.operator("anim.keyframe_delete_v3d", text="Delete Keyframe...") - layout.operator("anim.keying_set_active_set", text="Change Keying Set...") + layout.operator("anim.keyframe_insert_menu", text=_("Insert Keyframe...")) + layout.operator("anim.keyframe_delete_v3d", text=_("Delete Keyframe...")) + layout.operator("anim.keying_set_active_set", text=_("Change Keying Set...")) class VIEW3D_MT_object_clear(Menu): @@ -753,10 +754,10 @@ class VIEW3D_MT_object_clear(Menu): def draw(self, context): layout = self.layout - layout.operator("object.location_clear", text="Location") - layout.operator("object.rotation_clear", text="Rotation") - layout.operator("object.scale_clear", text="Scale") - layout.operator("object.origin_clear", text="Origin") + layout.operator("object.location_clear", text=_("Location")) + layout.operator("object.rotation_clear", text=_("Rotation")) + layout.operator("object.scale_clear", text=_("Scale")) + layout.operator("object.origin_clear", text=_("Origin")) class VIEW3D_MT_object_specials(Menu): @@ -775,19 +776,19 @@ class VIEW3D_MT_object_specials(Menu): layout.operator_context = 'INVOKE_REGION_WIN' if obj.data.type == 'PERSP': - props = layout.operator("wm.context_modal_mouse", text="Camera Lens Angle") + props = layout.operator("wm.context_modal_mouse", text=_("Camera Lens Angle")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.lens" props.input_scale = 0.1 else: - props = layout.operator("wm.context_modal_mouse", text="Camera Lens Scale") + props = layout.operator("wm.context_modal_mouse", text=_("Camera Lens Scale")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.ortho_scale" props.input_scale = 0.01 if not obj.data.dof_object: #layout.label(text="Test Has DOF obj"); - props = layout.operator("wm.context_modal_mouse", text="DOF Distance") + props = layout.operator("wm.context_modal_mouse", text=_("DOF Distance")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.dof_distance" props.input_scale = 0.02 @@ -795,12 +796,12 @@ class VIEW3D_MT_object_specials(Menu): if obj.type in {'CURVE', 'FONT'}: layout.operator_context = 'INVOKE_REGION_WIN' - props = layout.operator("wm.context_modal_mouse", text="Extrude Size") + props = layout.operator("wm.context_modal_mouse", text=_("Extrude Size")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.extrude" props.input_scale = 0.01 - props = layout.operator("wm.context_modal_mouse", text="Width Size") + props = layout.operator("wm.context_modal_mouse", text=_("Width Size")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.offset" props.input_scale = 0.01 @@ -808,7 +809,7 @@ class VIEW3D_MT_object_specials(Menu): if obj.type == 'EMPTY': layout.operator_context = 'INVOKE_REGION_WIN' - props = layout.operator("wm.context_modal_mouse", text="Empty Draw Size") + props = layout.operator("wm.context_modal_mouse", text=_("Empty Draw Size")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "empty_draw_size" props.input_scale = 0.01 @@ -816,34 +817,34 @@ class VIEW3D_MT_object_specials(Menu): if obj.type == 'LAMP': layout.operator_context = 'INVOKE_REGION_WIN' - props = layout.operator("wm.context_modal_mouse", text="Energy") + props = layout.operator("wm.context_modal_mouse", text=_("Energy")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.energy" if obj.data.type in {'SPOT', 'AREA', 'POINT'}: - props = layout.operator("wm.context_modal_mouse", text="Falloff Distance") + props = layout.operator("wm.context_modal_mouse", text=_("Falloff Distance")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.distance" props.input_scale = 0.1 if obj.data.type == 'SPOT': layout.separator() - props = layout.operator("wm.context_modal_mouse", text="Spot Size") + props = layout.operator("wm.context_modal_mouse", text=_("Spot Size")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.spot_size" props.input_scale = 0.01 - props = layout.operator("wm.context_modal_mouse", text="Spot Blend") + props = layout.operator("wm.context_modal_mouse", text=_("Spot Blend")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.spot_blend" props.input_scale = -0.01 - props = layout.operator("wm.context_modal_mouse", text="Clip Start") + props = layout.operator("wm.context_modal_mouse", text=_("Clip Start")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.shadow_buffer_clip_start" props.input_scale = 0.05 - props = layout.operator("wm.context_modal_mouse", text="Clip End") + props = layout.operator("wm.context_modal_mouse", text=_("Clip End")) props.data_path_iter = "selected_editable_objects" props.data_path_item = "data.shadow_buffer_clip_end" props.input_scale = 0.05 @@ -860,16 +861,16 @@ class VIEW3D_MT_object_apply(Menu): def draw(self, context): layout = self.layout - layout.operator("object.transform_apply", text="Location").location = True - layout.operator("object.transform_apply", text="Rotation").rotation = True - layout.operator("object.transform_apply", text="Scale").scale = True - props = layout.operator("object.transform_apply", text="Rotation & Scale") + layout.operator("object.transform_apply", text=_("Location")).location = True + layout.operator("object.transform_apply", text=_("Rotation")).rotation = True + layout.operator("object.transform_apply", text=_("Scale")).scale = True + props = layout.operator("object.transform_apply", text=_("Rotation & Scale")) props.scale = True props.rotation = True layout.separator() - layout.operator("object.visual_transform_apply", text="Visual Transform") + layout.operator("object.visual_transform_apply", text=_("Visual Transform")) layout.operator("object.duplicates_make_real") @@ -879,8 +880,8 @@ class VIEW3D_MT_object_parent(Menu): def draw(self, context): layout = self.layout - layout.operator("object.parent_set", text="Set") - layout.operator("object.parent_clear", text="Clear") + layout.operator("object.parent_set", text=_("Set")) + layout.operator("object.parent_clear", text=_("Clear")) class VIEW3D_MT_object_track(Menu): @@ -889,8 +890,8 @@ class VIEW3D_MT_object_track(Menu): def draw(self, context): layout = self.layout - layout.operator("object.track_set", text="Set") - layout.operator("object.track_clear", text="Clear") + layout.operator("object.track_set", text=_("Set")) + layout.operator("object.track_clear", text=_("Clear")) class VIEW3D_MT_object_group(Menu): @@ -925,9 +926,9 @@ class VIEW3D_MT_object_showhide(Menu): def draw(self, context): layout = self.layout - layout.operator("object.hide_view_clear", text="Show Hidden") - layout.operator("object.hide_view_set", text="Hide Selected") - layout.operator("object.hide_view_set", text="Hide Unselected").unselected = True + layout.operator("object.hide_view_clear", text=_("Show Hidden")) + layout.operator("object.hide_view_set", text=_("Hide Selected")) + layout.operator("object.hide_view_set", text=_("Hide Unselected")).unselected = True class VIEW3D_MT_make_single_user(Menu): @@ -936,19 +937,19 @@ class VIEW3D_MT_make_single_user(Menu): def draw(self, context): layout = self.layout - props = layout.operator("object.make_single_user", text="Object") + props = layout.operator("object.make_single_user", text=_("Object")) props.object = True - props = layout.operator("object.make_single_user", text="Object & Data") + props = layout.operator("object.make_single_user", text=_("Object & Data")) props.object = props.obdata = True - props = layout.operator("object.make_single_user", text="Object & Data & Materials+Tex") + props = layout.operator("object.make_single_user", text=_("Object & Data & Materials+Tex")) props.object = props.obdata = props.material = props.texture = True - props = layout.operator("object.make_single_user", text="Materials+Tex") + props = layout.operator("object.make_single_user", text=_("Materials+Tex")) props.material = props.texture = True - props = layout.operator("object.make_single_user", text="Object Animation") + props = layout.operator("object.make_single_user", text=_("Object Animation")) props.animation = True @@ -960,11 +961,11 @@ class VIEW3D_MT_make_links(Menu): if(len(bpy.data.scenes) > 10): layout.operator_context = 'INVOKE_DEFAULT' - layout.operator("object.make_links_scene", text="Objects to Scene...", icon='OUTLINER_OB_EMPTY') - layout.operator("object.make_links_scene", text="Markers to Scene...", icon='OUTLINER_OB_EMPTY') + layout.operator("object.make_links_scene", text=_("Objects to Scene..."), icon='OUTLINER_OB_EMPTY') + layout.operator("object.make_links_scene", text=_("Markers to Scene..."), icon='OUTLINER_OB_EMPTY') else: - layout.operator_menu_enum("object.make_links_scene", "scene", text="Objects to Scene...") - layout.operator_menu_enum("marker.make_links_scene", "scene", text="Markers to Scene...") + layout.operator_menu_enum("object.make_links_scene", "scene", text=_("Objects to Scene...")) + layout.operator_menu_enum("marker.make_links_scene", "scene", text=_("Markers to Scene...")) layout.operator_enum("object.make_links_data", "type") # inline @@ -975,13 +976,13 @@ class VIEW3D_MT_object_game(Menu): def draw(self, context): layout = self.layout - layout.operator("object.logic_bricks_copy", text="Copy Logic Bricks") + layout.operator("object.logic_bricks_copy", text=_("Copy Logic Bricks")) layout.separator() - layout.operator("object.game_property_copy", text="Replace Properties").operation = 'REPLACE' - layout.operator("object.game_property_copy", text="Merge Properties").operation = 'MERGE' - layout.operator_menu_enum("object.game_property_copy", "property", text="Copy Properties...") + layout.operator("object.game_property_copy", text=_("Replace Properties")).operation = 'REPLACE' + layout.operator("object.game_property_copy", text=_("Merge Properties")).operation = 'MERGE' + layout.operator_menu_enum("object.game_property_copy", "property", text=_("Copy Properties...")) layout.separator() @@ -1031,21 +1032,21 @@ class VIEW3D_MT_vertex_group(Menu): def draw(self, context): layout = self.layout layout.operator_context = 'EXEC_AREA' - layout.operator("object.vertex_group_assign", text="Assign to New Group").new = True + layout.operator("object.vertex_group_assign", text=_("Assign to New Group")).new = True ob = context.active_object if ob.mode == 'EDIT': if ob.vertex_groups.active: layout.separator() - layout.operator("object.vertex_group_assign", text="Assign to Active Group") - layout.operator("object.vertex_group_remove_from", text="Remove from Active Group") - layout.operator("object.vertex_group_remove_from", text="Remove from All").all = True + layout.operator("object.vertex_group_assign", text=_("Assign to Active Group")) + layout.operator("object.vertex_group_remove_from", text=_("Remove from Active Group")) + layout.operator("object.vertex_group_remove_from", text=_("Remove from All")).all = True layout.separator() if ob.vertex_groups.active: - layout.operator_menu_enum("object.vertex_group_set_active", "group", text="Set Active Group") - layout.operator("object.vertex_group_remove", text="Remove Active Group") - layout.operator("object.vertex_group_remove", text="Remove All Groups").all = True + layout.operator_menu_enum("object.vertex_group_set_active", "group", text=_("Set Active Group")) + layout.operator("object.vertex_group_remove", text=_("Remove Active Group")) + layout.operator("object.vertex_group_remove", text=_("Remove All Groups")).all = True # ********** Weight paint menu ********** @@ -1062,16 +1063,16 @@ class VIEW3D_MT_paint_weight(Menu): layout.separator() - layout.operator("paint.weight_from_bones", text="Assign Automatic From Bones").type = 'AUTOMATIC' - layout.operator("paint.weight_from_bones", text="Assign From Bone Envelopes").type = 'ENVELOPES' + layout.operator("paint.weight_from_bones", text=_("Assign Automatic From Bones")).type = 'AUTOMATIC' + layout.operator("paint.weight_from_bones", text=_("Assign From Bone Envelopes")).type = 'ENVELOPES' layout.separator() - layout.operator("object.vertex_group_normalize_all", text="Normalize All") - layout.operator("object.vertex_group_normalize", text="Normalize") - layout.operator("object.vertex_group_invert", text="Invert") - layout.operator("object.vertex_group_clean", text="Clean") - layout.operator("object.vertex_group_levels", text="Levels") + layout.operator("object.vertex_group_normalize_all", text=_("Normalize All")) + layout.operator("object.vertex_group_normalize", text=_("Normalize")) + layout.operator("object.vertex_group_invert", text=_("Invert")) + layout.operator("object.vertex_group_clean", text=_("Clean")) + layout.operator("object.vertex_group_levels", text=_("Levels")) layout.operator("object.vertex_group_fix", text="Fix Deforms") layout.separator() @@ -1121,12 +1122,12 @@ class VIEW3D_MT_sculpt(Menu): layout.operator("sculpt.set_persistent_base") layout.separator() - layout.prop(sculpt, "use_threaded", text="Threaded Sculpt") + layout.prop(sculpt, "use_threaded", text=_("Threaded Sculpt")) layout.prop(sculpt, "show_brush") # TODO, make availabel from paint menu! - layout.prop(tool_settings, "sculpt_paint_use_unified_size", text="Unify Size") - layout.prop(tool_settings, "sculpt_paint_use_unified_strength", text="Unify Strength") + layout.prop(tool_settings, "sculpt_paint_use_unified_size", text=_("Unify Size")) + layout.prop(tool_settings, "sculpt_paint_use_unified_strength", text=_("Unify Strength")) # ********** Particle menu ********** @@ -1219,7 +1220,7 @@ class VIEW3D_MT_pose(Menu): layout.operator("pose.copy") layout.operator("pose.paste") - layout.operator("pose.paste", text="Paste X-Flipped Pose").flipped = True + layout.operator("pose.paste", text=_("Paste X-Flipped Pose")).flipped = True layout.separator() @@ -1236,9 +1237,9 @@ class VIEW3D_MT_pose(Menu): layout.separator() layout.operator_context = 'EXEC_AREA' - layout.operator("pose.autoside_names", text="AutoName Left/Right").axis = 'XAXIS' - layout.operator("pose.autoside_names", text="AutoName Front/Back").axis = 'YAXIS' - layout.operator("pose.autoside_names", text="AutoName Top/Bottom").axis = 'ZAXIS' + layout.operator("pose.autoside_names", text=_("AutoName Left/Right")).axis = 'XAXIS' + layout.operator("pose.autoside_names", text=_("AutoName Front/Back")).axis = 'YAXIS' + layout.operator("pose.autoside_names", text=_("AutoName Top/Bottom")).axis = 'ZAXIS' layout.operator("pose.flip_names") @@ -1247,13 +1248,13 @@ class VIEW3D_MT_pose(Menu): layout.separator() layout.operator_context = 'INVOKE_AREA' - layout.operator("pose.armature_layers", text="Change Armature Layers...") - layout.operator("pose.bone_layers", text="Change Bone Layers...") + layout.operator("pose.armature_layers", text=_("Change Armature Layers...")) + layout.operator("pose.bone_layers", text=_("Change Bone Layers...")) layout.separator() layout.menu("VIEW3D_MT_pose_showhide") - layout.menu("VIEW3D_MT_bone_options_toggle", text="Bone Settings") + layout.menu("VIEW3D_MT_bone_options_toggle", text=_("Bone Settings")) class VIEW3D_MT_pose_transform(Menu): @@ -1262,17 +1263,17 @@ class VIEW3D_MT_pose_transform(Menu): def draw(self, context): layout = self.layout - layout.operator("pose.transforms_clear", text="All") + layout.operator("pose.transforms_clear", text=_("All")) layout.separator() - layout.operator("pose.loc_clear", text="Location") - layout.operator("pose.rot_clear", text="Rotation") - layout.operator("pose.scale_clear", text="Scale") + layout.operator("pose.loc_clear", text=_("Location")) + layout.operator("pose.rot_clear", text=_("Rotation")) + layout.operator("pose.scale_clear", text=_("Scale")) layout.separator() - layout.operator("pose.user_transforms_clear", text="Reset unkeyed") + layout.operator("pose.user_transforms_clear", text=_("Reset unkeyed")) class VIEW3D_MT_pose_slide(Menu): @@ -1296,12 +1297,12 @@ class VIEW3D_MT_pose_propagate(Menu): layout.separator() - layout.operator("pose.propagate", text="To Next Keyframe").mode = 'NEXT_KEY' - layout.operator("pose.propagate", text="To Last Keyframe (Make Cyclic)").mode = 'LAST_KEY' + layout.operator("pose.propagate", text=_("To Next Keyframe")).mode = 'NEXT_KEY' + layout.operator("pose.propagate", text=_("To Last Keyframe (Make Cyclic)")).mode = 'LAST_KEY' layout.separator() - layout.operator("pose.propagate", text="On Selected Markers").mode = 'SELECTED_MARKERS' + layout.operator("pose.propagate", text=_("On Selected Markers")).mode = 'SELECTED_MARKERS' class VIEW3D_MT_pose_library(Menu): @@ -1310,13 +1311,13 @@ class VIEW3D_MT_pose_library(Menu): def draw(self, context): layout = self.layout - layout.operator("poselib.browse_interactive", text="Browse Poses...") + layout.operator("poselib.browse_interactive", text=_("Browse Poses...")) layout.separator() - layout.operator("poselib.pose_add", text="Add Pose...") - layout.operator("poselib.pose_rename", text="Rename Pose...") - layout.operator("poselib.pose_remove", text="Remove Pose...") + layout.operator("poselib.pose_add", text=_("Add Pose...")) + layout.operator("poselib.pose_rename", text=_("Rename Pose...")) + layout.operator("poselib.pose_remove", text=_("Remove Pose...")) class VIEW3D_MT_pose_motion(Menu): @@ -1325,8 +1326,8 @@ class VIEW3D_MT_pose_motion(Menu): def draw(self, context): layout = self.layout - layout.operator("pose.paths_calculate", text="Calculate") - layout.operator("pose.paths_clear", text="Clear") + layout.operator("pose.paths_calculate", text=_("Calculate")) + layout.operator("pose.paths_clear", text=_("Clear")) class VIEW3D_MT_pose_group(Menu): @@ -1359,7 +1360,7 @@ class VIEW3D_MT_pose_constraints(Menu): def draw(self, context): layout = self.layout - layout.operator("pose.constraint_add_with_targets", text="Add (With Targets)...") + layout.operator("pose.constraint_add_with_targets", text=_("Add (With Targets)...")) layout.operator("pose.constraints_copy") layout.operator("pose.constraints_clear") @@ -1369,7 +1370,7 @@ class VIEW3D_MT_pose_showhide(ShowHideMenu, Menu): class VIEW3D_MT_pose_apply(Menu): - bl_label = "Apply" + bl_label = _("Apply") def draw(self, context): layout = self.layout @@ -1444,14 +1445,14 @@ class VIEW3D_MT_edit_mesh(Menu): layout.separator() - layout.menu("VIEW3D_MT_uv_map", text="UV Unwrap...") + layout.menu("VIEW3D_MT_uv_map", text=_("UV Unwrap...")) layout.separator() - layout.operator("view3d.edit_mesh_extrude_move_normal", text="Extrude Region") - layout.operator("view3d.edit_mesh_extrude_individual_move", text="Extrude Individual") + layout.operator("view3d.edit_mesh_extrude_move_normal", text=_("Extrude Region")) + layout.operator("view3d.edit_mesh_extrude_individual_move", text=_("Extrude Individual")) layout.operator("mesh.duplicate_move") - layout.operator("mesh.delete", text="Delete...") + layout.operator("mesh.delete", text=_("Delete...")) layout.separator() @@ -1479,15 +1480,15 @@ class VIEW3D_MT_edit_mesh_specials(Menu): layout.operator_context = 'INVOKE_REGION_WIN' - layout.operator("mesh.subdivide", text="Subdivide") - layout.operator("mesh.subdivide", text="Subdivide Smooth").smoothness = 1.0 - layout.operator("mesh.merge", text="Merge...") + layout.operator("mesh.subdivide", text=_("Subdivide")) + layout.operator("mesh.subdivide", text=_("Subdivide Smooth")).smoothness = 1.0 + layout.operator("mesh.merge", text=_("Merge...")) layout.operator("mesh.remove_doubles") - layout.operator("mesh.hide", text="Hide") - layout.operator("mesh.reveal", text="Reveal") + layout.operator("mesh.hide", text=_("Hide")) + layout.operator("mesh.reveal", text=_("Reveal")) layout.operator("mesh.select_inverse") layout.operator("mesh.flip_normals") - layout.operator("mesh.vertices_smooth", text="Smooth") + layout.operator("mesh.vertices_smooth", text=_("Smooth")) # layout.operator("mesh.bevel", text="Bevel") layout.operator("mesh.faces_shade_smooth") layout.operator("mesh.faces_shade_flat") @@ -1504,15 +1505,15 @@ class VIEW3D_MT_edit_mesh_select_mode(Menu): layout.operator_context = 'INVOKE_REGION_WIN' - 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" @@ -1521,10 +1522,10 @@ class VIEW3D_MT_edit_mesh_extrude(Menu): bl_label = "Extrude" _extrude_funcs = { \ - "VERT": lambda layout: layout.operator("mesh.extrude_vertices_move", text="Vertices Only"), - "EDGE": lambda layout: layout.operator("mesh.extrude_edges_move", text="Edges Only"), - "FACE": lambda layout: layout.operator("mesh.extrude_faces_move", text="Individual Faces"), - "REGION": lambda layout: layout.operator("view3d.edit_mesh_extrude_move_normal", text="Region"), + "VERT": lambda layout: layout.operator("mesh.extrude_vertices_move", text=_("Vertices Only")), + "EDGE": lambda layout: layout.operator("mesh.extrude_edges_move", text=_("Edges Only")), + "FACE": lambda layout: layout.operator("mesh.extrude_faces_move", text=_("Individual Faces")), + "REGION": lambda layout: layout.operator("view3d.edit_mesh_extrude_move_normal", text=_("Region")), } @staticmethod @@ -1651,28 +1652,28 @@ class VIEW3D_MT_edit_mesh_edges(Menu): layout.separator() layout.operator("mesh.mark_seam") - layout.operator("mesh.mark_seam", text="Clear Seam").clear = True + layout.operator("mesh.mark_seam", text=_("Clear Seam")).clear = True layout.separator() layout.operator("mesh.mark_sharp") - layout.operator("mesh.mark_sharp", text="Clear Sharp").clear = True + layout.operator("mesh.mark_sharp", text=_("Clear Sharp")).clear = True layout.separator() - layout.operator("mesh.edge_rotate", text="Rotate Edge CW").direction = 'CW' - layout.operator("mesh.edge_rotate", text="Rotate Edge CCW").direction = 'CCW' + layout.operator("mesh.edge_rotate", text=_("Rotate Edge CW")).direction = 'CW' + layout.operator("mesh.edge_rotate", text=_("Rotate Edge CCW")).direction = 'CCW' layout.separator() layout.operator("TRANSFORM_OT_edge_slide") layout.operator("TRANSFORM_OT_edge_crease") - layout.operator("mesh.loop_multi_select", text="Edge Loop") + layout.operator("mesh.loop_multi_select", text=_("Edge Loop")) # uiItemO(layout, "Loopcut", 0, "mesh.loop_cut"); // CutEdgeloop(em, 1); # uiItemO(layout, "Edge Slide", 0, "mesh.edge_slide"); // EdgeSlide(em, 0,0.0); - layout.operator("mesh.loop_multi_select", text="Edge Ring").ring = True + layout.operator("mesh.loop_multi_select", text=_("Edge Ring")).ring = True layout.operator("mesh.loop_to_region") layout.operator("mesh.region_to_loop") @@ -1716,7 +1717,7 @@ class VIEW3D_MT_edit_mesh_faces(Menu): # uiItemO(layout, NULL, 0, "mesh.face_mode"); // mesh_set_face_flags(em, 1); # uiItemBooleanO(layout, NULL, 0, "mesh.face_mode", "clear", 1); // mesh_set_face_flags(em, 0); - layout.operator("mesh.edge_rotate", text="Rotate Edge CW").direction = 'CW' + layout.operator("mesh.edge_rotate", text=_("Rotate Edge CW")).direction = 'CW' layout.separator() @@ -1732,8 +1733,8 @@ class VIEW3D_MT_edit_mesh_normals(Menu): def draw(self, context): layout = self.layout - layout.operator("mesh.normals_make_consistent", text="Recalculate Outside") - layout.operator("mesh.normals_make_consistent", text="Recalculate Inside").inside = True + layout.operator("mesh.normals_make_consistent", text=_("Recalculate Outside")) + layout.operator("mesh.normals_make_consistent", text=_("Recalculate Inside")).inside = True layout.separator() @@ -1763,7 +1764,7 @@ def draw_curve(self, context): layout.operator("curve.separate") layout.operator("curve.make_segment") layout.operator("curve.cyclic_toggle") - layout.operator("curve.delete", text="Delete...") + layout.operator("curve.delete", text=_("Delete...")) layout.separator() @@ -1795,7 +1796,7 @@ class VIEW3D_MT_edit_curve_ctrlpoints(Menu): edit_object = context.edit_object if edit_object.type == 'CURVE': - layout.operator("transform.transform", text="Tilt").mode = 'TILT' + layout.operator("transform.transform", text=_("Tilt")).mode = 'TILT' layout.operator("curve.tilt_clear") layout.operator("curve.separate") @@ -1856,10 +1857,10 @@ class VIEW3D_MT_edit_font(Menu): layout.separator() - layout.operator("font.style_toggle", text="Toggle Bold").style = 'BOLD' - layout.operator("font.style_toggle", text="Toggle Italic").style = 'ITALIC' - layout.operator("font.style_toggle", text="Toggle Underline").style = 'UNDERLINE' - layout.operator("font.style_toggle", text="Toggle Small Caps").style = 'SMALL_CAPS' + layout.operator("font.style_toggle", text=_("Toggle Bold")).style = 'BOLD' + layout.operator("font.style_toggle", text=_("Toggle Italic")).style = 'ITALIC' + layout.operator("font.style_toggle", text=_("Toggle Underline")).style = 'UNDERLINE' + layout.operator("font.style_toggle", text=_("Toggle Small Caps")).style = 'SMALL_CAPS' class VIEW3D_MT_edit_text_chars(Menu): @@ -1916,7 +1917,7 @@ class VIEW3D_MT_edit_meta(Menu): layout.separator() - layout.operator("mball.delete_metaelems", text="Delete...") + layout.operator("mball.delete_metaelems", text=_("Delete...")) layout.operator("mball.duplicate_metaelems") layout.separator() @@ -1935,9 +1936,9 @@ class VIEW3D_MT_edit_meta_showhide(Menu): def draw(self, context): layout = self.layout - layout.operator("mball.reveal_metaelems", text="Show Hidden") - layout.operator("mball.hide_metaelems", text="Hide Selected") - layout.operator("mball.hide_metaelems", text="Hide Unselected").unselected = True + layout.operator("mball.reveal_metaelems", text=_("Show Hidden")) + layout.operator("mball.hide_metaelems", text=_("Hide Selected")) + layout.operator("mball.hide_metaelems", text=_("Hide Unselected")).unselected = True class VIEW3D_MT_edit_lattice(Menu): @@ -1991,15 +1992,15 @@ class VIEW3D_MT_edit_armature(Menu): layout.separator() - layout.operator("armature.subdivide", text="Subdivide") - layout.operator("armature.switch_direction", text="Switch Direction") + layout.operator("armature.subdivide", text=_("Subdivide")) + layout.operator("armature.switch_direction", text=_("Switch Direction")) layout.separator() layout.operator_context = 'EXEC_AREA' - layout.operator("armature.autoside_names", text="AutoName Left/Right").type = 'XAXIS' - layout.operator("armature.autoside_names", text="AutoName Front/Back").type = 'YAXIS' - layout.operator("armature.autoside_names", text="AutoName Top/Bottom").type = 'ZAXIS' + layout.operator("armature.autoside_names", text=_("AutoName Left/Right")).type = 'XAXIS' + layout.operator("armature.autoside_names", text=_("AutoName Front/Back")).type = 'YAXIS' + layout.operator("armature.autoside_names", text=_("AutoName Top/Bottom")).type = 'ZAXIS' layout.operator("armature.flip_names") layout.separator() @@ -2014,7 +2015,7 @@ class VIEW3D_MT_edit_armature(Menu): layout.separator() - layout.menu("VIEW3D_MT_bone_options_toggle", text="Bone Settings") + layout.menu("VIEW3D_MT_bone_options_toggle", text=_("Bone Settings")) class VIEW3D_MT_armature_specials(Menu): @@ -2025,16 +2026,16 @@ class VIEW3D_MT_armature_specials(Menu): layout.operator_context = 'INVOKE_REGION_WIN' - layout.operator("armature.subdivide", text="Subdivide") - layout.operator("armature.switch_direction", text="Switch Direction") + layout.operator("armature.subdivide", text=_("Subdivide")) + layout.operator("armature.switch_direction", text=_("Switch Direction")) layout.separator() layout.operator_context = 'EXEC_REGION_WIN' - layout.operator("armature.autoside_names", text="AutoName Left/Right").type = 'XAXIS' - layout.operator("armature.autoside_names", text="AutoName Front/Back").type = 'YAXIS' - layout.operator("armature.autoside_names", text="AutoName Top/Bottom").type = 'ZAXIS' - layout.operator("armature.flip_names", text="Flip Names") + layout.operator("armature.autoside_names", text=_("AutoName Left/Right")).type = 'XAXIS' + layout.operator("armature.autoside_names", text=_("AutoName Front/Back")).type = 'YAXIS' + layout.operator("armature.autoside_names", text=_("AutoName Top/Bottom")).type = 'ZAXIS' + layout.operator("armature.flip_names", text=_("Flip Names")) class VIEW3D_MT_edit_armature_parent(Menu): @@ -2043,8 +2044,8 @@ class VIEW3D_MT_edit_armature_parent(Menu): def draw(self, context): layout = self.layout - layout.operator("armature.parent_set", text="Make") - layout.operator("armature.parent_clear", text="Clear") + layout.operator("armature.parent_set", text=_("Make")) + layout.operator("armature.parent_clear", text=_("Clear")) class VIEW3D_MT_edit_armature_roll(Menu): @@ -2057,7 +2058,7 @@ class VIEW3D_MT_edit_armature_roll(Menu): layout.separator() - layout.operator("transform.transform", text="Set Roll").mode = 'BONE_ROLL' + layout.operator("transform.transform", text=_("Set Roll")).mode = 'BONE_ROLL' # ********** Panel ********** @@ -2080,26 +2081,26 @@ class VIEW3D_PT_view3d_properties(Panel): col = layout.column() col.active = view.region_3d.view_perspective != 'CAMERA' col.prop(view, "lens") - col.label(text="Lock to Object:") + col.label(text=_("Lock to Object:")) col.prop(view, "lock_object", text="") lock_object = view.lock_object if lock_object: if lock_object.type == 'ARMATURE': col.prop_search(view, "lock_bone", lock_object.data, "edit_bones" if lock_object.mode == 'EDIT' else "bones", text="") else: - col.prop(view, "lock_cursor", text="Lock to Cursor") + col.prop(view, "lock_cursor", text=_("Lock to Cursor")) col = layout.column() col.prop(view, "lock_camera") col = layout.column(align=True) - col.label(text="Clip:") - col.prop(view, "clip_start", text="Start") - col.prop(view, "clip_end", text="End") + col.label(text=_("Clip:")) + col.prop(view, "clip_start", text=_("Start")) + col.prop(view, "clip_end", text=_("End")) subcol = col.column() subcol.enabled = not view.lock_camera_and_layers - subcol.label(text="Local Camera:") + subcol.label(text=_("Local Camera:")) subcol.prop(view, "camera", text="") layout.column().prop(view, "cursor_location") @@ -2165,7 +2166,7 @@ class VIEW3D_PT_view3d_display(Panel): col = layout.column() col.active = display_all split = col.split(percentage=0.55) - split.prop(view, "show_floor", text="Grid Floor") + split.prop(view, "show_floor", text=_("Grid Floor")) row = split.row(align=True) row.prop(view, "show_axis_x", text="X", toggle=True) @@ -2174,14 +2175,14 @@ class VIEW3D_PT_view3d_display(Panel): sub = col.column(align=True) sub.active = (display_all and view.show_floor) - sub.prop(view, "grid_lines", text="Lines") - sub.prop(view, "grid_scale", text="Scale") + sub.prop(view, "grid_lines", text=_("Lines")) + sub.prop(view, "grid_scale", text=_("Scale")) subsub = sub.column(align=True) subsub.active = scene.unit_settings.system == 'NONE' - subsub.prop(view, "grid_subdivisions", text="Subdivisions") + subsub.prop(view, "grid_subdivisions", text=_("Subdivisions")) col = layout.column() - col.label(text="Shading:") + col.label(text=_("Shading:")) col.prop(gs, "material_mode", text="") col.prop(view, "show_textured_solid") @@ -2189,7 +2190,7 @@ class VIEW3D_PT_view3d_display(Panel): region = view.region_quadview - layout.operator("screen.region_quadview", text="Toggle Quad View") + layout.operator("screen.region_quadview", text=_("Toggle Quad View")) if region: col = layout.column() @@ -2218,22 +2219,22 @@ class VIEW3D_PT_view3d_meshdisplay(Panel): mesh = context.active_object.data col = layout.column() - col.label(text="Overlays:") - col.prop(mesh, "show_edges", text="Edges") - col.prop(mesh, "show_faces", text="Faces") - col.prop(mesh, "show_edge_crease", text="Creases") - col.prop(mesh, "show_edge_bevel_weight", text="Bevel Weights") - col.prop(mesh, "show_edge_seams", text="Seams") - col.prop(mesh, "show_edge_sharp", text="Sharp") + col.label(text=_("Overlays:")) + col.prop(mesh, "show_edges", text=_("Edges")) + col.prop(mesh, "show_faces", text=_("Faces")) + col.prop(mesh, "show_edge_crease", text=_("Creases")) + col.prop(mesh, "show_edge_bevel_weight", text=_("Bevel Weights")) + col.prop(mesh, "show_edge_seams", text=_("Seams")) + col.prop(mesh, "show_edge_sharp", text=_("Sharp")) col.separator() - col.label(text="Normals:") - col.prop(mesh, "show_normal_face", text="Face") - col.prop(mesh, "show_normal_vertex", text="Vertex") - col.prop(context.scene.tool_settings, "normal_size", text="Normal Size") + col.label(text=_("Normals:")) + col.prop(mesh, "show_normal_face", text=_("Face")) + col.prop(mesh, "show_normal_vertex", text=_("Vertex")) + col.prop(context.scene.tool_settings, "normal_size", text=_("Normal Size")) col.separator() - col.label(text="Numerics:") + col.label(text=_("Numerics:")) col.prop(mesh, "show_extra_edge_length") col.prop(mesh, "show_extra_face_angle") col.prop(mesh, "show_extra_face_area") @@ -2255,10 +2256,10 @@ class VIEW3D_PT_view3d_curvedisplay(Panel): curve = context.active_object.data col = layout.column() - col.label(text="Overlays:") - col.prop(curve, "show_handles", text="Handles") - col.prop(curve, "show_normal_face", text="Normals") - col.prop(context.scene.tool_settings, "normal_size", text="Normal Size") + col.label(text=_("Overlays:")) + col.prop(curve, "show_handles", text=_("Handles")) + col.prop(curve, "show_normal_face", text=_("Normals")) + col.prop(context.scene.tool_settings, "normal_size", text=_("Normal Size")) class VIEW3D_PT_background_image(Panel): @@ -2285,7 +2286,7 @@ class VIEW3D_PT_background_image(Panel): view = context.space_data col = layout.column() - col.operator("view3d.background_image_add", text="Add Image") + col.operator("view3d.background_image_add", text=_("Add Image")) for i, bg in enumerate(view.background_images): layout.active = view.show_background_images @@ -2295,10 +2296,10 @@ class VIEW3D_PT_background_image(Panel): if bg.image: row.prop(bg.image, "name", text="", emboss=False) else: - row.label(text="Not Set") + row.label(text=_("Not Set")) row.operator("view3d.background_image_remove", text="", emboss=False, icon='X').index = i - box.prop(bg, "view_axis", text="Axis") + box.prop(bg, "view_axis", text=_("Axis")) if bg.show_expanded: row = box.row() @@ -2333,13 +2334,13 @@ class VIEW3D_PT_transform_orientations(Panel): col = layout.column() col.prop(view, "transform_orientation") - col.operator("transform.create_orientation", text="Create") + col.operator("transform.create_orientation", text=_("Create")) orientation = view.current_orientation if orientation: col.prop(orientation, "name") - col.operator("transform.delete_orientation", text="Delete") + col.operator("transform.delete_orientation", text=_("Delete")) class VIEW3D_PT_etch_a_ton(Panel): @@ -2384,7 +2385,7 @@ class VIEW3D_PT_etch_a_ton(Panel): col.prop(toolsettings, "etch_number") col.prop(toolsettings, "etch_side") - col.operator("sketch.convert", text="Convert") + col.operator("sketch.convert", text=_("Convert")) class VIEW3D_PT_context_properties(Panel): diff --git a/release/scripts/startup/bl_ui/space_view3d_toolbar.py b/release/scripts/startup/bl_ui/space_view3d_toolbar.py index e322a6dcd13..6bd2168dab9 100644 --- a/release/scripts/startup/bl_ui/space_view3d_toolbar.py +++ b/release/scripts/startup/bl_ui/space_view3d_toolbar.py @@ -19,6 +19,7 @@ # <pep8 compliant> import bpy from bpy.types import Menu, Panel +from blf import gettext as _ class View3DPanel(): @@ -31,33 +32,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") @@ -73,16 +74,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") @@ -91,17 +92,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) @@ -122,8 +123,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:") @@ -1016,7 +1017,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() diff --git a/source/blender/blenfont/BLF_api.h b/source/blender/blenfont/BLF_api.h index 00943ace05c..1bb61d02b78 100644 --- a/source/blender/blenfont/BLF_api.h +++ b/source/blender/blenfont/BLF_api.h @@ -178,20 +178,6 @@ void BLF_buffer_col(int fontid, float r, float g, float b, float a); */ void BLF_draw_buffer(int fontid, const char *str); -/* - * Search the path directory to the locale files, this try all - * the case for Linux, Win and Mac. - */ -void BLF_lang_init(void); - -/* Set the current locale. */ -void BLF_lang_set(const char *); - -/* Set the current encoding name. */ -void BLF_lang_encoding_name(const char *str); - -void BLF_lang_encoding(const char *str); - /* Add a path to the font dir paths. */ void BLF_dir_add(const char *path); diff --git a/source/blender/blenfont/BLF_translation.h b/source/blender/blenfont/BLF_translation.h new file mode 100644 index 00000000000..4377d391354 --- /dev/null +++ b/source/blender/blenfont/BLF_translation.h @@ -0,0 +1,66 @@ +/* + * $Id$ + * + * ***** 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. + * + * The Original Code is Copyright (C) 2011 Blender Foundation. + * All rights reserved. + * + * + * Contributor(s): Blender Foundation, + * Sergey Sharybin + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/blenfont/BLF_translation.h + * \ingroup blf + */ + + +#ifndef BLF_TRANSLATION_H +#define BLF_TRANSLATION_H + +/* blf_translation.c */ + +#ifdef INTERNATIONAL +unsigned char *BLF_get_unifont(int *unifont_size); +void BLF_free_unifont(void); +#endif + +const char* BLF_gettext(const char *msgid); + +/* blf_lang.c */ + +/* + * Search the path directory to the locale files, this try all + * the case for Linux, Win and Mac. + */ +void BLF_lang_init(void); + +/* Set the current locale. */ +void BLF_lang_set(const char *); + +/* Set the current encoding name. */ +void BLF_lang_encoding_name(const char *str); + +void BLF_lang_encoding(const char *str); + +#define _(msgid) BLF_gettext(msgid) +#define N_(msgid) msgid + +#endif /* BLF_TRANSLATION_H */ diff --git a/source/blender/blenfont/CMakeLists.txt b/source/blender/blenfont/CMakeLists.txt index 82099d4f125..b87a3b88f07 100644 --- a/source/blender/blenfont/CMakeLists.txt +++ b/source/blender/blenfont/CMakeLists.txt @@ -42,9 +42,11 @@ set(SRC intern/blf_font.c intern/blf_glyph.c intern/blf_lang.c + intern/blf_translation.c intern/blf_util.c BLF_api.h + BLF_translation.h intern/blf_internal.h intern/blf_internal_types.h ) @@ -56,9 +58,5 @@ if(WITH_INTERNATIONAL) add_definitions(-DINTERNATIONAL) endif() -if(WIN32 AND NOT UNIX) - add_definitions(-DUSE_GETTEXT_DLL) -endif() - blender_add_lib(bf_blenfont "${SRC}" "${INC}" "${INC_SYS}") diff --git a/source/blender/blenfont/SConscript b/source/blender/blenfont/SConscript index 2763bea0da0..45a55793856 100644 --- a/source/blender/blenfont/SConscript +++ b/source/blender/blenfont/SConscript @@ -13,7 +13,6 @@ defs = [] if sys.platform == 'win32' or env['OURPLATFORM'] == 'linuxcross': defs.append('_WIN32') - defs.append('USE_GETTEXT_DLL') if env['WITH_BF_INTERNATIONAL']: defs.append('INTERNATIONAL') diff --git a/source/blender/blenfont/intern/blf_lang.c b/source/blender/blenfont/intern/blf_lang.c index 80951899040..8f745180b8b 100644 --- a/source/blender/blenfont/intern/blf_lang.c +++ b/source/blender/blenfont/intern/blf_lang.c @@ -39,8 +39,14 @@ #ifdef INTERNATIONAL #include <locale.h> + +#if defined (_WIN32) +#include <windows.h> +#endif + #include "libintl.h" +#include "DNA_userdef_types.h" #include "DNA_listBase.h" #include "DNA_vec_types.h" @@ -60,6 +66,35 @@ static char global_messagepath[1024]; static char global_language[32]; static char global_encoding_name[32]; +/* map from the rna_userdef.c:rna_def_userdef_system(BlenderRNA *brna):language_items */ +static const char *locales[] = { + "", "", + "english", "en_US", + "japanese", "ja_JP", + "dutch", "nl_NL", + "italian", "it_IT", + "german", "de_DE", + "finnish", "fi_FI", + "swedish", "sv_SE", + "french", "fr_FR", + "spanish", "es_ES", + "catalan", "ca_AD", + "czech", "cs_CZ", + "ptb", "pt_BR", + "chs", "zh_CN", + "cht", "zh_TW", + "russian", "ru_RU", + "croatian", "hr_HR", + "serbian", "sr_RS", + "ukrainian", "uk_UA", + "polish", "pl_PL", + "romanian", "ro_RO", + "arabic", "ar_EG", + "bulgarian", "bg_BG", + "greek", "el_GR", + "korean", "ko_KR", + "nepali", "ne_NP", +}; void BLF_lang_init(void) { @@ -77,34 +112,95 @@ void BLF_lang_init(void) /* XXX WARNING!!! IN osx somehow the previous function call jumps in this one??? (ton, ppc) */ void BLF_lang_set(const char *str) { - if(str==NULL) { + char *locreturn; + const char *short_locale; + int ok= 1; +#if defined (_WIN32) + char *long_locale = locales[ 2 * U.language]; +#endif + + if((U.transopts&USER_DOTRANSLATE)==0) return; + + if(str) + short_locale = str; + else + short_locale = locales[ 2 * U.language + 1]; + +#if defined (_WIN32) + if(short_locale) { + char *envStr; + + if( U.language==0 )/* use system setting */ + envStr = BLI_sprintfN( "LANG=%s", getenv("LANG") ); + else + envStr = BLI_sprintfN( "LANG=%s", short_locale ); + + gettext_putenv(envStr); + MEM_freeN(envStr); + } + + locreturn= setlocale(LC_ALL, long_locale); + + if (locreturn == NULL) { + printf("Could not change locale to %s\n", long_locale); + ok= 0; } - else { - -#if defined (_WIN32) || defined(__APPLE__) - BLI_setenv("LANG", str); #else - char *locreturn= setlocale(LC_ALL, str); + { + const char *locale; + static char default_locale[64]="\0"; + + if(default_locale[0]==0) { + char *env_language= getenv("LANGUAGE"); + + if(env_language) { + char *s; + + /* store defaul locale */ + strncpy(default_locale, env_language, sizeof(default_locale)); + + /* use first language as default */ + s= strchr(default_locale, ':'); + if(s) s[0]= 0; + } + } + + if(short_locale[0]) + locale= short_locale; + else + locale= default_locale; + + BLI_setenv("LANG", locale); + BLI_setenv("LANGUAGE", locale); + + locreturn= setlocale(LC_ALL, locale); + if (locreturn == NULL) { - char *lang= BLI_sprintfN("%s.UTF-8", str); + char *short_locale_utf8= BLI_sprintfN("%s.UTF-8", short_locale); + + locreturn= setlocale(LC_ALL, short_locale_utf8); - locreturn= setlocale(LC_ALL, lang); if (locreturn == NULL) { - printf("could not change language to %s nor %s\n", str, lang); + printf("Could not change locale to %s nor %s\n", short_locale, short_locale_utf8); + ok= 0; } - MEM_freeN(lang); + MEM_freeN(short_locale_utf8); } - - setlocale(LC_NUMERIC, "C"); + } #endif - textdomain(DOMAIN_NAME); - bindtextdomain(DOMAIN_NAME, global_messagepath); - /* bind_textdomain_codeset(DOMAIN_NAME, global_encoding_name); */ - BLI_strncpy(global_language, str, sizeof(global_language)); - + + if(ok) { + //printf("Change locale to %s\n", locreturn ); + BLI_strncpy(global_language, locreturn, sizeof(global_language)); } + + setlocale(LC_NUMERIC, "C"); + + textdomain(DOMAIN_NAME); + bindtextdomain(DOMAIN_NAME, global_messagepath); + bind_textdomain_codeset(DOMAIN_NAME, global_encoding_name); } void BLF_lang_encoding(const char *str) diff --git a/source/blender/blenfont/intern/blf_translation.c b/source/blender/blenfont/intern/blf_translation.c new file mode 100644 index 00000000000..b53f4cf7609 --- /dev/null +++ b/source/blender/blenfont/intern/blf_translation.c @@ -0,0 +1,86 @@ +/* + * $Id$ + * + * ***** 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. + * + * The Original Code is Copyright (C) 2011 Blender Foundation. + * All rights reserved. + * + * Contributor(s): Blender Foundation, + * Sergey Sharybin + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/blenfont/intern/blf_translation.c + * \ingroup blf + */ + +#include <stdlib.h> + +#ifdef INTERNATIONAL +#include <libintl.h> +#endif + +#include "MEM_guardedalloc.h" + +#include "BLI_path_util.h" +#include "BLI_string.h" +#include "BLI_path_util.h" +#include "BLI_fileops.h" + +#include "BLF_translation.h" + +#ifdef INTERNATIONAL +const char unifont_filename[]="droidsans.ttf.gz"; +static unsigned char *unifont_ttf= NULL; +static int unifont_size= 0; + +unsigned char *BLF_get_unifont(int *unifont_size_r) +{ + if(unifont_ttf==NULL) { + char *fontpath = BLI_get_folder(BLENDER_DATAFILES, "fonts"); + char unifont_path[1024]; + + BLI_snprintf(unifont_path, sizeof(unifont_path), "%s/%s", fontpath, unifont_filename); + + unifont_ttf= (unsigned char*)BLI_ungzip_to_mem(unifont_path, &unifont_size); + } + + *unifont_size_r= unifont_size; + + return unifont_ttf; +} + +void BLF_free_unifont(void) +{ + if(unifont_ttf) + MEM_freeN(unifont_ttf); +} + +#endif + +const char* BLF_gettext(const char *msgid) +{ +#ifdef INTERNATIONAL + if( msgid[0] ) + return gettext( msgid ); + return ""; +#else + return msgid; +#endif +} diff --git a/source/blender/blenlib/BLI_fileops.h b/source/blender/blenlib/BLI_fileops.h index 59c01348c07..21d28ca3185 100644 --- a/source/blender/blenlib/BLI_fileops.h +++ b/source/blender/blenlib/BLI_fileops.h @@ -53,6 +53,7 @@ int BLI_exists(const char *file); int BLI_copy_fileops(const char *file, const char *to); int BLI_rename(const char *from, const char *to); int BLI_gzip(const char *from, const char *to); +char *BLI_ungzip_to_mem(const char *from_file, int *size_r); int BLI_delete(const char *file, int dir, int recursive); int BLI_move(const char *file, const char *to); int BLI_touch(const char *file); diff --git a/source/blender/blenlib/intern/fileops.c b/source/blender/blenlib/intern/fileops.c index 3299752646b..6b125435b31 100644 --- a/source/blender/blenlib/intern/fileops.c +++ b/source/blender/blenlib/intern/fileops.c @@ -52,6 +52,8 @@ #include <sys/param.h> #endif +#include "MEM_guardedalloc.h" + #include "BLI_blenlib.h" #include "BKE_utildefines.h" @@ -104,6 +106,45 @@ int BLI_gzip(const char *from, const char *to) { return rval; } +/* gzip the file in from_file and write it to memery to_mem, at most size bytes. + return the unziped size + */ +char *BLI_ungzip_to_mem(const char *from_file, int *size_r) +{ + gzFile gzfile; + int readsize, size, alloc_size=0; + char *mem= NULL; + const int chunk_size= 512*1024; + + size= 0; + + gzfile = gzopen( from_file, "rb" ); + + for(;;) { + if(mem==NULL) { + mem= MEM_callocN(chunk_size, "BLI_ungzip_to_mem"); + alloc_size= chunk_size; + } else { + mem= MEM_reallocN(mem, size+chunk_size); + alloc_size+= chunk_size; + } + + readsize= gzread(gzfile, mem+size, chunk_size); + if(readsize>0) { + size+= readsize; + } + else break; + } + + if(mem && alloc_size!=size) + mem= MEM_reallocN(mem, size); + + *size_r= size; + + return mem; +} + + /* return 1 when file can be written */ int BLI_is_writable(const char *filename) { diff --git a/source/blender/editors/armature/CMakeLists.txt b/source/blender/editors/armature/CMakeLists.txt index 9a44525611a..7ecbdc9ebe5 100644 --- a/source/blender/editors/armature/CMakeLists.txt +++ b/source/blender/editors/armature/CMakeLists.txt @@ -21,6 +21,7 @@ set(INC ../include + ../../blenfont ../../blenkernel ../../blenlib ../../blenloader diff --git a/source/blender/editors/armature/SConscript b/source/blender/editors/armature/SConscript index b7f9a263bc1..ded82b3dfb7 100644 --- a/source/blender/editors/armature/SConscript +++ b/source/blender/editors/armature/SConscript @@ -3,7 +3,7 @@ Import ('env') sources = env.Glob('*.c') -incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf ../../blenloader' +incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../imbuf ../../blenloader' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include' incs += ' ../../gpu ../../makesrna #/intern/opennl/extern' diff --git a/source/blender/editors/armature/poselib.c b/source/blender/editors/armature/poselib.c index 67c93c4c906..8a7d837d2a8 100644 --- a/source/blender/editors/armature/poselib.c +++ b/source/blender/editors/armature/poselib.c @@ -43,6 +43,8 @@ #include "BLI_dlrbTree.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "DNA_anim_types.h" #include "DNA_armature_types.h" #include "DNA_object_types.h" @@ -407,15 +409,15 @@ static int poselib_add_menu_invoke (bContext *C, wmOperator *op, wmEvent *UNUSED uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT); /* add new (adds to the first unoccupied frame) */ - uiItemIntO(layout, "Add New", ICON_NONE, "POSELIB_OT_pose_add", "frame", poselib_get_free_index(ob->poselib)); + uiItemIntO(layout, UI_translate_do_iface(N_("Add New")), ICON_NONE, "POSELIB_OT_pose_add", "frame", poselib_get_free_index(ob->poselib)); /* check if we have any choices to add a new pose in any other way */ if ((ob->poselib) && (ob->poselib->markers.first)) { /* add new (on current frame) */ - uiItemIntO(layout, "Add New (Current Frame)", ICON_NONE, "POSELIB_OT_pose_add", "frame", CFRA); + uiItemIntO(layout, UI_translate_do_iface(N_("Add New (Current Frame)")), ICON_NONE, "POSELIB_OT_pose_add", "frame", CFRA); /* replace existing - submenu */ - uiItemMenuF(layout, "Replace Existing...", 0, poselib_add_menu_invoke__replacemenu, NULL); + uiItemMenuF(layout, UI_translate_do_iface(N_("Replace Existing...")), 0, poselib_add_menu_invoke__replacemenu, NULL); } uiPupMenuEnd(C, pup); diff --git a/source/blender/editors/include/UI_interface.h b/source/blender/editors/include/UI_interface.h index 637940f59a6..06b44e36b69 100644 --- a/source/blender/editors/include/UI_interface.h +++ b/source/blender/editors/include/UI_interface.h @@ -799,9 +799,15 @@ void uiStyleFontDrawRotated(struct uiFontStyle *fs, struct rcti *rect, const cha int UI_GetStringWidth(const char *str); // XXX temp void UI_DrawString(float x, float y, const char *str); // XXX temp void UI_DrawTriIcon(float x, float y, char dir); - +uiStyle* UI_GetStyle(void); /* linker workaround ack! */ void UI_template_fix_linking(void); +/* translation */ +int UI_translate_iface(void); +int UI_translate_tooltips(void); +const char *UI_translate_do_iface(const char *msgid); +const char *UI_translate_do_tooltip(const char *msgid); + #endif /* UI_INTERFACE_H */ diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c index abc668d72dd..2ff77d255c6 100644 --- a/source/blender/editors/interface/interface.c +++ b/source/blender/editors/interface/interface.c @@ -55,6 +55,7 @@ #include "BIF_gl.h" #include "BLF_api.h" +#include "BLF_translation.h" #include "UI_interface.h" @@ -93,19 +94,46 @@ static void ui_free_but(const bContext *C, uiBut *but); /* ************* translation ************** */ -int ui_translate_buttons(void) +int UI_translate_iface(void) { - return (U.transopts & USER_TR_BUTTONS); +#ifdef INTERNATIONAL + return (U.transopts & USER_DOTRANSLATE) && (U.transopts & USER_TR_IFACE); +#else + return 0; +#endif } -int ui_translate_menus(void) +int UI_translate_tooltips(void) { - return (U.transopts & USER_TR_MENUS); +#ifdef INTERNATIONAL + return (U.transopts & USER_DOTRANSLATE) && (U.transopts & USER_TR_TOOLTIPS); +#else + return 0; +#endif } -int ui_translate_tooltips(void) +const char *UI_translate_do_iface(const char *msgid) { - return (U.transopts & USER_TR_TOOLTIPS); +#ifdef INTERNATIONAL + if(UI_translate_iface()) + return BLF_gettext(msgid); + else + return msgid; +#else + return msgid; +#endif +} + +const char *UI_translate_do_tooltip(const char *msgid) +{ +#ifdef INTERNATIONAL + if(UI_translate_tooltips()) + return BLF_gettext(msgid); + else + return msgid; +#else + return msgid; +#endif } /* ************* window matrix ************** */ @@ -229,7 +257,7 @@ void ui_block_translate(uiBlock *block, int x, int y) static void ui_text_bounds_block(uiBlock *block, float offset) { - uiStyle *style= U.uistyles.first; // XXX pass on as arg + uiStyle *style=UI_GetStyle(); uiBut *bt; int i = 0, j, x1addval= offset, nextcol; int lastcol= 0, col= 0; @@ -238,9 +266,6 @@ static void ui_text_bounds_block(uiBlock *block, float offset) for(bt= block->buttons.first; bt; bt= bt->next) { if(bt->type!=SEPR) { - //int transopts= ui_translate_buttons(); - //if(bt->type==TEX || bt->type==IDPOIN) transopts= 0; - j= BLF_width(style->widget.uifont_id, bt->drawstr); if(j > i) i = j; @@ -930,7 +955,7 @@ static void ui_but_to_pixelrect(rcti *rect, const ARegion *ar, uiBlock *block, u /* uses local copy of style, to scale things down, and allow widgets to change stuff */ void uiDrawBlock(const bContext *C, uiBlock *block) { - uiStyle style= *((uiStyle *)U.uistyles.first); // XXX pass on as arg + uiStyle style= *UI_GetStyle(); // XXX pass on as arg ARegion *ar; uiBut *but; rcti rect; @@ -2033,12 +2058,9 @@ void ui_check_but(uiBut *but) /* if something changed in the button */ double value= UI_BUT_VALUE_UNSET; // float okwidth; // UNUSED -// int transopts= ui_translate_buttons(); ui_is_but_sel(but, &value); -// if(but->type==TEX || but->type==IDPOIN) transopts= 0; - /* only update soft range while not editing */ if(but->rnaprop && !(but->editval || but->editstr || but->editvec)) { UI_GET_BUT_VALUE_INIT(but, value) @@ -2547,7 +2569,7 @@ static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *s DynStr *dynstr; int i, totitem, value, free; - RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free); value= RNA_property_enum_get(ptr, prop); dynstr= BLI_dynstr_new(); @@ -2582,7 +2604,7 @@ static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *s EnumPropertyItem *item; int i, totitem, free; - RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free); for(i=0; i<totitem; i++) { if(item[i].identifier[0] && item[i].value == (int)max) { str= item[i].name; @@ -2710,6 +2732,11 @@ static uiBut *ui_def_but_operator(uiBlock *block, int type, const char *opname, if ((!tip || tip[0]=='\0') && ot && ot->description) { tip= ot->description; + +#ifdef INTERNATIONAL + if(UI_translate_tooltips()) + tip= BLF_gettext(tip); +#endif } but= ui_def_but(block, type, -1, str, x1, y1, x2, y2, NULL, 0, 0, 0, 0, tip); diff --git a/source/blender/editors/interface/interface_handlers.c b/source/blender/editors/interface/interface_handlers.c index 7661fa5994b..125928c136b 100644 --- a/source/blender/editors/interface/interface_handlers.c +++ b/source/blender/editors/interface/interface_handlers.c @@ -1269,7 +1269,7 @@ static int ui_textedit_delete_selection(uiBut *but, uiHandleButtonData *data) /* note, but->block->aspect is used here, when drawing button style is getting scaled too */ static void ui_textedit_set_cursor_pos(uiBut *but, uiHandleButtonData *data, short x) { - uiStyle *style= U.uistyles.first; // XXX pass on as arg + uiStyle *style= UI_GetStyle(); // XXX pass on as arg uiFontStyle *fstyle = &style->widget; int startx= but->x1; char *origstr; @@ -4101,7 +4101,7 @@ static uiBlock *menu_change_shortcut(bContext *C, ARegion *ar, void *arg) wmKeyMapItem *kmi; PointerRNA ptr; uiLayout *layout; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); IDProperty *prop= (but->opptr)? but->opptr->data: NULL; int kmi_id = WM_key_event_operator_id(C, but->optype->idname, but->opcontext, prop, 1, &km); @@ -4133,7 +4133,7 @@ static uiBlock *menu_add_shortcut(bContext *C, ARegion *ar, void *arg) wmKeyMapItem *kmi; PointerRNA ptr; uiLayout *layout; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); IDProperty *prop= (but->opptr)? but->opptr->data: NULL; int kmi_id; diff --git a/source/blender/editors/interface/interface_intern.h b/source/blender/editors/interface/interface_intern.h index ebc8725ad5d..72eb869dea0 100644 --- a/source/blender/editors/interface/interface_intern.h +++ b/source/blender/editors/interface/interface_intern.h @@ -347,10 +347,6 @@ typedef struct uiSafetyRct { extern void ui_delete_linkline(uiLinkLine *line, uiBut *but); -extern int ui_translate_buttons(void); -extern int ui_translate_menus(void); -extern int ui_translate_tooltips(void); - void ui_fontscale(short *points, float aspect); extern void ui_block_to_window_fl(const struct ARegion *ar, uiBlock *block, float *x, float *y); diff --git a/source/blender/editors/interface/interface_layout.c b/source/blender/editors/interface/interface_layout.c index 10300cee9ea..3c02f7d4bd2 100644 --- a/source/blender/editors/interface/interface_layout.c +++ b/source/blender/editors/interface/interface_layout.c @@ -43,6 +43,8 @@ #include "BLI_string.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_global.h" #include "BKE_idprop.h" @@ -475,7 +477,7 @@ static void ui_item_enum_expand(uiLayout *layout, uiBlock *block, PointerRNA *pt const char *name; int a, totitem, itemw, icon, value, free; - RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free); uiBlockSetCurLayout(block, ui_item_local_sublayout(layout, layout, 1)); for(a=0; a<totitem; a++) { @@ -634,8 +636,14 @@ PointerRNA uiItemFullO(uiLayout *layout, const char *opname, const char *name, i return PointerRNA_NULL; } - if(!name) + if(!name) { name= ot->name; + +#ifdef INTERNATIONAL + name= UI_translate_do_iface(name); +#endif + } + if(layout->root->type == UI_LAYOUT_MENU && !icon) icon= ICON_BLANK1; @@ -701,7 +709,7 @@ static const char *ui_menu_enumpropname(uiLayout *layout, const char *opname, co int totitem, free; const char *name; - RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(layout->root->block->evil_C, &ptr, prop, &item, &totitem, &free); if(RNA_enum_name(item, retval, &name)) { if(free) MEM_freeN(item); return name; @@ -753,7 +761,7 @@ void uiItemsFullEnumO(uiLayout *layout, const char *opname, const char *propname uiLayout *split= uiLayoutSplit(layout, 0, 0); uiLayout *column= uiLayoutColumn(split, 0); - RNA_property_enum_items(block->evil_C, &ptr, prop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(block->evil_C, &ptr, prop, &item, &totitem, &free); for(i=0; i<totitem; i++) { if(item[i].identifier[0]) { @@ -841,7 +849,7 @@ void uiItemEnumO_string(uiLayout *layout, const char *name, int icon, const char /* enum lookup */ if((prop= RNA_struct_find_property(&ptr, propname))) { - RNA_property_enum_items(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free); + RNA_property_enum_items_gettexted(layout->root->block->evil_C, &ptr, prop, &item, NULL, &free); if(item==NULL || RNA_enum_value_from_id(item, value_str, &value)==0) { if(free) MEM_freeN(item); RNA_warning("%s.%s, enum %s not found", RNA_struct_identifier(ptr.type), propname, value_str); @@ -1091,7 +1099,7 @@ void uiItemEnumR_string(uiLayout *layout, struct PointerRNA *ptr, const char *pr return; } - RNA_property_enum_items(layout->root->block->evil_C, ptr, prop, &item, NULL, &free); + RNA_property_enum_items_gettexted(layout->root->block->evil_C, ptr, prop, &item, NULL, &free); if(!RNA_enum_value_from_id(item, value, &ivalue)) { if(free) MEM_freeN(item); @@ -1135,7 +1143,7 @@ void uiItemsEnumR(uiLayout *layout, struct PointerRNA *ptr, const char *propname uiLayout *split= uiLayoutSplit(layout, 0, 0); uiLayout *column= uiLayoutColumn(split, 0); - RNA_property_enum_items(block->evil_C, ptr, prop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(block->evil_C, ptr, prop, &item, &totitem, &free); for(i=0; i<totitem; i++) { if(item[i].identifier[0]) { @@ -1421,8 +1429,14 @@ void uiItemM(uiLayout *layout, bContext *UNUSED(C), const char *menuname, const return; } - if(!name) + if(!name) { name= mt->label; + +#ifdef INTERNATIONAL + name= UI_translate_do_iface(name); +#endif + } + if(layout->root->type == UI_LAYOUT_MENU && !icon) icon= ICON_BLANK1; @@ -2794,7 +2808,7 @@ void uiLayoutOperatorButs(const bContext *C, uiLayout *layout, wmOperator *op,in empty= uiDefAutoButsRNA(layout, &ptr, check_prop, label_align) == 0; if(empty && (flag & UI_LAYOUT_OP_SHOW_EMPTY)) { - uiItemL(layout, "No Properties", ICON_NONE); + uiItemL(layout, UI_translate_do_iface(N_("No Properties")), ICON_NONE); } } diff --git a/source/blender/editors/interface/interface_panel.c b/source/blender/editors/interface/interface_panel.c index cd1d250d6a4..ec7456eebdc 100644 --- a/source/blender/editors/interface/interface_panel.c +++ b/source/blender/editors/interface/interface_panel.c @@ -173,7 +173,7 @@ static void ui_panel_copy_offset(Panel *pa, Panel *papar) Panel *uiBeginPanel(ScrArea *sa, ARegion *ar, uiBlock *block, PanelType *pt, int *open) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); Panel *pa, *patab, *palast, *panext; char *drawname= pt->label; char *idname= pt->idname; @@ -292,7 +292,7 @@ void uiEndPanel(uiBlock *block, int width, int height) static void ui_offset_panel_block(uiBlock *block) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiBut *but; int ofsy; @@ -442,8 +442,12 @@ static void ui_draw_aligned_panel_header(uiStyle *style, uiBlock *block, rcti *r Panel *panel= block->panel; rcti hrect; int pnl_icons; - char *activename= panel->drawname[0]?panel->drawname:panel->panelname; - + const char *activename= panel->drawname[0]?panel->drawname:panel->panelname; + +#ifdef INTERNATIONAL + activename= UI_translate_do_iface(activename); +#endif + /* + 0.001f to avoid flirting with float inaccuracy */ if(panel->control & UI_PNL_CLOSE) pnl_icons=(panel->labelofs+2*PNL_ICON+5)/block->aspect + 0.001f; else pnl_icons= (panel->labelofs+PNL_ICON+5)/block->aspect + 0.001f; @@ -667,7 +671,7 @@ static int compare_panel(const void *a1, const void *a2) /* returns 1 when it did something */ static int uiAlignPanelStep(ScrArea *sa, ARegion *ar, float fac, int drag) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); Panel *pa; PanelSort *ps, *panelsort, *psnext; int a, tot=0, done; diff --git a/source/blender/editors/interface/interface_regions.c b/source/blender/editors/interface/interface_regions.c index f31c16cd020..4221f7c30ff 100644 --- a/source/blender/editors/interface/interface_regions.c +++ b/source/blender/editors/interface/interface_regions.c @@ -62,6 +62,7 @@ #include "UI_view2d.h" #include "BLF_api.h" +#include "BLF_translation.h" #include "ED_screen.h" @@ -318,7 +319,7 @@ static void ui_tooltip_region_draw_cb(const bContext *UNUSED(C), ARegion *ar) rcti bbox= data->bbox; int a; - ui_draw_menu_back(U.uistyles.first, NULL, &data->bbox); + ui_draw_menu_back(UI_GetStyle(), NULL, &data->bbox); /* draw text */ uiStyleFontSet(&data->fstyle); @@ -343,9 +344,10 @@ static void ui_tooltip_region_free_cb(ARegion *ar) ar->regiondata= NULL; } +#define TIP_(msgid) UI_translate_do_tooltip(msgid) ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) { - uiStyle *style= U.uistyles.first; // XXX pass on as arg + uiStyle *style= UI_GetStyle(); static ARegionType type; ARegion *ar; uiTooltipData *data; @@ -374,7 +376,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) EnumPropertyItem *item; int i, totitem, free; - RNA_property_enum_items(C, &but->rnapoin, but->rnaprop, &item, &totitem, &free); + RNA_property_enum_items_gettexted(C, &but->rnapoin, but->rnaprop, &item, &totitem, &free); for(i=0; i<totitem; i++) { if(item[i].identifier[0] && item[i].value == (int)but->hardmax) { @@ -403,7 +405,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) prop= (but->opptr)? but->opptr->data: NULL; if(WM_key_event_operator_string(C, but->optype->idname, but->opcontext, prop, buf, sizeof(buf))) { - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Shortcut: %s", buf); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Shortcut: %s")), buf); data->color[data->totline]= 0x888888; data->totline++; } @@ -413,7 +415,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) /* full string */ ui_get_but_string(but, buf, sizeof(buf)); if(buf[0]) { - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Value: %s", buf); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Value: %s")), buf); data->color[data->totline]= 0x888888; data->totline++; } @@ -425,7 +427,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) if (unit_type == PROP_UNIT_ROTATION) { if (RNA_property_type(but->rnaprop) == PROP_FLOAT) { float value= RNA_property_array_check(but->rnaprop) ? RNA_property_float_get_index(&but->rnapoin, but->rnaprop, but->rnaindex) : RNA_property_float_get(&but->rnapoin, but->rnaprop); - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Radians: %f", value); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Radians: %f")), value); data->color[data->totline]= 0x888888; data->totline++; } @@ -434,7 +436,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) if(but->flag & UI_BUT_DRIVEN) { if(ui_but_anim_expression_get(but, buf, sizeof(buf))) { /* expression */ - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Expression: %s", buf); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Expression: %s")), buf); data->color[data->totline]= 0x888888; data->totline++; } @@ -442,7 +444,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) /* rna info */ if ((U.flag & USER_TOOLTIPS_PYTHON) == 0) { - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Python: %s.%s", RNA_struct_identifier(but->rnapoin.type), RNA_property_identifier(but->rnaprop)); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Python: %s.%s")), RNA_struct_identifier(but->rnapoin.type), RNA_property_identifier(but->rnaprop)); data->color[data->totline]= 0x888888; data->totline++; } @@ -450,7 +452,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) if(but->rnapoin.id.data) { ID *id= but->rnapoin.id.data; if(id->lib && id->lib->name) { - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Library: %s", id->lib->name); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Library: %s")), id->lib->name); data->color[data->totline]= 0x888888; data->totline++; } @@ -465,7 +467,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) /* operator info */ if ((U.flag & USER_TOOLTIPS_PYTHON) == 0) { - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Python: %s", str); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Python: %s")), str); data->color[data->totline]= 0x888888; data->totline++; } @@ -479,7 +481,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) WM_operator_poll_context(C, but->optype, but->opcontext); poll_msg= CTX_wm_operator_poll_msg_get(C); if(poll_msg) { - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Disabled: %s", poll_msg); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Disabled: %s")), poll_msg); data->color[data->totline]= 0x6666ff; /* alert */ data->totline++; } @@ -489,7 +491,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) if ((U.flag & USER_TOOLTIPS_PYTHON) == 0) { if(but->menu_create_func && WM_menutype_contains((MenuType *)but->poin)) { MenuType *mt= (MenuType *)but->poin; - BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), "Python: %s", mt->idname); + BLI_snprintf(data->lines[data->totline], sizeof(data->lines[0]), TIP_(N_("Python: %s")), mt->idname); data->color[data->totline]= 0x888888; data->totline++; } @@ -608,6 +610,7 @@ ARegion *ui_tooltip_create(bContext *C, ARegion *butregion, uiBut *but) return ar; } +#undef TIP_ void ui_tooltip_free(bContext *C, ARegion *ar) { @@ -985,7 +988,7 @@ static void ui_searchbox_region_free_cb(ARegion *ar) ARegion *ui_searchbox_create(bContext *C, ARegion *butregion, uiBut *but) { - uiStyle *style= U.uistyles.first; // XXX pass on as arg + uiStyle *style= UI_GetStyle(); static ARegionType type; ARegion *ar; uiSearchboxData *data; @@ -2299,7 +2302,7 @@ static uiBlock *ui_block_func_POPUP(bContext *C, uiPopupBlockHandle *handle, voi uiPopupBlockHandle *ui_popup_menu_create(bContext *C, ARegion *butregion, uiBut *but, uiMenuCreateFunc menu_func, void *arg, char *str) { wmWindow *window= CTX_wm_window(C); - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiPopupBlockHandle *handle; uiPopupMenu *pup; @@ -2348,7 +2351,7 @@ uiPopupBlockHandle *ui_popup_menu_create(bContext *C, ARegion *butregion, uiBut /* only return handler, and set optional title */ uiPopupMenu *uiPupMenuBegin(bContext *C, const char *title, int icon) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiPopupMenu *pup= MEM_callocN(sizeof(uiPopupMenu), "popup menu"); uiBut *but; diff --git a/source/blender/editors/interface/interface_style.c b/source/blender/editors/interface/interface_style.c index 8d4b4209120..5ea20b33b3a 100644 --- a/source/blender/editors/interface/interface_style.c +++ b/source/blender/editors/interface/interface_style.c @@ -47,6 +47,7 @@ #include "BLF_api.h" +#include "BLF_translation.h" #include "UI_interface.h" @@ -76,7 +77,7 @@ /* ********************************************** */ -static uiStyle *ui_style_new(ListBase *styles, const char *name) +static uiStyle *ui_style_new(ListBase *styles, const char *name, short uifont_id) { uiStyle *style= MEM_callocN(sizeof(uiStyle), "new style"); @@ -85,7 +86,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name) style->panelzoom= 1.0; /* unused */ - style->paneltitle.uifont_id= UIFONT_DEFAULT; + style->paneltitle.uifont_id= uifont_id; style->paneltitle.points= 12; style->paneltitle.kerning= 1; style->paneltitle.shadow= 1; @@ -94,7 +95,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name) style->paneltitle.shadowalpha= 0.15f; style->paneltitle.shadowcolor= 1.0f; - style->grouplabel.uifont_id= UIFONT_DEFAULT; + style->grouplabel.uifont_id= uifont_id; style->grouplabel.points= 12; style->grouplabel.kerning= 1; style->grouplabel.shadow= 3; @@ -102,7 +103,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name) style->grouplabel.shady= -1; style->grouplabel.shadowalpha= 0.25f; - style->widgetlabel.uifont_id= UIFONT_DEFAULT; + style->widgetlabel.uifont_id= uifont_id; style->widgetlabel.points= 11; style->widgetlabel.kerning= 1; style->widgetlabel.shadow= 3; @@ -111,7 +112,7 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name) style->widgetlabel.shadowalpha= 0.15f; style->widgetlabel.shadowcolor= 1.0f; - style->widget.uifont_id= UIFONT_DEFAULT; + style->widget.uifont_id= uifont_id; style->widget.points= 11; style->widget.kerning= 1; style->widget.shadowalpha= 0.25f; @@ -251,11 +252,19 @@ void uiStyleFontDrawRotated(uiFontStyle *fs, rcti *rect, const char *str) } /* ************** helpers ************************ */ +/* XXX: read a style configure */ +uiStyle* UI_GetStyle(void) +{ + uiStyle *style = NULL; + /* offset is two struct uiStyle pointers */ + /* style = BLI_findstring( &U.uistyles, "Unifont Style", sizeof(style)*2 ) */; + return (style != NULL) ? style : U.uistyles.first; +} /* temporarily, does widget font */ int UI_GetStringWidth(const char *str) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiFontStyle *fstyle= &style->widget; int width; @@ -274,7 +283,7 @@ int UI_GetStringWidth(const char *str) /* temporarily, does widget font */ void UI_DrawString(float x, float y, const char *str) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); if (style->widget.kerning == 1) BLF_enable(style->widget.uifont_id, BLF_KERNING_DEFAULT); @@ -313,7 +322,17 @@ void uiStyleInit(void) for(font= U.uifonts.first; font; font= font->next) { if(font->uifont_id==UIFONT_DEFAULT) { +#ifdef INTERNATIONAL + int unifont_size; + unsigned char *unifont_ttf= BLF_get_unifont(&unifont_size); + + if(unifont_ttf) + font->blf_id= BLF_load_mem_unique("default", unifont_ttf, unifont_size); + else + font->blf_id= BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size); +#else font->blf_id= BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size); +#endif } else { font->blf_id= BLF_load(font->filename); @@ -337,7 +356,7 @@ void uiStyleInit(void) } if(style==NULL) { - ui_style_new(&U.uistyles, "Default Style"); + ui_style_new(&U.uistyles, "Default Style", UIFONT_DEFAULT ); } // XXX, this should be moved into a style, but for now best only load the monospaced font once. diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c index 493ccebc19e..af515bf8061 100644 --- a/source/blender/editors/interface/interface_templates.c +++ b/source/blender/editors/interface/interface_templates.c @@ -68,6 +68,7 @@ #include "interface_intern.h" #include "BLF_api.h" +#include "BLF_translation.h" void UI_template_fix_linking(void) { @@ -306,31 +307,31 @@ static const char *template_id_browse_tip(StructRNA *type) { if(type) { switch(RNA_type_to_ID_code(type)) { - case ID_SCE: return "Browse Scene to be linked"; - case ID_OB: return "Browse Object to be linked"; - case ID_ME: return "Browse Mesh Data to be linked"; - case ID_CU: return "Browse Curve Data to be linked"; - case ID_MB: return "Browse MetaBall Data to be linked"; - case ID_MA: return "Browse Material to be linked"; - case ID_TE: return "Browse Texture to be linked"; - case ID_IM: return "Browse Image to be linked"; - case ID_LT: return "Browse Lattice Data to be linked"; - case ID_LA: return "Browse Lamp Data to be linked"; - case ID_CA: return "Browse Camera Data to be linked"; - case ID_WO: return "Browse World Settings to be linked"; - case ID_SCR: return "Choose Screen lay-out"; - case ID_TXT: return "Browse Text to be linked"; - case ID_SPK: return "Browse Speaker Data to be linked"; - case ID_SO: return "Browse Sound to be linked"; - case ID_AR: return "Browse Armature data to be linked"; - case ID_AC: return "Browse Action to be linked"; - case ID_NT: return "Browse Node Tree to be linked"; - case ID_BR: return "Browse Brush to be linked"; - case ID_PA: return "Browse Particle System to be linked"; - case ID_GD: return "Browse Grease Pencil Data to be linked"; + case ID_SCE: return N_("Browse Scene to be linked"); + case ID_OB: return N_("Browse Object to be linked"); + case ID_ME: return N_("Browse Mesh Data to be linked"); + case ID_CU: return N_("Browse Curve Data to be linked"); + case ID_MB: return N_("Browse MetaBall Data to be linked"); + case ID_MA: return N_("Browse Material to be linked"); + case ID_TE: return N_("Browse Texture to be linked"); + case ID_IM: return N_("Browse Image to be linked"); + case ID_LT: return N_("Browse Lattice Data to be linked"); + case ID_LA: return N_("Browse Lamp Data to be linked"); + case ID_CA: return N_("Browse Camera Data to be linked"); + case ID_WO: return N_("Browse World Settings to be linked"); + case ID_SCR: return N_("Choose Screen lay-out"); + case ID_TXT: return N_("Browse Text to be linked"); + case ID_SPK: return N_("Browse Speaker Data to be linked"); + case ID_SO: return N_("Browse Sound to be linked"); + case ID_AR: return N_("Browse Armature data to be linked"); + case ID_AC: return N_("Browse Action to be linked"); + case ID_NT: return N_("Browse Node Tree to be linked"); + case ID_BR: return N_("Browse Brush to be linked"); + case ID_PA: return N_("Browse Particle System to be linked"); + case ID_GD: return N_("Browse Grease Pencil Data to be linked"); } } - return "Browse ID data to be linked"; + return N_("Browse ID data to be linked"); } static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, StructRNA *type, int flag, const char *newop, const char *openop, const char *unlinkop) @@ -355,7 +356,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str if(flag & UI_ID_PREVIEWS) { - but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*6, UI_UNIT_Y*6, template_id_browse_tip(type)); + but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*6, UI_UNIT_Y*6, + UI_translate_do_tooltip(template_id_browse_tip(type))); if(type) { but->icon= RNA_struct_ui_icon(type); if (id) but->icon = ui_id_icon_get(C, id, 1); @@ -367,7 +369,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str uiLayoutRow(layout, 1); } else if(flag & UI_ID_BROWSE) { - but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*1.6, UI_UNIT_Y, template_id_browse_tip(type)); + but= uiDefBlockButN(block, id_search_menu, MEM_dupallocN(template), "", 0, 0, UI_UNIT_X*1.6, UI_UNIT_Y, + UI_translate_do_tooltip(template_id_browse_tip(type))); if(type) { but->icon= RNA_struct_ui_icon(type); /* default dragging of icon for id browse buttons */ @@ -393,12 +396,12 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str if(id->lib) { if(id->flag & LIB_INDIRECT) { but= uiDefIconBut(block, BUT, 0, ICON_LIBRARY_DATA_INDIRECT, 0,0,UI_UNIT_X,UI_UNIT_Y, NULL, 0, 0, 0, 0, - "Indirect library datablock, cannot change"); + UI_translate_do_tooltip(N_("Indirect library datablock, cannot change"))); uiButSetFlag(but, UI_BUT_DISABLED); } else { but= uiDefIconBut(block, BUT, 0, ICON_LIBRARY_DATA_DIRECT, 0,0,UI_UNIT_X,UI_UNIT_Y, NULL, 0, 0, 0, 0, - "Direct linked library datablock, click to make local"); + UI_translate_do_tooltip(N_("Direct linked library datablock, click to make local"))); if(!id_make_local(id, 1 /* test */) || (idfrom && idfrom->lib)) uiButSetFlag(but, UI_BUT_DISABLED); } @@ -411,7 +414,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str sprintf(str, "%d", id->us); - but= uiDefBut(block, BUT, 0, str, 0,0,UI_UNIT_X + ((id->us < 10) ? 0:10), UI_UNIT_Y, NULL, 0, 0, 0, 0, "Displays number of users of this data, click to make a single-user copy"); + but= uiDefBut(block, BUT, 0, str, 0,0,UI_UNIT_X + ((id->us < 10) ? 0:10), UI_UNIT_Y, NULL, 0, 0, 0, 0, + UI_translate_do_tooltip(_("Displays number of users of this data. Click to make a single-user copy"))); uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_ALONE)); if(!id_copy(id, NULL, 1 /* test only */) || (idfrom && idfrom->lib) || !editable) @@ -429,11 +433,11 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str int w= id?UI_UNIT_X: (flag & UI_ID_OPEN)? UI_UNIT_X*3: UI_UNIT_X*6; if(newop) { - but= uiDefIconTextButO(block, BUT, newop, WM_OP_INVOKE_DEFAULT, ICON_ZOOMIN, (id)? "": "New", 0, 0, w, UI_UNIT_Y, NULL); + but= uiDefIconTextButO(block, BUT, newop, WM_OP_INVOKE_DEFAULT, ICON_ZOOMIN, (id)? "": UI_translate_do_iface(N_("New")), 0, 0, w, UI_UNIT_Y, NULL); uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_ADD_NEW)); } else { - but= uiDefIconTextBut(block, BUT, 0, ICON_ZOOMIN, (id)? "": "New", 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL); + but= uiDefIconTextBut(block, BUT, 0, ICON_ZOOMIN, (id)? "": _("New"), 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL); uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_ADD_NEW)); } @@ -445,11 +449,11 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str int w= id?UI_UNIT_X: (flag & UI_ID_ADD_NEW)? UI_UNIT_X*3: UI_UNIT_X*6; if(openop) { - but= uiDefIconTextButO(block, BUT, openop, WM_OP_INVOKE_DEFAULT, ICON_FILESEL, (id)? "": "Open", 0, 0, w, UI_UNIT_Y, NULL); + but= uiDefIconTextButO(block, BUT, openop, WM_OP_INVOKE_DEFAULT, ICON_FILESEL, (id)? "": UI_translate_do_iface(N_("Open")), 0, 0, w, UI_UNIT_Y, NULL); uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_OPEN)); } else { - but= uiDefIconTextBut(block, BUT, 0, ICON_FILESEL, (id)? "": "Open", 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL); + but= uiDefIconTextBut(block, BUT, 0, ICON_FILESEL, (id)? "": UI_translate_do_iface(N_("Open")), 0, 0, w, UI_UNIT_Y, NULL, 0, 0, 0, 0, NULL); uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_OPEN)); } @@ -465,7 +469,8 @@ static void template_ID(bContext *C, uiLayout *layout, TemplateID *template, Str uiButSetNFunc(but, NULL, MEM_dupallocN(template), NULL); } else { - but= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, "Unlink datablock. Shift + Click to set users to zero, data will then not be saved"); + but= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0, 0, 0, 0, + UI_translate_do_tooltip(N_("Unlink datablock. Shift + Click to set users to zero, data will then not be saved"))); uiButSetNFunc(but, template_id_cb, MEM_dupallocN(template), SET_INT_IN_POINTER(UI_ID_DELETE)); if(RNA_property_flag(template->prop) & PROP_NEVER_NULL) @@ -722,7 +727,8 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif sprintf(str, "%s parent deform", md->name); uiDefBut(block, LABEL, 0, str, 0, 0, 185, UI_UNIT_Y, NULL, 0.0, 0.0, 0.0, 0.0, "Modifier name"); - but = uiDefBut(block, BUT, 0, "Make Real", 0, 0, 80, 16, NULL, 0.0, 0.0, 0.0, 0.0, "Convert virtual modifier to a real modifier"); + but = uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Make Real")), 0, 0, 80, 16, NULL, 0.0, 0.0, 0.0, 0.0, + UI_translate_do_tooltip(N_("Convert virtual modifier to a real modifier"))); uiButSetFunc(but, modifiers_convertToReal, ob, md); } else { @@ -756,7 +762,8 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif if ((ob->type==OB_MESH) && modifier_couldBeCage(scene, md) && (index <= lastCageIndex)) { /* -- convert to rna ? */ - but = uiDefIconButBitI(block, TOG, eModifierMode_OnCage, 0, ICON_MESH_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0, "Apply modifier to editing cage during Editmode"); + but = uiDefIconButBitI(block, TOG, eModifierMode_OnCage, 0, ICON_MESH_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0, + UI_translate_do_tooltip(N_("Apply modifier to editing cage during Editmode"))); if (index < cageIndex) uiButSetFlag(but, UI_BUT_DISABLED); uiButSetFunc(but, modifiers_setOnCage, ob, md); @@ -768,7 +775,8 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif if (ELEM3(md->type, eModifierType_Hook, eModifierType_Softbody, eModifierType_MeshDeform)) { /* add disabled pre-tesselated button, so users could have message for this modifiers */ - but = uiDefIconButBitI(block, TOG, eModifierMode_ApplyOnSpline, 0, ICON_SURFACE_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0, "This modifier could be applied on splines' points only"); + but = uiDefIconButBitI(block, TOG, eModifierMode_ApplyOnSpline, 0, ICON_SURFACE_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0, + UI_translate_do_tooltip(N_("This modifier could be applied on splines' points only"))); uiButSetFlag(but, UI_BUT_DISABLED); } else if (mti->type != eModifierTypeType_Constructive) { /* constructive modifiers tesselates curve before applying */ @@ -818,17 +826,17 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob, Modif } else { uiLayoutSetOperatorContext(row, WM_OP_INVOKE_DEFAULT); - uiItemEnumO(row, "OBJECT_OT_modifier_apply", "Apply", 0, "apply_as", MODIFIER_APPLY_DATA); + uiItemEnumO(row, "OBJECT_OT_modifier_apply", UI_translate_do_iface(N_("Apply")), 0, "apply_as", MODIFIER_APPLY_DATA); if (modifier_sameTopology(md)) - uiItemEnumO(row, "OBJECT_OT_modifier_apply", "Apply as Shape", 0, "apply_as", MODIFIER_APPLY_SHAPE); + uiItemEnumO(row, "OBJECT_OT_modifier_apply", UI_translate_do_iface(N_("Apply as Shape")), 0, "apply_as", MODIFIER_APPLY_SHAPE); } uiBlockClearButLock(block); uiBlockSetButLock(block, ob && ob->id.lib, ERROR_LIBDATA_MESSAGE); if (!ELEM5(md->type, eModifierType_Fluidsim, eModifierType_Softbody, eModifierType_ParticleSystem, eModifierType_Cloth, eModifierType_Smoke)) - uiItemO(row, "Copy", ICON_NONE, "OBJECT_OT_modifier_copy"); + uiItemO(row, UI_translate_do_tooltip(N_("Copy")), ICON_NONE, "OBJECT_OT_modifier_copy"); } /* result is the layout block inside the box, that we return so that modifier settings can be drawn */ @@ -1005,8 +1013,8 @@ static uiLayout *draw_constraint(uiLayout *layout, Object *ob, bConstraint *con) uiBlockSetEmboss(block, UI_EMBOSSN); /* draw a ghost icon (for proxy) and also a lock beside it, to show that constraint is "proxy locked" */ - uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_GHOST, xco+244, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, "Proxy Protected"); - uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_LOCKED, xco+262, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, "Proxy Protected"); + uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_GHOST, xco+244, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Proxy Protected"))); + uiDefIconBut(block, BUT, B_CONSTRAINT_TEST, ICON_LOCKED, xco+262, yco, 19, 19, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Proxy Protected"))); uiBlockSetEmboss(block, UI_EMBOSS); } @@ -1192,14 +1200,14 @@ void uiTemplatePreview(uiLayout *layout, ID *id, int show_buttons, ID *parent, M RNA_pointer_create(id, &RNA_Texture, tex, &texture_ptr); uiLayoutRow(layout, 1); - uiDefButS(block, ROW, B_MATPRV, "Texture", 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_TEXTURE, 0, 0, ""); + uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Texture")), 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_TEXTURE, 0, 0, ""); if(GS(parent->name) == ID_MA) - uiDefButS(block, ROW, B_MATPRV, "Material", 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, ""); + uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Material")), 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, ""); else if(GS(parent->name) == ID_LA) - uiDefButS(block, ROW, B_MATPRV, "Lamp", 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, ""); + uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Lamp")), 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, ""); else if(GS(parent->name) == ID_WO) - uiDefButS(block, ROW, B_MATPRV, "World", 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, ""); - uiDefButS(block, ROW, B_MATPRV, "Both", 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_BOTH, 0, 0, ""); + uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("World")), 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_OTHER, 0, 0, ""); + uiDefButS(block, ROW, B_MATPRV, UI_translate_do_iface(N_("Both")), 0, 0,UI_UNIT_X*10,UI_UNIT_Y, pr_texture, 10, TEX_PR_BOTH, 0, 0, ""); /* Alpha buton for texture preview */ if(*pr_texture!=TEX_PR_OTHER) { @@ -1290,21 +1298,23 @@ static void colorband_buttons_large(uiLayout *layout, uiBlock *block, ColorBand if(coba==NULL) return; - bt= uiDefBut(block, BUT, 0, "Add", 0+xoffs,line1_y,40,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Add a new color stop to the colorband"); + bt= uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Add")), 0+xoffs,line1_y,40,UI_UNIT_Y, NULL, 0, 0, 0, 0, + UI_translate_do_tooltip(N_("Add a new color stop to the colorband"))); uiButSetNFunc(bt, colorband_add_cb, MEM_dupallocN(cb), coba); - bt= uiDefBut(block, BUT, 0, "Delete", 45+xoffs,line1_y,45,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Delete the active position"); + bt= uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Delete")), 45+xoffs,line1_y,45,UI_UNIT_Y, NULL, 0, 0, 0, 0, + UI_translate_do_tooltip(N_("Delete the active position"))); uiButSetNFunc(bt, colorband_del_cb, MEM_dupallocN(cb), coba); /* XXX, todo for later - convert to operator - campbell */ - bt= uiDefBut(block, BUT, 0, "F", 95+xoffs,line1_y,20,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Flip colorband"); + bt= uiDefBut(block, BUT, 0, "F", 95+xoffs,line1_y,20,UI_UNIT_Y, NULL, 0, 0, 0, 0, UI_translate_do_tooltip(N_("Flip colorband"))); uiButSetNFunc(bt, colorband_flip_cb, MEM_dupallocN(cb), coba); - uiDefButS(block, NUM, 0, "", 120+xoffs,line1_y,80, UI_UNIT_Y, &coba->cur, 0.0, (float)(MAX2(0, coba->tot-1)), 0, 0, "Choose active color stop"); + uiDefButS(block, NUM, 0, "", 120+xoffs,line1_y,80, UI_UNIT_Y, &coba->cur, 0.0, (float)(MAX2(0, coba->tot-1)), 0, 0, UI_translate_do_tooltip(N_("Choose active color stop"))); - bt= uiDefButS(block, MENU, 0, "Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4", - 210+xoffs, line1_y, 90, UI_UNIT_Y, &coba->ipotype, 0.0, 0.0, 0, 0, "Set interpolation between color stops"); + bt= uiDefButS(block, MENU, 0, UI_translate_do_iface(N_("Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4")), + 210+xoffs, line1_y, 90, UI_UNIT_Y, &coba->ipotype, 0.0, 0.0, 0, 0, UI_translate_do_tooltip(N_("Set interpolation between color stops"))); uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL); uiBlockEndAlign(block); @@ -1333,11 +1343,13 @@ static void colorband_buttons_small(uiLayout *layout, uiBlock *block, ColorBand float xs= butr->xmin; uiBlockBeginAlign(block); - bt= uiDefBut(block, BUT, 0, "Add", xs,butr->ymin+UI_UNIT_Y,2.0f*unit,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Add a new color stop to the colorband"); + bt= uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Add")), xs,butr->ymin+UI_UNIT_Y,2.0f*unit,UI_UNIT_Y, NULL, 0, 0, 0, 0, + UI_translate_do_tooltip(N_("Add a new color stop to the colorband"))); uiButSetNFunc(bt, colorband_add_cb, MEM_dupallocN(cb), coba); - bt= uiDefBut(block, BUT, 0, "Delete", xs+2.0f*unit,butr->ymin+UI_UNIT_Y,1.5f*unit,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Delete the active position"); + bt= uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Delete")), xs+2.0f*unit,butr->ymin+UI_UNIT_Y,1.5f*unit,UI_UNIT_Y, NULL, 0, 0, 0, 0, + UI_translate_do_tooltip(N_("Delete the active position"))); uiButSetNFunc(bt, colorband_del_cb, MEM_dupallocN(cb), coba); - bt= uiDefBut(block, BUT, 0, "F", xs+3.5f*unit,butr->ymin+UI_UNIT_Y,0.5f*unit,UI_UNIT_Y, NULL, 0, 0, 0, 0, "Flip the color ramp"); + bt= uiDefBut(block, BUT, 0, "F", xs+3.5f*unit,butr->ymin+UI_UNIT_Y,0.5f*unit,UI_UNIT_Y, NULL, 0, 0, 0, 0, UI_translate_do_tooltip(N_("Flip the color ramp"))); uiButSetNFunc(bt, colorband_flip_cb, MEM_dupallocN(cb), coba); uiBlockEndAlign(block); @@ -1348,8 +1360,9 @@ static void colorband_buttons_small(uiLayout *layout, uiBlock *block, ColorBand uiItemR(layout, &ptr, "color", 0, "", ICON_NONE); } - bt= uiDefButS(block, MENU, 0, "Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4", - xs+10.0f*unit, butr->ymin+UI_UNIT_Y, unit*4, UI_UNIT_Y, &coba->ipotype, 0.0, 0.0, 0, 0, "Set interpolation between color stops"); + bt= uiDefButS(block, MENU, 0, UI_translate_do_tooltip(N_("Interpolation %t|Ease %x1|Cardinal %x3|Linear %x0|B-Spline %x2|Constant %x4")), + xs+10.0f*unit, butr->ymin+UI_UNIT_Y, unit*4, UI_UNIT_Y, &coba->ipotype, 0.0, 0.0, 0, 0, + UI_translate_do_tooltip(N_("Set interpolation between color stops"))); uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL); bt= uiDefBut(block, BUT_COLORBAND, 0, "", xs,butr->ymin,butr->xmax-butr->xmin,UI_UNIT_Y, coba, 0, 0, 0, 0, ""); @@ -1600,10 +1613,10 @@ static uiBlock *curvemap_clipping_func(bContext *C, struct ARegion *ar, void *cu uiButSetFunc(bt, curvemap_buttons_setclip, cumap, NULL); uiBlockBeginAlign(block); - uiDefButF(block, NUM, 0, "Min X ", 0,4*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmin, -100.0, cumap->clipr.xmax, 10, 0, ""); - uiDefButF(block, NUM, 0, "Min Y ", 0,3*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymin, -100.0, cumap->clipr.ymax, 10, 0, ""); - uiDefButF(block, NUM, 0, "Max X ", 0,2*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmax, cumap->clipr.xmin, 100.0, 10, 0, ""); - uiDefButF(block, NUM, 0, "Max Y ", 0,UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymax, cumap->clipr.ymin, 100.0, 10, 0, ""); + uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Min X ")), 0,4*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmin, -100.0, cumap->clipr.xmax, 10, 0, ""); + uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Min Y ")), 0,3*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymin, -100.0, cumap->clipr.ymax, 10, 0, ""); + uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Max X ")), 0,2*UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.xmax, cumap->clipr.xmin, 100.0, 10, 0, ""); + uiDefButF(block, NUM, 0, UI_translate_do_iface(N_("Max Y ")), 0,UI_UNIT_Y,width,UI_UNIT_Y, &cumap->clipr.ymax, cumap->clipr.ymin, 100.0, 10, 0, ""); uiBlockSetDirection(block, UI_RIGHT); @@ -1652,12 +1665,12 @@ static uiBlock *curvemap_tools_func(bContext *C, struct ARegion *ar, void *cumap block= uiBeginBlock(C, ar, "curvemap_tools_func", UI_EMBOSS); uiBlockSetButmFunc(block, curvemap_tools_dofunc, cumap_v); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset View", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Vector Handle", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Auto Handle", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Extend Horizontal", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 4, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Extend Extrapolated", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 5, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset Curve", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset View")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Vector Handle")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Auto Handle")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Extend Horizontal")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 4, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Extend Extrapolated")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 5, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset Curve")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); uiBlockSetDirection(block, UI_RIGHT); uiTextBoundsBlock(block, 50); @@ -1674,10 +1687,10 @@ static uiBlock *curvemap_brush_tools_func(bContext *C, struct ARegion *ar, void block= uiBeginBlock(C, ar, "curvemap_tools_func", UI_EMBOSS); uiBlockSetButmFunc(block, curvemap_tools_dofunc, cumap_v); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset View", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Vector Handle", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Auto Handle", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, ""); - uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, "Reset Curve", 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset View")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 1, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Vector Handle")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 2, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Auto Handle")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 3, ""); + uiDefIconTextBut(block, BUTM, 1, ICON_BLANK1, UI_translate_do_iface(N_("Reset Curve")), 0, yco-=UI_UNIT_Y, menuwidth, UI_UNIT_Y, NULL, 0.0, 0.0, 0, 0, ""); uiBlockSetDirection(block, UI_RIGHT); uiTextBoundsBlock(block, 50); @@ -1794,24 +1807,24 @@ static void curvemap_buttons_layout(uiLayout *layout, PointerRNA *ptr, char labe uiBlockSetEmboss(block, UI_EMBOSSN); - bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMIN, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, "Zoom in"); + bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMIN, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Zoom in"))); uiButSetFunc(bt, curvemap_buttons_zoom_in, cumap, NULL); - bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMOUT, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, "Zoom out"); + bt= uiDefIconBut(block, BUT, 0, ICON_ZOOMOUT, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Zoom out"))); uiButSetFunc(bt, curvemap_buttons_zoom_out, cumap, NULL); if(brush) - bt= uiDefIconBlockBut(block, curvemap_brush_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, "Tools"); + bt= uiDefIconBlockBut(block, curvemap_brush_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, UI_translate_do_tooltip(N_("Tools"))); else - bt= uiDefIconBlockBut(block, curvemap_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, "Tools"); + bt= uiDefIconBlockBut(block, curvemap_tools_func, cumap, 0, ICON_MODIFIER, 0, 0, dx, dx, UI_translate_do_tooltip(N_("Tools"))); uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL); if(cumap->flag & CUMA_DO_CLIP) icon= ICON_CLIPUV_HLT; else icon= ICON_CLIPUV_DEHLT; - bt= uiDefIconBlockBut(block, curvemap_clipping_func, cumap, 0, icon, 0, 0, dx, dx, "Clipping Options"); + bt= uiDefIconBlockBut(block, curvemap_clipping_func, cumap, 0, icon, 0, 0, dx, dx, UI_translate_do_tooltip(N_("Clipping Options"))); uiButSetNFunc(bt, rna_update_cb, MEM_dupallocN(cb), NULL); - bt= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, "Delete points"); + bt= uiDefIconBut(block, BUT, 0, ICON_X, 0, 0, dx, dx, NULL, 0.0, 0.0, 0.0, 0.0, UI_translate_do_tooltip(N_("Delete points"))); uiButSetNFunc(bt, curvemap_buttons_delete, MEM_dupallocN(cb), cumap); uiBlockSetEmboss(block, UI_EMBOSS); @@ -1830,7 +1843,8 @@ static void curvemap_buttons_layout(uiLayout *layout, PointerRNA *ptr, char labe uiItemR(uiLayoutColumn(split, 0), ptr, "white_level", UI_ITEM_R_EXPAND, NULL, ICON_NONE); uiLayoutRow(layout, 0); - bt=uiDefBut(block, BUT, 0, "Reset", 0, 0, UI_UNIT_X*10, UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "Reset Black/White point and curves"); + bt=uiDefBut(block, BUT, 0, UI_translate_do_iface(N_("Reset")), 0, 0, UI_UNIT_X*10, UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, + UI_translate_do_tooltip(N_("Reset Black/White point and curves"))); uiButSetNFunc(bt, curvemap_buttons_reset, MEM_dupallocN(cb), cumap); } @@ -2449,16 +2463,18 @@ void uiTemplateRunningJobs(uiLayout *layout, bContext *C) (void)ui_abs; // UNUSED uiDefIconBut(block, BUT, handle_event, ICON_PANEL_CLOSE, - 0, UI_UNIT_Y*0.1, UI_UNIT_X*0.8, UI_UNIT_Y*0.8, NULL, 0.0f, 0.0f, 0, 0, "Stop this job"); + 0, UI_UNIT_Y*0.1, UI_UNIT_X*0.8, UI_UNIT_Y*0.8, NULL, 0.0f, 0.0f, 0, 0, UI_translate_do_tooltip(N_("Stop this job"))); uiDefBut(block, PROGRESSBAR, 0, WM_jobs_name(wm, owner), - UI_UNIT_X, 0, 100, UI_UNIT_Y, NULL, 0.0f, 0.0f, WM_jobs_progress(wm, owner), 0, "Progress"); + UI_UNIT_X, 0, 100, UI_UNIT_Y, NULL, 0.0f, 0.0f, WM_jobs_progress(wm, owner), 0, UI_translate_do_tooltip(N_("Progress"))); uiLayoutRow(layout, 0); } if(WM_jobs_test(wm, screen)) - uiDefIconTextBut(block, BUT, B_STOPCAST, ICON_CANCEL, "Capture", 0,0,85,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "Stop screencast"); + uiDefIconTextBut(block, BUT, B_STOPCAST, ICON_CANCEL, UI_translate_do_iface(N_("Capture")), 0,0,85,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, + UI_translate_do_tooltip(N_("Stop screencast"))); if(screen->animtimer) - uiDefIconTextBut(block, BUT, B_STOPANIM, ICON_CANCEL, "Anim Player", 0,0,100,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, "Stop animation playback"); + uiDefIconTextBut(block, BUT, B_STOPANIM, ICON_CANCEL, UI_translate_do_tooltip(N_("Anim Player")), 0,0,100,UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, + UI_translate_do_tooltip(N_("Stop animation playback"))); } /************************* Reports for Last Operator Template **************************/ @@ -2520,7 +2536,7 @@ void uiTemplateReportsBanner(uiLayout *layout, bContext *C) uiBlockSetEmboss(block, UI_EMBOSSN); if (reports->list.first != reports->list.last) - uiDefIconButO(block, BUT, "UI_OT_reports_to_textblock", WM_OP_INVOKE_REGION_WIN, icon, 2, 0, UI_UNIT_X, UI_UNIT_Y, "Click to see rest of reports in textblock: 'Recent Reports'"); + uiDefIconButO(block, BUT, "UI_OT_reports_to_textblock", WM_OP_INVOKE_REGION_WIN, icon, 2, 0, UI_UNIT_X, UI_UNIT_Y, UI_translate_do_tooltip(N_("Click to see rest of reports in textblock: 'Recent Reports'"))); else uiDefIconBut(block, LABEL, 0, icon, 2, 0, UI_UNIT_X, UI_UNIT_Y, NULL, 0.0f, 0.0f, 0, 0, ""); diff --git a/source/blender/editors/interface/interface_utils.c b/source/blender/editors/interface/interface_utils.c index a3f56192cb5..a49060eaca2 100644 --- a/source/blender/editors/interface/interface_utils.c +++ b/source/blender/editors/interface/interface_utils.c @@ -37,6 +37,8 @@ #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" @@ -114,7 +116,7 @@ uiBut *uiDefAutoButR(uiBlock *block, PointerRNA *ptr, PropertyRNA *prop, int ind } case PROP_COLLECTION: { char text[256]; - sprintf(text, "%d items", RNA_property_collection_length(ptr, prop)); + sprintf(text, UI_translate_do_iface(N_("%d items")), RNA_property_collection_length(ptr, prop)); but= uiDefBut(block, LABEL, 0, text, x1, y1, x2, y2, NULL, 0, 0, 0, 0, NULL); uiButSetFlag(but, UI_BUT_DISABLED); break; diff --git a/source/blender/editors/interface/view2d.c b/source/blender/editors/interface/view2d.c index 9242ddc2f60..18db1c8c894 100644 --- a/source/blender/editors/interface/view2d.c +++ b/source/blender/editors/interface/view2d.c @@ -168,7 +168,7 @@ static void view2d_masks(View2D *v2d) void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy) { short tot_changed= 0, init= 0; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); /* initialise data if there is a need for such */ if ((v2d->flag & V2D_IS_INITIALISED) == 0) { diff --git a/source/blender/editors/interface/view2d_ops.c b/source/blender/editors/interface/view2d_ops.c index 460c2f038a4..0aaf6fe3bc6 100644 --- a/source/blender/editors/interface/view2d_ops.c +++ b/source/blender/editors/interface/view2d_ops.c @@ -51,6 +51,7 @@ #include "ED_screen.h" #include "UI_view2d.h" +#include "UI_interface.h" #include "PIL_time.h" /* USER_ZOOM_CONT */ @@ -1587,7 +1588,7 @@ static void VIEW2D_OT_scroller_activate(wmOperatorType *ot) static int reset_exec(bContext *C, wmOperator *UNUSED(op)) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); ARegion *ar= CTX_wm_region(C); View2D *v2d= &ar->v2d; int winx, winy; diff --git a/source/blender/editors/screen/area.c b/source/blender/editors/screen/area.c index d41d3245623..8951df9221e 100644 --- a/source/blender/editors/screen/area.c +++ b/source/blender/editors/screen/area.c @@ -43,6 +43,8 @@ #include "BLI_rand.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_global.h" #include "BKE_screen.h" @@ -1347,7 +1349,7 @@ void ED_area_prevspace(bContext *C, ScrArea *sa) static const char *editortype_pup(void) { - return( + const char *types= N_( "Editor type:%t" "|3D View %x1" @@ -1382,6 +1384,8 @@ static const char *editortype_pup(void) "|Python Console %x18" ); + + return UI_translate_do_iface(types); } static void spacefunc(struct bContext *C, void *UNUSED(arg1), void *UNUSED(arg2)) @@ -1403,8 +1407,7 @@ int ED_area_header_switchbutton(const bContext *C, uiBlock *block, int yco) but= uiDefIconTextButC(block, ICONTEXTROW, 0, ICON_VIEW3D, editortype_pup(), xco, yco, UI_UNIT_X+10, UI_UNIT_Y, &(sa->butspacetype), 1.0, SPACEICONMAX, 0, 0, - "Displays current editor type. " - "Click for menu of available types"); + UI_translate_do_tooltip(N_("Displays current editor type. Click for menu of available types"))); uiButSetFunc(but, spacefunc, NULL, NULL); uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */ @@ -1449,7 +1452,7 @@ int ED_area_header_standardbuttons(const bContext *C, uiBlock *block, int yco) void ED_region_panels(const bContext *C, ARegion *ar, int vertical, const char *context, int contextnr) { ScrArea *sa= CTX_wm_area(C); - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiBlock *block; PanelType *pt; Panel *panel; @@ -1637,7 +1640,7 @@ void ED_region_panels_init(wmWindowManager *wm, ARegion *ar) void ED_region_header(const bContext *C, ARegion *ar) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiBlock *block; uiLayout *layout; HeaderType *ht; diff --git a/source/blender/editors/space_buttons/CMakeLists.txt b/source/blender/editors/space_buttons/CMakeLists.txt index 631e2adea34..a9aaf6a6d58 100644 --- a/source/blender/editors/space_buttons/CMakeLists.txt +++ b/source/blender/editors/space_buttons/CMakeLists.txt @@ -21,6 +21,7 @@ set(INC ../include + ../../blenfont ../../blenkernel ../../blenlib ../../blenloader diff --git a/source/blender/editors/space_buttons/SConscript b/source/blender/editors/space_buttons/SConscript index a4270f1f59a..740353bc1f0 100644 --- a/source/blender/editors/space_buttons/SConscript +++ b/source/blender/editors/space_buttons/SConscript @@ -3,7 +3,7 @@ Import ('env') sources = env.Glob('*.c') -incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' +incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include' incs += ' ../../makesrna ../../render/extern/include ../../blenloader' diff --git a/source/blender/editors/space_buttons/buttons_header.c b/source/blender/editors/space_buttons/buttons_header.c index e631718b0cb..b18b5373240 100644 --- a/source/blender/editors/space_buttons/buttons_header.c +++ b/source/blender/editors/space_buttons/buttons_header.c @@ -37,6 +37,7 @@ #include "BLI_blenlib.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" #include "BKE_context.h" @@ -124,24 +125,23 @@ void buttons_header_buttons(const bContext *C, ARegion *ar) #define BUTTON_HEADER_CTX(_ctx, _icon, _tip) \ if(sbuts->pathflag & (1<<_ctx)) { \ - but= uiDefIconButS(block, ROW, B_CONTEXT_SWITCH, _icon, xco+=BUT_UNIT_X, yco, BUT_UNIT_X, UI_UNIT_Y, &(sbuts->mainb), 0.0, (float)_ctx, 0, 0, _tip); \ + but= uiDefIconButS(block, ROW, B_CONTEXT_SWITCH, _icon, xco+=BUT_UNIT_X, yco, BUT_UNIT_X, UI_UNIT_Y, &(sbuts->mainb), 0.0, (float)_ctx, 0, 0, UI_translate_do_tooltip(_tip)); \ uiButClearFlag(but, UI_BUT_UNDO); \ } \ - - BUTTON_HEADER_CTX(BCONTEXT_RENDER, ICON_SCENE, "Render") - BUTTON_HEADER_CTX(BCONTEXT_SCENE, ICON_SCENE_DATA, "Scene"); - BUTTON_HEADER_CTX(BCONTEXT_WORLD, ICON_WORLD, "World"); - BUTTON_HEADER_CTX(BCONTEXT_OBJECT, ICON_OBJECT_DATA, "Object"); - BUTTON_HEADER_CTX(BCONTEXT_CONSTRAINT, ICON_CONSTRAINT, "Object Constraints"); - BUTTON_HEADER_CTX(BCONTEXT_MODIFIER, ICON_MODIFIER, "Object Modifiers"); - BUTTON_HEADER_CTX(BCONTEXT_DATA, sbuts->dataicon, "Object Data"); - BUTTON_HEADER_CTX(BCONTEXT_BONE, ICON_BONE_DATA, "Bone"); - BUTTON_HEADER_CTX(BCONTEXT_BONE_CONSTRAINT, ICON_CONSTRAINT_BONE, "Bone Constraints"); - BUTTON_HEADER_CTX(BCONTEXT_MATERIAL, ICON_MATERIAL, "Material"); - BUTTON_HEADER_CTX(BCONTEXT_TEXTURE, ICON_TEXTURE, "Textures"); - BUTTON_HEADER_CTX(BCONTEXT_PARTICLE, ICON_PARTICLES, "Particles"); - BUTTON_HEADER_CTX(BCONTEXT_PHYSICS, ICON_PHYSICS, "Physics"); + BUTTON_HEADER_CTX(BCONTEXT_RENDER, ICON_SCENE, N_("Render")) + BUTTON_HEADER_CTX(BCONTEXT_SCENE, ICON_SCENE_DATA, N_("Scene")); + BUTTON_HEADER_CTX(BCONTEXT_WORLD, ICON_WORLD, N_("World")); + BUTTON_HEADER_CTX(BCONTEXT_OBJECT, ICON_OBJECT_DATA, N_("Object")); + BUTTON_HEADER_CTX(BCONTEXT_CONSTRAINT, ICON_CONSTRAINT, N_("Object Constraints")); + BUTTON_HEADER_CTX(BCONTEXT_MODIFIER, ICON_MODIFIER, N_("Object Modifiers")); + BUTTON_HEADER_CTX(BCONTEXT_DATA, sbuts->dataicon, N_("Object Data")); + BUTTON_HEADER_CTX(BCONTEXT_BONE, ICON_BONE_DATA, N_("Bone")); + BUTTON_HEADER_CTX(BCONTEXT_BONE_CONSTRAINT, ICON_CONSTRAINT_BONE, N_("Bone Constraints")); + BUTTON_HEADER_CTX(BCONTEXT_MATERIAL, ICON_MATERIAL, N_("Material")); + BUTTON_HEADER_CTX(BCONTEXT_TEXTURE, ICON_TEXTURE, N_("Textures")); + BUTTON_HEADER_CTX(BCONTEXT_PARTICLE, ICON_PARTICLES, N_("Particles")); + BUTTON_HEADER_CTX(BCONTEXT_PHYSICS, ICON_PHYSICS, N_("Physics")); #undef BUTTON_HEADER_CTX diff --git a/source/blender/editors/space_file/file_draw.c b/source/blender/editors/space_file/file_draw.c index 5f9b91e9cc2..b2b734159ff 100644 --- a/source/blender/editors/space_file/file_draw.c +++ b/source/blender/editors/space_file/file_draw.c @@ -50,6 +50,7 @@ #include "BKE_main.h" #include "BLF_api.h" +#include "BLF_translation.h" #include "IMB_imbuf_types.h" @@ -181,7 +182,7 @@ void file_draw_buttons(const bContext *C, ARegion *ar) but = uiDefButTextO(block, TEX, "FILE_OT_directory", 0, "", min_x, line1_y, line1_w-chan_offs, btn_h, params->dir, 0.0, (float)FILE_MAX-1, 0, 0, - "File path"); + UI_translate_do_tooltip(N_("File path"))); uiButSetCompleteFunc(but, autocomplete_directory, NULL); uiButSetFlag(but, UI_BUT_NO_UTF8); @@ -189,7 +190,7 @@ void file_draw_buttons(const bContext *C, ARegion *ar) but = uiDefBut(block, TEX, B_FS_FILENAME, "", min_x, line2_y, line2_w-chan_offs, btn_h, params->file, 0.0, (float)FILE_MAXFILE-1, 0, 0, - overwrite_alert ?"File name, overwrite existing" : "File name"); + UI_translate_do_tooltip(overwrite_alert ?N_("File name, overwrite existing") : N_("File name"))); uiButSetCompleteFunc(but, autocomplete_file, NULL); uiButSetFlag(but, UI_BUT_NO_UTF8); @@ -209,13 +210,13 @@ void file_draw_buttons(const bContext *C, ARegion *ar) but = uiDefIconButO(block, BUT, "FILE_OT_filenum", 0, ICON_ZOOMOUT, min_x + line2_w + separator - chan_offs, line2_y, btn_fn_w, btn_h, - "Decrement the filename number"); + UI_translate_do_tooltip(N_("Decrement the filename number"))); RNA_int_set(uiButGetOperatorPtrRNA(but), "increment", -1); but = uiDefIconButO(block, BUT, "FILE_OT_filenum", 0, ICON_ZOOMIN, min_x + line2_w + separator + btn_fn_w - chan_offs, line2_y, btn_fn_w, btn_h, - "Increment the filename number"); + UI_translate_do_tooltip(N_("Increment the filename number"))); RNA_int_set(uiButGetOperatorPtrRNA(but), "increment", 1); uiBlockEndAlign(block); } @@ -226,9 +227,9 @@ void file_draw_buttons(const bContext *C, ARegion *ar) uiDefButO(block, BUT, "FILE_OT_execute", WM_OP_EXEC_REGION_WIN, params->title, max_x - loadbutton, line1_y, loadbutton, btn_h, params->title); - uiDefButO(block, BUT, "FILE_OT_cancel", WM_OP_EXEC_REGION_WIN, "Cancel", + uiDefButO(block, BUT, "FILE_OT_cancel", WM_OP_EXEC_REGION_WIN, UI_translate_do_iface(N_("Cancel")), max_x - loadbutton, line2_y, loadbutton, btn_h, - "Cancel"); + UI_translate_do_tooltip(N_("Cancel"))); } uiEndBlock(C, block); @@ -295,7 +296,7 @@ static void file_draw_icon(uiBlock *block, char *path, int sx, int sy, int icon, static void file_draw_string(int sx, int sy, const char* string, float width, int height, short align) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiFontStyle fs = style->widgetlabel; rcti rect; char fname[FILE_MAXFILE]; diff --git a/source/blender/editors/space_file/file_panels.c b/source/blender/editors/space_file/file_panels.c index 959b1ddf1b5..37dce293d77 100644 --- a/source/blender/editors/space_file/file_panels.c +++ b/source/blender/editors/space_file/file_panels.c @@ -37,6 +37,8 @@ #include "BLI_blenlib.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "DNA_screen_types.h" #include "DNA_space_types.h" #include "DNA_userdef_types.h" @@ -144,7 +146,7 @@ static void file_panel_bookmarks(const bContext *C, Panel *pa) if(sfile) { row= uiLayoutRow(pa->layout, 0); - uiItemO(row, "Add", ICON_ZOOMIN, "file.bookmark_add"); + uiItemO(row, UI_translate_do_iface(N_("Add")), ICON_ZOOMIN, "file.bookmark_add"); uiItemL(row, NULL, ICON_NONE); file_panel_category(C, pa, FS_CATEGORY_BOOKMARKS, &sfile->bookmarknr, ICON_BOOKMARKS, 1, 0); diff --git a/source/blender/editors/space_file/filesel.c b/source/blender/editors/space_file/filesel.c index a8e7e08a7e0..1e113abfcd2 100644 --- a/source/blender/editors/space_file/filesel.c +++ b/source/blender/editors/space_file/filesel.c @@ -403,7 +403,7 @@ float file_shorten_string(char* string, float w, int front) float file_string_width(const char* str) { - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiStyleFontSet(&style->widget); return BLF_width(style->widget.uifont_id, str); } @@ -413,12 +413,12 @@ float file_font_pointsize(void) #if 0 float s; char tmp[2] = "X"; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiStyleFontSet(&style->widget); s = BLF_height(style->widget.uifont_id, tmp); return style->widget.points; #else - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); uiStyleFontSet(&style->widget); return style->widget.points * UI_DPI_FAC; #endif diff --git a/source/blender/editors/space_graph/CMakeLists.txt b/source/blender/editors/space_graph/CMakeLists.txt index 80205ad5564..28383b29b36 100644 --- a/source/blender/editors/space_graph/CMakeLists.txt +++ b/source/blender/editors/space_graph/CMakeLists.txt @@ -21,6 +21,7 @@ set(INC ../include + ../../blenfont ../../blenkernel ../../blenlib ../../blenloader diff --git a/source/blender/editors/space_graph/SConscript b/source/blender/editors/space_graph/SConscript index 75d0927192b..fe8846d2c30 100644 --- a/source/blender/editors/space_graph/SConscript +++ b/source/blender/editors/space_graph/SConscript @@ -3,7 +3,7 @@ Import ('env') sources = env.Glob('*.c') -incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf' +incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include' incs += ' #/intern/audaspace/intern ../../blenloader' diff --git a/source/blender/editors/space_graph/graph_buttons.c b/source/blender/editors/space_graph/graph_buttons.c index ffb43b753af..28fd1cd3304 100644 --- a/source/blender/editors/space_graph/graph_buttons.c +++ b/source/blender/editors/space_graph/graph_buttons.c @@ -46,6 +46,8 @@ #include "BLI_rand.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_depsgraph.h" #include "BKE_fcurve.h" @@ -750,7 +752,8 @@ static void graph_panel_modifiers(const bContext *C, Panel *pa) block= uiLayoutGetBlock(row); // XXX for now, this will be a operator button which calls a 'add modifier' operator - uiDefButO(block, BUT, "GRAPH_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, "Add Modifier", 10, 0, 150, 20, "Adds a new F-Curve Modifier for the active F-Curve"); + uiDefButO(block, BUT, "GRAPH_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, UI_translate_do_iface(N_("Add Modifier")), 10, 0, 150, 20, + UI_translate_do_tooltip(N_("Adds a new F-Curve Modifier for the active F-Curve"))); /* copy/paste (as sub-row)*/ row= uiLayoutRow(row, 1); diff --git a/source/blender/editors/space_info/space_info.c b/source/blender/editors/space_info/space_info.c index bd2e8077eab..75e13b24ede 100644 --- a/source/blender/editors/space_info/space_info.c +++ b/source/blender/editors/space_info/space_info.c @@ -41,6 +41,8 @@ #include "BLI_rand.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_global.h" #include "BKE_screen.h" @@ -278,7 +280,7 @@ static void recent_files_menu_draw(const bContext *UNUSED(C), Menu *menu) uiItemStringO(layout, BLI_path_basename(recent->filepath), ICON_FILE_BLEND, "WM_OT_open_mainfile", "filepath", recent->filepath); } } else { - uiItemL(layout, "No Recent Files", ICON_NONE); + uiItemL(layout, UI_translate_do_iface(N_("No Recent Files")), ICON_NONE); } } diff --git a/source/blender/editors/space_logic/CMakeLists.txt b/source/blender/editors/space_logic/CMakeLists.txt index 44471902040..f4bb255e11f 100644 --- a/source/blender/editors/space_logic/CMakeLists.txt +++ b/source/blender/editors/space_logic/CMakeLists.txt @@ -21,10 +21,11 @@ set(INC ../include - ../interface + ../../blenfont ../../blenkernel ../../blenlib ../../blenloader + ../../editors/interface ../../makesdna ../../makesrna ../../windowmanager diff --git a/source/blender/editors/space_logic/logic_window.c b/source/blender/editors/space_logic/logic_window.c index 00f8f488b3c..3a4371e8bb9 100644 --- a/source/blender/editors/space_logic/logic_window.c +++ b/source/blender/editors/space_logic/logic_window.c @@ -4548,7 +4548,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar) /* ****************** Controllers ****************** */ xco= 420; yco= 170; width= 300; - layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first); + layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, UI_GetStyle()); row = uiLayoutRow(layout, 1); uiDefBlockBut(block, controller_menu, NULL, "Controllers", xco-10, yco, 300, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */ @@ -4651,7 +4651,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar) /* ****************** Sensors ****************** */ xco= 10; yco= 170; width= 340; - layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first); + layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, UI_GetStyle()); row = uiLayoutRow(layout, 1); uiDefBlockBut(block, sensor_menu, NULL, "Sensors", xco-10, yco, 300, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */ @@ -4717,7 +4717,7 @@ static void logic_buttons_new(bContext *C, ARegion *ar) /* ****************** Actuators ****************** */ xco= 800; yco= 170; width= 340; - layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, U.uistyles.first); + layout= uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, xco, yco, width, 20, UI_GetStyle()); row = uiLayoutRow(layout, 1); uiDefBlockBut(block, actuator_menu, NULL, "Actuators", xco-10, yco, 300, UI_UNIT_Y, ""); /* replace this with uiLayout stuff later */ diff --git a/source/blender/editors/space_nla/CMakeLists.txt b/source/blender/editors/space_nla/CMakeLists.txt index b05d157365d..819e80d7b2e 100644 --- a/source/blender/editors/space_nla/CMakeLists.txt +++ b/source/blender/editors/space_nla/CMakeLists.txt @@ -21,6 +21,7 @@ set(INC ../include + ../../blenfont ../../blenkernel ../../blenlib ../../blenloader diff --git a/source/blender/editors/space_nla/SConscript b/source/blender/editors/space_nla/SConscript index 51ce829ed8d..6738f3380b4 100644 --- a/source/blender/editors/space_nla/SConscript +++ b/source/blender/editors/space_nla/SConscript @@ -3,7 +3,7 @@ Import ('env') sources = env.Glob('*.c') -incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf' +incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include ../../blenloader' env.BlenderLib ( 'bf_editors_space_nla', sources, Split(incs), [], libtype=['core'], priority=[85] ) diff --git a/source/blender/editors/space_nla/nla_buttons.c b/source/blender/editors/space_nla/nla_buttons.c index 4392e49e5d7..5e1f2745559 100644 --- a/source/blender/editors/space_nla/nla_buttons.c +++ b/source/blender/editors/space_nla/nla_buttons.c @@ -45,6 +45,8 @@ #include "BLI_editVert.h" #include "BLI_rand.h" +#include "BLF_translation.h" + #include "BKE_nla.h" #include "BKE_context.h" #include "BKE_screen.h" @@ -446,7 +448,8 @@ static void nla_panel_modifiers(const bContext *C, Panel *pa) // XXX for now, this will be a operator button which calls a temporary 'add modifier' operator // FIXME: we need to set the only-active property so that this will only add modifiers for the active strip (not all selected) - uiDefButO(block, BUT, "NLA_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, "Add Modifier", 10, 0, 150, 20, "Adds a new F-Modifier for the active NLA Strip"); + uiDefButO(block, BUT, "NLA_OT_fmodifier_add", WM_OP_INVOKE_REGION_WIN, UI_translate_do_iface(N_("Add Modifier")), 10, 0, 150, 20, + UI_translate_do_tooltip(N_("Adds a new F-Modifier for the active NLA Strip"))); /* copy/paste (as sub-row)*/ row= uiLayoutRow(row, 1); diff --git a/source/blender/editors/space_node/node_draw.c b/source/blender/editors/space_node/node_draw.c index c1b114d5436..e713ed5a678 100644 --- a/source/blender/editors/space_node/node_draw.c +++ b/source/blender/editors/space_node/node_draw.c @@ -303,7 +303,7 @@ static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node) RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr); layout= uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, - locx+NODE_DYS, dy, node->butr.xmax, NODE_DY, U.uistyles.first); + locx+NODE_DYS, dy, node->butr.xmax, NODE_DY, UI_GetStyle()); node->typeinfo->uifunc(layout, (bContext *)C, &ptr); diff --git a/source/blender/editors/space_node/node_header.c b/source/blender/editors/space_node/node_header.c index 7077f4a7497..996e05afdef 100644 --- a/source/blender/editors/space_node/node_header.c +++ b/source/blender/editors/space_node/node_header.c @@ -44,6 +44,8 @@ #include "BLI_blenlib.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_global.h" #include "BKE_screen.h" @@ -216,6 +218,7 @@ static void node_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass) } } +#define IFACE_(msgid) UI_translate_do_iface(msgid) static void node_menu_add(const bContext *C, Menu *menu) { SpaceNode *snode= CTX_wm_space_node(C); @@ -225,39 +228,40 @@ static void node_menu_add(const bContext *C, Menu *menu) uiLayoutSetActive(layout, 0); if(snode->treetype==NTREE_SHADER) { - uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT)); - uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT)); - uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR)); - uiItemMenuF(layout, "Vector", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR)); - uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR)); - uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP)); - uiItemMenuF(layout, "Dynamic", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_DYNAMIC)); - uiItemMenuF(layout, "Layout", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT)); + uiItemMenuF(layout, IFACE_(N_("Input")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT)); + uiItemMenuF(layout, IFACE_(N_("Output")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT)); + uiItemMenuF(layout, IFACE_(N_("Color")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR)); + uiItemMenuF(layout, IFACE_(N_("Vector")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR)); + uiItemMenuF(layout, IFACE_(N_("Convertor")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR)); + uiItemMenuF(layout, IFACE_(N_("Group")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP)); + uiItemMenuF(layout, IFACE_(N_("Dynamic")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_DYNAMIC)); + uiItemMenuF(layout, IFACE_(N_("Layout")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT)); } else if(snode->treetype==NTREE_COMPOSIT) { - uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT)); - uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT)); - uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR)); - uiItemMenuF(layout, "Vector", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR)); - uiItemMenuF(layout, "Filter", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_FILTER)); - uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR)); - uiItemMenuF(layout, "Matte", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_MATTE)); - uiItemMenuF(layout, "Distort", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT)); - uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP)); - uiItemMenuF(layout, "Layout", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT)); + uiItemMenuF(layout, IFACE_(N_("Input")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT)); + uiItemMenuF(layout, IFACE_(N_("Output")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT)); + uiItemMenuF(layout, IFACE_(N_("Color")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR)); + uiItemMenuF(layout, IFACE_(N_("Vector")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR)); + uiItemMenuF(layout, IFACE_(N_("Filter")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_FILTER)); + uiItemMenuF(layout, IFACE_(N_("Convertor")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR)); + uiItemMenuF(layout, IFACE_(N_("Matte")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_MATTE)); + uiItemMenuF(layout, IFACE_(N_("Distort")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT)); + uiItemMenuF(layout, IFACE_(N_("Group")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP)); + uiItemMenuF(layout, IFACE_(N_("Layout")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT)); } else if(snode->treetype==NTREE_TEXTURE) { - uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT)); - uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT)); - uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR)); - uiItemMenuF(layout, "Patterns", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_PATTERN)); - uiItemMenuF(layout, "Textures", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_TEXTURE)); - uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR)); - uiItemMenuF(layout, "Distort", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT)); - uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP)); - uiItemMenuF(layout, "Layout", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT)); + uiItemMenuF(layout, IFACE_(N_("Input")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT)); + uiItemMenuF(layout, IFACE_(N_("Output")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT)); + uiItemMenuF(layout, IFACE_(N_("Color")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR)); + uiItemMenuF(layout, IFACE_(N_("Patterns")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_PATTERN)); + uiItemMenuF(layout, IFACE_(N_("Textures")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_TEXTURE)); + uiItemMenuF(layout, IFACE_(N_("Convertor")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR)); + uiItemMenuF(layout, IFACE_(N_("Distort")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT)); + uiItemMenuF(layout, IFACE_(N_("Group")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP)); + uiItemMenuF(layout, IFACE_(N_("Layout")), 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_LAYOUT)); } } +#undef IFACE_ void node_menus_register(void) { diff --git a/source/blender/editors/space_view3d/view3d_header.c b/source/blender/editors/space_view3d/view3d_header.c index 980e27ce116..0776ca752a9 100644 --- a/source/blender/editors/space_view3d/view3d_header.c +++ b/source/blender/editors/space_view3d/view3d_header.c @@ -47,6 +47,8 @@ #include "BLI_editVert.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_depsgraph.h" #include "BKE_effect.h" @@ -269,16 +271,29 @@ void VIEW3D_OT_layers(wmOperatorType *ot) RNA_def_boolean(ot->srna, "toggle", 1, "Toggle", "Toggle the layer"); } +static int modeselect_addmode(char *str, const char *title, int id, int icon) +{ + static char formatstr[] = "|%s %%x%d %%i%d"; + + if(UI_translate_iface()) + return sprintf(str, formatstr, BLF_gettext(title), id, icon); + else + return sprintf(str, formatstr, title, id, icon); +} + static char *view3d_modeselect_pup(Scene *scene) { Object *ob= OBACT; static char string[256]; - static char formatstr[] = "|%s %%x%d %%i%d"; + const char *title= N_("Mode: %%t"); char *str = string; - str += sprintf(str, "Mode: %%t"); + if(U.transopts&USER_TR_IFACE) + title= BLF_gettext(title); + + sprintf(str, title); - str += sprintf(str, formatstr, "Object Mode", OB_MODE_OBJECT, ICON_OBJECT_DATA); + str += modeselect_addmode(str, N_("Object Mode"), OB_MODE_OBJECT, ICON_OBJECT_DATA); if(ob==NULL || ob->data==NULL) return string; if(ob->id.lib) return string; @@ -289,31 +304,31 @@ static char *view3d_modeselect_pup(Scene *scene) || (ob->type == OB_CURVE) || (ob->type == OB_SURF) || (ob->type == OB_FONT) || (ob->type == OB_MBALL) || (ob->type == OB_LATTICE))) { - str += sprintf(str, formatstr, "Edit Mode", OB_MODE_EDIT, ICON_EDITMODE_HLT); + str += modeselect_addmode(str, N_("Edit Mode"), OB_MODE_EDIT, ICON_EDITMODE_HLT); } else if (ob->type == OB_ARMATURE) { if (ob->mode & OB_MODE_POSE) - str += sprintf(str, formatstr, "Edit Mode", OB_MODE_EDIT|OB_MODE_POSE, ICON_EDITMODE_HLT); + str += modeselect_addmode(str, N_("Edit Mode"), OB_MODE_EDIT|OB_MODE_POSE, ICON_EDITMODE_HLT); else - str += sprintf(str, formatstr, "Edit Mode", OB_MODE_EDIT, ICON_EDITMODE_HLT); + str += modeselect_addmode(str, N_("Edit Mode"), OB_MODE_EDIT, ICON_EDITMODE_HLT); } if (ob->type == OB_MESH) { - str += sprintf(str, formatstr, "Sculpt Mode", OB_MODE_SCULPT, ICON_SCULPTMODE_HLT); - str += sprintf(str, formatstr, "Vertex Paint", OB_MODE_VERTEX_PAINT, ICON_VPAINT_HLT); - str += sprintf(str, formatstr, "Texture Paint", OB_MODE_TEXTURE_PAINT, ICON_TPAINT_HLT); - str += sprintf(str, formatstr, "Weight Paint", OB_MODE_WEIGHT_PAINT, ICON_WPAINT_HLT); + str += modeselect_addmode(str, N_("Sculpt Mode"), OB_MODE_SCULPT, ICON_SCULPTMODE_HLT); + str += modeselect_addmode(str, N_("Vertex Paint"), OB_MODE_VERTEX_PAINT, ICON_VPAINT_HLT); + str += modeselect_addmode(str, N_("Texture Paint"), OB_MODE_TEXTURE_PAINT, ICON_TPAINT_HLT); + str += modeselect_addmode(str, N_("Weight Paint"), OB_MODE_WEIGHT_PAINT, ICON_WPAINT_HLT); } } /* if active object is an armature */ if (ob->type==OB_ARMATURE) { - str += sprintf(str, formatstr, "Pose Mode", OB_MODE_POSE, ICON_POSE_HLT); + str += modeselect_addmode(str, N_("Pose Mode"), OB_MODE_POSE, ICON_POSE_HLT); } if (ob->particlesystem.first || modifiers_findByType(ob, eModifierType_Cloth) || modifiers_findByType(ob, eModifierType_Softbody)) { - str += sprintf(str, formatstr, "Particle Mode", OB_MODE_PARTICLE_EDIT, ICON_PARTICLEMODE); + str += modeselect_addmode(str, N_("Particle Mode"), OB_MODE_PARTICLE_EDIT, ICON_PARTICLEMODE); } (void)str; return (string); @@ -455,6 +470,7 @@ void uiTemplateEditModeSelection(uiLayout *layout, struct bContext *C) } } +#define TIP_(msgid) UI_translate_do_tooltip(msgid) void uiTemplateHeader3D(uiLayout *layout, struct bContext *C) { bScreen *screen= CTX_wm_screen(C); @@ -488,7 +504,7 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C) uiBlockBeginAlign(block); uiDefIconTextButS(block, MENU, B_MODESELECT, object_mode_icon(v3d->modeselect), view3d_modeselect_pup(scene) , - 0,0,126 * dpi_fac, UI_UNIT_Y, &(v3d->modeselect), 0, 0, 0, 0, "Mode"); + 0,0,126 * dpi_fac, UI_UNIT_Y, &(v3d->modeselect), 0, 0, 0, 0, TIP_(N_("Mode"))); uiBlockEndAlign(block); /* Draw type */ @@ -522,11 +538,11 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C) block= uiLayoutGetBlock(row); if(v3d->twflag & V3D_USE_MANIPULATOR) { - but= uiDefIconButBitC(block, TOG, V3D_MANIP_TRANSLATE, B_MAN_TRANS, ICON_MAN_TRANS, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, "Translate manipulator mode"); + but= uiDefIconButBitC(block, TOG, V3D_MANIP_TRANSLATE, B_MAN_TRANS, ICON_MAN_TRANS, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, TIP_(N_("Translate manipulator mode"))); uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */ - but= uiDefIconButBitC(block, TOG, V3D_MANIP_ROTATE, B_MAN_ROT, ICON_MAN_ROT, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, "Rotate manipulator mode"); + but= uiDefIconButBitC(block, TOG, V3D_MANIP_ROTATE, B_MAN_ROT, ICON_MAN_ROT, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, TIP_(N_("Rotate manipulator mode"))); uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */ - but= uiDefIconButBitC(block, TOG, V3D_MANIP_SCALE, B_MAN_SCALE, ICON_MAN_SCALE, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, "Scale manipulator mode"); + but= uiDefIconButBitC(block, TOG, V3D_MANIP_SCALE, B_MAN_SCALE, ICON_MAN_SCALE, 0,0,UI_UNIT_X,UI_UNIT_Y, &v3d->twtype, 1.0, 0.0, 0, 0, TIP_(N_("Scale manipulator mode"))); uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */ } @@ -534,8 +550,8 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C) v3d->twmode = 0; } - str_menu = BIF_menustringTransformOrientation(C, "Orientation"); - but= uiDefButC(block, MENU, B_MAN_MODE, str_menu,0,0,70 * dpi_fac, UI_UNIT_Y, &v3d->twmode, 0, 0, 0, 0, "Transform Orientation"); + str_menu = BIF_menustringTransformOrientation(C, N_("Orientation")); + but= uiDefButC(block, MENU, B_MAN_MODE, str_menu,0,0,70 * dpi_fac, UI_UNIT_Y, &v3d->twmode, 0, 0, 0, 0, TIP_(N_("Transform Orientation"))); uiButClearFlag(but, UI_BUT_UNDO); /* skip undo on screen buttons */ MEM_freeN((void *)str_menu); } @@ -555,4 +571,4 @@ void uiTemplateHeader3D(uiLayout *layout, struct bContext *C) uiTemplateEditModeSelection(layout, C); } - +#undef TIP_ diff --git a/source/blender/editors/space_view3d/view3d_toolbar.c b/source/blender/editors/space_view3d/view3d_toolbar.c index a2aed67821d..ddea89e1cdb 100644 --- a/source/blender/editors/space_view3d/view3d_toolbar.c +++ b/source/blender/editors/space_view3d/view3d_toolbar.c @@ -48,6 +48,8 @@ #include "BLI_utildefines.h" #include "BLI_ghash.h" +#include "BLF_translation.h" + #include "BKE_context.h" #include "BKE_idprop.h" #include "BKE_global.h" @@ -80,7 +82,7 @@ static void view3d_panel_operator_redo_header(const bContext *C, Panel *pa) wmOperator *op= WM_operator_last_redo(C); if(op) BLI_strncpy(pa->drawname, op->type->name, sizeof(pa->drawname)); - else BLI_strncpy(pa->drawname, "Operator", sizeof(pa->drawname)); + else BLI_strncpy(pa->drawname, N_("Operator"), sizeof(pa->drawname)); } static void view3d_panel_operator_redo_operator(const bContext *C, Panel *pa, wmOperator *op) diff --git a/source/blender/editors/transform/CMakeLists.txt b/source/blender/editors/transform/CMakeLists.txt index e44cc1f5df3..c4305ed6a9f 100644 --- a/source/blender/editors/transform/CMakeLists.txt +++ b/source/blender/editors/transform/CMakeLists.txt @@ -21,6 +21,7 @@ set(INC ../include + ../../blenfont ../../blenkernel ../../blenlib ../../blenloader diff --git a/source/blender/editors/transform/SConscript b/source/blender/editors/transform/SConscript index edc2156a07b..f2d5baecfb3 100644 --- a/source/blender/editors/transform/SConscript +++ b/source/blender/editors/transform/SConscript @@ -3,7 +3,7 @@ Import ('env') sources = env.Glob('*.c') -incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' +incs = '../include ../../blenfont ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include' incs += ' ../../render/extern/include' incs += ' ../../gpu ../../makesrna ../../blenloader' diff --git a/source/blender/editors/transform/transform_orientations.c b/source/blender/editors/transform/transform_orientations.c index 7556c5ae110..cd4cbc77c49 100644 --- a/source/blender/editors/transform/transform_orientations.c +++ b/source/blender/editors/transform/transform_orientations.c @@ -50,6 +50,8 @@ #include "BLI_editVert.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + //#include "BIF_editmesh.h" //#include "BIF_interface.h" //#include "BIF_space.h" @@ -60,6 +62,8 @@ #include "RNA_define.h" +#include "UI_interface.h" + #include "transform.h" /* *********************** TransSpace ************************** */ @@ -406,14 +410,18 @@ EnumPropertyItem *BIF_enumTransformOrientation(bContext *C) } const char * BIF_menustringTransformOrientation(const bContext *C, const char *title) { - char menu[] = "%t|Global%x0|Local%x1|Gimbal%x4|Normal%x2|View%x3"; + const char* menu = N_("%t|Global%x0|Local%x1|Gimbal%x4|Normal%x2|View%x3"); ListBase *transform_spaces = &CTX_data_scene(C)->transform_spaces; TransformOrientation *ts; int i = V3D_MANIP_CUSTOM; char *str_menu, *p; + + if(UI_translate_iface()) { + title= BLF_gettext(title); + menu= BLF_gettext(menu); + } - - str_menu = MEM_callocN(strlen(menu) + strlen(title) + 1 + 40 * BIF_countTransformOrientation(C), "UserTransSpace from matrix"); + str_menu = MEM_callocN(strlen(menu) + strlen(title) + 1 + 40 * BIF_countTransformOrientation(C), UI_translate_do_tooltip(N_("UserTransSpace from matrix"))); p = str_menu; p += sprintf(str_menu, "%s", title); diff --git a/source/blender/makesdna/DNA_userdef_types.h b/source/blender/makesdna/DNA_userdef_types.h index d3ac09dc812..05b16f869a8 100644 --- a/source/blender/makesdna/DNA_userdef_types.h +++ b/source/blender/makesdna/DNA_userdef_types.h @@ -510,8 +510,8 @@ extern UserDef U; /* from blenkernel blender.c */ /* transopts */ #define USER_TR_TOOLTIPS (1 << 0) -#define USER_TR_BUTTONS (1 << 1) -#define USER_TR_MENUS (1 << 2) +#define USER_TR_IFACE (1 << 1) +/*#define USER_TR_MENUS (1 << 2) deprecated*/ /*#define USER_TR_FILESELECT (1 << 3) deprecated*/ /*#define USER_TR_TEXTEDIT (1 << 4) deprecated*/ #define USER_DOTRANSLATE (1 << 5) diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h index 8af4fe7b76b..26bae68d5a4 100644 --- a/source/blender/makesrna/RNA_access.h +++ b/source/blender/makesrna/RNA_access.h @@ -49,7 +49,10 @@ struct Scene; extern BlenderRNA BLENDER_RNA; extern StructRNA RNA_Action; extern StructRNA RNA_ActionConstraint; +extern StructRNA RNA_ActionFCurves; extern StructRNA RNA_ActionGroup; +extern StructRNA RNA_ActionGroups; +extern StructRNA RNA_ActionPoseMarkers; extern StructRNA RNA_Actuator; extern StructRNA RNA_ActuatorSensor; extern StructRNA RNA_Addon; @@ -190,6 +193,7 @@ extern StructRNA RNA_DelaySensor; extern StructRNA RNA_DisplaceModifier; extern StructRNA RNA_DistortedNoiseTexture; extern StructRNA RNA_DomainFluidSettings; +extern StructRNA RNA_DopeSheet; extern StructRNA RNA_Driver; extern StructRNA RNA_DriverTarget; extern StructRNA RNA_DriverVariable; @@ -260,11 +264,13 @@ extern StructRNA RNA_Key; extern StructRNA RNA_KeyConfig; extern StructRNA RNA_KeyMap; extern StructRNA RNA_KeyMapItem; +extern StructRNA RNA_KeyMapItems; extern StructRNA RNA_KeyboardSensor; extern StructRNA RNA_Keyframe; extern StructRNA RNA_KeyingSet; extern StructRNA RNA_KeyingSetInfo; extern StructRNA RNA_KeyingSetPath; +extern StructRNA RNA_KeyingSetsAll; extern StructRNA RNA_KinematicConstraint; extern StructRNA RNA_Lamp; extern StructRNA RNA_LampSkySettings; @@ -552,6 +558,7 @@ extern StructRNA RNA_UnknownType; extern StructRNA RNA_UserPreferences; extern StructRNA RNA_UserPreferencesEdit; extern StructRNA RNA_UserPreferencesFilePaths; +extern StructRNA RNA_UserPreferencesInput; extern StructRNA RNA_UserPreferencesSystem; extern StructRNA RNA_UserPreferencesView; extern StructRNA RNA_UserSolidLight; @@ -573,13 +580,13 @@ extern StructRNA RNA_WipeSequence; extern StructRNA RNA_WoodTexture; extern StructRNA RNA_World; extern StructRNA RNA_WorldAmbientOcclusion; +extern StructRNA RNA_WorldLighting; extern StructRNA RNA_WorldMistSettings; extern StructRNA RNA_WorldStarsSettings; extern StructRNA RNA_WorldTextureSlot; extern StructRNA RNA_XnorController; extern StructRNA RNA_XorController; - /* Pointer * * These functions will fill in RNA pointers, this can be done in three ways: @@ -689,6 +696,7 @@ int RNA_enum_name(EnumPropertyItem *item, const int value, const char **name); int RNA_enum_description(EnumPropertyItem *item, const int value, const char **description); void RNA_property_enum_items(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free); +void RNA_property_enum_items_gettexted(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free); int RNA_property_enum_value(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const char *identifier, int *value); int RNA_property_enum_identifier(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **identifier); int RNA_property_enum_name(struct bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **name); diff --git a/source/blender/makesrna/SConscript b/source/blender/makesrna/SConscript index 10b20fc795a..d0002eda30b 100644 --- a/source/blender/makesrna/SConscript +++ b/source/blender/makesrna/SConscript @@ -62,4 +62,7 @@ if env['OURPLATFORM'] == 'linux': if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'): incs += ' ' + env['BF_PTHREADS_INC'] +if env['WITH_BF_INTERNATIONAL']: + defs.append('INTERNATIONAL') + env.BlenderLib ( 'bf_rna', objs, Split(incs), defines=defs, libtype=['core','player'], priority = [165,20] ) diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt index c2b46a3b69a..966bc8f100c 100644 --- a/source/blender/makesrna/intern/CMakeLists.txt +++ b/source/blender/makesrna/intern/CMakeLists.txt @@ -219,6 +219,10 @@ if(WITH_OPENCOLLADA) add_definitions(-DWITH_COLLADA) endif() +if(WITH_INTERNATIONAL) + add_definitions(-DINTERNATIONAL) +endif() + # Build makesrna executable blender_include_dirs( . diff --git a/source/blender/makesrna/intern/SConscript b/source/blender/makesrna/intern/SConscript index 5c2580e4b90..ef05875fe86 100644 --- a/source/blender/makesrna/intern/SConscript +++ b/source/blender/makesrna/intern/SConscript @@ -98,6 +98,9 @@ if env['OURPLATFORM'] == 'linux': if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'): incs += ' ' + env['BF_PTHREADS_INC'] +if env['WITH_BF_INTERNATIONAL']: + defs.append('INTERNATIONAL') + makesrna_tool.Append(CPPDEFINES=defs) makesrna_tool.Append (CPPPATH = Split(incs)) diff --git a/source/blender/makesrna/intern/rna_access.c b/source/blender/makesrna/intern/rna_access.c index 5dad7112eb9..b7709416a75 100644 --- a/source/blender/makesrna/intern/rna_access.c +++ b/source/blender/makesrna/intern/rna_access.c @@ -43,6 +43,9 @@ #include "BLI_dynstr.h" #include "BLI_ghash.h" +#include "BLF_api.h" +#include "BLF_translation.h" + #include "BKE_animsys.h" #include "BKE_context.h" #include "BKE_idprop.h" @@ -449,8 +452,10 @@ static const char *rna_ensure_property_identifier(PropertyRNA *prop) static const char *rna_ensure_property_description(PropertyRNA *prop) { + const char *description= NULL; + if(prop->magic == RNA_MAGIC) - return prop->description; + description= prop->description; else { /* attempt to get the local ID values */ IDProperty *idp_ui= rna_idproperty_ui(prop); @@ -458,19 +463,36 @@ static const char *rna_ensure_property_description(PropertyRNA *prop) if(idp_ui) { IDProperty *item= IDP_GetPropertyTypeFromGroup(idp_ui, "description", IDP_STRING); if(item) - return IDP_String(item); + description= IDP_String(item); } - return ((IDProperty*)prop)->name; /* XXX - not correct */ + if(description == NULL) + description= ((IDProperty*)prop)->name; /* XXX - not correct */ } + +#ifdef INTERNATIONAL + if((U.transopts&USER_DOTRANSLATE) && (U.transopts&USER_TR_TOOLTIPS)) + description= BLF_gettext(description); +#endif + + return description; } static const char *rna_ensure_property_name(PropertyRNA *prop) { + const char *name; + if(prop->magic == RNA_MAGIC) - return prop->name; + name= prop->name; else - return ((IDProperty*)prop)->name; + name= ((IDProperty*)prop)->name; + +#ifdef INTERNATIONAL + if((U.transopts&USER_DOTRANSLATE) && (U.transopts&USER_TR_IFACE)) + name= BLF_gettext(name); +#endif + + return name; } /* Structs */ @@ -1125,6 +1147,7 @@ void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, En *totitem= tot; } + } else { *item= eprop->item; @@ -1133,6 +1156,45 @@ void RNA_property_enum_items(bContext *C, PointerRNA *ptr, PropertyRNA *prop, En } } +void RNA_property_enum_items_gettexted(bContext *C, PointerRNA *ptr, PropertyRNA *prop, EnumPropertyItem **item, int *totitem, int *free) +{ + RNA_property_enum_items(C, ptr, prop, item, totitem, free); + +#ifdef INTERNATIONAL + if((U.transopts&USER_DOTRANSLATE) && (U.transopts&USER_TR_IFACE)) { + int i; + EnumPropertyItem *nitem; + + if(*free) { + nitem= *item; + } else { + int totitem= 0; + + /* count */ + for(i=0; (*item)[i].identifier; i++) + totitem++; + + nitem= MEM_callocN(sizeof(EnumPropertyItem)*(totitem+1), "enum_items_gettexted"); + + for(i=0; (*item)[i].identifier; i++) + nitem[i]= (*item)[i]; + + *free= 1; + } + + for(i=0; nitem[i].identifier; i++) { + if( nitem[i].name ) + nitem[i].name = BLF_gettext(nitem[i].name); + if( nitem[i].description ) + nitem[i].description = BLF_gettext(nitem[i].description); + } + + *item= nitem; + } +#endif +} + + int RNA_property_enum_value(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const char *identifier, int *value) { EnumPropertyItem *item, *item_array; diff --git a/source/blender/makesrna/intern/rna_userdef.c b/source/blender/makesrna/intern/rna_userdef.c index 7a5899afd73..b9a53acd6f4 100644 --- a/source/blender/makesrna/intern/rna_userdef.c +++ b/source/blender/makesrna/intern/rna_userdef.c @@ -44,6 +44,7 @@ #include "WM_types.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" #include "BKE_sound.h" @@ -76,6 +77,11 @@ static void rna_userdef_dpi_update(Main *bmain, Scene *scene, PointerRNA *ptr) WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL); /* refresh region sizes */ } +static void rna_userdef_language_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr)) +{ + BLF_lang_set(NULL); +} + static void rna_userdef_show_manipulator_update(Main *bmain, Scene *scene, PointerRNA *ptr) { UserDef *userdef = (UserDef *)ptr->data; @@ -2463,30 +2469,35 @@ static void rna_def_userdef_system(BlenderRNA *brna) {0, NULL, 0, NULL, NULL}}; /* hardcoded here, could become dynamic somehow */ + /* locale according to http://www.roseindia.net/tutorials/I18N/locales-list.shtml */ + /* if you edit here, please also edit the source/blender/blenfont/intern/blf_lang.c 's locales */ static EnumPropertyItem language_items[] = { - {0, "ENGLISH", 0, "English", ""}, - {1, "JAPANESE", 0, "Japanese", ""}, - {2, "DUTCH", 0, "Dutch", ""}, - {3, "ITALIAN", 0, "Italian", ""}, - {4, "GERMAN", 0, "German", ""}, - {5, "FINNISH", 0, "Finnish", ""}, - {6, "SWEDISH", 0, "Swedish", ""}, - {7, "FRENCH", 0, "French", ""}, - {8, "SPANISH", 0, "Spanish", ""}, - {9, "CATALAN", 0, "Catalan", ""}, - {10, "CZECH", 0, "Czech", ""}, - {11, "BRAZILIAN_PORTUGUESE", 0, "Brazilian Portuguese", ""}, - {12, "SIMPLIFIED_CHINESE", 0, "Simplified Chinese", ""}, - {13, "RUSSIAN", 0, "Russian", ""}, - {14, "CROATIAN", 0, "Croatian", ""}, - {15, "SERBIAN", 0, "Serbian", ""}, - {16, "UKRAINIAN", 0, "Ukrainian", ""}, - {17, "POLISH", 0, "Polish", ""}, - {18, "ROMANIAN", 0, "Romanian", ""}, - {19, "ARABIC", 0, "Arabic", ""}, - {20, "BULGARIAN", 0, "Bulgarian", ""}, - {21, "GREEK", 0, "Greek", ""}, - {22, "KOREAN", 0, "Korean", ""}, + {0, "DEFAULT", 0, N_("Default (Default)"), ""}, + {1, "ENGLISH", 0, N_("English (English)"), "en_US"}, + {2, "JAPANESE", 0, N_("Japanese (日本語)"), "ja_JP"}, + {3, "DUTCH", 0, N_("Dutch (Nederlandse taal)"), "nl_NL"}, + {4, "ITALIAN", 0, N_("Italian (Italiano)"), "it_IT"}, + {5, "GERMAN", 0, N_("German (Deutsch)"), "de_DE"}, + {6, "FINNISH", 0, N_("Finnish (Suomi)"), "fi_FI"}, + {7, "SWEDISH", 0, N_("Swedish (Svenska)"), "sv_SE"}, + {8, "FRENCH", 0, N_("French (Française)"), "fr_FR"}, + {9, "SPANISH", 0, N_("Spanish (Español)"), "es_ES"}, + {10, "CATALAN", 0, N_("Catalan (Català)"), "ca_AD"}, + {11, "CZECH", 0, N_("Czech (Český)"), "cs_CZ"}, + {12, "BRAZILIAN_PORTUGUESE", 0, N_("Brazilian Portuguese (Português do Brasil)"), "pt_BR"}, + {13, "SIMPLIFIED_CHINESE", 0, N_("Simplified Chinese (简体中文)"), "zh_CN"}, + {14, "TRADITIONAL_CHINESE", 0, N_("Traditional Chinese (繁體中文)"), "zh_TW"}, + {15, "RUSSIAN", 0, N_("Russian (Русский)"), "ru_RU"}, + {16, "CROATIAN", 0, N_("Croatian (Hrvatski)"), "hr_HR"}, + {17, "SERBIAN", 0, N_("Serbian (Српском језику)"), "sr_RS"}, + {18, "UKRAINIAN", 0, N_("Ukrainian (Український)"), "uk_UA"}, + {19, "POLISH", 0, N_("Polish (Polski)"), "pl_PL"}, + {20, "ROMANIAN", 0, N_("Romanian (Român)"), "ro_RO"}, + {21, "ARABIC", 0, N_("Arabic (العربية)"), "ar_EG"}, + {22, "BULGARIAN", 0, N_("Bulgarian (Български)"), "bg_BG"}, + {23, "GREEK", 0, N_("Greek (Ελληνικά)"), "el_GR"}, + {24, "KOREAN", 0, N_("Korean (한국 언어)"), "ko_KR"}, + /*{25, "Nepali", 0, N_("Nepali (नेपाली)"), "ne_NP"},*/ {0, NULL, 0, NULL, NULL}}; srna= RNA_def_struct(brna, "UserPreferencesSystem", NULL); @@ -2499,7 +2510,7 @@ static void rna_def_userdef_system(BlenderRNA *brna) prop= RNA_def_property(srna, "use_international_fonts", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_DOTRANSLATE); RNA_def_property_ui_text(prop, "International Fonts", "Use international fonts"); - RNA_def_property_update(prop, 0, "rna_userdef_update"); + RNA_def_property_update(prop, NC_WINDOW, "rna_userdef_language_update"); prop= RNA_def_property(srna, "dpi", PROP_INT, PROP_NONE); RNA_def_property_int_sdna(prop, NULL, "dpi"); @@ -2522,21 +2533,16 @@ static void rna_def_userdef_system(BlenderRNA *brna) prop= RNA_def_property(srna, "language", PROP_ENUM, PROP_NONE); RNA_def_property_enum_items(prop, language_items); RNA_def_property_ui_text(prop, "Language", "Language use for translation"); - RNA_def_property_update(prop, 0, "rna_userdef_update"); + RNA_def_property_update(prop, NC_WINDOW, "rna_userdef_language_update"); prop= RNA_def_property(srna, "use_translate_tooltips", PROP_BOOLEAN, PROP_NONE); RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_TOOLTIPS); RNA_def_property_ui_text(prop, "Translate Tooltips", "Translate Tooltips"); RNA_def_property_update(prop, 0, "rna_userdef_update"); - prop= RNA_def_property(srna, "use_translate_buttons", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_BUTTONS); - RNA_def_property_ui_text(prop, "Translate Buttons", "Translate button labels"); - RNA_def_property_update(prop, 0, "rna_userdef_update"); - - prop= RNA_def_property(srna, "use_translate_toolbox", PROP_BOOLEAN, PROP_NONE); - RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_MENUS); - RNA_def_property_ui_text(prop, "Translate Toolbox", "Translate toolbox menu"); + prop= RNA_def_property(srna, "use_translate_interface", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "transopts", USER_TR_IFACE); + RNA_def_property_ui_text(prop, "Translate Interface", "Translate Interface"); RNA_def_property_update(prop, 0, "rna_userdef_update"); prop= RNA_def_property(srna, "use_textured_fonts", PROP_BOOLEAN, PROP_NONE); diff --git a/source/blender/python/SConscript b/source/blender/python/SConscript index 9d7928c4432..5cc3f3bedc4 100644 --- a/source/blender/python/SConscript +++ b/source/blender/python/SConscript @@ -17,6 +17,9 @@ defs = [] if is_debug: defs.append('_DEBUG') +if env['WITH_BF_INTERNATIONAL']: + defs.append('INTERNATIONAL') + sources = env.Glob('generic/*.c') env.BlenderLib( libname = 'bf_python_ext', sources = Split(sources), includes = Split(incs), defines = defs, libtype = ['core','player'], priority = [363,165]) # ketsji is 360 diff --git a/source/blender/python/generic/CMakeLists.txt b/source/blender/python/generic/CMakeLists.txt index 8dfbf476995..0a49036c15d 100644 --- a/source/blender/python/generic/CMakeLists.txt +++ b/source/blender/python/generic/CMakeLists.txt @@ -48,5 +48,8 @@ set(SRC py_capi_utils.h ) +if(WITH_INTERNATIONAL) + add_definitions(-DINTERNATIONAL) +endif() blender_add_lib(bf_python_ext "${SRC}" "${INC}" "${INC_SYS}") diff --git a/source/blender/python/generic/blf_py_api.c b/source/blender/python/generic/blf_py_api.c index 3cf0b0f1f27..abf5ee7bada 100644 --- a/source/blender/python/generic/blf_py_api.c +++ b/source/blender/python/generic/blf_py_api.c @@ -31,9 +31,13 @@ #include "blf_py_api.h" #include "../../blenfont/BLF_api.h" +#include "../../blenfont/BLF_translation.h" #include "BLI_utildefines.h" +#ifdef INTERNATIONAL +#include "DNA_userdef_types.h" /* is it bad level? */ +#endif PyDoc_STRVAR(py_blf_position_doc, @@ -367,6 +371,34 @@ static PyObject *py_blf_load(PyObject *UNUSED(self), PyObject *args) return PyLong_FromLong(BLF_load(filename)); } +#ifdef INTERNATIONAL +PyDoc_STRVAR(py_blf_gettext_doc, +".. function:: gettext(msgid)\n" +"\n" +" Get a msg in local language.\n" +"\n" +" :arg msgid: the source string.\n" +" :type msgid: string\n" +" :return: the localized string.\n" +" :rtype: string\n" +); +static PyObject *py_blf_gettext(PyObject *UNUSED(self), PyObject *value) +{ + if ((U.transopts & USER_DOTRANSLATE) && (U.transopts & USER_TR_IFACE)) { + const char *msgid= _PyUnicode_AsString(value); + if(msgid == NULL) { + PyErr_SetString(PyExc_TypeError, "blf.gettext expects a single string argument"); + return NULL; + } + + return PyUnicode_FromString(BLF_gettext(msgid)); + } + else { + return Py_INCREF(value), value; + } +} +#endif /* INTERNATIONAL */ + /*----------------------------MODULE INIT-------------------------*/ static PyMethodDef BLF_methods[] = { {"aspect", (PyCFunction) py_blf_aspect, METH_VARARGS, py_blf_aspect_doc}, @@ -382,6 +414,9 @@ static PyMethodDef BLF_methods[] = { {"shadow_offset", (PyCFunction) py_blf_shadow_offset, METH_VARARGS, py_blf_shadow_offset_doc}, {"size", (PyCFunction) py_blf_size, METH_VARARGS, py_blf_size_doc}, {"load", (PyCFunction) py_blf_load, METH_VARARGS, py_blf_load_doc}, +#ifdef INTERNATIONAL + {"gettext", (PyCFunction) py_blf_gettext, METH_O, py_blf_gettext_doc}, +#endif {NULL, NULL, 0, NULL} }; diff --git a/source/blender/windowmanager/SConscript b/source/blender/windowmanager/SConscript index 80c526f8649..c60752b85f8 100644 --- a/source/blender/windowmanager/SConscript +++ b/source/blender/windowmanager/SConscript @@ -39,4 +39,7 @@ if env['OURPLATFORM'] != 'darwin' or env['WITH_GHOST_COCOA']: if env['BF_BUILDINFO']: defs.append('WITH_BUILDINFO') +if env['WITH_BF_INTERNATIONAL']: + defs.append('INTERNATIONAL') + env.BlenderLib ( 'bf_windowmanager', sources, Split(incs), defines=defs, libtype=['core'], priority=[5] ) diff --git a/source/blender/windowmanager/intern/wm_files.c b/source/blender/windowmanager/intern/wm_files.c index 6b3a574b6b6..f862af6173a 100644 --- a/source/blender/windowmanager/intern/wm_files.c +++ b/source/blender/windowmanager/intern/wm_files.c @@ -59,6 +59,8 @@ #include "BLI_utildefines.h" #include "BLI_callbacks.h" +#include "BLF_translation.h" + #include "DNA_anim_types.h" #include "DNA_ipo_types.h" // XXX old animation system #include "DNA_object_types.h" @@ -429,16 +431,17 @@ void WM_read_file(bContext *C, const char *filepath, ReportList *reports) else if(retval == BKE_READ_EXOTIC_OK_OTHER) BKE_write_undo(C, "Import file"); else if(retval == BKE_READ_EXOTIC_FAIL_OPEN) { - BKE_reportf(reports, RPT_ERROR, "Can't read file: \"%s\", %s.", filepath, errno ? strerror(errno) : "Unable to open the file"); + BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("Can't read file: \"%s\", %s.")), filepath, + errno ? strerror(errno) : UI_translate_do_iface(N_("Unable to open the file"))); } else if(retval == BKE_READ_EXOTIC_FAIL_FORMAT) { - BKE_reportf(reports, RPT_ERROR, "File format is not supported in file: \"%s\".", filepath); + BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("File format is not supported in file: \"%s\".")), filepath); } else if(retval == BKE_READ_EXOTIC_FAIL_PATH) { - BKE_reportf(reports, RPT_ERROR, "File path invalid: \"%s\".", filepath); + BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("File path invalid: \"%s\".")), filepath); } else { - BKE_reportf(reports, RPT_ERROR, "Unknown error loading: \"%s\".", filepath); + BKE_reportf(reports, RPT_ERROR, UI_translate_do_iface(N_("Unknown error loading: \"%s\".")), filepath); BLI_assert(!"invalid 'retval'"); } diff --git a/source/blender/windowmanager/intern/wm_init_exit.c b/source/blender/windowmanager/intern/wm_init_exit.c index 365301538b0..f114b19debb 100644 --- a/source/blender/windowmanager/intern/wm_init_exit.c +++ b/source/blender/windowmanager/intern/wm_init_exit.c @@ -99,6 +99,7 @@ #include "UI_interface.h" #include "BLF_api.h" +#include "BLF_translation.h" #include "GPU_buffers.h" #include "GPU_extensions.h" @@ -143,6 +144,8 @@ void WM_init(bContext *C, int argc, const char **argv) /* get the default database, plus a wm */ WM_read_homefile(C, NULL, G.factory_startup); + BLF_lang_set(NULL); + /* note: there is a bug where python needs initializing before loading the * startup.blend because it may contain PyDrivers. It also needs to be after * initializing space types and other internal data. @@ -378,7 +381,7 @@ void WM_exit(bContext *C) BIF_freeTemplates(C); free_ttfont(); /* bke_font.h */ - + free_openrecent(); BKE_freecubetable(); @@ -398,6 +401,7 @@ void WM_exit(bContext *C) free_posebuf(); BLF_exit(); + BLF_free_unifont(); ANIM_keyingset_infos_exit(); diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c index 5e4505abaa5..320dc2ecdda 100644 --- a/source/blender/windowmanager/intern/wm_operators.c +++ b/source/blender/windowmanager/intern/wm_operators.c @@ -49,7 +49,7 @@ #include "DNA_userdef_types.h" #include "DNA_windowmanager_types.h" -#include "BLF_api.h" +#include "BLF_translation.h" #include "PIL_time.h" @@ -78,6 +78,7 @@ #include "BIF_gl.h" #include "BIF_glutil.h" /* for paint cursor */ +#include "BLF_api.h" #include "IMB_imbuf_types.h" #include "IMB_imbuf.h" @@ -150,12 +151,11 @@ void WM_operatortype_append(void (*opfunc)(wmOperatorType*)) opfunc(ot); if(ot->name==NULL) { - static char dummy_name[] = "Dummy Name"; fprintf(stderr, "ERROR: Operator %s has no name property!\n", ot->idname); - ot->name= dummy_name; + ot->name= UI_translate_do_iface(N_("Dummy Name")); } - RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:"(undocumented operator)"); // XXX All ops should have a description but for now allow them not to. + RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:UI_translate_do_iface(N_("(undocumented operator)"))); // XXX All ops should have a description but for now allow them not to. RNA_def_struct_identifier(ot->srna, ot->idname); BLI_ghash_insert(global_ops_hash, (void *)ot->idname, ot); @@ -168,7 +168,7 @@ void WM_operatortype_append_ptr(void (*opfunc)(wmOperatorType*, void*), void *us ot= MEM_callocN(sizeof(wmOperatorType), "operatortype"); ot->srna= RNA_def_struct(&BLENDER_RNA, "", "OperatorProperties"); opfunc(ot, userdata); - RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:"(undocumented operator)"); + RNA_def_struct_ui_text(ot->srna, ot->name, ot->description ? ot->description:UI_translate_do_iface(N_("(undocumented operator)"))); RNA_def_struct_identifier(ot->srna, ot->idname); BLI_ghash_insert(global_ops_hash, (void *)ot->idname, ot); @@ -362,7 +362,7 @@ wmOperatorType *WM_operatortype_append_macro(const char *idname, const char *nam ot->poll= NULL; if(!ot->description) - ot->description= "(undocumented operator)"; + ot->description= UI_translate_do_iface(N_("(undocumented operator)")); RNA_def_struct_ui_text(ot->srna, ot->name, ot->description); // XXX All ops should have a description but for now allow them not to. RNA_def_struct_identifier(ot->srna, ot->idname); @@ -387,7 +387,7 @@ void WM_operatortype_append_macro_ptr(void (*opfunc)(wmOperatorType*, void*), vo ot->poll= NULL; if(!ot->description) - ot->description= "(undocumented operator)"; + ot->description= UI_translate_do_iface(N_("(undocumented operator)")); opfunc(ot, userdata); @@ -784,7 +784,7 @@ int WM_operator_confirm_message(bContext *C, wmOperator *op, const char *message else properties= NULL; - pup= uiPupMenuBegin(C, "OK?", ICON_QUESTION); + pup= uiPupMenuBegin(C, UI_translate_do_iface(N_("OK?")), ICON_QUESTION); layout= uiPupMenuLayout(pup); uiItemFullO(layout, op->type->idname, message, ICON_NONE, properties, WM_OP_EXEC_REGION_WIN, 0); uiPupMenuEnd(C, pup); @@ -865,10 +865,10 @@ void WM_operator_properties_filesel(wmOperatorType *ot, int filter, short type, void WM_operator_properties_select_all(wmOperatorType *ot) { static EnumPropertyItem select_all_actions[] = { - {SEL_TOGGLE, "TOGGLE", 0, "Toggle", "Toggle selection for all elements"}, - {SEL_SELECT, "SELECT", 0, "Select", "Select all elements"}, - {SEL_DESELECT, "DESELECT", 0, "Deselect", "Deselect all elements"}, - {SEL_INVERT, "INVERT", 0, "Invert", "Invert selection of all elements"}, + {SEL_TOGGLE, "TOGGLE", 0, N_("Toggle"), "Toggle selection for all elements"}, + {SEL_SELECT, "SELECT", 0, N_("Select"), "Select all elements"}, + {SEL_DESELECT, "DESELECT", 0, N_("Deselect"), "Deselect all elements"}, + {SEL_INVERT, "INVERT", 0, N_("Invert"), "Invert selection of all elements"}, {0, NULL, 0, NULL, NULL} }; @@ -877,25 +877,25 @@ void WM_operator_properties_select_all(wmOperatorType *ot) { void WM_operator_properties_gesture_border(wmOperatorType *ot, int extend) { - RNA_def_int(ot->srna, "gesture_mode", 0, INT_MIN, INT_MAX, "Gesture Mode", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "xmin", 0, INT_MIN, INT_MAX, "X Min", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "xmax", 0, INT_MIN, INT_MAX, "X Max", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "ymin", 0, INT_MIN, INT_MAX, "Y Min", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "ymax", 0, INT_MIN, INT_MAX, "Y Max", "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "gesture_mode", 0, INT_MIN, INT_MAX, N_("Gesture Mode"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "xmin", 0, INT_MIN, INT_MAX, N_("X Min"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "xmax", 0, INT_MIN, INT_MAX, N_("X Max"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "ymin", 0, INT_MIN, INT_MAX, N_("Y Min"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "ymax", 0, INT_MIN, INT_MAX, N_("Y Max"), "", INT_MIN, INT_MAX); if(extend) - RNA_def_boolean(ot->srna, "extend", 1, "Extend", "Extend selection instead of deselecting everything first"); + RNA_def_boolean(ot->srna, "extend", 1, _("Extend"), _("Extend selection instead of deselecting everything first")); } void WM_operator_properties_gesture_straightline(wmOperatorType *ot, int cursor) { - RNA_def_int(ot->srna, "xstart", 0, INT_MIN, INT_MAX, "X Start", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "xend", 0, INT_MIN, INT_MAX, "X End", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "ystart", 0, INT_MIN, INT_MAX, "Y Start", "", INT_MIN, INT_MAX); - RNA_def_int(ot->srna, "yend", 0, INT_MIN, INT_MAX, "Y End", "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "xstart", 0, INT_MIN, INT_MAX, N_("X Start"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "xend", 0, INT_MIN, INT_MAX, N_("X End"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "ystart", 0, INT_MIN, INT_MAX, N_("Y Start"), "", INT_MIN, INT_MAX); + RNA_def_int(ot->srna, "yend", 0, INT_MIN, INT_MAX, N_("Y End"), "", INT_MIN, INT_MAX); if(cursor) - RNA_def_int(ot->srna, "cursor", cursor, 0, INT_MAX, "Cursor", "Mouse cursor style to use during the modal operator", 0, INT_MAX); + RNA_def_int(ot->srna, "cursor", cursor, 0, INT_MAX, N_("Cursor"), N_("Mouse cursor style to use during the modal operator"), 0, INT_MAX); } @@ -924,7 +924,7 @@ static uiBlock *wm_block_create_redo(bContext *C, ARegion *ar, void *arg_op) wmOperator *op= arg_op; uiBlock *block; uiLayout *layout; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); int width= 300; @@ -1002,7 +1002,7 @@ static uiBlock *wm_block_dialog_create(bContext *C, ARegion *ar, void *userData) wmOperator *op= data->op; uiBlock *block; uiLayout *layout; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); block = uiBeginBlock(C, ar, "operator dialog", UI_EMBOSS); uiBlockClearFlag(block, UI_BLOCK_LOOP); @@ -1026,7 +1026,7 @@ static uiBlock *wm_block_dialog_create(bContext *C, ARegion *ar, void *userData) col= uiLayoutColumn(layout, FALSE); col_block= uiLayoutGetBlock(col); /* Create OK button, the callback of which will execute op */ - btn= uiDefBut(col_block, BUT, 0, "OK", 0, -30, 0, UI_UNIT_Y, NULL, 0, 0, 0, 0, ""); + btn= uiDefBut(col_block, BUT, 0, UI_translate_do_iface(N_("OK")), 0, -30, 0, UI_UNIT_Y, NULL, 0, 0, 0, 0, ""); uiButSetFunc(btn, dialog_exec_cb, data, col_block); } @@ -1043,7 +1043,7 @@ static uiBlock *wm_operator_ui_create(bContext *C, ARegion *ar, void *userData) wmOperator *op= data->op; uiBlock *block; uiLayout *layout; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); block= uiBeginBlock(C, ar, "opui_popup", UI_EMBOSS); uiBlockClearFlag(block, UI_BLOCK_LOOP); @@ -1213,7 +1213,7 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar uiBlock *block; uiBut *but; uiLayout *layout, *split, *col; - uiStyle *style= U.uistyles.first; + uiStyle *style= UI_GetStyle(); struct RecentFile *recent; int i; MenuType *mt= WM_menutype_find("USERPREF_MT_splash", TRUE); @@ -1272,19 +1272,19 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar split = uiLayoutSplit(layout, 0, 0); col = uiLayoutColumn(split, 0); uiItemL(col, "Links", ICON_NONE); - uiItemStringO(col, "Donations", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/blenderorg/blender-foundation/donation-payment"); - uiItemStringO(col, "Credits", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/credits"); - uiItemStringO(col, "Release Log", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/release-logs/blender-259"); - uiItemStringO(col, "Manual", ICON_URL, "WM_OT_url_open", "url", "http://wiki.blender.org/index.php/Doc:2.5/Manual"); - uiItemStringO(col, "Blender Website", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org"); - uiItemStringO(col, "User Community", ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/community/user-community"); + uiItemStringO(col, UI_translate_do_iface(N_("Donations")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/blenderorg/blender-foundation/donation-payment"); + uiItemStringO(col, UI_translate_do_iface(N_("Credits")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/credits"); + uiItemStringO(col, UI_translate_do_iface(N_("Release Log")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/development/release-logs/blender-259"); + uiItemStringO(col, UI_translate_do_iface(N_("Manual")), ICON_URL, "WM_OT_url_open", "url", "http://wiki.blender.org/index.php/Doc:2.5/Manual"); + uiItemStringO(col, UI_translate_do_iface(N_("Blender Website")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org"); + uiItemStringO(col, UI_translate_do_iface(N_("User Community")), ICON_URL, "WM_OT_url_open", "url", "http://www.blender.org/community/user-community"); if(strcmp(STRINGIFY(BLENDER_VERSION_CYCLE), "release")==0) { BLI_snprintf(url, sizeof(url), "http://www.blender.org/documentation/blender_python_api_%d_%d" STRINGIFY(BLENDER_VERSION_CHAR) "_release", BLENDER_VERSION/100, BLENDER_VERSION%100); } else { BLI_snprintf(url, sizeof(url), "http://www.blender.org/documentation/blender_python_api_%d_%d_%d", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION); } - uiItemStringO(col, "Python API Reference", ICON_URL, "WM_OT_url_open", "url", url); + uiItemStringO(col, UI_translate_do_iface(N_("Python API Reference")), ICON_URL, "WM_OT_url_open", "url", url); uiItemL(col, "", ICON_NONE); col = uiLayoutColumn(split, 0); @@ -1294,7 +1294,7 @@ static uiBlock *wm_block_create_splash(bContext *C, ARegion *ar, void *UNUSED(ar uiItemS(col); } - uiItemL(col, "Recent", ICON_NONE); + uiItemL(col, UI_translate_do_iface(N_("Recent")), ICON_NONE); for(recent = G.recent_files.first, i=0; (i<5) && (recent); recent = recent->next, i++) { uiItemStringO(col, BLI_path_basename(recent->filepath), ICON_FILE_BLEND, "WM_OT_open_mainfile", "filepath", recent->filepath); } @@ -3304,13 +3304,13 @@ static void redraw_timer_window_swap(bContext *C) } static EnumPropertyItem redraw_timer_type_items[] = { - {0, "DRAW", 0, "Draw Region", "Draw Region"}, - {1, "DRAW_SWAP", 0, "Draw Region + Swap", "Draw Region and Swap"}, - {2, "DRAW_WIN", 0, "Draw Window", "Draw Window"}, - {3, "DRAW_WIN_SWAP", 0, "Draw Window + Swap", "Draw Window and Swap"}, - {4, "ANIM_STEP", 0, "Anim Step", "Animation Steps"}, - {5, "ANIM_PLAY", 0, "Anim Play", "Animation Playback"}, - {6, "UNDO", 0, "Undo/Redo", "Undo/Redo"}, + {0, "DRAW", 0, N_("Draw Region"), N_("Draw Region")}, + {1, "DRAW_SWAP", 0, N_("Draw Region + Swap"), N_("Draw Region and Swap")}, + {2, "DRAW_WIN", 0, N_("Draw Window"), N_("Draw Window")}, + {3, "DRAW_WIN_SWAP", 0, N_("Draw Window + Swap"), N_("Draw Window and Swap")}, + {4, "ANIM_STEP", 0, N_("Anim Step"), N_("Animation Steps")}, + {5, "ANIM_PLAY", 0, N_("Anim Play"), N_("Animation Playback")}, + {6, "UNDO", 0, N_("Undo/Redo"), N_("Undo/Redo")}, {0, NULL, 0, NULL, NULL}}; static int redraw_timer_exec(bContext *C, wmOperator *op) @@ -3543,14 +3543,14 @@ void wm_operatortype_init(void) static void gesture_circle_modal_keymap(wmKeyConfig *keyconf) { static EnumPropertyItem modal_items[] = { - {GESTURE_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""}, - {GESTURE_MODAL_CONFIRM, "CONFIRM", 0, "Confirm", ""}, - {GESTURE_MODAL_CIRCLE_ADD, "ADD", 0, "Add", ""}, - {GESTURE_MODAL_CIRCLE_SUB, "SUBTRACT", 0, "Subtract", ""}, + {GESTURE_MODAL_CANCEL, "CANCEL", 0, N_("Cancel"), ""}, + {GESTURE_MODAL_CONFIRM, "CONFIRM", 0, N_("Confirm"), ""}, + {GESTURE_MODAL_CIRCLE_ADD, "ADD", 0, N_("Add"), ""}, + {GESTURE_MODAL_CIRCLE_SUB, "SUBTRACT", 0, N_("Subtract"), ""}, - {GESTURE_MODAL_SELECT, "SELECT", 0, "Select", ""}, - {GESTURE_MODAL_DESELECT,"DESELECT", 0, "DeSelect", ""}, - {GESTURE_MODAL_NOP,"NOP", 0, "No Operation", ""}, + {GESTURE_MODAL_SELECT, "SELECT", 0, N_("Select"), ""}, + {GESTURE_MODAL_DESELECT,"DESELECT", 0, N_("DeSelect"), ""}, + {GESTURE_MODAL_NOP,"NOP", 0, N_("No Operation"), ""}, {0, NULL, 0, NULL, NULL}}; @@ -3596,9 +3596,9 @@ static void gesture_circle_modal_keymap(wmKeyConfig *keyconf) static void gesture_straightline_modal_keymap(wmKeyConfig *keyconf) { static EnumPropertyItem modal_items[] = { - {GESTURE_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""}, - {GESTURE_MODAL_SELECT, "SELECT", 0, "Select", ""}, - {GESTURE_MODAL_BEGIN, "BEGIN", 0, "Begin", ""}, + {GESTURE_MODAL_CANCEL, "CANCEL", 0, N_("Cancel"), ""}, + {GESTURE_MODAL_SELECT, "SELECT", 0, N_("Select"), ""}, + {GESTURE_MODAL_BEGIN, "BEGIN", 0, N_("Begin"), ""}, {0, NULL, 0, NULL, NULL}}; wmKeyMap *keymap= WM_modalkeymap_get(keyconf, "Gesture Straight Line"); @@ -3624,10 +3624,10 @@ static void gesture_straightline_modal_keymap(wmKeyConfig *keyconf) static void gesture_border_modal_keymap(wmKeyConfig *keyconf) { static EnumPropertyItem modal_items[] = { - {GESTURE_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""}, - {GESTURE_MODAL_SELECT, "SELECT", 0, "Select", ""}, - {GESTURE_MODAL_DESELECT,"DESELECT", 0, "DeSelect", ""}, - {GESTURE_MODAL_BEGIN, "BEGIN", 0, "Begin", ""}, + {GESTURE_MODAL_CANCEL, "CANCEL", 0, N_("Cancel"), ""}, + {GESTURE_MODAL_SELECT, "SELECT", 0, N_("Select"), ""}, + {GESTURE_MODAL_DESELECT,"DESELECT", 0, N_("DeSelect"), ""}, + {GESTURE_MODAL_BEGIN, "BEGIN", 0, N_("Begin"), ""}, {0, NULL, 0, NULL, NULL}}; wmKeyMap *keymap= WM_modalkeymap_get(keyconf, "Gesture Border"); @@ -3679,10 +3679,10 @@ static void gesture_border_modal_keymap(wmKeyConfig *keyconf) static void gesture_zoom_border_modal_keymap(wmKeyConfig *keyconf) { static EnumPropertyItem modal_items[] = { - {GESTURE_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""}, - {GESTURE_MODAL_IN, "IN", 0, "In", ""}, - {GESTURE_MODAL_OUT, "OUT", 0, "Out", ""}, - {GESTURE_MODAL_BEGIN, "BEGIN", 0, "Begin", ""}, + {GESTURE_MODAL_CANCEL, "CANCEL", 0, N_("Cancel"), ""}, + {GESTURE_MODAL_IN, "IN", 0, N_("In"), ""}, + {GESTURE_MODAL_OUT, "OUT", 0, N_("Out"), ""}, + {GESTURE_MODAL_BEGIN, "BEGIN", 0, N_("Begin"), ""}, {0, NULL, 0, NULL, NULL}}; wmKeyMap *keymap= WM_modalkeymap_get(keyconf, "Gesture Zoom Border"); diff --git a/source/blender/windowmanager/intern/wm_window.c b/source/blender/windowmanager/intern/wm_window.c index 7d6010786d2..d9ca275c819 100644 --- a/source/blender/windowmanager/intern/wm_window.c +++ b/source/blender/windowmanager/intern/wm_window.c @@ -48,6 +48,8 @@ #include "BLI_blenlib.h" #include "BLI_utildefines.h" +#include "BLF_translation.h" + #include "BKE_blender.h" #include "BKE_context.h" #include "BKE_library.h" @@ -73,6 +75,8 @@ #include "GPU_draw.h" #include "GPU_extensions.h" +#include "UI_interface.h" + /* the global to talk to ghost */ static GHOST_SystemHandle g_system= NULL; @@ -504,11 +508,11 @@ void WM_window_open_temp(bContext *C, rcti *position, int type) ED_screen_set(C, win->screen); if(sa->spacetype==SPACE_IMAGE) - GHOST_SetTitle(win->ghostwin, "Blender Render"); + GHOST_SetTitle(win->ghostwin, UI_translate_do_iface(N_("Blender Render"))); else if(ELEM(sa->spacetype, SPACE_OUTLINER, SPACE_USERPREF)) - GHOST_SetTitle(win->ghostwin, "Blender User Preferences"); + GHOST_SetTitle(win->ghostwin, UI_translate_do_iface(N_("Blender User Preferences"))); else if(sa->spacetype==SPACE_FILE) - GHOST_SetTitle(win->ghostwin, "Blender File View"); + GHOST_SetTitle(win->ghostwin, UI_translate_do_iface(N_("Blender File View"))); else GHOST_SetTitle(win->ghostwin, "Blender"); } diff --git a/source/creator/CMakeLists.txt b/source/creator/CMakeLists.txt index 666be16e73e..0b5d9f7c15c 100644 --- a/source/creator/CMakeLists.txt +++ b/source/creator/CMakeLists.txt @@ -356,7 +356,9 @@ if(UNIX AND NOT APPLE) ) install( - DIRECTORY ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale + DIRECTORY + ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale + ${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts DESTINATION ${TARGETDIR_VER}/datafiles PATTERN ".svn" EXCLUDE ) @@ -430,7 +432,9 @@ elseif(WIN32) DESTINATION ${TARGETDIR_VER} ) install( - DIRECTORY ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale + DIRECTORY + ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale + ${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts DESTINATION ${TARGETDIR_VER}/datafiles PATTERN ".svn" EXCLUDE ) @@ -449,8 +453,10 @@ elseif(WIN32) endif() install( # same as linux!, deduplicate - DIRECTORY ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale - DESTINATION ${TARGETDIR_VER}/datafiles/locale + DIRECTORY + ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale + ${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts + DESTINATION ${TARGETDIR_VER}/datafiles PATTERN ".svn" EXCLUDE ) @@ -662,9 +668,12 @@ elseif(APPLE) DESTINATION ${TARGETDIR_VER}/datafiles ) - install_dir( - ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale/ - \${TARGETDIR_VER}/datafiles/locale + install( + DIRECTORY + ${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts + ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale + DESTINATION ${TARGETDIR_VER}/datafiles + PATTERN ".svn" EXCLUDE ) endif() diff --git a/source/gameengine/GamePlayer/ghost/CMakeLists.txt b/source/gameengine/GamePlayer/ghost/CMakeLists.txt index 944ec9abd67..b452bb97cde 100644 --- a/source/gameengine/GamePlayer/ghost/CMakeLists.txt +++ b/source/gameengine/GamePlayer/ghost/CMakeLists.txt @@ -78,4 +78,8 @@ if(WITH_CODEC_FFMPEG) add_definitions(-DWITH_FFMPEG) endif() +if(WITH_INTERNATIONAL) + add_definitions(-DINTERNATIONAL) +endif() + blender_add_lib_nolist(ge_player_ghost "${SRC}" "${INC}" "${INC_SYS}") diff --git a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp index d4ce19de83f..eee27ca0790 100644 --- a/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp +++ b/source/gameengine/GamePlayer/ghost/GPG_ghost.cpp @@ -81,6 +81,7 @@ extern char btempdir[]; /* use this to store a valid temp directory */ // For BLF #include "BLF_api.h" +#include "BLF_translation.h" extern int datatoc_bfont_ttf_size; extern char datatoc_bfont_ttf[]; @@ -404,7 +405,7 @@ int main(int argc, char** argv) // We don't use threads directly in the BGE, but we need to call this so things like // freeing up GPU_Textures works correctly. BLI_threadapi_init(); - + RNA_init(); init_nodesystem(); @@ -420,6 +421,9 @@ int main(int argc, char** argv) // Setup builtin font for BLF (mostly copied from creator.c, wm_init_exit.c and interface_style.c) BLF_init(11, U.dpi); BLF_lang_init(); + BLF_lang_encoding(""); + BLF_lang_set(""); + BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size); // Parse command line options @@ -994,6 +998,7 @@ int main(int argc, char** argv) // Cleanup RNA_exit(); BLF_exit(); + BLF_free_unifont(); IMB_exit(); free_nodesystem(); diff --git a/source/gameengine/GamePlayer/ghost/SConscript b/source/gameengine/GamePlayer/ghost/SConscript index de063f5e297..57c1122c2cd 100644 --- a/source/gameengine/GamePlayer/ghost/SConscript +++ b/source/gameengine/GamePlayer/ghost/SConscript @@ -51,4 +51,7 @@ if env['WITH_BF_PYTHON']: if env['WITH_BF_FFMPEG']: defs.append('WITH_FFMPEG') +if env['WITH_BF_INTERNATIONAL']: + defs.append('INTERNATIONAL') + env.BlenderLib (libname='ge_player_ghost', sources=source_files, includes = incs, defines = defs, libtype=['player'],priority=[0], cxx_compileflags=env['BGE_CXXFLAGS']) |