merge from trunk 38379
authorXiao Xiangquan <xiaoxiangquan@gmail.com>
Thu, 14 Jul 2011 17:29:53 +0000 (17:29 +0000)
committerXiao Xiangquan <xiaoxiangquan@gmail.com>
Thu, 14 Jul 2011 17:29:53 +0000 (17:29 +0000)
87 files changed:
1  2 
build_files/cmake/cmake_consistency_check_config.py
doc/python_api/examples/aud.py
doc/python_api/examples/bge.constraints.py
doc/python_api/examples/bge.texture.1.py
doc/python_api/examples/bge.texture.py
doc/python_api/examples/blf.py
doc/python_api/rst/bge.constraints.rst
doc/python_api/rst/bge.texture.rst
doc/python_api/rst/bgl.rst
intern/ffmpeg/ffmpeg_compat.h
intern/ghost/intern/GHOST_DisplayManagerSDL.cpp
intern/ghost/intern/GHOST_DisplayManagerSDL.h
intern/ghost/intern/GHOST_SystemSDL.cpp
intern/ghost/intern/GHOST_SystemSDL.h
intern/ghost/intern/GHOST_WindowNULL.h
intern/ghost/intern/GHOST_WindowSDL.cpp
intern/ghost/intern/GHOST_WindowSDL.h
intern/ghost/test/CMakeLists.txt
release/scripts/startup/bl_operators/object.py
release/scripts/startup/bl_operators/object_align.py
release/scripts/startup/bl_operators/presets.py
release/scripts/startup/bl_operators/screen_play_rendered_anim.py
release/scripts/startup/bl_operators/wm.py
release/scripts/startup/bl_ui/properties_render.py
release/scripts/startup/bl_ui/properties_texture.py
release/scripts/startup/bl_ui/space_console.py
release/scripts/startup/bl_ui/space_image.py
release/scripts/startup/bl_ui/space_node.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/blenlib/BLI_callbacks.h
source/blender/blenlib/intern/callbacks.c
source/blender/blenlib/intern/path_util.c
source/blender/editors/animation/anim_markers.c
source/blender/editors/armature/armature_ops.c
source/blender/editors/armature/editarmature.c
source/blender/editors/curve/editcurve.c
source/blender/editors/datafiles/CMakeLists.txt
source/blender/editors/interface/interface_style.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/mesh/editmesh_loop.c
source/blender/editors/object/object_edit.c
source/blender/editors/object/object_relations.c
source/blender/editors/object/object_transform.c
source/blender/editors/physics/particle_edit.c
source/blender/editors/render/render_internal.c
source/blender/editors/render/render_opengl.c
source/blender/editors/screen/area.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sound/CMakeLists.txt
source/blender/editors/sound/sound_ops.c
source/blender/editors/space_graph/CMakeLists.txt
source/blender/editors/space_graph/graph_edit.c
source/blender/editors/space_image/image_buttons.c
source/blender/editors/space_node/node_buttons.c
source/blender/editors/space_node/node_edit.c
source/blender/editors/space_node/node_ops.c
source/blender/editors/space_outliner/outliner.c
source/blender/editors/space_sequencer/CMakeLists.txt
source/blender/editors/space_sequencer/sequencer_add.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/editors/space_view3d/view3d_buttons.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/transform/transform.c
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/rna_ID.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_curve.c
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_force.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_userdef.c
source/blender/python/generic/mathutils_geometry.c
source/blender/python/intern/bpy_app_handlers.c
source/blender/python/intern/bpy_app_handlers.h
source/blender/windowmanager/intern/wm_files.c
source/blender/windowmanager/intern/wm_init_exit.c
source/blender/windowmanager/intern/wm_operators.c
source/blender/windowmanager/intern/wm_window.c
source/creator/CMakeLists.txt
source/gameengine/GamePlayer/ghost/GPG_ghost.cpp

index 0000000000000000000000000000000000000000,60a46d3a1dd287955cfb3ff5fae28a324d071821..60a46d3a1dd287955cfb3ff5fae28a324d071821
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,e41e8214cc0ab1bdadc26e3002267df58e9cf958..e41e8214cc0ab1bdadc26e3002267df58e9cf958
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,4cd967310ccb8a69c06ab9e5aef40367bc587720..4cd967310ccb8a69c06ab9e5aef40367bc587720
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,74b37e729943633d95c575086b2a940ea7ad97e8..74b37e729943633d95c575086b2a940ea7ad97e8
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,0ec9aa16bca050ba5d4ff18beefe8cc72bcb023c..0ec9aa16bca050ba5d4ff18beefe8cc72bcb023c
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,3ab7f789ce832999a25e6124855c6ab7edbdd777..3ab7f789ce832999a25e6124855c6ab7edbdd777
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,882bbc39b9f49ac23629d9cf68de623868b6e8d5..882bbc39b9f49ac23629d9cf68de623868b6e8d5
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,996f79a313aa602ccedb7752234d472d73b216a6..996f79a313aa602ccedb7752234d472d73b216a6
mode 000000,100644..100755
--- /dev/null
index 0000000000000000000000000000000000000000,76b7442f2c55a9a3da02c831660b5b7a64ca42c2..76b7442f2c55a9a3da02c831660b5b7a64ca42c2
mode 000000,100644..100755
--- /dev/null
index 238519ebaec035282d732f21030efdb9f19971ce,d8edffbfe0b9d646f7402b8de1701a3d7b19cf5a..ecdd441c263ea794079a8b38edc1eb6ff27031eb
mode 100755,100644..100755
index 0000000000000000000000000000000000000000,2e55957e60aa8020ae5551ba79b84e5ffd3c2705..107725a3f87bf5939c1c0b0fdbe4bb15ca52ed5b
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,93 +1,93 @@@
 - * $Id$
+ /*
++ * $Id: GHOST_DisplayManagerSDL.cpp 38349 2011-07-13 00:49:22Z gsrb3d $
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file ghost/intern/GHOST_DisplayManagerSDL.cpp
+  *  \ingroup GHOST
+  */
+ #include "GHOST_SystemSDL.h"
+ #include "GHOST_DisplayManagerSDL.h"
+ GHOST_DisplayManagerSDL::GHOST_DisplayManagerSDL(GHOST_SystemSDL *system)
+     :
+       GHOST_DisplayManager(),
+       m_system(system)
+ {
+       /* do nothing */
+ }
+ GHOST_TSuccess
+ GHOST_DisplayManagerSDL::getNumDisplays(GHOST_TUns8& numDisplays)
+ {
+       numDisplays=  SDL_GetNumVideoDisplays();
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess GHOST_DisplayManagerSDL::getNumDisplaySettings(GHOST_TUns8 display,
+                                                               GHOST_TInt32& numSettings)
+ {
+       GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n");
+       numSettings= GHOST_TInt32(1);
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_DisplayManagerSDL::getDisplaySetting(GHOST_TUns8 display,
+                                            GHOST_TInt32 index,
+                                            GHOST_DisplaySetting& setting)
+ {
+       GHOST_ASSERT(display < 1, "Only single display systems are currently supported.\n");
+       GHOST_ASSERT(index < 1, "Requested setting outside of valid range.\n");
+       SDL_DisplayMode mode;
+       SDL_GetDesktopDisplayMode(display, &mode);
+       setting.xPixels= mode.w;
+       setting.yPixels= mode.h;
+       setting.bpp= SDL_BYTESPERPIXEL(mode.format);
+       /* assume 60 when unset */
+       setting.frequency= mode.refresh_rate ? mode.refresh_rate : 60;
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_DisplayManagerSDL::getCurrentDisplaySetting(GHOST_TUns8 display,
+                                                   GHOST_DisplaySetting& setting)
+ {
+       return getDisplaySetting(display,GHOST_TInt32(0),setting);
+ }
+ GHOST_TSuccess
+ GHOST_DisplayManagerSDL:: setCurrentDisplaySetting(GHOST_TUns8 display,
+                                                    const GHOST_DisplaySetting& setting)
+ {
+       // This is never going to work robustly in X
+       // but it's currently part of the full screen interface
+       // we fudge it for now.
+       return GHOST_kSuccess;
+ }
index 0000000000000000000000000000000000000000,2a815b1dc28fb1dd1cf2a4924e495eaa90b5d02e..ba6060c859253f8682cde631d60ed3eb089f4553
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,73 +1,73 @@@
 - * $Id$
+ /*
++ * $Id: GHOST_DisplayManagerSDL.h 38349 2011-07-13 00:49:22Z gsrb3d $
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file ghost/intern/GHOST_DisplayManagerSDL.h
+  *  \ingroup GHOST
+  * Declaration of GHOST_DisplayManagerSDL class.
+  */
+ #ifndef _GHOST_DISPLAY_MANAGER_SDL_H_
+ #define _GHOST_DISPLAY_MANAGER_SDL_H_
+ #include "GHOST_DisplayManager.h"
+ extern "C" {
+       #include "SDL.h"
+ }
+ #if !SDL_VERSION_ATLEAST(1, 3, 0)
+ #  error "SDL 1.3 or newer is needed to build with Ghost"
+ #endif
+ class GHOST_SystemSDL;
+ class GHOST_DisplayManagerSDL : public GHOST_DisplayManager
+ {
+ public:
+       GHOST_DisplayManagerSDL(GHOST_SystemSDL *system);
+       GHOST_TSuccess
+       getNumDisplays(GHOST_TUns8& numDisplays);
+       GHOST_TSuccess
+       getNumDisplaySettings(GHOST_TUns8 display,
+                             GHOST_TInt32& numSettings);
+       GHOST_TSuccess
+       getDisplaySetting(GHOST_TUns8 display,
+                         GHOST_TInt32 index,
+                         GHOST_DisplaySetting& setting);
+       GHOST_TSuccess
+       getCurrentDisplaySetting(GHOST_TUns8 display,
+                                GHOST_DisplaySetting& setting);
+       GHOST_TSuccess
+       setCurrentDisplaySetting(GHOST_TUns8 display,
+                                const GHOST_DisplaySetting& setting);
+ private :
+       GHOST_SystemSDL * m_system;
+ };
+ #endif /* _GHOST_DISPLAY_MANAGER_SDL_H_ */
index 0000000000000000000000000000000000000000,2c61acc2d931d648884787382ffd03bb40859c8a..918b37dd905be3289a24fe8e7a945530ad3d81c1
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,555 +1,555 @@@
 - * $Id$
+ /*
++ * $Id: GHOST_SystemSDL.cpp 38349 2011-07-13 00:49:22Z gsrb3d $
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file ghost/intern/GHOST_SystemSDL.cpp
+  *  \ingroup GHOST
+  */
+ #include <assert.h>
+ #include "GHOST_SystemSDL.h"
+ #include "GHOST_WindowManager.h"
+ #include "GHOST_EventCursor.h"
+ #include "GHOST_EventKey.h"
+ #include "GHOST_EventButton.h"
+ #include "GHOST_EventWheel.h"
+ GHOST_SystemSDL::GHOST_SystemSDL()
+     :
+       GHOST_System()
+ {
+       if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) != 0) {
+               printf ("Error initializing SDL:  %s\n", SDL_GetError());
+       }
+       /* SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); */
+     /* SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); */
+     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+     SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+     SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+     SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+     SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+     SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+ }
+ GHOST_SystemSDL::~GHOST_SystemSDL()
+ {
+       SDL_Quit();
+ }
+ GHOST_IWindow *
+ GHOST_SystemSDL::createWindow(const STR_String& title,
+                               GHOST_TInt32 left,
+                               GHOST_TInt32 top,
+                               GHOST_TUns32 width,
+                               GHOST_TUns32 height,
+                               GHOST_TWindowState state,
+                               GHOST_TDrawingContextType type,
+                               bool stereoVisual,
+                               const GHOST_TUns16 numOfAASamples,
+                               const GHOST_TEmbedderWindowID parentWindow
+                               )
+ {
+       GHOST_WindowSDL *window= NULL;
+       window= new GHOST_WindowSDL (this, title, left, top, width, height, state, parentWindow, type, stereoVisual, 1);
+       if (window) {
+               if (window->getValid()) {
+                       m_windowManager->addWindow(window);
+                       pushEvent(new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window));
+               }
+               else {
+                       delete window;
+                       window= NULL;
+               }
+       }
+       return window;
+ }
+ GHOST_TSuccess
+ GHOST_SystemSDL::init() {
+       GHOST_TSuccess success = GHOST_System::init();
+       if (success) {
+               m_displayManager = new GHOST_DisplayManagerSDL(this);
+               if (m_displayManager) {
+                       return GHOST_kSuccess;
+               }
+       }
+       return GHOST_kFailure;
+ }
+ void
+ GHOST_SystemSDL::getMainDisplayDimensions(GHOST_TUns32& width,
+                                           GHOST_TUns32& height) const
+ {
+       SDL_DisplayMode mode;
+       SDL_GetCurrentDisplayMode(0, &mode); /* note, always 0 display */
+       width= mode.w;
+       height= mode.h;
+ }
+ GHOST_TUns8
+ GHOST_SystemSDL::getNumDisplays() const
+ {
+       return SDL_GetNumVideoDisplays();
+ }
+ GHOST_TSuccess
+ GHOST_SystemSDL::getModifierKeys(GHOST_ModifierKeys& keys) const
+ {
+       SDL_Keymod mod= SDL_GetModState();
+       keys.set(GHOST_kModifierKeyLeftShift,    (mod & KMOD_LSHIFT) != 0);
+       keys.set(GHOST_kModifierKeyRightShift,   (mod & KMOD_RSHIFT) != 0);
+       keys.set(GHOST_kModifierKeyLeftControl,  (mod & KMOD_LCTRL) != 0);
+       keys.set(GHOST_kModifierKeyRightControl, (mod & KMOD_RCTRL) != 0);
+       keys.set(GHOST_kModifierKeyLeftAlt,      (mod & KMOD_LALT) != 0);
+       keys.set(GHOST_kModifierKeyRightAlt,     (mod & KMOD_RALT) != 0);
+       keys.set(GHOST_kModifierKeyOS,           (mod & (KMOD_LGUI|KMOD_RGUI)) != 0);
+       return GHOST_kSuccess;
+ }
+ #define GXMAP(k,x,y) case x: k= y; break;
+ static GHOST_TKey
+ convertSDLKey(SDL_Scancode key)
+ {
+       GHOST_TKey type;
+       if ((key >= SDL_SCANCODE_A) && (key <= SDL_SCANCODE_Z)) {
+               type= GHOST_TKey( key - SDL_SCANCODE_A + int(GHOST_kKeyA));
+       } else if ((key >= SDL_SCANCODE_1) && (key <= SDL_SCANCODE_0)) {
+               type= GHOST_TKey(key - SDL_SCANCODE_1 + int(GHOST_kKey0));
+       } else if ((key >= SDL_SCANCODE_F1) && (key <= SDL_SCANCODE_F12)) {
+               type= GHOST_TKey(key - SDL_SCANCODE_F1 + int(GHOST_kKeyF1));
+       } else if ((key >= SDL_SCANCODE_F13) && (key <= SDL_SCANCODE_F24)) {
+               type= GHOST_TKey(key - SDL_SCANCODE_F13 + int(GHOST_kKeyF13));
+       } else {
+               switch(key) {
+                       /* TODO SDL_SCANCODE_NONUSBACKSLASH */
+               GXMAP(type,SDL_SCANCODE_BACKSPACE,      GHOST_kKeyBackSpace);
+               GXMAP(type,SDL_SCANCODE_TAB,            GHOST_kKeyTab);
+               GXMAP(type,SDL_SCANCODE_RETURN,         GHOST_kKeyEnter);
+               GXMAP(type,SDL_SCANCODE_ESCAPE,         GHOST_kKeyEsc);
+               GXMAP(type,SDL_SCANCODE_SPACE,          GHOST_kKeySpace);
+               GXMAP(type,SDL_SCANCODE_SEMICOLON,      GHOST_kKeySemicolon);
+               GXMAP(type,SDL_SCANCODE_PERIOD,         GHOST_kKeyPeriod);
+               GXMAP(type,SDL_SCANCODE_COMMA,          GHOST_kKeyComma);
+               GXMAP(type,SDL_SCANCODE_APOSTROPHE,     GHOST_kKeyQuote);
+               GXMAP(type,SDL_SCANCODE_GRAVE,          GHOST_kKeyAccentGrave);
+               GXMAP(type,SDL_SCANCODE_MINUS,          GHOST_kKeyMinus);
+               GXMAP(type,SDL_SCANCODE_SLASH,          GHOST_kKeySlash);
+               GXMAP(type,SDL_SCANCODE_BACKSLASH,      GHOST_kKeyBackslash);
+               GXMAP(type,SDL_SCANCODE_KP_EQUALS,      GHOST_kKeyEqual);
+               GXMAP(type,SDL_SCANCODE_LEFTBRACKET,    GHOST_kKeyLeftBracket);
+               GXMAP(type,SDL_SCANCODE_RIGHTBRACKET,   GHOST_kKeyRightBracket);
+               GXMAP(type,SDL_SCANCODE_PAUSE,          GHOST_kKeyPause);
+               GXMAP(type,SDL_SCANCODE_LSHIFT,         GHOST_kKeyLeftShift);
+               GXMAP(type,SDL_SCANCODE_RSHIFT,         GHOST_kKeyRightShift);
+               GXMAP(type,SDL_SCANCODE_LCTRL,          GHOST_kKeyLeftControl);
+               GXMAP(type,SDL_SCANCODE_RCTRL,          GHOST_kKeyRightControl);
+               GXMAP(type,SDL_SCANCODE_LALT,           GHOST_kKeyLeftAlt);
+               GXMAP(type,SDL_SCANCODE_RALT,           GHOST_kKeyRightAlt);
+               GXMAP(type,SDL_SCANCODE_RGUI,           GHOST_kKeyOS);
+               GXMAP(type,SDL_SCANCODE_INSERT,         GHOST_kKeyInsert);
+               GXMAP(type,SDL_SCANCODE_DELETE,         GHOST_kKeyDelete);
+               GXMAP(type,SDL_SCANCODE_HOME,           GHOST_kKeyHome);
+               GXMAP(type,SDL_SCANCODE_END,            GHOST_kKeyEnd);
+               GXMAP(type,SDL_SCANCODE_PAGEUP,         GHOST_kKeyUpPage);
+               GXMAP(type,SDL_SCANCODE_PAGEDOWN,       GHOST_kKeyDownPage);
+               GXMAP(type,SDL_SCANCODE_LEFT,           GHOST_kKeyLeftArrow);
+               GXMAP(type,SDL_SCANCODE_RIGHT,          GHOST_kKeyRightArrow);
+               GXMAP(type,SDL_SCANCODE_UP,             GHOST_kKeyUpArrow);
+               GXMAP(type,SDL_SCANCODE_DOWN,           GHOST_kKeyDownArrow);
+               GXMAP(type,SDL_SCANCODE_CAPSLOCK,       GHOST_kKeyCapsLock);
+               GXMAP(type,SDL_SCANCODE_SCROLLLOCK,     GHOST_kKeyScrollLock);
+               GXMAP(type,SDL_SCANCODE_NUMLOCKCLEAR,   GHOST_kKeyNumLock);
+               /* keypad events */
+               /* note, sdl defines a bunch of kp defines I never saw before like
+                * SDL_SCANCODE_KP_PERCENT, SDL_SCANCODE_KP_XOR - campbell */
+               GXMAP(type,SDL_SCANCODE_KP_0,           GHOST_kKeyNumpad0);
+               GXMAP(type,SDL_SCANCODE_KP_1,           GHOST_kKeyNumpad1);
+               GXMAP(type,SDL_SCANCODE_KP_2,           GHOST_kKeyNumpad2);
+               GXMAP(type,SDL_SCANCODE_KP_3,           GHOST_kKeyNumpad3);
+               GXMAP(type,SDL_SCANCODE_KP_4,           GHOST_kKeyNumpad4);
+               GXMAP(type,SDL_SCANCODE_KP_5,           GHOST_kKeyNumpad5);
+               GXMAP(type,SDL_SCANCODE_KP_6,           GHOST_kKeyNumpad6);
+               GXMAP(type,SDL_SCANCODE_KP_7,           GHOST_kKeyNumpad7);
+               GXMAP(type,SDL_SCANCODE_KP_8,           GHOST_kKeyNumpad8);
+               GXMAP(type,SDL_SCANCODE_KP_9,           GHOST_kKeyNumpad9);
+               GXMAP(type,SDL_SCANCODE_KP_PERIOD,      GHOST_kKeyNumpadPeriod);
+         GXMAP(type,SDL_SCANCODE_KP_ENTER,       GHOST_kKeyNumpadEnter);
+         GXMAP(type,SDL_SCANCODE_KP_PLUS,        GHOST_kKeyNumpadPlus);
+         GXMAP(type,SDL_SCANCODE_KP_MINUS,       GHOST_kKeyNumpadMinus);
+         GXMAP(type,SDL_SCANCODE_KP_MULTIPLY,    GHOST_kKeyNumpadAsterisk);
+         GXMAP(type,SDL_SCANCODE_KP_DIVIDE,      GHOST_kKeyNumpadSlash);
+         /* Media keys in some keyboards and laptops with XFree86/Xorg */
+         GXMAP(type,SDL_SCANCODE_AUDIOPLAY,      GHOST_kKeyMediaPlay);
+         GXMAP(type,SDL_SCANCODE_AUDIOSTOP,      GHOST_kKeyMediaStop);
+         GXMAP(type,SDL_SCANCODE_AUDIOPREV,      GHOST_kKeyMediaFirst);
+         // GXMAP(type,XF86XK_AudioRewind,       GHOST_kKeyMediaFirst);
+         GXMAP(type,SDL_SCANCODE_AUDIONEXT,      GHOST_kKeyMediaLast);
+               default:
+                       type= GHOST_kKeyUnknown;
+                       break;
+               }
+       }
+       return type;
+ }
+ #undef GXMAP
+ void
+ GHOST_SystemSDL::processEvent(SDL_Event *sdl_event)
+ {
+       GHOST_Event * g_event= NULL;
+       switch(sdl_event->type) {
+       case SDL_WINDOWEVENT:
+               {
+                       SDL_WindowEvent &sdl_sub_evt= sdl_event->window;
+                       GHOST_WindowSDL *window= findGhostWindow(SDL_GetWindowFromID(sdl_sub_evt.windowID));
+                       //assert(window != NULL); // can be NULL on close window.
+                       switch (sdl_sub_evt.event) {
+                       case SDL_WINDOWEVENT_EXPOSED:
+                               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowUpdate, window);
+                               break;
+                       case SDL_WINDOWEVENT_RESIZED:
+                               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowSize, window);
+                               break;
+                       case SDL_WINDOWEVENT_MOVED:
+                               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowMove, window);
+                               break;
+                       case SDL_WINDOWEVENT_FOCUS_GAINED:
+                               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowActivate, window);
+                               break;
+                       case SDL_WINDOWEVENT_FOCUS_LOST:
+                               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowDeactivate, window);
+                               break;
+                       case SDL_WINDOWEVENT_CLOSE:
+                               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventWindowClose, window);
+                               break;
+                       }
+               }
+               break;
+       case SDL_QUIT:
+               g_event= new GHOST_Event(getMilliSeconds(), GHOST_kEventQuit, NULL);
+               break;
+       case SDL_MOUSEMOTION:
+               {
+                       SDL_MouseMotionEvent &sdl_sub_evt= sdl_event->motion;
+                       SDL_Window *sdl_win= SDL_GetWindowFromID(sdl_sub_evt.windowID);
+                       GHOST_WindowSDL *window= findGhostWindow(sdl_win);
+                       assert(window != NULL);
+                       int x_win, y_win;
+                       SDL_GetWindowPosition(sdl_win, &x_win, &y_win);
+                       GHOST_TInt32 x_root= sdl_sub_evt.x + x_win;
+                       GHOST_TInt32 y_root= sdl_sub_evt.y + y_win;
+ #if 0
+                       if(window->getCursorGrabMode() != GHOST_kGrabDisable && window->getCursorGrabMode() != GHOST_kGrabNormal)
+                       {
+                               GHOST_TInt32 x_new= x_root;
+                               GHOST_TInt32 y_new= y_root;
+                               GHOST_TInt32 x_accum, y_accum;
+                               GHOST_Rect bounds;
+                               /* fallback to window bounds */
+                               if(window->getCursorGrabBounds(bounds)==GHOST_kFailure)
+                                       window->getClientBounds(bounds);
+                               /* could also clamp to screen bounds
+                                * wrap with a window outside the view will fail atm  */
+                               bounds.wrapPoint(x_new, y_new, 8); /* offset of one incase blender is at screen bounds */
+                               window->getCursorGrabAccum(x_accum, y_accum);
+                               // cant use setCursorPosition because the mouse may have no focus!
+                               if(x_new != x_root || y_new != y_root) {
+                                       if (1 ) { //xme.time > m_last_warp) {
+                                               /* when wrapping we don't need to add an event because the
+                                                * setCursorPosition call will cause a new event after */
+                                               SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win); /* wrap */
+                                               window->setCursorGrabAccum(x_accum + (x_root - x_new), y_accum + (y_root - y_new));
+                                               // m_last_warp= lastEventTime(xme.time);
+                                       } else {
+                                               // setCursorPosition(x_new, y_new); /* wrap but don't accumulate */
+                                               SDL_WarpMouseInWindow(sdl_win, x_new - x_win, y_new - y_win);
+                                       }
+                                       g_event = new GHOST_EventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, x_new, y_new);
+                               }
+                               else {
+                                       g_event = new GHOST_EventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, x_root + x_accum, y_root + y_accum);
+                               }
+                       }
+                       else
+ #endif
+                       {
+                               g_event= new GHOST_EventCursor(getMilliSeconds(), GHOST_kEventCursorMove, window, x_root, y_root);
+                       }
+                       break;
+               }
+       case SDL_MOUSEBUTTONUP:
+       case SDL_MOUSEBUTTONDOWN:
+               {
+                       SDL_MouseButtonEvent &sdl_sub_evt= sdl_event->button;
+                       GHOST_TButtonMask gbmask= GHOST_kButtonMaskLeft;
+                       GHOST_TEventType type= (sdl_sub_evt.state==SDL_PRESSED) ? GHOST_kEventButtonDown : GHOST_kEventButtonUp;
+                       GHOST_WindowSDL *window= findGhostWindow(SDL_GetWindowFromID(sdl_sub_evt.windowID));
+                       assert(window != NULL);
+                       /* process rest of normal mouse buttons */
+                       if(sdl_sub_evt.button == SDL_BUTTON_LEFT)
+                               gbmask= GHOST_kButtonMaskLeft;
+                       else if(sdl_sub_evt.button == SDL_BUTTON_MIDDLE)
+                               gbmask= GHOST_kButtonMaskMiddle;
+                       else if(sdl_sub_evt.button == SDL_BUTTON_RIGHT)
+                               gbmask= GHOST_kButtonMaskRight;
+                       /* these buttons are untested! */
+                       else if(sdl_sub_evt.button == SDL_BUTTON_X1)
+                               gbmask= GHOST_kButtonMaskButton4;
+                       else if(sdl_sub_evt.button == SDL_BUTTON_X2)
+                               gbmask= GHOST_kButtonMaskButton5;
+                       else
+                               break;
+                       g_event= new GHOST_EventButton(getMilliSeconds(), type, window, gbmask);
+                       break;
+               }
+       case SDL_MOUSEWHEEL:
+               {
+                       SDL_MouseWheelEvent &sdl_sub_evt= sdl_event->wheel;
+                       GHOST_WindowSDL *window= findGhostWindow(SDL_GetWindowFromID(sdl_sub_evt.windowID));
+                       assert(window != NULL);
+                       g_event= new GHOST_EventWheel(getMilliSeconds(), window, sdl_sub_evt.y);
+               }
+               break;
+       case SDL_KEYDOWN:
+       case SDL_KEYUP:
+               {
+                       SDL_KeyboardEvent &sdl_sub_evt= sdl_event->key;
+                       GHOST_TEventType type= (sdl_sub_evt.state == SDL_PRESSED) ? GHOST_kEventKeyDown : GHOST_kEventKeyUp;
+                       GHOST_WindowSDL *window= findGhostWindow(SDL_GetWindowFromID(sdl_sub_evt.windowID));
+                       assert(window != NULL);
+                       GHOST_TKey gkey= convertSDLKey(sdl_sub_evt.keysym.scancode);
+                       /* note, the sdl_sub_evt.keysym.sym is truncated, for unicode support ghost has to be modified */
+                       g_event= new GHOST_EventKey(getMilliSeconds(), type, window, gkey, sdl_sub_evt.keysym.sym);
+               }
+               break;
+       }
+       if (g_event) {
+               pushEvent(g_event);
+       }
+ }
+ GHOST_TSuccess
+ GHOST_SystemSDL::getCursorPosition(GHOST_TInt32& x,
+                                    GHOST_TInt32& y) const
+ {
+       int x_win, y_win;
+       SDL_Window *win= SDL_GetMouseFocus();
+       SDL_GetWindowPosition(win, &x_win, &y_win);
+       int xi, yi;
+       SDL_GetMouseState(&xi, &yi);
+       x= xi + x_win;
+       y= yi + x_win;
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_SystemSDL::setCursorPosition(GHOST_TInt32 x,
+                                    GHOST_TInt32 y)
+ {
+       int x_win, y_win;
+       SDL_Window *win= SDL_GetMouseFocus();
+       SDL_GetWindowPosition(win, &x_win, &y_win);
+       SDL_WarpMouseInWindow(win, x - x_win, y - y_win);
+       return GHOST_kSuccess;
+ }
+ bool
+ GHOST_SystemSDL::generateWindowExposeEvents()
+ {
+       vector<GHOST_WindowSDL *>::iterator w_start= m_dirty_windows.begin();
+       vector<GHOST_WindowSDL *>::const_iterator w_end= m_dirty_windows.end();
+       bool anyProcessed= false;
+       for (;w_start != w_end; ++w_start) {
+               GHOST_Event * g_event= new
+                       GHOST_Event(
+                               getMilliSeconds(),
+                               GHOST_kEventWindowUpdate,
+                               *w_start
+                       );
+               (*w_start)->validate();
+               if (g_event) {
+                       printf("Expose events pushed\n");
+                       pushEvent(g_event);
+                       anyProcessed= true;
+               }
+       }
+       m_dirty_windows.clear();
+       return anyProcessed;
+ }
+ bool
+ GHOST_SystemSDL::processEvents(bool waitForEvent)
+ {
+       // Get all the current events -- translate them into
+       // ghost events and call base class pushEvent() method.
+       bool anyProcessed= false;
+       do {
+               GHOST_TimerManager* timerMgr= getTimerManager();
+               if (waitForEvent && m_dirty_windows.empty() && !SDL_HasEvents(SDL_FIRSTEVENT, SDL_LASTEVENT)) {
+                       GHOST_TUns64 next= timerMgr->nextFireTime();
+                       if (next==GHOST_kFireTimeNever) {
+                               SDL_WaitEventTimeout(NULL, -1);
+                               //SleepTillEvent(m_display, -1);
+                       } else {
+                               GHOST_TInt64 maxSleep= next - getMilliSeconds();
+                               if(maxSleep >= 0) {
+                                       SDL_WaitEventTimeout(NULL, next - getMilliSeconds());
+                                       // SleepTillEvent(m_display, next - getMilliSeconds()); // X11
+                               }
+                       }
+               }
+               if (timerMgr->fireTimers(getMilliSeconds())) {
+                       anyProcessed= true;
+               }
+               SDL_Event sdl_event;
+               while (SDL_PollEvent(&sdl_event)) {
+                       processEvent(&sdl_event);
+                       anyProcessed= true;
+               }
+               if (generateWindowExposeEvents()) {
+                       anyProcessed= true;
+               }
+       } while (waitForEvent && !anyProcessed);
+       return anyProcessed;
+ }
+ GHOST_WindowSDL *
+ GHOST_SystemSDL::findGhostWindow(SDL_Window *sdl_win)
+ {
+       if (sdl_win == NULL) return NULL;
+       // It is not entirely safe to do this as the backptr may point
+       // to a window that has recently been removed.
+       // We should always check the window manager's list of windows
+       // and only process events on these windows.
+       vector<GHOST_IWindow *> & win_vec= m_windowManager->getWindows();
+       vector<GHOST_IWindow *>::iterator win_it= win_vec.begin();
+       vector<GHOST_IWindow *>::const_iterator win_end= win_vec.end();
+       for (; win_it != win_end; ++win_it) {
+               GHOST_WindowSDL * window= static_cast<GHOST_WindowSDL *>(*win_it);
+               if (window->getSDLWindow() == sdl_win) {
+                       return window;
+               }
+       }
+       return NULL;
+ }
+ void
+ GHOST_SystemSDL::addDirtyWindow(GHOST_WindowSDL *bad_wind)
+ {
+       GHOST_ASSERT((bad_wind != NULL), "addDirtyWindow() NULL ptr trapped (window)");
+       m_dirty_windows.push_back(bad_wind);
+ }
+ GHOST_TSuccess GHOST_SystemSDL::getButtons(GHOST_Buttons& buttons) const
+ {
+       Uint8 state= SDL_GetMouseState(NULL, NULL);
+       buttons.set(GHOST_kButtonMaskLeft,   (state & SDL_BUTTON_LMASK) != 0);
+       buttons.set(GHOST_kButtonMaskMiddle, (state & SDL_BUTTON_MMASK) != 0);
+       buttons.set(GHOST_kButtonMaskRight,  (state & SDL_BUTTON_RMASK) != 0);
+       return GHOST_kSuccess;
+ }
+ GHOST_TUns8 *
+ GHOST_SystemSDL::getClipboard(bool selection) const
+ {
+       return (GHOST_TUns8 *)SDL_GetClipboardText();
+ }
+ void
+ GHOST_SystemSDL::putClipboard(GHOST_TInt8 *buffer, bool selection) const
+ {
+       SDL_SetClipboardText(buffer);
+ }
+ GHOST_TUns64
+ GHOST_SystemSDL::getMilliSeconds()
+ {
+       return GHOST_TUns64(SDL_GetTicks()); /* note, 32 -> 64bits */
+ }
index 0000000000000000000000000000000000000000,87d288117c51670b0851c8fa4f43d0e539202c48..42907c06e1ecc6fe44e6c234b7f647d5e04a922b
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,126 +1,126 @@@
 - * $Id$
+ /*
++ * $Id: GHOST_SystemSDL.h 38349 2011-07-13 00:49:22Z gsrb3d $
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file ghost/intern/GHOST_SystemSDL.h
+  *  \ingroup GHOST
+  * Declaration of GHOST_SystemSDL class.
+  */
+ #ifndef _GHOST_SYSTEM_SDL_H_
+ #define _GHOST_SYSTEM_SDL_H_
+ #include "GHOST_System.h"
+ #include "../GHOST_Types.h"
+ #include "GHOST_DisplayManagerSDL.h"
+ #include "GHOST_TimerManager.h"
+ #include "GHOST_WindowSDL.h"
+ #include "GHOST_Event.h"
+ extern "C" {
+       #include "SDL.h"
+ }
+ #if !SDL_VERSION_ATLEAST(1, 3, 0)
+ #  error "SDL 1.3 or newer is needed to build with Ghost"
+ #endif
+ class GHOST_WindowSDL;
+ class GHOST_SystemSDL : public GHOST_System {
+ public:
+       void addDirtyWindow(GHOST_WindowSDL *bad_wind);
+       GHOST_SystemSDL();
+       ~GHOST_SystemSDL();
+       bool
+       processEvents(bool waitForEvent);
+       int
+       toggleConsole(int action) { return 0; }
+       GHOST_TSuccess
+       getModifierKeys(GHOST_ModifierKeys& keys) const;
+       GHOST_TSuccess
+       getButtons(GHOST_Buttons& buttons) const;
+       GHOST_TUns8 *
+       getClipboard(bool selection) const;
+       void
+       putClipboard(GHOST_TInt8 *buffer, bool selection) const;
+       GHOST_TUns64
+       getMilliSeconds();
+       GHOST_TUns8
+       getNumDisplays() const;
+       GHOST_TSuccess
+       getCursorPosition(GHOST_TInt32& x,
+                         GHOST_TInt32& y) const;
+       GHOST_TSuccess
+       setCursorPosition(GHOST_TInt32 x,
+                         GHOST_TInt32 y);
+       void
+       getMainDisplayDimensions(GHOST_TUns32& width,
+                                GHOST_TUns32& height) const;
+ private:
+       GHOST_TSuccess
+       init();
+       GHOST_IWindow *
+       createWindow(const STR_String& title,
+                    GHOST_TInt32 left,
+                    GHOST_TInt32 top,
+                    GHOST_TUns32 width,
+                    GHOST_TUns32 height,
+                    GHOST_TWindowState state,
+                    GHOST_TDrawingContextType type,
+                    bool stereoVisual,
+                    const GHOST_TUns16 numOfAASamples,
+                    const GHOST_TEmbedderWindowID parentWindow
+                    );
+       /* SDL spesific */
+       GHOST_WindowSDL * findGhostWindow(SDL_Window *sdl_win);
+       bool
+       generateWindowExposeEvents();
+       void
+       processEvent(SDL_Event *sdl_event);
+       /// The vector of windows that need to be updated.
+       std::vector<GHOST_WindowSDL *> m_dirty_windows;
+ };
+ #endif
index ff3967baa9373852a2481821f750fc7e466b121f,f979313af5c672f6faa8bac6079a410b02de258f..d3e0c89a7a7c86c83eb73e2a0aa9aeec5881ba5f
mode 100755,100644..100755
index 0000000000000000000000000000000000000000,1675c1fb12b223c76e5bbb3e11f2db4e14b34e0b..45ddd99d65d923785b0409f1f48035211862a457
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,628 +1,628 @@@
 - * $Id$
+ /*
++ * $Id: GHOST_WindowSDL.cpp 38349 2011-07-13 00:49:22Z gsrb3d $
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file ghost/intern/GHOST_WindowSDL.cpp
+  *  \ingroup GHOST
+  */
+ #include "GHOST_WindowSDL.h"
+ #include "SDL_mouse.h"
+ #include <assert.h>
+ static SDL_GLContext s_firstContext= NULL;
+ GHOST_WindowSDL::GHOST_WindowSDL(GHOST_SystemSDL *system,
+                                  const STR_String& title,
+                                  GHOST_TInt32 left,
+                                  GHOST_TInt32 top,
+                                  GHOST_TUns32 width,
+                                  GHOST_TUns32 height,
+                                  GHOST_TWindowState state,
+                                  const GHOST_TEmbedderWindowID parentWindow,
+                                  GHOST_TDrawingContextType type,
+                                  const bool stereoVisual,
+                                  const GHOST_TUns16 numOfAASamples
+                                  )
+     :
+       GHOST_Window(width,height,state,type,stereoVisual,numOfAASamples),
+       m_system (system),
+       m_invalid_window(false),
+       m_sdl_custom_cursor(NULL)
+ {
+       m_sdl_win= SDL_CreateWindow(title,
+                                   left,
+                                   top,
+                                   width,
+                                   height,
+                                   SDL_WINDOW_RESIZABLE|SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN);
+       //SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+       //SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
+       SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+       SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+       SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+       SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+       SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+       SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
+       m_sdl_glcontext= SDL_GL_CreateContext(m_sdl_win);
+       //fprintf(stderr, "Ignoring Xlib error: error code %d request code %d\n",
+       //      theEvent->error_code, theEvent->request_code) ;
+       setTitle(title);
+ }
+ GHOST_WindowSDL::~GHOST_WindowSDL()
+ {
+       if(m_sdl_custom_cursor) {
+               SDL_FreeCursor(m_sdl_custom_cursor);
+       }
+       if (m_sdl_glcontext != s_firstContext) {
+               SDL_GL_DeleteContext(m_sdl_glcontext);
+       }
+       SDL_DestroyWindow(m_sdl_win);
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::installDrawingContext(GHOST_TDrawingContextType type)
+ {
+       // only support openGL for now.
+       GHOST_TSuccess success;
+       switch (type) {
+       case GHOST_kDrawingContextTypeOpenGL:
+               m_sdl_glcontext= SDL_GL_CreateContext(m_sdl_win);
+               if (m_sdl_glcontext != NULL) {
+                       if (!s_firstContext) {
+                               s_firstContext= m_sdl_glcontext;
+                       }
+                       success= (SDL_GL_MakeCurrent(m_sdl_win, m_sdl_glcontext) < 0) ?
+                                   GHOST_kFailure : GHOST_kSuccess;
+               }
+               else {
+                       success= GHOST_kFailure;
+               }
+               break;
+       case GHOST_kDrawingContextTypeNone:
+               success= GHOST_kSuccess;
+               break;
+       default:
+               success= GHOST_kFailure;
+       }
+       return success;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::invalidate(void)
+ {
+       // So the idea of this function is to generate an expose event
+       // for the window.
+       // Unfortunately X does not handle expose events for you and
+       // it is the client's job to refresh the dirty part of the window.
+       // We need to queue up invalidate calls and generate GHOST events
+       // for them in the system.
+       // We implement this by setting a boolean in this class to concatenate
+       // all such calls into a single event for this window.
+       // At the same time we queue the dirty windows in the system class
+       // and generate events for them at the next processEvents call.
+       if (m_invalid_window == false) {
+               m_system->addDirtyWindow(this);
+               m_invalid_window= true;
+       }
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::swapBuffers()
+ {
+       if (getDrawingContextType() == GHOST_kDrawingContextTypeOpenGL) {
+               SDL_GL_SwapWindow(m_sdl_win);
+               return GHOST_kSuccess;
+       }
+       else {
+               return GHOST_kFailure;
+       }
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::activateDrawingContext()
+ {
+       if (m_sdl_glcontext !=NULL) {
+               int status=SDL_GL_MakeCurrent(m_sdl_win, m_sdl_glcontext);
+               (void)status;
+               return GHOST_kSuccess;
+       }
+       return GHOST_kFailure;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::removeDrawingContext()
+ {
+       GHOST_TSuccess success;
+       if (m_sdl_glcontext != NULL) {
+               SDL_GL_DeleteContext(m_sdl_glcontext);
+               success= GHOST_kSuccess;
+       }
+       else {
+               success= GHOST_kFailure;
+       }
+       return success;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setState(GHOST_TWindowState state)
+ {
+       switch(state) {
+       case GHOST_kWindowStateNormal:
+               SDL_SetWindowFullscreen(m_sdl_win, SDL_FALSE);
+               SDL_RestoreWindow(m_sdl_win);
+               break;
+       case GHOST_kWindowStateMaximized:
+               SDL_SetWindowFullscreen(m_sdl_win, SDL_FALSE);
+               SDL_MaximizeWindow(m_sdl_win);
+               break;
+       case GHOST_kWindowStateMinimized:
+               SDL_MinimizeWindow(m_sdl_win);
+               break;
+       case GHOST_kWindowStateFullScreen:
+               SDL_SetWindowFullscreen(m_sdl_win, SDL_TRUE);
+               break;
+       default:
+               break;
+       }
+       return GHOST_kSuccess;
+ }
+ GHOST_TWindowState
+ GHOST_WindowSDL::getState() const
+ {
+       Uint32 flags= SDL_GetWindowFlags(m_sdl_win);
+       if(flags & SDL_WINDOW_FULLSCREEN)      return GHOST_kWindowStateFullScreen;
+       else if(flags & SDL_WINDOW_MAXIMIZED)  return GHOST_kWindowStateMaximized;
+       else if(flags & SDL_WINDOW_MINIMIZED)  return GHOST_kWindowStateMinimized;
+       return GHOST_kWindowStateNormal;
+ }
+ void
+ GHOST_WindowSDL::setTitle(const STR_String& title)
+ {
+       SDL_SetWindowTitle(m_sdl_win, title.ReadPtr());
+ }
+ void
+ GHOST_WindowSDL::getTitle(STR_String& title) const
+ {
+       title= SDL_GetWindowTitle(m_sdl_win);
+ }
+ void
+ GHOST_WindowSDL::getWindowBounds(GHOST_Rect& bounds) const
+ {
+       getClientBounds(bounds);
+ }
+ void
+ GHOST_WindowSDL::getClientBounds(GHOST_Rect& bounds) const
+ {
+       int x, y, w, h;
+       SDL_GetWindowSize(m_sdl_win, &w, &h);
+       SDL_GetWindowPosition(m_sdl_win, &x, &y);
+       bounds.m_l= x;
+       bounds.m_r= x + w;
+       bounds.m_t= y;
+       bounds.m_b= y + h;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setClientWidth(GHOST_TUns32 width)
+ {
+       int height;
+       SDL_GetWindowSize(m_sdl_win, NULL, &height);
+       SDL_SetWindowSize(m_sdl_win, width, height);
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setClientHeight(GHOST_TUns32 height)
+ {
+       int width;
+       SDL_GetWindowSize(m_sdl_win, &width, NULL);
+       SDL_SetWindowSize(m_sdl_win, width, height);
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setClientSize(GHOST_TUns32 width,
+                                               GHOST_TUns32 height)
+ {
+       SDL_SetWindowSize(m_sdl_win, width, height);
+       return GHOST_kSuccess;
+ }
+ void
+ GHOST_WindowSDL::screenToClient( GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY ) const
+ {
+       /* XXXSDL_WEAK_ABS_COORDS */
+       int x_win, y_win;
+       SDL_GetWindowPosition(m_sdl_win, &x_win, &y_win);
+       outX = inX - x_win;
+       outY = inY - y_win;
+ }
+ void
+ GHOST_WindowSDL::clientToScreen( GHOST_TInt32 inX, GHOST_TInt32 inY, GHOST_TInt32& outX, GHOST_TInt32& outY ) const
+ {
+       /* XXXSDL_WEAK_ABS_COORDS */
+       int x_win, y_win;
+       SDL_GetWindowPosition(m_sdl_win, &x_win, &y_win);
+       outX = inX + x_win;
+       outY = inY + y_win;
+ }
+ /* mouse cursor */
+ static unsigned char sdl_std_cursor_mask_xterm[]= {0xef,0x01,0xff,0x01,0xff,0x01,0x7c,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x38,0x00,0x7c,0x00,0xff,0x01,0xff,0x01,0xef,0x01,};
+ static unsigned char sdl_std_cursor_xterm[]= {0x00,0x77,0x00,0x1c,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x1c,0x00,0x77,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_xterm  9
+ #define sdl_std_cursor_HEIGHT_xterm 16
+ #define sdl_std_cursor_HOT_X_xterm  -3
+ #define sdl_std_cursor_HOT_Y_xterm  -7
+ static unsigned char sdl_std_cursor_mask_watch[]= {0xfc,0x0f,0xfc,0x0f,0xfc,0x0f,0xfe,0x1f,0xff,0x3f,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x3f,0xfe,0x1f,0xfc,0x0f,0xfc,0x0f,0xfc,0x0f,};
+ static unsigned char sdl_std_cursor_watch[]= {0xf8,0x07,0xf8,0x07,0xf8,0x07,0xfc,0x0f,0x86,0x18,0x83,0x30,0x81,0xe0,0xc1,0xe1,0xc1,0xe1,0x21,0xe0,0x13,0x30,0x06,0x18,0xfc,0x0f,0xf8,0x07,0xf8,0x07,0xf8,0x07,};
+ #define sdl_std_cursor_WIDTH_watch  16
+ #define sdl_std_cursor_HEIGHT_watch 16
+ #define sdl_std_cursor_HOT_X_watch  -15
+ #define sdl_std_cursor_HOT_Y_watch  -7
+ static unsigned char sdl_std_cursor_mask_umbrella[]= {0xe8,0x76,0xfb,0xdf,0xfd,0x3f,0xfe,0xff,0xff,0x3f,0xff,0xff,0xcf,0x79,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x07,0xc0,0x07,0xc0,0x07,0xc0,0x07,0x80,0x03,};
+ static unsigned char sdl_std_cursor_umbrella[]= {0x88,0x04,0x20,0x0a,0xc9,0x32,0xf2,0x09,0x4c,0x06,0x43,0x18,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x01,0x40,0x01,0x80,0x00,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_umbrella  16
+ #define sdl_std_cursor_HEIGHT_umbrella 16
+ #define sdl_std_cursor_HOT_X_umbrella  -7
+ #define sdl_std_cursor_HOT_Y_umbrella  -12
+ static unsigned char sdl_std_cursor_mask_top_side[]= {0xff,0x7f,0xff,0x7f,0xff,0x7f,0xff,0x7f,0xc0,0x01,0xe0,0x03,0xf0,0x07,0xf8,0x0f,0xdc,0x1d,0xcc,0x19,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,};
+ static unsigned char sdl_std_cursor_top_side[]= {0xff,0x1f,0xff,0x1f,0x00,0x00,0x40,0x00,0xe0,0x00,0x50,0x01,0x48,0x02,0x44,0x04,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_top_side  15
+ #define sdl_std_cursor_HEIGHT_top_side 16
+ #define sdl_std_cursor_HOT_X_top_side  -6
+ #define sdl_std_cursor_HOT_Y_top_side  -14
+ static unsigned char sdl_std_cursor_mask_top_right_corner[]= {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0xf0,0xfc,0xf7,0xfc,0xf7,0xfc,0xf7,0xc0,0xf7,0xe0,0xf7,0x70,0xf7,0x38,0xf7,0x1c,0xf7,0x0c,0xf7,0x00,0xf0,0x00,0xf0,};
+ static unsigned char sdl_std_cursor_top_right_corner[]= {0xff,0x3f,0xff,0x3f,0x00,0x30,0x00,0x30,0x00,0x30,0xfc,0x31,0x80,0x31,0x40,0x31,0x20,0x31,0x10,0x31,0x08,0x31,0x04,0x31,0x00,0x30,0x00,0x30,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_top_right_corner  16
+ #define sdl_std_cursor_HEIGHT_top_right_corner 16
+ #define sdl_std_cursor_HOT_X_top_right_corner  -13
+ #define sdl_std_cursor_HOT_Y_top_right_corner  -14
+ static unsigned char sdl_std_cursor_mask_top_left_corner[]= {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x0f,0x00,0xef,0x3f,0xef,0x3f,0xef,0x3f,0xef,0x03,0xef,0x07,0xef,0x0e,0xef,0x1c,0xef,0x38,0xef,0x30,0x0f,0x00,0x0f,0x00,};
+ static unsigned char sdl_std_cursor_top_left_corner[]= {0xff,0x3f,0xff,0x3f,0x03,0x00,0x03,0x00,0x03,0x00,0xe3,0x0f,0x63,0x00,0xa3,0x00,0x23,0x01,0x23,0x02,0x23,0x04,0x23,0x08,0x03,0x00,0x03,0x00,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_top_left_corner  16
+ #define sdl_std_cursor_HEIGHT_top_left_corner 16
+ #define sdl_std_cursor_HOT_X_top_left_corner  0
+ #define sdl_std_cursor_HOT_Y_top_left_corner  -14
+ static unsigned char sdl_std_cursor_mask_spraycan[]= {0x00,0x0c,0x18,0x0d,0x7c,0x0d,0x7c,0x0d,0x7e,0x0d,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,0xff,0x00,};
+ static unsigned char sdl_std_cursor_spraycan[]= {0x00,0x06,0x80,0x00,0x2c,0x06,0x9e,0x00,0x16,0x06,0x3f,0x00,0x21,0x00,0x27,0x00,0x25,0x00,0x27,0x00,0x25,0x00,0x27,0x00,0x27,0x00,0x21,0x00,0x21,0x00,0x3f,0x00,};
+ #define sdl_std_cursor_WIDTH_spraycan  12
+ #define sdl_std_cursor_HEIGHT_spraycan 16
+ #define sdl_std_cursor_HOT_X_spraycan  -9
+ #define sdl_std_cursor_HOT_Y_spraycan  -14
+ static unsigned char sdl_std_cursor_mask_sb_v_double_arrow[]= {0x38,0x00,0x7c,0x00,0xfe,0x00,0xff,0x01,0xff,0x01,0x7c,0x00,0x7c,0x00,0x7c,0x00,0x7c,0x00,0x7c,0x00,0xff,0x01,0xff,0x01,0xfe,0x00,0x7c,0x00,0x38,0x00,};
+ static unsigned char sdl_std_cursor_sb_v_double_arrow[]= {0x10,0x00,0x38,0x00,0x7c,0x00,0xfe,0x00,0x28,0x00,0x28,0x00,0x28,0x00,0x28,0x00,0x28,0x00,0x28,0x00,0x28,0x00,0xfe,0x00,0x7c,0x00,0x38,0x00,0x10,0x00,};
+ #define sdl_std_cursor_WIDTH_sb_v_double_arrow  9
+ #define sdl_std_cursor_HEIGHT_sb_v_double_arrow 15
+ #define sdl_std_cursor_HOT_X_sb_v_double_arrow  -3
+ #define sdl_std_cursor_HOT_Y_sb_v_double_arrow  -8
+ static unsigned char sdl_std_cursor_mask_sb_h_double_arrow[]= {0x18,0x0c,0x1c,0x1c,0xfe,0x3f,0xff,0x7f,0xff,0x7f,0xff,0x7f,0xfe,0x3f,0x1c,0x1c,0x18,0x0c,};
+ static unsigned char sdl_std_cursor_sb_h_double_arrow[]= {0x00,0x00,0x08,0x08,0x0c,0x18,0xfe,0x3f,0x0f,0x78,0xfe,0x3f,0x0c,0x18,0x08,0x08,0x00,0x00};
+ #define sdl_std_cursor_WIDTH_sb_h_double_arrow  15
+ #define sdl_std_cursor_HEIGHT_sb_h_double_arrow 9
+ #define sdl_std_cursor_HOT_X_sb_h_double_arrow  -7
+ #define sdl_std_cursor_HOT_Y_sb_h_double_arrow  -4
+ static unsigned char sdl_std_cursor_mask_right_side[]= {0x00,0xf0,0x00,0xf0,0xc0,0xf0,0xc0,0xf1,0x80,0xf3,0x00,0xf7,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0xf7,0x80,0xf3,0xc0,0xf1,0xc0,0xf0,0x00,0xf0,0x00,0xf0,};
+ static unsigned char sdl_std_cursor_right_side[]= {0x00,0x30,0x00,0x30,0x40,0x30,0x80,0x30,0x00,0x31,0x00,0x32,0xff,0x37,0x00,0x32,0x00,0x31,0x80,0x30,0x40,0x30,0x00,0x30,0x00,0x30,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_right_side  16
+ #define sdl_std_cursor_HEIGHT_right_side 15
+ #define sdl_std_cursor_HOT_X_right_side  -13
+ #define sdl_std_cursor_HOT_Y_right_side  -7
+ static unsigned char sdl_std_cursor_mask_right_ptr[]= {0x00,0x03,0x80,0x03,0xc0,0x03,0xe0,0x03,0xf0,0x03,0xf8,0x03,0xfc,0x03,0xfe,0x03,0xff,0x03,0xff,0x03,0xf8,0x03,0xbc,0x03,0x3c,0x03,0x1e,0x00,0x1e,0x00,0x0c,0x00,};
+ static unsigned char sdl_std_cursor_right_ptr[]= {0x00,0x80,0x00,0xc0,0x00,0xe0,0x00,0xf0,0x00,0xf8,0x00,0xfc,0x00,0xfe,0x00,0xff,0x00,0xf8,0x00,0xd8,0x00,0x8c,0x00,0x0c,0x00,0x06,0x00,0x06,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_right_ptr  10
+ #define sdl_std_cursor_HEIGHT_right_ptr 16
+ #define sdl_std_cursor_HOT_X_right_ptr  -7
+ #define sdl_std_cursor_HOT_Y_right_ptr  -14
+ static unsigned char sdl_std_cursor_mask_question_arrow[]= {0xf8,0x00,0xfc,0x01,0xfe,0x03,0xff,0x07,0x8f,0x07,0x9f,0x07,0xde,0x07,0xfc,0x03,0xf8,0x01,0xf8,0x00,0xf8,0x00,0xfc,0x01,0xfe,0x03,0xfc,0x01,0xf8,0x00,0x70,0x00,};
+ static unsigned char sdl_std_cursor_question_arrow[]= {0x7c,0x00,0xfe,0x00,0xc7,0x01,0x83,0x01,0x87,0x01,0xc6,0x01,0xe0,0x00,0x78,0x00,0x38,0x00,0x28,0x00,0x28,0x00,0xee,0x00,0x6c,0x00,0x38,0x00,0x10,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_question_arrow  11
+ #define sdl_std_cursor_HEIGHT_question_arrow 16
+ #define sdl_std_cursor_HOT_X_question_arrow  -4
+ #define sdl_std_cursor_HOT_Y_question_arrow  -8
+ static unsigned char sdl_std_cursor_mask_pirate[]= {0xf0,0x03,0xf8,0x07,0xfc,0x0f,0xfe,0x1f,0xfe,0x1f,0xfc,0x0f,0xf8,0x07,0xf1,0x83,0xf1,0xe3,0xf3,0xf3,0xef,0x39,0x1e,0x1e,0xe0,0x01,0xfe,0xc7,0xff,0xff,0x0f,0x7c,};
+ static unsigned char sdl_std_cursor_pirate[]= {0xe0,0x01,0xf0,0x03,0xf8,0x07,0xcc,0x0c,0xcc,0x0c,0xf8,0x07,0xf0,0x03,0xe0,0x01,0xe1,0x21,0xe1,0x61,0xc2,0x10,0x1c,0x0e,0xe0,0x01,0xf8,0x47,0x0f,0x7c,0x01,0x20,};
+ #define sdl_std_cursor_WIDTH_pirate  16
+ #define sdl_std_cursor_HEIGHT_pirate 16
+ #define sdl_std_cursor_HOT_X_pirate  -7
+ #define sdl_std_cursor_HOT_Y_pirate  -4
+ static unsigned char sdl_std_cursor_mask_left_side[]= {0x0f,0x00,0x0f,0x00,0x0f,0x03,0x8f,0x03,0xcf,0x01,0xef,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xef,0x00,0xcf,0x01,0x8f,0x03,0x0f,0x03,0x0f,0x00,0x0f,0x00,};
+ static unsigned char sdl_std_cursor_left_side[]= {0x03,0x00,0x03,0x00,0x83,0x00,0x43,0x00,0x23,0x00,0x13,0x00,0xfb,0x3f,0x13,0x00,0x23,0x00,0x43,0x00,0x83,0x00,0x03,0x00,0x03,0x00,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_left_side  16
+ #define sdl_std_cursor_HEIGHT_left_side 15
+ #define sdl_std_cursor_HOT_X_left_side  0
+ #define sdl_std_cursor_HOT_Y_left_side  -7
+ static unsigned char sdl_std_cursor_mask_left_ptr[]= {0x03,0x00,0x07,0x00,0x0f,0x00,0x1f,0x00,0x3f,0x00,0x7f,0x00,0xff,0x00,0xff,0x01,0xff,0x03,0xff,0x03,0x7f,0x00,0xf7,0x00,0xf3,0x00,0xe0,0x01,0xe0,0x01,0xc0,0x00,};
+ static unsigned char sdl_std_cursor_left_ptr[]= {0x00,0x00,0x02,0x00,0x06,0x00,0x0e,0x00,0x1e,0x00,0x3e,0x00,0x7e,0x00,0xfe,0x00,0xfe,0x00,0x3e,0x00,0x36,0x00,0x62,0x00,0x60,0x00,0xc0,0x00,0xc0,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_left_ptr  10
+ #define sdl_std_cursor_HEIGHT_left_ptr 16
+ #define sdl_std_cursor_HOT_X_left_ptr  -8
+ #define sdl_std_cursor_HOT_Y_left_ptr  -14
+ static unsigned char sdl_std_cursor_mask_exchange[]= {0xe3,0x07,0xf7,0x0f,0xff,0x1f,0xff,0x3f,0x3f,0x38,0xff,0x30,0xff,0x00,0xff,0x00,0x00,0xff,0x00,0xff,0x0c,0xfe,0x1c,0xfc,0xfc,0xff,0xf8,0xff,0xf0,0xef,0xe0,0xc7,};
+ static unsigned char sdl_std_cursor_exchange[]= {0xf1,0x03,0xfb,0x07,0x1f,0x0c,0x09,0x08,0x19,0x00,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0x00,0x26,0x04,0x24,0x0c,0x3e,0xf8,0x37,0xf0,0x23,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_exchange  16
+ #define sdl_std_cursor_HEIGHT_exchange 16
+ #define sdl_std_cursor_HOT_X_exchange  -6
+ #define sdl_std_cursor_HOT_Y_exchange  -8
+ static unsigned char sdl_std_cursor_mask_crosshair[]= {0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xff,0xff,0xff,0xff,0xff,0xff,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,};
+ static unsigned char sdl_std_cursor_crosshair[]= {0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x7f,0xff,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_crosshair  16
+ #define sdl_std_cursor_HEIGHT_crosshair 16
+ #define sdl_std_cursor_HOT_X_crosshair  -7
+ #define sdl_std_cursor_HOT_Y_crosshair  -8
+ static unsigned char sdl_std_cursor_mask_bottom_side[]= {0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xc0,0x01,0xcc,0x19,0xdc,0x1d,0xf8,0x0f,0xf0,0x07,0xe0,0x03,0xc0,0x01,0xff,0x7f,0xff,0x7f,0xff,0x7f,0xff,0x7f,};
+ static unsigned char sdl_std_cursor_bottom_side[]= {0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x44,0x04,0x48,0x02,0x50,0x01,0xe0,0x00,0x40,0x00,0x00,0x00,0xff,0x1f,0xff,0x1f,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_bottom_side  15
+ #define sdl_std_cursor_HEIGHT_bottom_side 16
+ #define sdl_std_cursor_HOT_X_bottom_side  -6
+ #define sdl_std_cursor_HOT_Y_bottom_side  -1
+ static unsigned char sdl_std_cursor_mask_bottom_right_corner[]= {0x00,0xf0,0x00,0xf0,0x0c,0xf7,0x1c,0xf7,0x38,0xf7,0x70,0xf7,0xe0,0xf7,0xc0,0xf7,0xfc,0xf7,0xfc,0xf7,0xfc,0xf7,0x00,0xf0,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,};
+ static unsigned char sdl_std_cursor_bottom_right_corner[]= {0x00,0x30,0x00,0x30,0x04,0x31,0x08,0x31,0x10,0x31,0x20,0x31,0x40,0x31,0x80,0x31,0xfc,0x31,0x00,0x30,0x00,0x30,0x00,0x30,0xff,0x3f,0xff,0x3f,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_bottom_right_corner  16
+ #define sdl_std_cursor_HEIGHT_bottom_right_corner 16
+ #define sdl_std_cursor_HOT_X_bottom_right_corner  -13
+ #define sdl_std_cursor_HOT_Y_bottom_right_corner  -1
+ static unsigned char sdl_std_cursor_mask_bottom_left_corner[]= {0x0f,0x00,0x0f,0x00,0xef,0x30,0xef,0x38,0xef,0x1c,0xef,0x0e,0xef,0x07,0xef,0x03,0xef,0x3f,0xef,0x3f,0xef,0x3f,0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,};
+ static unsigned char sdl_std_cursor_bottom_left_corner[]= {0x03,0x00,0x03,0x00,0x23,0x08,0x23,0x04,0x23,0x02,0x23,0x01,0xa3,0x00,0x63,0x00,0xe3,0x0f,0x03,0x00,0x03,0x00,0x03,0x00,0xff,0x3f,0xff,0x3f,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_bottom_left_corner  16
+ #define sdl_std_cursor_HEIGHT_bottom_left_corner 16
+ #define sdl_std_cursor_HOT_X_bottom_left_corner  0
+ #define sdl_std_cursor_HOT_Y_bottom_left_corner  -1
+ static unsigned char sdl_std_cursor_mask_arrow[]= {0x00,0xe0,0x00,0xf8,0x00,0xfe,0x80,0x7f,0xe0,0x7f,0xf8,0x3f,0xfc,0x3f,0xfc,0x1f,0xe0,0x1f,0xf0,0x0f,0xf8,0x0f,0x7c,0x07,0x3e,0x07,0x1f,0x02,0x0e,0x00,0x04,0x00,};
+ static unsigned char sdl_std_cursor_arrow[]= {0x00,0x30,0x00,0x3c,0x00,0x1f,0xc0,0x1f,0xf0,0x0f,0xfc,0x0f,0xc0,0x07,0xe0,0x07,0x70,0x03,0x38,0x03,0x1c,0x01,0x0e,0x01,0x07,0x00,0x02,0x00,0x00,0x00,0x00,0x00,};
+ #define sdl_std_cursor_WIDTH_arrow  16
+ #define sdl_std_cursor_HEIGHT_arrow 16
+ #define sdl_std_cursor_HOT_X_arrow  -13
+ #define sdl_std_cursor_HOT_Y_arrow  -14
+ /* end cursor data */
+ static SDL_Cursor *sdl_std_cursor_array[(int)GHOST_kStandardCursorNumCursors]= {0};
+ /* utility function mostly a copy of SDL_CreateCursor but allows us to change
+  * color and supports blenders flipped bits */
+ static SDL_Cursor *
+ sdl_ghost_CreateCursor(const Uint8 *data,
+                        const Uint8 *mask,
+                        int w,
+                        int h,
+                        int hot_x,
+                        int hot_y)
+ {
+     SDL_Surface *surface;
+     SDL_Cursor *cursor;
+     int x, y;
+     Uint32 *pixel;
+     Uint8 datab= 0, maskb= 0;
+     const Uint32 black= 0xFF000000;
+     const Uint32 white= 0xFFFFFFFF;
+     const Uint32 transparent= 0x00000000;
+     /* Make sure the width is a multiple of 8 */
+     w= ((w + 7) & ~7);
+     /* Create the surface from a bitmap */
+       surface= SDL_CreateRGBSurface(0, w, h, 32,
+                                     0x00FF0000,
+                                     0x0000FF00,
+                                     0x000000FF,
+                                     0xFF000000);
+     if (!surface) {
+         return NULL;
+     }
+     for (y= 0; y < h; ++y) {
+         pixel= (Uint32 *) ((Uint8 *) surface->pixels + y * surface->pitch);
+         for (x= 0; x < w; ++x) {
+             if ((x % 8) == 0) {
+                 datab= *data++;
+                 maskb= *mask++;
+                               /* reverse bit order */
+                               datab= (datab * 0x0202020202ULL & 0x010884422010ULL) % 1023;
+                               maskb= (maskb * 0x0202020202ULL & 0x010884422010ULL) % 1023;
+             }
+             if (maskb & 0x80) {
+                 *pixel++= (datab & 0x80) ?  white : black;
+             }
+                       else {
+                 *pixel++= (datab & 0x80) ? white : transparent;
+             }
+             datab <<= 1;
+             maskb <<= 1;
+         }
+     }
+     cursor= SDL_CreateColorCursor(surface, hot_x, hot_y);
+     SDL_FreeSurface(surface);
+     return cursor;
+ }
+ /* TODO, this is currently never freed but it wont leak either. */
+ static void sdl_cursor_init(void)
+ {
+ #define DEF_CURSOR(name, ind) \
+       assert(\
+               (\
+               sdl_std_cursor_array[(int)ind]= \
+                               sdl_ghost_CreateCursor(sdl_std_cursor_##name, \
+                               sdl_std_cursor_mask_##name, \
+                               sdl_std_cursor_WIDTH_##name, \
+                               sdl_std_cursor_HEIGHT_##name, \
+                               (sdl_std_cursor_WIDTH_##name + (sdl_std_cursor_HOT_X_##name)) - 1, \
+                               (sdl_std_cursor_HEIGHT_##name + (sdl_std_cursor_HOT_Y_##name)) - 1) \
+               ) != NULL) \
+       DEF_CURSOR(left_ptr, GHOST_kStandardCursorDefault);
+       DEF_CURSOR(right_ptr, GHOST_kStandardCursorRightArrow);
+       DEF_CURSOR(left_ptr, GHOST_kStandardCursorLeftArrow);
+       DEF_CURSOR(umbrella, GHOST_kStandardCursorInfo); // TODO, replace this one.
+       DEF_CURSOR(pirate, GHOST_kStandardCursorDestroy);
+       DEF_CURSOR(question_arrow, GHOST_kStandardCursorHelp);
+       DEF_CURSOR(exchange, GHOST_kStandardCursorCycle);
+       DEF_CURSOR(spraycan, GHOST_kStandardCursorSpray);
+       DEF_CURSOR(watch, GHOST_kStandardCursorWait);
+       DEF_CURSOR(xterm, GHOST_kStandardCursorText);
+       DEF_CURSOR(crosshair, GHOST_kStandardCursorCrosshair);
+       DEF_CURSOR(sb_v_double_arrow, GHOST_kStandardCursorUpDown);
+       DEF_CURSOR(sb_h_double_arrow, GHOST_kStandardCursorLeftRight);
+       DEF_CURSOR(top_side, GHOST_kStandardCursorTopSide);
+       DEF_CURSOR(bottom_side, GHOST_kStandardCursorBottomSide);
+       DEF_CURSOR(left_side, GHOST_kStandardCursorLeftSide);
+       DEF_CURSOR(right_side, GHOST_kStandardCursorRightSide);
+       DEF_CURSOR(top_left_corner, GHOST_kStandardCursorTopLeftCorner);
+       DEF_CURSOR(top_right_corner, GHOST_kStandardCursorTopRightCorner);
+       DEF_CURSOR(bottom_right_corner, GHOST_kStandardCursorBottomRightCorner);
+       DEF_CURSOR(bottom_left_corner , GHOST_kStandardCursorBottomLeftCorner);
+       DEF_CURSOR(arrow , GHOST_kStandardCursorCopy);
+       //DEF_CURSOR(arrow, GHOST_kStandardCursorCustom);
+       DEF_CURSOR(arrow, GHOST_kStandardCursorPencil);
+ #undef DEF_CURSOR
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setWindowCursorGrab(GHOST_TGrabCursorMode mode)
+ {
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setWindowCursorShape(GHOST_TStandardCursor shape)
+ {
+       if(sdl_std_cursor_array[0] == NULL) {
+               sdl_cursor_init();
+       }
+       SDL_SetCursor(sdl_std_cursor_array[(int)shape]);
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2],
+                                             GHOST_TUns8 mask[16][2],
+                                             int hotX,
+                                             int hotY)
+ {
+       return setWindowCustomCursorShape((GHOST_TUns8 *)bitmap,
+                                         (GHOST_TUns8 *)mask,
+                                         16, 16,
+                                         hotX, hotY,
+                                         0, 1);
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setWindowCustomCursorShape(GHOST_TUns8 *bitmap,
+                                             GHOST_TUns8 *mask,
+                                             int sizex, int sizey,
+                                             int hotX, int hotY,
+                                             int fg_color, int bg_color)
+ {
+       if(m_sdl_custom_cursor) {
+               SDL_FreeCursor(m_sdl_custom_cursor);
+       }
+       m_sdl_custom_cursor= sdl_ghost_CreateCursor((const Uint8 *)bitmap,
+                                                   (const Uint8 *)mask,
+                                                   sizex, sizex,
+                                                   hotX, hotY);
+       SDL_SetCursor(m_sdl_custom_cursor);
+       return GHOST_kSuccess;
+ }
+ GHOST_TSuccess
+ GHOST_WindowSDL::setWindowCursorVisibility(bool visible)
+ {
+       SDL_ShowCursor(visible);
+       return GHOST_kSuccess;
+ }
index 0000000000000000000000000000000000000000,6b016b85126f8434f3f047713bfa35dd5603a2b5..4be8962bf29533826a7eac77754759e0d3ca0be6
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,167 +1,167 @@@
 - * $Id$
+ /*
++ * $Id: GHOST_WindowSDL.h 38349 2011-07-13 00:49:22Z gsrb3d $
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file ghost/intern/GHOST_WindowSDL.h
+  *  \ingroup GHOST
+  * Declaration of GHOST_WindowSDL class.
+  */
+ #ifndef _GHOST_WINDOWSDL_H_
+ #define _GHOST_WINDOWSDL_H_
+ #include "GHOST_Window.h"
+ #include "GHOST_SystemSDL.h"
+ #include <map>
+ extern "C" {
+       #include "SDL.h"
+ }
+ #if !SDL_VERSION_ATLEAST(1, 3, 0)
+ #  error "SDL 1.3 or newer is needed to build with Ghost"
+ #endif
+ class STR_String;
+ class GHOST_WindowSDL : public GHOST_Window
+ {
+ private :
+       GHOST_SystemSDL  * m_system;
+       bool               m_invalid_window;
+       SDL_Window       * m_sdl_win;
+       SDL_GLContext      m_sdl_glcontext;
+       SDL_Cursor               * m_sdl_custom_cursor;
+ public:
+       const GHOST_TabletData* GetTabletData() { return NULL; }
+       GHOST_WindowSDL(GHOST_SystemSDL *system,
+                       const STR_String& title,
+                       GHOST_TInt32 left, GHOST_TInt32 top,
+                       GHOST_TUns32 width, GHOST_TUns32 height,
+                       GHOST_TWindowState state,
+                       const GHOST_TEmbedderWindowID parentWindow,
+                       GHOST_TDrawingContextType type,
+                       const bool stereoVisual,
+                       const GHOST_TUns16 numOfAASamples
+                       );
+       ~GHOST_WindowSDL();
+       /* SDL spesific */
+       SDL_Window *
+       getSDLWindow()
+       {
+               return m_sdl_win;
+       }
+       GHOST_TSuccess invalidate(void);
+       /**
+        * called by the X11 system implementation when expose events
+        * for the window have been pushed onto the GHOST queue
+        */
+       void validate()
+       {
+               m_invalid_window = false;
+       }
+       bool getValid() const
+       {
+               return (m_sdl_win != NULL);
+       }
+       void getWindowBounds(GHOST_Rect& bounds) const;
+       void getClientBounds(GHOST_Rect& bounds) const;
+ protected:
+       GHOST_TSuccess installDrawingContext(GHOST_TDrawingContextType type);
+       GHOST_TSuccess removeDrawingContext();
+       GHOST_TSuccess
+       setWindowCursorGrab(GHOST_TGrabCursorMode mode);
+       GHOST_TSuccess
+       setWindowCursorShape(GHOST_TStandardCursor shape);
+       GHOST_TSuccess
+       setWindowCustomCursorShape(GHOST_TUns8 bitmap[16][2],
+                                  GHOST_TUns8 mask[16][2],
+                                  int hotX, int hotY);
+       GHOST_TSuccess
+       setWindowCustomCursorShape(GHOST_TUns8 *bitmap,
+                                  GHOST_TUns8 *mask,
+                                  int sizex, int sizey,
+                                  int hotX, int hotY,
+                                  int fg_color, int bg_color);
+       GHOST_TSuccess
+       setWindowCursorVisibility(bool visible);
+       void
+       setTitle(const STR_String& title);
+       void
+       getTitle(STR_String& title) const;
+       GHOST_TSuccess
+       setClientWidth(GHOST_TUns32 width);
+       GHOST_TSuccess
+       setClientHeight(GHOST_TUns32 height);
+       GHOST_TSuccess
+       setClientSize(GHOST_TUns32 width,
+                     GHOST_TUns32 height);
+       void
+       screenToClient(GHOST_TInt32 inX, GHOST_TInt32 inY,
+                      GHOST_TInt32& outX, GHOST_TInt32& outY) const;
+       void
+       clientToScreen(GHOST_TInt32 inX, GHOST_TInt32 inY,
+                      GHOST_TInt32& outX, GHOST_TInt32& outY) const;
+       GHOST_TSuccess
+       swapBuffers();
+       GHOST_TSuccess
+       activateDrawingContext();
+       GHOST_TSuccess
+       setState(GHOST_TWindowState state);
+       GHOST_TWindowState
+       getState() const;
+       GHOST_TSuccess setOrder(GHOST_TWindowOrder order) { return GHOST_kSuccess; } // TODO
+ };
+ #endif // _GHOST_WINDOWSDL_H_
index 0000000000000000000000000000000000000000,f834b55b387ff17f747bcb6986af40480d76a6d2..f834b55b387ff17f747bcb6986af40480d76a6d2
mode 000000,100644..100755
--- /dev/null
index c5ee2488a315f9cefb782b677b4519acbac4895d,0342a14a1b23c7e1fe4491222b0b010347b24004..72e521be5cf197413f575484799cc546fefa3ee9
@@@ -232,15 -231,15 +232,15 @@@ class ShapeTransfer(bpy.types.Operator)
      bl_options = {'REGISTER', 'UNDO'}
  
      mode = EnumProperty(items=(
-                         ('OFFSET', "Offset", _("Apply the relative positional offset")),
 -                        ('OFFSET', "Offset", "Apply the relative positional offset"),
 -                        ('RELATIVE_FACE', "Relative Face", "Calculate the geometricly relative position (using faces)."),
 -                        ('RELATIVE_EDGE', "Relative Edge", "Calculate the geometricly relative position (using edges).")),
 -                name="Transformation Mode",
 -                description="Method to apply relative shape positions to the new shape",
++                        ('OFFSET', _("Offset"), _("Apply the relative positional offset")),
 +                        ('RELATIVE_FACE', _("Relative Face"), _("Calculate the geometricly relative position (using faces).")),
 +                        ('RELATIVE_EDGE', _("Relative Edge"), _("Calculate the geometricly relative position (using edges)."))),
 +                name=_("Transformation Mode"),
 +                description=_("Method to apply relative shape positions to the new shape"),
                  default='OFFSET')
  
 -    use_clamp = BoolProperty(name="Clamp Offset",
 -                description="Clamp the transformation to the distance each vertex moves in the original shape.",
 +    use_clamp = BoolProperty(name=_("Clamp Offset"),
 +                description=_("Clamp the transformation to the distance each vertex moves in the original shape."),
                  default=False)
  
      def _main(self, ob_act, objects, mode='OFFSET', use_clamp=False):
index 14ca1b4705da50acdfe1ca7da233237c7975100b,f3c799c9ac28ed85035aef91d65c3cdcb5aa1a7b..6624c2ad2881816ba1aebe72796035138d197ad4
@@@ -19,8 -19,8 +19,9 @@@
  # <pep8 compliant>
  
  import bpy
 +from blf import gettext as _
  
  class AddPresetBase():
      '''Base preset class, only for subclassing
      subclasses must define
index 561738d1706e4e5d20d9bca0a7b7c8a82c7b1b04,910ccf96c0e41e96cd3487d7bd8c687e52b07495..2406cc599526414b2b42c6a32352291d5ca627c9
@@@ -26,8 -26,8 +26,9 @@@
  
  import bpy
  import os
 +from blf import gettext as _
  
  def guess_player_path(preset):
      import sys
  
index f2b19923e327bb52da1a0c7ed42bc9a2613a04df,af33e45668c19933b84a5e1f0a50cc2172f44314..00a2f5463828c2f76a428bb5b2cb8b8cc187c9c9
  # <pep8 compliant>
  
  import bpy
- from bpy.props import StringProperty, BoolProperty, IntProperty, FloatProperty
+ from bpy.props import StringProperty, BoolProperty, IntProperty, \
+                       FloatProperty, EnumProperty
  from rna_prop_ui import rna_idprop_ui_prop_get, rna_idprop_ui_prop_clear
 +from blf import gettext as _
  
  
  class MESH_OT_delete_edgeloop(bpy.types.Operator):
@@@ -452,23 -453,84 +454,84 @@@ class WM_OT_context_set_id(bpy.types.Op
          return {'FINISHED'}
  
  
 -doc_id = StringProperty(name="Doc ID",
 +doc_id = StringProperty(name=_("Doc ID"),
          description="", maxlen=1024, default="", options={'HIDDEN'})
  
 -doc_new = StringProperty(name="Edit Description",
 +doc_new = StringProperty(name=_("Edit Description"),
          description="", maxlen=1024, default="")
  
+ data_path_iter = StringProperty(
+         description="The data path relative to the context, must point to an iterable.")
+ data_path_item = StringProperty(
+         description="The data path from each iterable to the value (int or float)")
+ class WM_OT_context_collection_boolean_set(bpy.types.Operator):
+     '''Set boolean values for a collection of items'''
+     bl_idname = "wm.context_collection_boolean_set"
+     bl_label = "Context Collection Boolean Set"
+     bl_options = {'UNDO', 'REGISTER', 'INTERNAL'}
+     data_path_iter = data_path_iter
+     data_path_item = data_path_item
+     type = EnumProperty(items=(
+             ('TOGGLE', "Toggle", ""),
+             ('ENABLE', "Enable", ""),
+             ('DISABLE', "Disable", ""),
+             ),
+         name="Type")
+     def execute(self, context):
+         data_path_iter = self.data_path_iter
+         data_path_item = self.data_path_item
+         items = list(getattr(context, data_path_iter))
+         items_ok = []
+         is_set = False
+         for item in items:
+             try:
+                 value_orig = eval("item." + data_path_item)
+             except:
+                 continue
+             if value_orig == True:
+                 is_set = True
+             elif value_orig == False:
+                 pass
+             else:
+                 self.report({'WARNING'}, "Non boolean value found: %s[ ].%s" %
+                             (data_path_iter, data_path_item))
+                 return {'CANCELLED'}
+             items_ok.append(item)
+         if self.type == 'ENABLE':
+             is_set = True
+         elif self.type == 'DISABLE':
+             is_set = False
+         else:
+             is_set = not is_set
+         exec_str = "item.%s = %s" % (data_path_item, is_set)
+         for item in items_ok:
+             exec(exec_str)
+         return {'FINISHED'}
  
  class WM_OT_context_modal_mouse(bpy.types.Operator):
      '''Adjust arbitrary values with mouse input'''
      bl_idname = "wm.context_modal_mouse"
 -    bl_label = "Context Modal Mouse"
 +    bl_label = _("Context Modal Mouse")
-     bl_options = {'INTERNAL'}
+     bl_options = {'GRAB_POINTER', 'BLOCKING', 'INTERNAL'}
+     data_path_iter = data_path_iter
+     data_path_item = data_path_item
  
-     data_path_iter = StringProperty(description=_("The data path relative to the context, must point to an iterable."))
-     data_path_item = StringProperty(description=_("The data path from each iterable to the value (int or float)"))
 -    input_scale = FloatProperty(default=0.01, description="Scale the mouse movement by this value before applying the delta")
 -    invert = BoolProperty(default=False, description="Invert the mouse input")
 +    input_scale = FloatProperty(default=0.01, description=_("Scale the mouse movement by this value before applying the delta"))
 +    invert = BoolProperty(default=False, description=_("Invert the mouse input"))
      initial_x = IntProperty(options={'HIDDEN'})
  
      def _values_store(self, context):
index a4dfe0cb7f8b827cfcf0e377dca814473d82317d,7ca8818cbd2eb6518d5f8a588f78e3f7563a2bbd..8cb37a0b9877e68cc69a96a7f0ee3691b6299342
@@@ -19,8 -19,8 +19,9 @@@
  # <pep8 compliant>
  import bpy
  from rna_prop_ui import PropertyPanel
 +from blf import gettext as _
  
  class TEXTURE_MT_specials(bpy.types.Menu):
      bl_label = "Texture Specials"
      COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
index de83e7bab1f958a58240f870b86415ee1146b5d8,da6c102100b4e8c0c4286af3d7dbcebb17c4f066..7e4c84d5afcd98e458b167d2fa08bec03b20e650
@@@ -19,7 -19,7 +19,8 @@@
  # <pep8 compliant>
  import bpy
  from bpy.props import StringProperty
 +from blf import gettext as _
  
  class CONSOLE_HT_header(bpy.types.Header):
      bl_space_type = 'CONSOLE'
index 7f2d88a6e4e00280c7f52ce648f289cfba52cdfa,722b46aba1178f13a2ad5c4a65c8688ebb952c80..6e0eded1d4c158ff4c9e1d137578b0efa77d31a0
@@@ -617,13 -615,12 +616,12 @@@ class IMAGE_PT_view_properties(bpy.type
  
              split = layout.split()
              col = split.column()
 -            col.prop(uvedit, "show_smooth_edges", text="Smooth")
 -            col.prop(uvedit, "show_modified_edges", text="Modified")
+             col.prop(uvedit, "show_faces")
-             #col.prop(uvedit, "show_edges")
-             #col.prop(uvedit, "show_faces")
 +            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)
index 3b6b4575e8e85ed0133c1c9c9505a1d39274adb5,7e62465d1eef0cbb5155949757d7f4fa56c80351..d6d34eb8888773a75473858a5171fd870807f4ae
@@@ -18,8 -18,8 +18,9 @@@
  
  # <pep8 compliant>
  import bpy
 +from blf import gettext as _
  
  class TIME_HT_header(bpy.types.Header):
      bl_space_type = 'TIMELINE'
  
index a78a5ceba808be26856754f293de13cefaa77ff1,6a809aefb9dfbf98df6daae06ebe457258fa8dcf..5f47ca7bc87fe5fa07c5db9b7680ca5b17eb1ee8
@@@ -127,7 -126,7 +127,7 @@@ class USERPREF_MT_appconfigs(bpy.types.
      preset_operator = "wm.appconfig_activate"
  
      def draw(self, context):
-         props = self.layout.operator("wm.appconfig_default", text=_("Blender (default)"))
 -        self.layout.operator("wm.appconfig_default", text="Blender (default)")
++        self.layout.operator("wm.appconfig_default", text=_("Blender (default)"))
  
          # now draw the presets
          bpy.types.Menu.draw_preset(self, context)
@@@ -850,7 -849,7 +850,7 @@@ class USERPREF_PT_input(bpy.types.Panel
  
  
  class USERPREF_MT_addons_dev_guides(bpy.types.Menu):
-     bl_label = _("Develoment Guides")
 -    bl_label = "Development Guides"
++    bl_label = _("Development Guides")
  
      # menu to open webpages with addons development guides
      def draw(self, context):
@@@ -968,22 -983,26 +984,26 @@@ class USERPREF_PT_addons(bpy.types.Pane
                          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')
-                     if info["wiki_url"] or info["tracker_url"]:
+                     user_addon = USERPREF_PT_addons.is_user_addon(mod, user_addon_paths)
+                     tot_row = bool(info["wiki_url"]) + bool(info["tracker_url"]) + bool(user_addon)
+                     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__
  
-                         if info["wiki_url"] and info["tracker_url"]:
-                             split.separator()
-                         else:
-                             split.separator()
+                         for i in range(4 - tot_row):
                              split.separator()
  
          # Append missing scripts
          # First collect scripts that are used but have no script file.
          module_names = {mod.__name__ for mod, info in addons}
@@@ -1187,6 -1205,54 +1206,54 @@@ class WM_OT_addon_install(bpy.types.Ope
          return {'RUNNING_MODAL'}
  
  
 -    bl_label = "Remove Add-On"
+ class WM_OT_addon_remove(bpy.types.Operator):
+     "Disable an addon"
+     bl_idname = "wm.addon_remove"
++    bl_label = _("Remove Add-On")
+     module = StringProperty(name="Module", description="Module name of the addon to remove")
+     @staticmethod
+     def path_from_addon(module):
+         for mod in addon_utils.modules(USERPREF_PT_addons._addons_fake_modules):
+             if mod.__name__ == module:
+                 filepath = mod.__file__
+                 if os.path.exists(filepath):
+                     if os.path.splitext(os.path.basename(filepath))[0] == "__init__":
+                         return os.path.dirname(filepath), True
+                     else:
+                         return filepath, False
+         return None, False
+     def execute(self, context):
+         path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
+         if path is None:
+             self.report('WARNING', "Addon path %r could not be found" % path)
+             return {'CANCELLED'}
+         # incase its enabled
+         addon_utils.disable(self.module)
+         import shutil
+         if isdir:
+             shutil.rmtree(path)
+         else:
+             os.remove(path)
+         context.area.tag_redraw()
+         return {'FINISHED'}
+     # lame confirmation check
+     def draw(self, context):
+         self.layout.label(text="Remove Addon: %r?" % self.module)
+         path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
+         self.layout.label(text="Path: %r" % path)
+     def invoke(self, context, event):
+         wm = context.window_manager
+         return wm.invoke_props_dialog(self, width=600)
  class WM_OT_addon_expand(bpy.types.Operator):
      "Display more information on this add-on"
      bl_idname = "wm.addon_expand"
index 749c506a78a8ef8c0ec930d4018e9a8aa5a1db27,85764c5530481807d0b46e6bd60ca900487df530..feb90cadd68d32f20458afbdffea9f3a1a0e2ab5
  # <pep8 compliant>
  import bpy
  import os
 +from blf import gettext as _
 +from blf import fake_gettext as N_
  
  KM_HIERARCHY = [
 -    ('Window', 'EMPTY', 'WINDOW', []),  # file save, window change, exit
 -    ('Screen', 'EMPTY', 'WINDOW', [     # full screen, undo, screenshot
 -        ('Screen Editing', 'EMPTY', 'WINDOW', []),    # resizing, action corners
 +    ( N_('Window'), 'EMPTY', 'WINDOW', []),  # file save, window change, exit
 +    ( N_('Screen'), 'EMPTY', 'WINDOW', [     # full screen, undo, screenshot
 +        ( N_('Screen Editing'), 'EMPTY', 'WINDOW', []),    # resizing, action corners
          ]),
  
 -    ('View2D', 'EMPTY', 'WINDOW', []),    # view 2d navigation (per region)
 -    ('View2D Buttons List', 'EMPTY', 'WINDOW', []),  # view 2d with buttons navigation
 -    ('Header', 'EMPTY', 'WINDOW', []),    # header stuff (per region)
 -    ('Grease Pencil', 'EMPTY', 'WINDOW', []),  # grease pencil stuff (per region)
 +    ( N_('View2D'), 'EMPTY', 'WINDOW', []),    # view 2d navigation (per region)
 +    ( N_('View2D Buttons List'), 'EMPTY', 'WINDOW', []),  # view 2d with buttons navigation
 +    ( N_('Header'), 'EMPTY', 'WINDOW', []),    # header stuff (per region)
 +    ( N_('Grease Pencil'), 'EMPTY', 'WINDOW', []),  # grease pencil stuff (per region)
  
 -    ('3D View', 'VIEW_3D', 'WINDOW', [  # view 3d navigation and generic stuff (select, transform)
 -        ('Object Mode', 'EMPTY', 'WINDOW', []),
 -        ('Mesh', 'EMPTY', 'WINDOW', []),
 -        ('Curve', 'EMPTY', 'WINDOW', []),
 -        ('Armature', 'EMPTY', 'WINDOW', []),
 -        ('Metaball', 'EMPTY', 'WINDOW', []),
 -        ('Lattice', 'EMPTY', 'WINDOW', []),
 -        ('Font', 'EMPTY', 'WINDOW', []),
 +    ( N_('3D View'), 'VIEW_3D', 'WINDOW', [  # view 3d navigation and generic stuff (select, transform)
 +        ( N_('Object Mode'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Mesh'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Curve'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Armature'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Metaball'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Lattice'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Font'), 'EMPTY', 'WINDOW', []),
  
 -        ('Pose', 'EMPTY', 'WINDOW', []),
 +        ( N_('Pose'), 'EMPTY', 'WINDOW', []),
  
 -        ('Vertex Paint', 'EMPTY', 'WINDOW', []),
 -        ('Weight Paint', 'EMPTY', 'WINDOW', []),
 -        ('Face Mask', 'EMPTY', 'WINDOW', []),
 -        ('Image Paint', 'EMPTY', 'WINDOW', []),  # image and view3d
 -        ('Sculpt', 'EMPTY', 'WINDOW', []),
 +        ( N_('Vertex Paint'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Weight Paint'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Face Mask'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Image Paint'), 'EMPTY', 'WINDOW', []),  # image and view3d
 +        ( N_('Sculpt'), 'EMPTY', 'WINDOW', []),
  
 -        ('Armature Sketch', 'EMPTY', 'WINDOW', []),
 -        ('Particle', 'EMPTY', 'WINDOW', []),
 +        ( N_('Armature Sketch'), 'EMPTY', 'WINDOW', []),
 +        ( N_('Particle'), 'EMPTY', 'WINDOW', []),
  
 -        ('Object Non-modal', 'EMPTY', 'WINDOW', []),  # mode change
 +        ( N_('Object Non-modal'), 'EMPTY', 'WINDOW', []),  # mode change
  
 -        ('3D View Generic', 'VIEW_3D', 'WINDOW', [])    # toolbar and properties
 +        ( N_('3D View Generic'), 'VIEW_3D', 'WINDOW', [])    # toolbar and properties
          ]),
  
 -    ('Frames', 'EMPTY', 'WINDOW', []),    # frame navigation (per region)
 -    ('Markers', 'EMPTY', 'WINDOW', []),    # markers (per region)
 -    ('Animation', 'EMPTY', 'WINDOW', []),    # frame change on click, preview range (per region)
 -    ('Animation Channels', 'EMPTY', 'WINDOW', []),
 -    ('Graph Editor', 'GRAPH_EDITOR', 'WINDOW', [
 -        ('Graph Editor Generic', 'GRAPH_EDITOR', 'WINDOW', [])
 +    ( N_('Frames'), 'EMPTY', 'WINDOW', []),    # frame navigation (per region)
 +    ( N_('Markers'), 'EMPTY', 'WINDOW', []),    # markers (per region)
 +    ( N_('Animation'), 'EMPTY', 'WINDOW', []),    # frame change on click, preview range (per region)
 +    ( N_('Animation Channels'), 'EMPTY', 'WINDOW', []),
 +    ( N_('Graph Editor'), 'GRAPH_EDITOR', 'WINDOW', [
 +        ( N_('Graph Editor Generic'), 'GRAPH_EDITOR', 'WINDOW', [])
          ]),
 -    ('Dopesheet', 'DOPESHEET_EDITOR', 'WINDOW', []),
 -    ('NLA Editor', 'NLA_EDITOR', 'WINDOW', [
 -        ('NLA Channels', 'NLA_EDITOR', 'WINDOW', []),
 -        ('NLA Generic', 'NLA_EDITOR', 'WINDOW', [])
 +    ( N_('Dopesheet'), 'DOPESHEET_EDITOR', 'WINDOW', []),
 +    ( N_('NLA Editor'), 'NLA_EDITOR', 'WINDOW', [
 +        ( N_('NLA Channels'), 'NLA_EDITOR', 'WINDOW', []),
 +        ( N_('NLA Generic'), 'NLA_EDITOR', 'WINDOW', [])
          ]),
  
 -    ('Image', 'IMAGE_EDITOR', 'WINDOW', [
 -        ('UV Editor', 'EMPTY', 'WINDOW', []),  # image (reverse order, UVEdit before Image
 -        ('Image Paint', 'EMPTY', 'WINDOW', []),  # image and view3d
 -        ('Image Generic', 'IMAGE_EDITOR', 'WINDOW', [])
 +    ( N_('Image'), 'IMAGE_EDITOR', 'WINDOW', [
 +        ( N_('UV Editor'), 'EMPTY', 'WINDOW', []),  # image (reverse order, UVEdit before Image
 +        ( N_('Image Paint'), 'EMPTY', 'WINDOW', []),  # image and view3d
 +        ( N_('Image Generic'), 'IMAGE_EDITOR', 'WINDOW', [])
          ]),
  
 -    ('Timeline', 'TIMELINE', 'WINDOW', []),
 -    ('Outliner', 'OUTLINER', 'WINDOW', []),
 +    ( N_('Timeline'), 'TIMELINE', 'WINDOW', []),
 +    ( N_('Outliner'), 'OUTLINER', 'WINDOW', []),
  
 -    ('Node Editor', 'NODE_EDITOR', 'WINDOW', [
 -        ('Node Generic', 'NODE_EDITOR', 'WINDOW', [])
 +    ( N_('Node Editor'), 'NODE_EDITOR', 'WINDOW', [
 +        ( N_('Node Generic'), 'NODE_EDITOR', 'WINDOW', [])
          ]),
 -    ('Sequencer', 'SEQUENCE_EDITOR', 'WINDOW', []),
 -    ('Logic Editor', 'LOGIC_EDITOR', 'WINDOW', []),
 +    ( N_('Sequencer'), 'SEQUENCE_EDITOR', 'WINDOW', []),
 +    ( N_('Logic Editor'), 'LOGIC_EDITOR', 'WINDOW', []),
  
 -    ('File Browser', 'FILE_BROWSER', 'WINDOW', [
 -        ('File Browser Main', 'FILE_BROWSER', 'WINDOW', []),
 -        ('File Browser Buttons', 'FILE_BROWSER', 'WINDOW', [])
 +    ( N_('File Browser'), 'FILE_BROWSER', 'WINDOW', [
 +        ( N_('File Browser Main'), 'FILE_BROWSER', 'WINDOW', []),
 +        ( N_('File Browser Buttons'), 'FILE_BROWSER', 'WINDOW', [])
          ]),
  
 -    ('Property Editor', 'PROPERTIES', 'WINDOW', []),  # align context menu
 +    ( N_('Property Editor'), 'PROPERTIES', 'WINDOW', []),  # align context menu
  
 -    ('Script', 'SCRIPTS_WINDOW', 'WINDOW', []),
 -    ('Text', 'TEXT_EDITOR', 'WINDOW', []),
 -    ('Console', 'CONSOLE', 'WINDOW', []),
 +    ( N_('Script'), 'SCRIPTS_WINDOW', 'WINDOW', []),
 +    ( N_('Text'), 'TEXT_EDITOR', 'WINDOW', []),
 +    ( N_('Console'), 'CONSOLE', 'WINDOW', []),
  
 -    ('View3D Gesture Circle', 'EMPTY', 'WINDOW', []),
 -    ('Gesture Border', 'EMPTY', 'WINDOW', []),
 -    ('Standard Modal Map', 'EMPTY', 'WINDOW', []),
 -    ('Transform Modal Map', 'EMPTY', 'WINDOW', []),
 -    ('View3D Fly Modal', 'EMPTY', 'WINDOW', []),
 -    ('View3D Rotate Modal', 'EMPTY', 'WINDOW', []),
 -    ('View3D Move Modal', 'EMPTY', 'WINDOW', []),
 -    ('View3D Zoom Modal', 'EMPTY', 'WINDOW', []),
 +    ( N_('View3D Gesture Circle'), 'EMPTY', 'WINDOW', []),
 +    ( N_('Gesture Border'), 'EMPTY', 'WINDOW', []),
 +    ( N_('Standard Modal Map'), 'EMPTY', 'WINDOW', []),
 +    ( N_('Transform Modal Map'), 'EMPTY', 'WINDOW', []),
 +    ( N_('View3D Fly Modal'), 'EMPTY', 'WINDOW', []),
 +    ( N_('View3D Rotate Modal'), 'EMPTY', 'WINDOW', []),
 +    ( N_('View3D Move Modal'), 'EMPTY', 'WINDOW', []),
 +    ( N_('View3D Zoom Modal'), 'EMPTY', 'WINDOW', []),
      ]
  
  
@@@ -190,9 -189,9 +191,9 @@@ class InputKeyMapPanel
          if km.is_modal:
              row.label(text="", icon='LINKED')
          if km.is_user_defined:
-             op = row.operator("wm.keymap_restore", text=_("Restore"))
 -            row.operator("wm.keymap_restore", text="Restore")
++            row.operator("wm.keymap_restore", text=_("Restore"))
          else:
-             op = row.operator("wm.keymap_edit", text=_("Edit"))
 -            row.operator("wm.keymap_edit", text="Edit")
++            row.operator("wm.keymap_edit", text=_("Edit"))
  
          if km.show_expanded_children:
              if children:
                  col = self.indented_layout(col, level + 1)
                  subcol = col.split(percentage=0.2).column()
                  subcol.enabled = km.is_user_defined
-                 op = subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
 -                subcol.operator("wm.keyitem_add", text="Add New", icon='ZOOMIN')
++                subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
  
              col.separator()
  
                  row.label()
  
                  if km.is_user_defined:
-                     op = row.operator("wm.keymap_restore", text=_("Restore"))
 -                    row.operator("wm.keymap_restore", text="Restore")
++                    row.operator("wm.keymap_restore", text=_("Restore"))
                  else:
-                     op = row.operator("wm.keymap_edit", text=_("Edit"))
 -                    row.operator("wm.keymap_edit", text="Edit")
++                    row.operator("wm.keymap_edit", text=_("Edit"))
  
                  for kmi in filtered_items:
                      self.draw_kmi(display_keymaps, kc, km, kmi, col, 1)
                  col = self.indented_layout(layout, 1)
                  subcol = col.split(percentage=0.2).column()
                  subcol.enabled = km.is_user_defined
-                 op = subcol.operator("wm.keyitem_add", text=_("Add New"), icon='ZOOMIN')
 -                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:
@@@ -727,13 -720,10 +728,11 @@@ class WM_OT_keyitem_restore(bpy.types.O
  class WM_OT_keyitem_add(bpy.types.Operator):
      "Add key map item"
      bl_idname = "wm.keyitem_add"
 -    bl_label = "Add Key Map Item"
 +    bl_label = _("Add Key Map Item")
 +    __doc__ = _("Add key map item")
  
      def execute(self, context):
-         wm = context.window_manager
          km = context.keymap
-         kc = wm.keyconfigs.default
  
          if km.is_modal:
              km.keymap_items.new_modal("", 'A', 'PRESS')  # kmi
index 209ef13a3120347ef89eaf3b3cc9fbd308661fc6,aef6accb4e1bff3011260bf21313f4ce3ebe0786..9ead8bb98df8f47bf4fe6e5ef577c169c606aaf6
@@@ -775,10 -774,16 +775,16 @@@ class VIEW3D_MT_object_specials(bpy.typ
          if obj.type == 'CAMERA':
              layout.operator_context = 'INVOKE_REGION_WIN'
  
-             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
+             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");
@@@ -1101,20 -1106,21 +1107,21 @@@ class VIEW3D_MT_sculpt(bpy.types.Menu)
          layout.operator_menu_enum("brush.curve_preset", "shape")
          layout.separator()
  
-         sculpt_tool = brush.sculpt_tool
+         if brush is not None:  # unlikely but can happen
+             sculpt_tool = brush.sculpt_tool
  
-         if sculpt_tool != 'GRAB':
-             layout.prop_menu_enum(brush, "stroke_method")
+             if sculpt_tool != 'GRAB':
+                 layout.prop_menu_enum(brush, "stroke_method")
  
-             if sculpt_tool in {'DRAW', 'PINCH', 'INFLATE', 'LAYER', 'CLAY'}:
-                 layout.prop_menu_enum(brush, "direction")
+                 if sculpt_tool in {'DRAW', 'PINCH', 'INFLATE', 'LAYER', 'CLAY'}:
+                     layout.prop_menu_enum(brush, "direction")
  
-             if sculpt_tool == 'LAYER':
-                 layout.prop(brush, "use_persistent")
-                 layout.operator("sculpt.set_persistent_base")
+                 if sculpt_tool == 'LAYER':
+                     layout.prop(brush, "use_persistent")
+                     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!
@@@ -1246,7 -1252,7 +1253,7 @@@ class VIEW3D_MT_pose(bpy.types.Menu)
          layout.separator()
  
          layout.menu("VIEW3D_MT_pose_showhide")
-         layout.operator_menu_enum("pose.flags_set", 'mode', text=_("Bone Settings"))
 -        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(bpy.types.Menu):
@@@ -1960,7 -2009,7 +2010,7 @@@ class VIEW3D_MT_edit_armature(bpy.types
  
          layout.separator()
  
-         layout.operator_menu_enum("armature.flags_set", "mode", text=_("Bone Settings"))
 -        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(bpy.types.Menu):
index b02f7dd75c1032cfd1064a855152f5fb5f938795,e1efeed87ea5fc7ed386dffda15443a4d040f8f2..f2370ec39ac2cae0f5ac09a3986f890d623385ef
@@@ -61,10 -60,9 +61,9 @@@ def draw_gpencil_tools(context, layout)
  
  # ********** default tools for objectmode ****************
  
  class VIEW3D_PT_tools_objectmode(View3DPanel, bpy.types.Panel):
      bl_context = "objectmode"
 -    bl_label = "Object Tools"
 +    bl_label = _("Object Tools")
  
      def draw(self, context):
          layout = self.layout
@@@ -1003,9 -1003,13 +1004,13 @@@ class VIEW3D_PT_tools_brush_appearance(
      def draw(self, context):
          layout = self.layout
  
-         settings = __class__.paint_settings(context)
+         settings = self.paint_settings(context)
          brush = settings.brush
  
 -            layout.label(text="Brush Unset")
+         if brush is None:  # unlikely but can happen
++            layout.label(text=_("Brush Unset"))
+             return
          col = layout.column()
  
          if context.sculpt_object and context.tool_settings.sculpt:
index 0000000000000000000000000000000000000000,1735848e774c5bcfeadec66875f4368840daf979..fc5c5a80131a158c18861eb18861ffceb1d4cefa
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,72 +1,72 @@@
 - * $Id$
+ /*
++ * $Id: BLI_callbacks.h 37799 2011-06-24 23:14:26Z gsrb3d $
+  *
+  * ***** 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) 2001-2002 by NaN Holding BV.
+  * All rights reserved.
+  *
+  * The Original Code is: all of this file.
+  *
+  * Contributor(s): mar 2001 Nzc
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file blender/blenlib/BLI_callbacks.h
+  *  \ingroup bli
+  */
+ #ifndef BLI_CALLBACKS_H
+ #define BLI_CALLBACKS_H
+ struct bContext;
+ struct Main;
+ struct ID;
+ typedef enum {
+       BLI_CB_EVT_RENDER_PRE,
+       BLI_CB_EVT_RENDER_POST,
+       BLI_CB_EVT_LOAD_PRE,
+       BLI_CB_EVT_LOAD_POST,
+       BLI_CB_EVT_SAVE_PRE,
+       BLI_CB_EVT_SAVE_POST,
+       BLI_CB_EVT_TOT
+ } eCbEvent;
+ typedef struct {
+       struct bCallbackFuncStore *next, *prev;
+       void (* func)(struct Main *, struct ID *, void *arg);
+       void *arg;
+       short alloc;
+ } bCallbackFuncStore;
+ void BLI_exec_cb(struct Main *main, struct ID *self, eCbEvent evt);
+ void BLI_add_cb(bCallbackFuncStore *funcstore, eCbEvent evt);
+ #endif
+ void BLI_cb_init(void);
+ void BLI_cb_finalize(void);
+ /* This is blenlib internal only, unrelated to above */
+ void callLocalErrorCallBack(const char* msg);
index 0000000000000000000000000000000000000000,a033e01696d16b1cabf650bea6abca7e789389ba..2599c21812324a5493404b28445a1da51c1b97ce
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,70 +1,70 @@@
 - * $Id$
+ /*
++ * $Id: callbacks.c 37799 2011-06-24 23:14:26Z gsrb3d $
+  *
+  * ***** 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.
+  *
+  * Contributor(s): Blender Foundation (2011)
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ #include "BLI_utildefines.h"
+ #include "BLI_listbase.h"
+ #include "BLI_callbacks.h"
+ #include "MEM_guardedalloc.h"
+ static ListBase callback_slots[BLI_CB_EVT_TOT]= {{0}};
+ void BLI_exec_cb(struct Main *main, struct ID *self, eCbEvent evt)
+ {
+       ListBase *lb= &callback_slots[evt];
+       bCallbackFuncStore *funcstore;
+       for(funcstore= (bCallbackFuncStore *)lb->first; funcstore; funcstore= (bCallbackFuncStore *)funcstore->next) {
+               funcstore->func(main, self, funcstore->arg);
+       }
+ }
+ void BLI_add_cb(bCallbackFuncStore *funcstore, eCbEvent evt)
+ {
+       ListBase *lb= &callback_slots[evt];
+       BLI_addtail(lb, funcstore);
+ }
+ void BLI_cb_init(void)
+ {
+       /* do nothing */
+ }
+ /* call on application exit */
+ void BLI_cb_finalize(void)
+ {
+       eCbEvent evt;
+       for(evt= 0; evt < BLI_CB_EVT_TOT; evt++) {
+               ListBase *lb= &callback_slots[evt];
+               bCallbackFuncStore *funcstore;
+               bCallbackFuncStore *funcstore_next;
+               for(funcstore= (bCallbackFuncStore *)lb->first; funcstore; funcstore= funcstore_next) {
+                       funcstore_next= (bCallbackFuncStore *)funcstore->next;
+                       BLI_remlink(lb, funcstore);
+                       if(funcstore->alloc) {
+                               MEM_freeN(funcstore);
+                       }
+               }
+       }
+ }
index feac4301c4a485824f9e1220ba262bd729c2dd20,17e3a868a8cc89da62b7e9d5a7a14551ec01b54f..fc85dcf5fa85b3cf04e58c83a89fa1a51d2646d8
@@@ -31,48 -31,57 +32,58 @@@ set(INC_SY
  set(SRC
        Bfont.c
        bfont.ttf.c
-       bmonofont.ttf.c
 +      bunifont.ttf.c
-       startup.blend.c
-       preview.blend.c
  )
  
- if(NOT WITH_HEADLESS)
+ if(WITH_BLENDER)
+       # blender only
        list(APPEND SRC
-               splash.png.c
-               blenderbuttons.c
-               # brushes
-               add.png.c
-               blob.png.c
-               blur.png.c
-               clay.png.c
-               clone.png.c
-               crease.png.c
-               darken.png.c
-               draw.png.c
-               fill.png.c
-               flatten.png.c
-               grab.png.c
-               inflate.png.c
-               layer.png.c
-               lighten.png.c
-               mix.png.c
-               multiply.png.c
-               nudge.png.c
-               pinch.png.c
-               prvicons.c
-               scrape.png.c
-               smear.png.c
-               smooth.png.c
-               snake_hook.png.c
-               soften.png.c
-               subtract.png.c
-               texdraw.png.c
-               thumb.png.c
-               twist.png.c
-               vertexdraw.png.c
+               startup.blend.c
+               bmonofont.ttf.c
        )
+       if(NOT WITH_HEADLESS)
+               # blender UI only
+               list(APPEND SRC
+                       # blends
+                       preview.blend.c
+                       # images
+                       splash.png.c
+                       blenderbuttons.c
+                       # brushes
+                       add.png.c
+                       blob.png.c
+                       blur.png.c
+                       clay.png.c
+                       clone.png.c
+                       crease.png.c
+                       darken.png.c
+                       draw.png.c
+                       fill.png.c
+                       flatten.png.c
+                       grab.png.c
+                       inflate.png.c
+                       layer.png.c
+                       lighten.png.c
+                       mix.png.c
+                       multiply.png.c
+                       nudge.png.c
+                       pinch.png.c
+                       prvicons.c
+                       scrape.png.c
+                       smear.png.c
+                       smooth.png.c
+                       snake_hook.png.c
+                       soften.png.c
+                       subtract.png.c
+                       texdraw.png.c
+                       thumb.png.c
+                       twist.png.c
+                       vertexdraw.png.c
+               )
+       endif()
  endif()
  
  blender_add_lib(bf_editor_datafiles "${SRC}" "${INC}" "${INC_SYS}")
index 64280bbda03c1190c633fdf969a3e3d3a8c43200,5f2a757d2e36732392acdc5847753c8da83e2c13..efc26e11920f7a37b1b1d959c74b5323e127814d
@@@ -83,9 -83,9 +83,9 @@@ static uiStyle *ui_style_new(ListBase *
        BLI_addtail(styles, style);
        BLI_strncpy(style->name, name, MAX_STYLE_NAME);
        
-       style->panelzoom= 1.0;
+       style->panelzoom= 1.0; /* unused */
  
 -      style->paneltitle.uifont_id= UIFONT_DEFAULT;
 +      style->paneltitle.uifont_id= fontid;
        style->paneltitle.points= 12;
        style->paneltitle.kerning= 1;
        style->paneltitle.shadow= 1;
index dda2f55dee45ffd98532b1123e733f205bed87da,29a740affc534051240f5303cda2208fd106211c..bf8ebcea7548cc6e0bee508abe61b3435a97ac83
@@@ -1690,8 -1688,8 +1690,8 @@@ static int shade_poll(bContext *C
  void OBJECT_OT_shade_flat(wmOperatorType *ot)
  {
        /* identifiers */
 -      ot->name= "Shade Flat";
 -      ot->description= "Display faces 'flat'";
 +      ot->name= _("Shade Flat");
-       ot->description= _("Display faces 'smooth' (using vertext normals)");
++      ot->description= _("Display faces 'flat'");
        ot->idname= "OBJECT_OT_shade_flat";
        
        /* api callbacks */
  void OBJECT_OT_shade_smooth(wmOperatorType *ot)
  {
        /* identifiers */
 -      ot->name= "Shade Smooth";
 -      ot->description= "Display faces 'smooth' (using vertex normals)";
 +      ot->name= _("Shade Smooth");
-       ot->description= _("Display faces 'flat'");
++      ot->description= _("Display faces 'smooth' (using vertex normals)");
        ot->idname= "OBJECT_OT_shade_smooth";
        
        /* api callbacks */
index 23221885fa094b8ac7d08e09c51a3fc2d5315cc6,f21241b6e7afd0ecd84ac72c14d241c49187a816..aaff55be8cfe922c9c92aadb792c627d59970f96
@@@ -1319,8 -1318,8 +1320,8 @@@ void OBJECT_OT_make_links_scene(wmOpera
        PropertyRNA *prop;
  
        /* identifiers */
 -      ot->name= "Link Objects to Scene";
 -      ot->description = "Link selection to another scene";
 +      ot->name= _("Link Objects to Scene");
-       ot->description = _("Make linked data local to each object");
++      ot->description = _("Link selection to another scene");
        ot->idname= "OBJECT_OT_make_links_scene";
  
        /* api callbacks */
Simple merge
index fd236c683a1b08ecfc00cdb38ae425f91421f38f,4d181a3489489e75d3795e7609882755adffc037..08e506253f869983f288691b8e107b10343c4771
@@@ -107,11 -106,10 +108,10 @@@ void ED_operatormacros_node(void
        WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
        WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
  
 -      ot= WM_operatortype_append_macro("NODE_OT_select_link_viewer", "Link Viewer", OPTYPE_UNDO);
 +      ot= WM_operatortype_append_macro("NODE_OT_select_link_viewer", _("Link Viewer"), OPTYPE_UNDO);
        WM_operatortype_macro_define(ot, "NODE_OT_select");
        WM_operatortype_macro_define(ot, "NODE_OT_link_viewer");
-       
- }
+       }
  
  void node_keymap(struct wmKeyConfig *keyconf)
  {
index d70e9af1a0be6d96003d6462b5457e5ddfdfd56f,93dc96cf9c04601353245daf307ba82fed4963a4..b0cd5ae799369477f4e8f135239ee5e126326fd2
@@@ -479,11 -477,15 +479,15 @@@ static void outliner_add_passes(SpaceOo
        te->directdata= &srl->passflag;
        
        te= outliner_add_element(soops, &tenla->subtree, id, tenla, TSE_R_PASS, LOG2I(SCE_PASS_INDEXOB));
 -      te->name= "Index Object";
 +      te->name= _("Index Object");
        te->directdata= &srl->passflag;
        
 -      te->name= "Index Material";
+       te= outliner_add_element(soops, &tenla->subtree, id, tenla, TSE_R_PASS, LOG2I(SCE_PASS_INDEXMA));
++      te->name= _("Index Material");
+       te->directdata= &srl->passflag;
        te= outliner_add_element(soops, &tenla->subtree, id, tenla, TSE_R_PASS, LOG2I(SCE_PASS_RGBA));
 -      te->name= "Color";
 +      te->name= _("Color");
        te->directdata= &srl->passflag;
        
        te= outliner_add_element(soops, &tenla->subtree, id, tenla, TSE_R_PASS, LOG2I(SCE_PASS_DIFFUSE));
index a885c6700bba76007b43c66d8385fde91d574541,d9fbdd7caf2f2dd24155a4d4b62536b01394a13f..efa7306124a92b66ac5f9694b7e169e0c988cfd4
@@@ -98,84 -96,6 +98,85 @@@ void RNA_exit(void
        RNA_free(&BLENDER_RNA);
  }
  
 +void RNA_struct_gettexted( StructRNA* ptr )
 +{
 +      PropertyRNA *temp_property, *end_property;
 +
 +      ptr->name = _(ptr->name);
 +      ptr->description = _(ptr->description);
 +
 +      temp_property = (PropertyRNA*)ptr->cont.properties.first;
 +      end_property = (PropertyRNA*)ptr->cont.properties.last;
 +      while( temp_property!=end_property )
 +      {
 +              temp_property->name = _(temp_property->name);
 +              temp_property->description = _(temp_property->description);
 +              if( temp_property->type == PROP_ENUM )
 +                      RNA_enum_items_gettexted( ((EnumPropertyRNA*)temp_property)->item );
 +              temp_property = temp_property->next;
 +      }
 +      if( end_property!=NULL )
 +      {
 +              end_property->name = _(end_property->name);
 +              end_property->description = _(end_property->description);
 +              if( end_property->type == PROP_ENUM )
 +                      RNA_enum_items_gettexted( ((EnumPropertyRNA*)end_property)->item );
 +      }
 +}
 +
 +void RNA_types_init_gettext(void)
 +{
 +      StructRNA* target_struct[] = {
 +                      &RNA_Action, &RNA_ActionFCurves, &RNA_ActionGroup, &RNA_ActionGroups, &RNA_ActionPoseMarkers,
 +                      &RNA_BackgroundImage,
 +                      &RNA_ConsoleLine,
 +                      &RNA_DopeSheet,
 +                      &RNA_Event,
 +                      &RNA_FileSelectParams,
 +                      &RNA_ID,
 +                      &RNA_KeyMap, &RNA_KeyMapItem, &RNA_KeyMapItems, 
 +                      &RNA_KeyboardSensor,
 +                      &RNA_KeyingSetsAll,
 +                      &RNA_Object,
 +                      &RNA_RenderLayer, &RNA_RenderSettings,
 +                      &RNA_Macro,
++                      &RNA_Material,
 +                      &RNA_Scene,
 +                      &RNA_Scopes,
 +
 +                      &RNA_Space,
 +                      &RNA_SpaceConsole,
 +                      &RNA_SpaceDopeSheetEditor,
 +                      &RNA_SpaceFileBrowser,
 +                      &RNA_SpaceGraphEditor,
 +                      &RNA_SpaceImageEditor,
 +                      &RNA_SpaceInfo,
 +                      &RNA_SpaceLogicEditor,
 +                      &RNA_SpaceNLA,
 +                      &RNA_SpaceNodeEditor,
 +                      &RNA_SpaceOutliner,
 +                      &RNA_SpaceProperties,
 +                      &RNA_SpaceSequenceEditor,
 +                      &RNA_SpaceTextEditor,
 +                      &RNA_SpaceTimeline,
 +                      &RNA_SpaceView3D,
 +                      &RNA_SpaceUVEditor,
 +                      &RNA_SpaceUserPreferences,
 +
 +                      &RNA_Theme, &RNA_ThemeBoneColorSet, &RNA_ThemeWidgetColors,
 +                      &RNA_ToolSettings,                      
 +                      &RNA_UserPreferences, &RNA_UserPreferencesEdit, &RNA_UserPreferencesFilePaths,
 +                      &RNA_UserPreferencesInput, &RNA_UserPreferencesSystem, &RNA_UserPreferencesView,
 +                      /* for test */
 +                      NULL
 +      };
 +      int i=0;
 +      for( i=0; target_struct[i]!=NULL; i++ )
 +      {
 +              RNA_struct_gettexted( target_struct[i] );
 +      }
 +}
 +
  /* Pointer */
  
  void RNA_main_pointer_create(struct Main *main, PointerRNA *r_ptr)
index b86a91967a6715752a4b57bb24f0cfdeb998939b,f407aba82fbc921dc9425f9cb302398eebba91dc..3303ad0dde8e8324b667b0d607b7d61aa6c307f2
  #include "WM_api.h"
  #include "WM_types.h"
  
++#include "BLF_api.h"
++
  static EnumPropertyItem prop_texture_coordinates_items[] = {
--{TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates"},
--{TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates"},
--{TEXCO_UV, "UV", 0, "UV", "Uses UV coordinates for texture coordinates"},
--{TEXCO_ORCO, "ORCO", 0, "Generated", "Uses the original undeformed coordinates of the object"},
--{TEXCO_STRAND, "STRAND", 0, "Strand / Particle", "Uses normalized strand texture coordinate (1D) or particle age (X) and trail position (Y)"},
--{TEXCO_STICKY, "STICKY", 0, "Sticky", "Uses mesh's sticky coordinates for the texture coordinates"},
--{TEXCO_WINDOW, "WINDOW", 0, "Window", "Uses screen coordinates as texture coordinates"},
--{TEXCO_NORM, "NORMAL", 0, "Normal", "Uses normal vector as texture coordinates"},
--{TEXCO_REFL, "REFLECTION", 0, "Reflection", "Uses reflection vector as texture coordinates"},
--{TEXCO_STRESS, "STRESS", 0, "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh"},
--{TEXCO_TANGENT, "TANGENT", 0, "Tangent", "Uses the optional tangent vector as texture coordinates"},
++{TEXCO_GLOB, "GLOBAL", 0, N_("Global"), N_("Uses global coordinates for the texture coordinates")},
++{TEXCO_OBJECT, "OBJECT", 0, N_("Object"), N_("Uses linked object's coordinates for texture coordinates")},
++{TEXCO_UV, "UV", 0, "UV", N_("Uses UV coordinates for texture coordinates")},
++{TEXCO_ORCO, "ORCO", 0, N_("Generated"), N_("Uses the original undeformed coordinates of the object")},
++{TEXCO_STRAND, "STRAND", 0, N_("Strand / Particle"), N_("Uses normalized strand texture coordinate (1D) or particle age (X) and trail position (Y)")},
++{TEXCO_STICKY, "STICKY", 0, N_("Sticky"), N_("Uses mesh's sticky coordinates for the texture coordinates")},
++{TEXCO_WINDOW, "WINDOW", 0, N_("Window"), N_("Uses screen coordinates as texture coordinates")},
++{TEXCO_NORM, "NORMAL", 0, N_("Normal"), N_("Uses normal vector as texture coordinates")},
++{TEXCO_REFL, "REFLECTION", 0, N_("Reflection"), N_("Uses reflection vector as texture coordinates")},
++{TEXCO_STRESS, "STRESS", 0, N_("Stress"), N_("Uses the difference of edge lengths compared to original coordinates of the mesh")},
++{TEXCO_TANGENT, "TANGENT", 0, N_("Tangent"), N_("Uses the optional tangent vector as texture coordinates")},
  {0, NULL, 0, NULL, NULL}};
  
  EnumPropertyItem ramp_blend_items[] = {
--{MA_RAMP_BLEND, "MIX", 0, "Mix", ""},
--{MA_RAMP_ADD, "ADD", 0, "Add", ""},
--{MA_RAMP_MULT, "MULTIPLY", 0, "Multiply", ""},
--{MA_RAMP_SUB, "SUBTRACT", 0, "Subtract", ""},
--{MA_RAMP_SCREEN, "SCREEN", 0, "Screen", ""},
--{MA_RAMP_DIV, "DIVIDE", 0, "Divide", ""},
--{MA_RAMP_DIFF, "DIFFERENCE", 0, "Difference", ""},
--{MA_RAMP_DARK, "DARKEN", 0, "Darken", ""},
--{MA_RAMP_LIGHT, "LIGHTEN", 0, "Lighten", ""},
--{MA_RAMP_OVERLAY, "OVERLAY", 0, "Overlay", ""},
--{MA_RAMP_DODGE, "DODGE", 0, "Dodge", ""},
--{MA_RAMP_BURN, "BURN", 0, "Burn", ""},
--{MA_RAMP_HUE, "HUE", 0, "Hue", ""},
--{MA_RAMP_SAT, "SATURATION", 0, "Saturation", ""},
--{MA_RAMP_VAL, "VALUE", 0, "Value", ""},
--{MA_RAMP_COLOR, "COLOR", 0, "Color", ""},
--{MA_RAMP_SOFT, "SOFT_LIGHT", 0, "Soft Light", ""}, 
--{MA_RAMP_LINEAR, "LINEAR_LIGHT", 0, "Linear Light", ""}, 
++{MA_RAMP_BLEND, "MIX", 0, N_("Mix"), ""},
++{MA_RAMP_ADD, "ADD", 0, N_("Add"), ""},
++{MA_RAMP_MULT, "MULTIPLY", 0, N_("Multiply"), ""},
++{MA_RAMP_SUB, "SUBTRACT", 0, N_("Subtract"), ""},
++{MA_RAMP_SCREEN, "SCREEN", 0, N_("Screen"), ""},
++{MA_RAMP_DIV, "DIVIDE", 0, N_("Divide"), ""},
++{MA_RAMP_DIFF, "DIFFERENCE", 0, N_("Difference"), ""},
++{MA_RAMP_DARK, "DARKEN", 0, N_("Darken"), ""},
++{MA_RAMP_LIGHT, "LIGHTEN", 0, N_("Lighten"), ""},
++{MA_RAMP_OVERLAY, "OVERLAY", 0, N_("Overlay"), ""},
++{MA_RAMP_DODGE, "DODGE", 0, N_("Dodge"), ""},
++{MA_RAMP_BURN, "BURN", 0, N_("Burn"), ""},
++{MA_RAMP_HUE, "HUE", 0, N_("Hue"), ""},
++{MA_RAMP_SAT, "SATURATION", 0, N_("Saturation"), ""},
++{MA_RAMP_VAL, "VALUE", 0, N_("Value"), ""},
++{MA_RAMP_COLOR, "COLOR", 0, N_("Color"), ""},
++{MA_RAMP_SOFT, "SOFT_LIGHT", 0, N_("Soft Light"), ""}, 
++{MA_RAMP_LINEAR, "LINEAR_LIGHT", 0, N_("Linear Light"), ""}, 
  {0, NULL, 0, NULL, NULL}};
  
  #ifdef RNA_RUNTIME
@@@ -375,364 -375,364 +377,364 @@@ static void rna_def_material_mtex(Blend
        PropertyRNA *prop;
  
        static EnumPropertyItem prop_mapping_items[] = {
--              {MTEX_FLAT, "FLAT", 0, "Flat", "Maps X and Y coordinates directly"},
--              {MTEX_CUBE, "CUBE", 0, "Cube", "Maps using the normal vector"},
--              {MTEX_TUBE, "TUBE", 0, "Tube", "Maps with Z as central axis"},
--              {MTEX_SPHERE, "SPHERE", 0, "Sphere", "Maps with Z as central axis"},
++              {MTEX_FLAT, "FLAT", 0, N_("Flat"), N_("Maps X and Y coordinates directly")},
++              {MTEX_CUBE, "CUBE", 0, N_("Cube"), N_("Maps using the normal vector")},
++              {MTEX_TUBE, "TUBE", 0, N_("Tube"), N_("Maps with Z as central axis")},
++              {MTEX_SPHERE, "SPHERE", 0, N_("Sphere"), N_("Maps with Z as central axis")},
                {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_x_mapping_items[] = {
--              {0, "NONE", 0, "None", ""},
++              {0, "NONE", 0, N_("None"), ""},
                {1, "X", 0, "X", ""},
                {2, "Y", 0, "Y", ""},
                {3, "Z", 0, "Z", ""},
                {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_y_mapping_items[] = {
--              {0, "NONE", 0, "None", ""},
++              {0, "NONE", 0, N_("None"), ""},
                {1, "X", 0, "X", ""},
                {2, "Y", 0, "Y", ""},
                {3, "Z", 0, "Z", ""},
                {0, NULL, 0, NULL, NULL}};
                
        static EnumPropertyItem prop_z_mapping_items[] = {
--              {0, "NONE", 0, "None", ""},
++              {0, "NONE", 0, N_("None"), ""},
                {1, "X", 0, "X", ""},
                {2, "Y", 0, "Y", ""},
                {3, "Z", 0, "Z", ""},
                {0, NULL, 0, NULL, NULL}};
  
        static EnumPropertyItem prop_normal_map_space_items[] = {
--              {MTEX_NSPACE_CAMERA, "CAMERA", 0, "Camera", ""},
--              {MTEX_NSPACE_WORLD, "WORLD", 0, "World", ""},
--              {MTEX_NSPACE_OBJECT, "OBJECT", 0, "Object", ""},
--              {MTEX_NSPACE_TANGENT, "TANGENT", 0, "Tangent", ""},
++              {MTEX_NSPACE_CAMERA, "CAMERA", 0, N_("Camera"), ""},
++              {MTEX_NSPACE_WORLD, "WORLD", 0, N_("World"), ""},
++              {MTEX_NSPACE_OBJECT, "OBJECT", 0, N_("Object"), ""},
++              {MTEX_NSPACE_TANGENT, "TANGENT", 0, N_("Tangent"), ""},
                {0, NULL, 0, NULL, NULL}};
  
        static EnumPropertyItem prop_bump_method_items[] = {
--              {0, "BUMP_ORIGINAL", 0, "Original", ""},
--              {MTEX_COMPAT_BUMP, "BUMP_COMPATIBLE", 0, "Compatible", ""},
--              {MTEX_3TAP_BUMP, "BUMP_DEFAULT", 0, "Default", ""},
--              {MTEX_5TAP_BUMP, "BUMP_BEST_QUALITY", 0, "Best Quality", ""},
++              {0, "BUMP_ORIGINAL", 0, N_("Original"), ""},
++              {MTEX_COMPAT_BUMP, "BUMP_COMPATIBLE", 0, N_("Compatible"), ""},
++              {MTEX_3TAP_BUMP, "BUMP_DEFAULT", 0, N_("Default"), ""},
++              {MTEX_5TAP_BUMP, "BUMP_BEST_QUALITY", 0, N_("Best Quality"), ""},
                {0, NULL, 0, NULL, NULL}};
  
        static EnumPropertyItem prop_bump_space_items[] = {
--              {0, "BUMP_VIEWSPACE", 0, "ViewSpace", ""},
--              {MTEX_BUMP_OBJECTSPACE, "BUMP_OBJECTSPACE", 0, "ObjectSpace", ""},
--              {MTEX_BUMP_TEXTURESPACE, "BUMP_TEXTURESPACE", 0, "TextureSpace", ""},
++              {0, "BUMP_VIEWSPACE", 0, N_("ViewSpace"), ""},
++              {MTEX_BUMP_OBJECTSPACE, "BUMP_OBJECTSPACE", 0, N_("ObjectSpace"), ""},
++              {MTEX_BUMP_TEXTURESPACE, "BUMP_TEXTURESPACE", 0, N_("TextureSpace"), ""},
                {0, NULL, 0, NULL, NULL}};
        
        srna= RNA_def_struct(brna, "MaterialTextureSlot", "TextureSlot");
        RNA_def_struct_sdna(srna, "MTex");
--      RNA_def_struct_ui_text(srna, "Material Texture Slot", "Texture slot for textures in a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Texture Slot"), N_("Texture slot for textures in a Material datablock"));
  
        prop= RNA_def_property(srna, "texture_coords", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "texco");
        RNA_def_property_enum_items(prop, prop_texture_coordinates_items);
        RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Material_texture_coordinates_itemf");
--      RNA_def_property_ui_text(prop, "Texture Coordinates", "");
++      RNA_def_property_ui_text(prop, N_("Texture Coordinates"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "object");
        RNA_def_property_struct_type(prop, "Object");
        RNA_def_property_flag(prop, PROP_EDITABLE);
--      RNA_def_property_ui_text(prop, "Object", "Object to use for mapping with Object texture coordinates");
++      RNA_def_property_ui_text(prop, N_("Object"), N_("Object to use for mapping with Object texture coordinates"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "uvname");
--      RNA_def_property_ui_text(prop, "UV Layer", "UV layer to use for mapping with UV texture coordinates");
++      RNA_def_property_ui_text(prop, N_("UV Layer"), N_("UV layer to use for mapping with UV texture coordinates"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_from_dupli", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_DUPLI_MAPTO);
--      RNA_def_property_ui_text(prop, "From Dupli", "Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent");
++      RNA_def_property_ui_text(prop, N_("From Dupli"), N_("Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_from_original", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_OB_DUPLI_ORIG);
--      RNA_def_property_ui_text(prop, "From Original", "Dupli's derive their object coordinates from the original objects transformation");
++      RNA_def_property_ui_text(prop, N_("From Original"), N_("Dupli's derive their object coordinates from the original objects transformation"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_map_color_diffuse", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COL);
--      RNA_def_property_ui_text(prop, "Diffuse Color", "Causes the texture to affect basic color of the material");
++      RNA_def_property_ui_text(prop, N_("Diffuse Color"), N_("Causes the texture to affect basic color of the material"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_normal", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_NORM);
--      RNA_def_property_ui_text(prop, "Normal", "Causes the texture to affect the rendered normal");
++      RNA_def_property_ui_text(prop, N_("Normal"), N_("Causes the texture to affect the rendered normal"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_color_spec", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COLSPEC);
--      RNA_def_property_ui_text(prop, "Specular Color", "Causes the texture to affect the specularity color");
++      RNA_def_property_ui_text(prop, N_("Specular Color"), N_("Causes the texture to affect the specularity color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_mirror", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_COLMIR);
--      RNA_def_property_ui_text(prop, "Mirror", "Causes the texture to affect the mirror color");
++      RNA_def_property_ui_text(prop, N_("Mirror"), N_("Causes the texture to affect the mirror color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_diffuse", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_REF);
--      RNA_def_property_ui_text(prop, "Diffuse", "Causes the texture to affect the value of the materials diffuse reflectivity");
++      RNA_def_property_ui_text(prop, N_("Diffuse"), N_("Causes the texture to affect the value of the materials diffuse reflectivity"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_specular", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_SPEC);
--      RNA_def_property_ui_text(prop, "Specular", "Causes the texture to affect the value of specular reflectivity");
++      RNA_def_property_ui_text(prop, N_("Specular"), N_("Causes the texture to affect the value of specular reflectivity"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_ambient", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_AMB);
--      RNA_def_property_ui_text(prop, "Ambient", "Causes the texture to affect the value of ambient");
++      RNA_def_property_ui_text(prop, N_("Ambient"), N_("Causes the texture to affect the value of ambient"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_hardness", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_HAR);
--      RNA_def_property_ui_text(prop, "Hardness", "Causes the texture to affect the hardness value");
++      RNA_def_property_ui_text(prop, N_("Hardness"), N_("Causes the texture to affect the hardness value"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_raymir", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_RAYMIRR);
--      RNA_def_property_ui_text(prop, "Ray-Mirror", "Causes the texture to affect the ray-mirror value");
++      RNA_def_property_ui_text(prop, N_("Ray-Mirror"), N_("Causes the texture to affect the ray-mirror value"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_alpha", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_ALPHA);
--      RNA_def_property_ui_text(prop, "Alpha", "Causes the texture to affect the alpha value");
++      RNA_def_property_ui_text(prop, N_("Alpha"), N_("Causes the texture to affect the alpha value"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_emit", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_EMIT);
--      RNA_def_property_ui_text(prop, "Emit", "Causes the texture to affect the emit value");
++      RNA_def_property_ui_text(prop, N_("Emit"), N_("Causes the texture to affect the emit value"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_translucency", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_TRANSLU);
--      RNA_def_property_ui_text(prop, "Translucency", "Causes the texture to affect the translucency value");
++      RNA_def_property_ui_text(prop, N_("Translucency"), N_("Causes the texture to affect the translucency value"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_displacement", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_DISPLACE);
--      RNA_def_property_ui_text(prop, "Displacement", "Let the texture displace the surface");
++      RNA_def_property_ui_text(prop, N_("Displacement"), N_("Let the texture displace the surface"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_warp", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_WARP);
--      RNA_def_property_ui_text(prop, "Warp", "Let the texture warp texture coordinates of next channels");
++      RNA_def_property_ui_text(prop, N_("Warp"), N_("Let the texture warp texture coordinates of next channels"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "mapping_x", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "projx");
        RNA_def_property_enum_items(prop, prop_x_mapping_items);
--      RNA_def_property_ui_text(prop, "X Mapping", "");
++      RNA_def_property_ui_text(prop, N_("X Mapping"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "mapping_y", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "projy");
        RNA_def_property_enum_items(prop, prop_y_mapping_items);
--      RNA_def_property_ui_text(prop, "Y Mapping", "");
++      RNA_def_property_ui_text(prop, N_("Y Mapping"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "mapping_z", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "projz");
        RNA_def_property_enum_items(prop, prop_z_mapping_items);
--      RNA_def_property_ui_text(prop, "Z Mapping", "");
++      RNA_def_property_ui_text(prop, N_("Z Mapping"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_items(prop, prop_mapping_items);
--      RNA_def_property_ui_text(prop, "Mapping", "");
++      RNA_def_property_ui_text(prop, N_("Mapping"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "normal_map_space", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "normapspace");
        RNA_def_property_enum_items(prop, prop_normal_map_space_items);
--      RNA_def_property_ui_text(prop, "Normal Map Space", "Sets space of normal map image");
++      RNA_def_property_ui_text(prop, N_("Normal Map Space"), N_("Sets space of normal map image"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "normal_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "norfac");
        RNA_def_property_ui_range(prop, -5, 5, 10, 3);
--      RNA_def_property_ui_text(prop, "Normal Factor", "Amount texture affects normal values");
++      RNA_def_property_ui_text(prop, N_("Normal Factor"), N_("Amount texture affects normal values"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "displacement_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "dispfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Displacement Factor", "Amount texture displaces the surface");
++      RNA_def_property_ui_text(prop, N_("Displacement Factor"), N_("Amount texture displaces the surface"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "warp_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "warpfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Warp Factor", "Amount texture affects texture coordinates of next channels");
++      RNA_def_property_ui_text(prop, N_("Warp Factor"), N_("Amount texture affects texture coordinates of next channels"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_color_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "colspecfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Specular Color Factor", "Amount texture affects specular color");
++      RNA_def_property_ui_text(prop, N_("Specular Color Factor"), N_("Amount texture affects specular color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_color_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "colfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Diffuse Color Factor", "Amount texture affects diffuse color");
++      RNA_def_property_ui_text(prop, N_("Diffuse Color Factor"), N_("Amount texture affects diffuse color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "mirror_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "mirrfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Mirror Factor", "Amount texture affects mirror color");
++      RNA_def_property_ui_text(prop, N_("Mirror Factor"), N_("Amount texture affects mirror color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "alpha_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "alphafac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Alpha Factor", "Amount texture affects alpha");
++      RNA_def_property_ui_text(prop, N_("Alpha Factor"), N_("Amount texture affects alpha"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "difffac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Diffuse Factor", "Amount texture affects diffuse reflectivity");
++      RNA_def_property_ui_text(prop, N_("Diffuse Factor"), N_("Amount texture affects diffuse reflectivity"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "specfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Specular Factor", "Amount texture affects specular reflectivity");
++      RNA_def_property_ui_text(prop, N_("Specular Factor"), N_("Amount texture affects specular reflectivity"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "emit_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "emitfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Emit Factor", "Amount texture affects emission");
++      RNA_def_property_ui_text(prop, N_("Emit Factor"), N_("Amount texture affects emission"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "hardness_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "hardfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Hardness Factor", "Amount texture affects hardness");
++      RNA_def_property_ui_text(prop, N_("Hardness Factor"), N_("Amount texture affects hardness"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "raymir_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "raymirrfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Ray Mirror Factor", "Amount texture affects ray mirror");
++      RNA_def_property_ui_text(prop, N_("Ray Mirror Factor"), N_("Amount texture affects ray mirror"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "translucency_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "translfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Translucency Factor", "Amount texture affects translucency");
++      RNA_def_property_ui_text(prop, N_("Translucency Factor"), N_("Amount texture affects translucency"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "ambient_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ambfac");
        RNA_def_property_ui_range(prop, -1, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Ambient Factor", "Amount texture affects ambient");
++      RNA_def_property_ui_text(prop, N_("Ambient Factor"), N_("Amount texture affects ambient"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        /* volume material */
        prop= RNA_def_property(srna, "use_map_color_emission", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_EMISSION_COL);
--      RNA_def_property_ui_text(prop, "Emission Color", "Causes the texture to affect the color of emission");
++      RNA_def_property_ui_text(prop, N_("Emission Color"), N_("Causes the texture to affect the color of emission"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_color_reflection", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_REFLECTION_COL);
--      RNA_def_property_ui_text(prop, "Reflection Color", "Causes the texture to affect the color of scattered light");
++      RNA_def_property_ui_text(prop, N_("Reflection Color"), N_("Causes the texture to affect the color of scattered light"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_color_transmission", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_TRANSMISSION_COL);
--      RNA_def_property_ui_text(prop, "Transmission Color", "Causes the texture to affect the result color after other light has been scattered/absorbed");
++      RNA_def_property_ui_text(prop, N_("Transmission Color"), N_("Causes the texture to affect the result color after other light has been scattered/absorbed"));
        RNA_def_property_update(prop, NC_TEXTURE, NULL);
        
        prop= RNA_def_property(srna, "use_map_density", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_DENSITY);
--      RNA_def_property_ui_text(prop, "Density", "Causes the texture to affect the volume's density");
++      RNA_def_property_ui_text(prop, N_("Density"), N_("Causes the texture to affect the volume's density"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_emission", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_EMISSION);
--      RNA_def_property_ui_text(prop, "Emission", "Causes the texture to affect the volume's emission");
++      RNA_def_property_ui_text(prop, N_("Emission"), N_("Causes the texture to affect the volume's emission"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_scatter", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_SCATTERING);
--      RNA_def_property_ui_text(prop, "Scattering", "Causes the texture to affect the volume's scattering");
++      RNA_def_property_ui_text(prop, N_("Scattering"), N_("Causes the texture to affect the volume's scattering"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_map_reflect", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mapto", MAP_REFLECTION);
--      RNA_def_property_ui_text(prop, "Reflection", "Causes the texture to affect the reflected light's brightness");
++      RNA_def_property_ui_text(prop, N_("Reflection"), N_("Causes the texture to affect the reflected light's brightness"));
        RNA_def_property_update(prop, NC_TEXTURE, NULL);
        
        prop= RNA_def_property(srna, "emission_color_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "colemitfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Emission Color Factor", "Amount texture affects emission color");
++      RNA_def_property_ui_text(prop, N_("Emission Color Factor"), N_("Amount texture affects emission color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "reflection_color_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "colreflfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Reflection Color Factor", "Amount texture affects color of out-scattered light");
++      RNA_def_property_ui_text(prop, N_("Reflection Color Factor"), N_("Amount texture affects color of out-scattered light"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "transmission_color_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "coltransfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Transmission Color Factor", "Amount texture affects result color after light has been scattered/absorbed");
++      RNA_def_property_ui_text(prop, N_("Transmission Color Factor"), N_("Amount texture affects result color after light has been scattered/absorbed"));
        RNA_def_property_update(prop, NC_TEXTURE, NULL);
        
        prop= RNA_def_property(srna, "density_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "densfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Density Factor", "Amount texture affects density");
++      RNA_def_property_ui_text(prop, N_("Density Factor"), N_("Amount texture affects density"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "emission_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "emitfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Emission Factor", "Amount texture affects emission");
++      RNA_def_property_ui_text(prop, N_("Emission Factor"), N_("Amount texture affects emission"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "scattering_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "scatterfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Scattering Factor", "Amount texture affects scattering");
++      RNA_def_property_ui_text(prop, N_("Scattering Factor"), N_("Amount texture affects scattering"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
                                                                  
        prop= RNA_def_property(srna, "reflection_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "reflfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Reflection Factor", "Amount texture affects brightness of out-scattered light");
++      RNA_def_property_ui_text(prop, N_("Reflection Factor"), N_("Amount texture affects brightness of out-scattered light"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        /* end volume material */
        
        prop= RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_funcs(prop, "rna_MaterialTextureSlot_use_get", "rna_MaterialTextureSlot_use_set");
--      RNA_def_property_ui_text(prop, "Enabled", "Enable this material texture slot");
++      RNA_def_property_ui_text(prop, N_("Enabled"), N_("Enable this material texture slot"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "bump_method", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "texflag");
        RNA_def_property_enum_items(prop, prop_bump_method_items);
--      RNA_def_property_ui_text(prop, "Bump Method", "Method to use for bump mapping");
++      RNA_def_property_ui_text(prop, N_("Bump Method"), N_("Method to use for bump mapping"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "bump_objectspace", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "texflag");
        RNA_def_property_enum_items(prop, prop_bump_space_items);
--      RNA_def_property_ui_text(prop, "Bump Space", "Space to apply bump mapping in");
++      RNA_def_property_ui_text(prop, N_("Bump Space"), N_("Space to apply bump mapping in"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -741,100 -741,100 +743,100 @@@ static void rna_def_material_colors(Str
        PropertyRNA *prop;
  
        static EnumPropertyItem prop_ramp_input_items[] = {
--              {MA_RAMP_IN_SHADER, "SHADER", 0, "Shader", ""},
--              {MA_RAMP_IN_ENERGY, "ENERGY", 0, "Energy", ""},
--              {MA_RAMP_IN_NOR, "NORMAL", 0, "Normal", ""},
--              {MA_RAMP_IN_RESULT, "RESULT", 0, "Result", ""},
++              {MA_RAMP_IN_SHADER, "SHADER", 0, N_("Shader"), ""},
++              {MA_RAMP_IN_ENERGY, "ENERGY", 0, N_("Energy"), ""},
++              {MA_RAMP_IN_NOR, "NORMAL", 0, N_("Normal"), ""},
++              {MA_RAMP_IN_RESULT, "RESULT", 0, N_("Result"), ""},
                {0, NULL, 0, NULL, NULL}};
  
        prop= RNA_def_property(srna, "diffuse_color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "r");
        RNA_def_property_array(prop, 3);
--      RNA_def_property_ui_text(prop, "Diffuse Color", "Diffuse color of the material");
++      RNA_def_property_ui_text(prop, N_("Diffuse Color"), N_("Diffuse color of the material"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "specular_color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "specr");
        RNA_def_property_array(prop, 3);
--      RNA_def_property_ui_text(prop, "Specular Color", "Specular color of the material");
++      RNA_def_property_ui_text(prop, N_("Specular Color"), N_("Specular color of the material"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "mirror_color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "mirr");
        RNA_def_property_array(prop, 3);
--      RNA_def_property_ui_text(prop, "Mirror Color", "Mirror color of the material");
++      RNA_def_property_ui_text(prop, N_("Mirror Color"), N_("Mirror color of the material"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Alpha", "Alpha transparency of the material");
++      RNA_def_property_ui_text(prop, N_("Alpha"), N_("Alpha transparency of the material"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
  
        prop= RNA_def_property(srna, "specular_alpha", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "spectra");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Specular Alpha", "Alpha transparency for specular areas");
++      RNA_def_property_ui_text(prop, N_("Specular Alpha"), N_("Alpha transparency for specular areas"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        /* Color bands */
        prop= RNA_def_property(srna, "use_diffuse_ramp", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAMP_COL);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_Material_use_diffuse_ramp_set");
--      RNA_def_property_ui_text(prop, "Use Diffuse Ramp", "Toggle diffuse ramp operations");
++      RNA_def_property_ui_text(prop, N_("Use Diffuse Ramp"), N_("Toggle diffuse ramp operations"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_ramp", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "ramp_col");
        RNA_def_property_struct_type(prop, "ColorRamp");
--      RNA_def_property_ui_text(prop, "Diffuse Ramp", "Color ramp used to affect diffuse shading");
++      RNA_def_property_ui_text(prop, N_("Diffuse Ramp"), N_("Color ramp used to affect diffuse shading"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_specular_ramp", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAMP_SPEC);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_Material_use_specular_ramp_set");
--      RNA_def_property_ui_text(prop, "Use Specular Ramp", "Toggle specular ramp operations");
++      RNA_def_property_ui_text(prop, N_("Use Specular Ramp"), N_("Toggle specular ramp operations"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_ramp", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "ramp_spec");
        RNA_def_property_struct_type(prop, "ColorRamp");
--      RNA_def_property_ui_text(prop, "Specular Ramp", "Color ramp used to affect specular shading");
++      RNA_def_property_ui_text(prop, N_("Specular Ramp"), N_("Color ramp used to affect specular shading"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "diffuse_ramp_blend", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "rampblend_col");
        RNA_def_property_enum_items(prop, ramp_blend_items);
--      RNA_def_property_ui_text(prop, "Diffuse Ramp Blend", "Blending method of the ramp and the diffuse color");
++      RNA_def_property_ui_text(prop, N_("Diffuse Ramp Blend"), N_("Blending method of the ramp and the diffuse color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "specular_ramp_blend", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "rampblend_spec");
        RNA_def_property_enum_items(prop, ramp_blend_items);
--      RNA_def_property_ui_text(prop, "Diffuse Ramp Blend", "Blending method of the ramp and the specular color");
++      RNA_def_property_ui_text(prop, N_("Diffuse Ramp Blend"), N_("Blending method of the ramp and the specular color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_ramp_input", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "rampin_col");
        RNA_def_property_enum_items(prop, prop_ramp_input_items);
--      RNA_def_property_ui_text(prop, "Diffuse Ramp Input", "Determines how the ramp maps on the surface");
++      RNA_def_property_ui_text(prop, N_("Diffuse Ramp Input"), N_("Determines how the ramp maps on the surface"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "specular_ramp_input", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "rampin_spec");
        RNA_def_property_enum_items(prop, prop_ramp_input_items);
--      RNA_def_property_ui_text(prop, "Specular Ramp Input", "Determines how the ramp maps on the surface");
++      RNA_def_property_ui_text(prop, N_("Specular Ramp Input"), N_("Determines how the ramp maps on the surface"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_ramp_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "rampfac_col");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Diffuse Ramp Factor", "Blending factor (also uses alpha in Colorband)");
++      RNA_def_property_ui_text(prop, N_("Diffuse Ramp Factor"), N_("Blending factor (also uses alpha in Colorband)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_ramp_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "rampfac_spec");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Specular Ramp Factor", "Blending factor (also uses alpha in Colorband)");
++      RNA_def_property_ui_text(prop, N_("Specular Ramp Factor"), N_("Blending factor (also uses alpha in Colorband)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -843,57 -843,57 +845,57 @@@ static void rna_def_material_diffuse(St
        PropertyRNA *prop;
  
        static EnumPropertyItem prop_diff_shader_items[] = {
--              {MA_DIFF_LAMBERT, "LAMBERT", 0, "Lambert", "Use a Lambertian shader"},
--              {MA_DIFF_ORENNAYAR, "OREN_NAYAR", 0, "Oren-Nayar", "Use an Oren-Nayar shader"},
--              {MA_DIFF_TOON, "TOON", 0, "Toon", "Use a toon shader"},
--              {MA_DIFF_MINNAERT, "MINNAERT", 0, "Minnaert", "Use a Minnaert shader"},
--              {MA_DIFF_FRESNEL, "FRESNEL", 0, "Fresnel", "Use a Fresnel shader"},
++              {MA_DIFF_LAMBERT, "LAMBERT", 0, N_("Lambert"), N_("Use a Lambertian shader")},
++              {MA_DIFF_ORENNAYAR, "OREN_NAYAR", 0, N_("Oren-Nayar"), N_("Use an Oren-Nayar shader")},
++              {MA_DIFF_TOON, "TOON", 0, N_("Toon"), N_("Use a toon shader")},
++              {MA_DIFF_MINNAERT, "MINNAERT", 0, N_("Minnaert"), N_("Use a Minnaert shader")},
++              {MA_DIFF_FRESNEL, "FRESNEL", 0, N_("Fresnel"), N_("Use a Fresnel shader")},
                {0, NULL, 0, NULL, NULL}};
        
        prop= RNA_def_property(srna, "diffuse_shader", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "diff_shader");
        RNA_def_property_enum_items(prop, prop_diff_shader_items);
--      RNA_def_property_ui_text(prop, "Diffuse Shader Model", "");
++      RNA_def_property_ui_text(prop, N_("Diffuse Shader Model"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "diffuse_intensity", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "ref");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Diffuse Intensity", "Amount of diffuse reflection");
++      RNA_def_property_ui_text(prop, N_("Diffuse Intensity"), N_("Amount of diffuse reflection"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "roughness", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0.0f, 3.14f);
--      RNA_def_property_ui_text(prop, "Roughness", "Oren-Nayar Roughness");
++      RNA_def_property_ui_text(prop, N_("Roughness"), N_("Oren-Nayar Roughness"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_toon_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "param[0]");
        RNA_def_property_range(prop, 0.0f, 3.14f);
--      RNA_def_property_ui_text(prop, "Diffuse Toon Size", "Size of diffuse toon area");
++      RNA_def_property_ui_text(prop, N_("Diffuse Toon Size"), N_("Size of diffuse toon area"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_toon_smooth", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "param[1]");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Diffuse Toon Smooth", "Smoothness of diffuse toon area");
++      RNA_def_property_ui_text(prop, N_("Diffuse Toon Smooth"), N_("Smoothness of diffuse toon area"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_fresnel", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "param[1]");
        RNA_def_property_range(prop, 0.0f, 5.0f);
--      RNA_def_property_ui_text(prop, "Diffuse Fresnel", "Power of Fresnel");
++      RNA_def_property_ui_text(prop, N_("Diffuse Fresnel"), N_("Power of Fresnel"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "diffuse_fresnel_factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "param[0]");
        RNA_def_property_range(prop, 0.0f, 5.0f);
--      RNA_def_property_ui_text(prop, "Diffuse Fresnel Factor", "Blending factor of Fresnel");
++      RNA_def_property_ui_text(prop, N_("Diffuse Fresnel Factor"), N_("Blending factor of Fresnel"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "darkness", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0.0f, 2.0f);
--      RNA_def_property_ui_text(prop, "Darkness", "Minnaert darkness");
++      RNA_def_property_ui_text(prop, N_("Darkness"), N_("Minnaert darkness"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -903,78 -903,78 +905,78 @@@ static void rna_def_material_raymirror(
        PropertyRNA *prop;
  
        static EnumPropertyItem prop_fadeto_mir_items[] = {
--              {MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", 0, "Sky", ""},
--              {MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", 0, "Material", ""},
++              {MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", 0, N_("Sky"), ""},
++              {MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", 0, N_("Material"), ""},
                {0, NULL, 0, NULL, NULL}};
  
        srna= RNA_def_struct(brna, "MaterialRaytraceMirror", NULL);
        RNA_def_struct_sdna(srna, "Material");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Raytrace Mirror", "Raytraced reflection settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Raytrace Mirror"), N_("Raytraced reflection settings for a Material datablock"));
  
        prop= RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAYMIRROR); /* use bitflags */
--      RNA_def_property_ui_text(prop, "Enabled", "Enable raytraced reflections");
++      RNA_def_property_ui_text(prop, N_("Enabled"), N_("Enable raytraced reflections"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
                
        prop= RNA_def_property(srna, "reflect_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "ray_mirror");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Reflectivity", "Sets the amount mirror reflection for raytrace");
++      RNA_def_property_ui_text(prop, N_("Reflectivity"), N_("Sets the amount mirror reflection for raytrace"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "fresnel", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fresnel_mir");
        RNA_def_property_range(prop, 0.0f, 5.0f);
--      RNA_def_property_ui_text(prop, "Fresnel", "Power of Fresnel for mirror reflection");
++      RNA_def_property_ui_text(prop, N_("Fresnel"), N_("Power of Fresnel for mirror reflection"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "fresnel_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "fresnel_mir_i");
        RNA_def_property_range(prop, 0.0f, 5.0f);
--      RNA_def_property_ui_text(prop, "Fresnel Factor", "Blending factor for Fresnel");
++      RNA_def_property_ui_text(prop, N_("Fresnel Factor"), N_("Blending factor for Fresnel"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "gloss_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "gloss_mir");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Gloss Amount", "The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections");
++      RNA_def_property_ui_text(prop, N_("Gloss Amount"), N_("The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "gloss_anisotropic", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "aniso_gloss_mir");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Gloss Anisotropy", "The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent");
++      RNA_def_property_ui_text(prop, N_("Gloss Anisotropy"), N_("The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
                
        prop= RNA_def_property(srna, "gloss_samples", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "samp_gloss_mir");
        RNA_def_property_range(prop, 0, 1024);
--      RNA_def_property_ui_text(prop, "Gloss Samples", "Number of cone samples averaged for blurry reflections");
++      RNA_def_property_ui_text(prop, N_("Gloss Samples"), N_("Number of cone samples averaged for blurry reflections"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "gloss_threshold", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "adapt_thresh_mir");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Gloss Threshold", "Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped");
++      RNA_def_property_ui_text(prop, N_("Gloss Threshold"), N_("Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "ray_depth");
        RNA_def_property_ui_range(prop, 0, 100, 1, 3);
--      RNA_def_property_ui_text(prop, "Depth", "Maximum allowed number of light inter-reflections");
++      RNA_def_property_ui_text(prop, N_("Depth"), N_("Maximum allowed number of light inter-reflections"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "dist_mir");
        RNA_def_property_range(prop, 0.0f, 10000.0f);
--      RNA_def_property_ui_text(prop, "Maximum Distance", "Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color");
++      RNA_def_property_ui_text(prop, N_("Maximum Distance"), N_("Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "fade_to", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "fadeto_mir");
        RNA_def_property_enum_items(prop, prop_fadeto_mir_items);
--      RNA_def_property_ui_text(prop, "Fade-out Color", "The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor");
++      RNA_def_property_ui_text(prop, N_("Fade-out Color"), N_("The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -986,66 -986,66 +988,66 @@@ static void rna_def_material_raytra(Ble
        srna= RNA_def_struct(brna, "MaterialRaytraceTransparency", NULL);
        RNA_def_struct_sdna(srna, "Material");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Raytrace Transparency", "Raytraced refraction settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Raytrace Transparency"), N_("Raytraced refraction settings for a Material datablock"));
  
        prop= RNA_def_property(srna, "ior", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ang");
        RNA_def_property_range(prop, 0.25f, 4.0f);
--      RNA_def_property_ui_text(prop, "IOR", "Sets angular index of refraction for raytraced refraction");
++      RNA_def_property_ui_text(prop, "IOR", N_("Sets angular index of refraction for raytraced refraction"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "fresnel", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fresnel_tra");
        RNA_def_property_range(prop, 0.0f, 5.0f);
--      RNA_def_property_ui_text(prop, "Fresnel", "Power of Fresnel for transparency (Ray or ZTransp)");
++      RNA_def_property_ui_text(prop, N_("Fresnel"), N_("Power of Fresnel for transparency (Ray or ZTransp)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "fresnel_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "fresnel_tra_i");
        RNA_def_property_range(prop, 1.0f, 5.0f);
--      RNA_def_property_ui_text(prop, "Fresnel Factor", "Blending factor for Fresnel");
++      RNA_def_property_ui_text(prop, N_("Fresnel Factor"), N_("Blending factor for Fresnel"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "gloss_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "gloss_tra");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Gloss Amount", "The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions");
++      RNA_def_property_ui_text(prop, N_("Gloss Amount"), N_("The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "gloss_samples", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "samp_gloss_tra");
        RNA_def_property_range(prop, 0, 1024);
--      RNA_def_property_ui_text(prop, "Gloss Samples", "Number of cone samples averaged for blurry refractions");
++      RNA_def_property_ui_text(prop, N_("Gloss Samples"), N_("Number of cone samples averaged for blurry refractions"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "gloss_threshold", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "adapt_thresh_tra");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Gloss Threshold", "Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped");
++      RNA_def_property_ui_text(prop, N_("Gloss Threshold"), N_("Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "ray_depth_tra");
        RNA_def_property_ui_range(prop, 0, 100, 1, 3);
--      RNA_def_property_ui_text(prop, "Depth", "Maximum allowed number of light inter-refractions");
++      RNA_def_property_ui_text(prop, N_("Depth"), N_("Maximum allowed number of light inter-refractions"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "filter", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "filter");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Filter", "Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption)");
++      RNA_def_property_ui_text(prop, N_("Filter"), N_("Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "depth_max", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "tx_limit");
        RNA_def_property_range(prop, 0.0f, 100.0f);
--      RNA_def_property_ui_text(prop, "Limit", "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)");
++      RNA_def_property_ui_text(prop, N_("Limit"), N_("Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "tx_falloff");
        RNA_def_property_range(prop, 0.1f, 10.0f);
--      RNA_def_property_ui_text(prop, "Falloff", "Falloff power for transmissivity filter effect (1.0 is linear)");
++      RNA_def_property_ui_text(prop, N_("Falloff"), N_("Falloff power for transmissivity filter effect (1.0 is linear)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -1055,140 -1055,140 +1057,140 @@@ static void rna_def_material_volume(Ble
        PropertyRNA *prop;
  
        static EnumPropertyItem prop_lighting_items[] = {
--              {MA_VOL_SHADE_SHADELESS, "SHADELESS", 0, "Shadeless", "Do not calculate lighting and shadows"},
--              {MA_VOL_SHADE_SHADOWED, "SHADOWED", 0, "Shadowed", ""},
--              {MA_VOL_SHADE_SHADED, "SHADED", 0, "Shaded", ""},
--              {MA_VOL_SHADE_MULTIPLE, "MULTIPLE_SCATTERING", 0, "Multiple Scattering", ""},
--              {MA_VOL_SHADE_SHADEDPLUSMULTIPLE, "SHADED_PLUS_MULTIPLE_SCATTERING", 0, "Shaded + Multiple Scattering", ""},
++              {MA_VOL_SHADE_SHADELESS, "SHADELESS", 0, N_("Shadeless"), N_("Do not calculate lighting and shadows")},
++              {MA_VOL_SHADE_SHADOWED, "SHADOWED", 0, N_("Shadowed"), ""},
++              {MA_VOL_SHADE_SHADED, "SHADED", 0, N_("Shaded"), ""},
++              {MA_VOL_SHADE_MULTIPLE, "MULTIPLE_SCATTERING", 0, N_("Multiple Scattering"), ""},
++              {MA_VOL_SHADE_SHADEDPLUSMULTIPLE, "SHADED_PLUS_MULTIPLE_SCATTERING", 0, N_("Shaded + Multiple Scattering"), ""},
                {0, NULL, 0, NULL, NULL}};
  
        static EnumPropertyItem prop_stepsize_items[] = {
--              {MA_VOL_STEP_RANDOMIZED, "RANDOMIZED", 0, "Randomized", ""},
--              {MA_VOL_STEP_CONSTANT, "CONSTANT", 0, "Constant", ""},
++              {MA_VOL_STEP_RANDOMIZED, "RANDOMIZED", 0, N_("Randomized"), ""},
++              {MA_VOL_STEP_CONSTANT, "CONSTANT", 0, N_("Constant"), ""},
                //{MA_VOL_STEP_ADAPTIVE, "ADAPTIVE", 0, "Adaptive", ""},
                {0, NULL, 0, NULL, NULL}};
                
        srna= RNA_def_struct(brna, "MaterialVolume", NULL);
        RNA_def_struct_sdna(srna, "VolumeSettings");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Volume", "Volume rendering settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Volume"), N_("Volume rendering settings for a Material datablock"));
        
        prop= RNA_def_property(srna, "step_method", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "stepsize_type");
        RNA_def_property_enum_items(prop, prop_stepsize_items);
--      RNA_def_property_ui_text(prop, "Step Calculation", "Method of calculating the steps through the volume");
++      RNA_def_property_ui_text(prop, N_("Step Calculation"), N_("Method of calculating the steps through the volume"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "step_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "stepsize");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.001f, 1.0f, 1, 3);
--      RNA_def_property_ui_text(prop, "Step Size", "Distance between subsequent volume depth samples");
++      RNA_def_property_ui_text(prop, N_("Step Size"), N_("Distance between subsequent volume depth samples"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "light_method", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "shade_type");
        RNA_def_property_enum_items(prop, prop_lighting_items);
--      RNA_def_property_ui_text(prop, "Lighting Mode", "Method of shading, attenuating, and scattering light through the volume");
++      RNA_def_property_ui_text(prop, N_("Lighting Mode"), N_("Method of shading, attenuating, and scattering light through the volume"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_external_shadows", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shadeflag", MA_VOL_RECV_EXT_SHADOW); /* use bitflags */
--      RNA_def_property_ui_text(prop, "External Shadows", "Receive shadows from sources outside the volume (temporary)");
++      RNA_def_property_ui_text(prop, N_("External Shadows"), N_("Receive shadows from sources outside the volume (temporary)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_light_cache", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shadeflag", MA_VOL_PRECACHESHADING); /* use bitflags */
--      RNA_def_property_ui_text(prop, "Light Cache", "Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy");
++      RNA_def_property_ui_text(prop, N_("Light Cache"), N_("Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "cache_resolution", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "precache_resolution");
        RNA_def_property_range(prop, 1, 1024);
--      RNA_def_property_ui_text(prop, "Resolution", "Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory");
++      RNA_def_property_ui_text(prop, N_("Resolution"), N_("Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "ms_diffusion", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ms_diff");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
--      RNA_def_property_ui_text(prop, "Diffusion", "Diffusion factor, the strength of the blurring effect");
++      RNA_def_property_ui_text(prop, N_("Diffusion"), N_("Diffusion factor, the strength of the blurring effect"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "ms_spread", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ms_spread");
        RNA_def_property_range(prop, 0, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
--      RNA_def_property_ui_text(prop, "Spread", "Proportional distance over which the light is diffused");
++      RNA_def_property_ui_text(prop, N_("Spread"), N_("Proportional distance over which the light is diffused"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "ms_intensity", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "ms_intensity");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
--      RNA_def_property_ui_text(prop, "Intensity", "Multiplier for multiple scattered light energy");
++      RNA_def_property_ui_text(prop, N_("Intensity"), N_("Multiplier for multiple scattered light energy"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "depth_threshold", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "depth_cutoff");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Depth Cutoff", "Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy");
++      RNA_def_property_ui_text(prop, N_("Depth Cutoff"), N_("Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "density", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "density");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Density", "The base density of the volume");
++      RNA_def_property_ui_text(prop, N_("Density"), N_("The base density of the volume"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "density_scale", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "density_scale");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
--      RNA_def_property_ui_text(prop, "Density Scale", "Multiplier for the material's density");
++      RNA_def_property_ui_text(prop, N_("Density Scale"), N_("Multiplier for the material's density"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "scattering", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "scattering");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1 ,3);
--      RNA_def_property_ui_text(prop, "Scattering", "Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate ");
++      RNA_def_property_ui_text(prop, N_("Scattering"), N_("Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate "));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "transmission_color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "transmission_col");
        RNA_def_property_array(prop, 3);
--      RNA_def_property_ui_text(prop, "Transmission Color", "Result color of the volume, after other light has been scattered/absorbed");
++      RNA_def_property_ui_text(prop, N_("Transmission Color"), N_("Result color of the volume, after other light has been scattered/absorbed"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "reflection_color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "reflection_col");
        RNA_def_property_array(prop, 3);
--      RNA_def_property_ui_text(prop, "Reflection Color", "Color of light scattered out of the volume (does not affect transmission)");
++      RNA_def_property_ui_text(prop, N_("Reflection Color"), N_("Color of light scattered out of the volume (does not affect transmission)"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "reflection", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "reflection");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1 ,3);
--      RNA_def_property_ui_text(prop, "Reflection", "Multiplier to make out-scattered light brighter or darker (non-physically correct)");
++      RNA_def_property_ui_text(prop, N_("Reflection"), N_("Multiplier to make out-scattered light brighter or darker (non-physically correct)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "emission_color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "emission_col");
        RNA_def_property_array(prop, 3);
--      RNA_def_property_ui_text(prop, "Emission Color", "Color of emitted light");
++      RNA_def_property_ui_text(prop, N_("Emission Color"), N_("Color of emitted light"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "emission", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "emission");
        RNA_def_property_range(prop, 0.0f, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
--      RNA_def_property_ui_text(prop, "Emission", "Amount of light that gets emitted by the volume");
++      RNA_def_property_ui_text(prop, N_("Emission"), N_("Amount of light that gets emitted by the volume"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
                
        prop= RNA_def_property(srna, "asymmetry", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "asymmetry");
        RNA_def_property_range(prop, -1.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Asymmetry", "Back scattering (-1.0) to Forward scattering (1.0) and the range in between");
++      RNA_def_property_ui_text(prop, N_("Asymmetry"), N_("Back scattering (-1.0) to Forward scattering (1.0) and the range in between"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -1201,123 -1201,123 +1203,123 @@@ static void rna_def_material_halo(Blend
        srna= RNA_def_struct(brna, "MaterialHalo", NULL);
        RNA_def_struct_sdna(srna, "Material");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Halo", "Halo particle effect settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Halo"), N_("Halo particle effect settings for a Material datablock"));
  
        prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "hasize");
        RNA_def_property_range(prop, 0.0f, 100.0f);
--      RNA_def_property_ui_text(prop, "Size", "Sets the dimension of the halo");
++      RNA_def_property_ui_text(prop, N_("Size"), N_("Sets the dimension of the halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "hardness", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "har");
        RNA_def_property_range(prop, 0, 127);
--      RNA_def_property_ui_text(prop, "Hardness", "Sets the hardness of the halo");
++      RNA_def_property_ui_text(prop, N_("Hardness"), N_("Sets the hardness of the halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "add", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "add");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Add", "Sets the strength of the add effect");
++      RNA_def_property_ui_text(prop, N_("Add"), N_("Sets the strength of the add effect"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "ring_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "ringc");
        RNA_def_property_range(prop, 0, 24);
--      RNA_def_property_ui_text(prop, "Rings", "Sets the number of rings rendered over the halo");
++      RNA_def_property_ui_text(prop, N_("Rings"), N_("Sets the number of rings rendered over the halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "line_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "linec");
        RNA_def_property_range(prop, 0, 250);
--      RNA_def_property_ui_text(prop, "Line Number", "Sets the number of star shaped lines rendered over the halo");
++      RNA_def_property_ui_text(prop, N_("Line Number"), N_("Sets the number of star shaped lines rendered over the halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "star_tip_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "starc");
        RNA_def_property_range(prop, 3, 50);
--      RNA_def_property_ui_text(prop, "Star Tips", "Sets the number of points on the star shaped halo");
++      RNA_def_property_ui_text(prop, N_("Star Tips"), N_("Sets the number of points on the star shaped halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "seed", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "seed1");
        RNA_def_property_range(prop, 0, 255);
--      RNA_def_property_ui_text(prop, "Seed", "Randomizes ring dimension and line location");
++      RNA_def_property_ui_text(prop, N_("Seed"), N_("Randomizes ring dimension and line location"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_flare_mode", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_FLARE); /* use bitflags */
--      RNA_def_property_ui_text(prop, "Flare", "Renders halo as a lens flare");
++      RNA_def_property_ui_text(prop, N_("Flare"), N_("Renders halo as a lens flare"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "flare_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "flaresize");
        RNA_def_property_range(prop, 0.1f, 25.0f);
--      RNA_def_property_ui_text(prop, "Flare Size", "Sets the factor by which the flare is larger than the halo");
++      RNA_def_property_ui_text(prop, N_("Flare Size"), N_("Sets the factor by which the flare is larger than the halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "flare_subflare_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "subsize");
        RNA_def_property_range(prop, 0.1f, 25.0f);
--      RNA_def_property_ui_text(prop, "Flare Subsize", "Sets the dimension of the sub-flares, dots and circles");
++      RNA_def_property_ui_text(prop, N_("Flare Subsize"), N_("Sets the dimension of the sub-flares, dots and circles"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "flare_boost", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "flareboost");
        RNA_def_property_range(prop, 0.1f, 10.0f);
--      RNA_def_property_ui_text(prop, "Flare Boost", "Gives the flare extra strength");
++      RNA_def_property_ui_text(prop, N_("Flare Boost"), N_("Gives the flare extra strength"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "flare_seed", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "seed2");
        RNA_def_property_range(prop, 0, 255);
--      RNA_def_property_ui_text(prop, "Flare Seed", "Specifies an offset in the flare seed table");
++      RNA_def_property_ui_text(prop, N_("Flare Seed"), N_("Specifies an offset in the flare seed table"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "flare_subflare_count", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "flarec");
        RNA_def_property_range(prop, 1, 32);
--      RNA_def_property_ui_text(prop, "Flares Sub", "Sets the number of sub-flares");
++      RNA_def_property_ui_text(prop, N_("Flares Sub"), N_("Sets the number of sub-flares"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_ring", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_RINGS);
--      RNA_def_property_ui_text(prop, "Rings", "Renders rings over halo");
++      RNA_def_property_ui_text(prop, N_("Rings"), N_("Renders rings over halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_lines", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_LINES);
--      RNA_def_property_ui_text(prop, "Lines", "Renders star shaped lines over halo");
++      RNA_def_property_ui_text(prop, N_("Lines"), N_("Renders star shaped lines over halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_star", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STAR);
--      RNA_def_property_ui_text(prop, "Star", "Renders halo as a star");
++      RNA_def_property_ui_text(prop, N_("Star"), N_("Renders halo as a star"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_texture", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALOTEX);
--      RNA_def_property_ui_text(prop, "Texture", "Gives halo a texture");
++      RNA_def_property_ui_text(prop, N_("Texture"), N_("Gives halo a texture"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_vertex_normal", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALOPUNO);
--      RNA_def_property_ui_text(prop, "Vertex Normal", "Uses the vertex normal to specify the dimension of the halo");
++      RNA_def_property_ui_text(prop, N_("Vertex Normal"), N_("Uses the vertex normal to specify the dimension of the halo"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_extreme_alpha", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_XALPHA);
--      RNA_def_property_ui_text(prop, "Extreme Alpha", "Uses extreme alpha");
++      RNA_def_property_ui_text(prop, N_("Extreme Alpha"), N_("Uses extreme alpha"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_shaded", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_SHADE);
--      RNA_def_property_ui_text(prop, "Shaded", "Lets halo receive light and shadows from external objects");
++      RNA_def_property_ui_text(prop, N_("Shaded"), N_("Lets halo receive light and shadows from external objects"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_soft", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_SOFT);
--      RNA_def_property_ui_text(prop, "Soft", "Softens the edges of halos at intersections with other geometry");
++      RNA_def_property_ui_text(prop, N_("Soft"), N_("Softens the edges of halos at intersections with other geometry"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -1329,65 -1329,65 +1331,65 @@@ static void rna_def_material_sss(Blende
        srna= RNA_def_struct(brna, "MaterialSubsurfaceScattering", NULL);
        RNA_def_struct_sdna(srna, "Material");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Subsurface Scattering", "Diffuse subsurface scattering settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Subsurface Scattering"), N_("Diffuse subsurface scattering settings for a Material datablock"));
  
        prop= RNA_def_property(srna, "radius", PROP_FLOAT, PROP_COLOR|PROP_UNIT_LENGTH);
        RNA_def_property_float_sdna(prop, NULL, "sss_radius");
        RNA_def_property_range(prop, 0.001, FLT_MAX);
        RNA_def_property_ui_range(prop, 0.001, 10000, 1, 3);
--      RNA_def_property_ui_text(prop, "Radius", "Mean red/green/blue scattering path length");
++      RNA_def_property_ui_text(prop, N_("Radius"), N_("Mean red/green/blue scattering path length"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
        RNA_def_property_float_sdna(prop, NULL, "sss_col");
--      RNA_def_property_ui_text(prop, "Color", "Scattering color");
++      RNA_def_property_ui_text(prop, N_("Color"), N_("Scattering color"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "error_threshold", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sss_error");
        RNA_def_property_ui_range(prop, 0.0001, 10, 1, 3);
--      RNA_def_property_ui_text(prop, "Error Tolerance", "Error tolerance (low values are slower and higher quality)");
++      RNA_def_property_ui_text(prop, N_("Error Tolerance"), N_("Error tolerance (low values are slower and higher quality)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sss_scale");
        RNA_def_property_ui_range(prop, 0.001, 1000, 1, 3);
--      RNA_def_property_ui_text(prop, "Scale", "Object scale factor");
++      RNA_def_property_ui_text(prop, N_("Scale"), N_("Object scale factor"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "ior", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sss_ior");
        RNA_def_property_ui_range(prop, 0.1, 2, 1, 3);
--      RNA_def_property_ui_text(prop, "IOR", "Index of refraction (higher values are denser)");
++      RNA_def_property_ui_text(prop, "IOR", N_("Index of refraction (higher values are denser)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "color_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "sss_colfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Color Factor", "Blend factor for SSS colors");
++      RNA_def_property_ui_text(prop, N_("Color Factor"), N_("Blend factor for SSS colors"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "texture_factor", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "sss_texfac");
        RNA_def_property_ui_range(prop, 0, 1, 10, 3);
--      RNA_def_property_ui_text(prop, "Texture Factor", "Texture scatting blend factor");
++      RNA_def_property_ui_text(prop, N_("Texture Factor"), N_("Texture scatting blend factor"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "front", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sss_front");
        RNA_def_property_range(prop, 0, 2);
--      RNA_def_property_ui_text(prop, "Front", "Front scattering weight");
++      RNA_def_property_ui_text(prop, N_("Front"), N_("Front scattering weight"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sss_back");
        RNA_def_property_range(prop, 0, 10);
--      RNA_def_property_ui_text(prop, "Back", "Back scattering weight");
++      RNA_def_property_ui_text(prop, N_("Back"), N_("Back scattering weight"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "sss_flag", MA_DIFF_SSS);
--      RNA_def_property_ui_text(prop, "Enabled", "Enable diffuse subsurface scatting effects in a material");
++      RNA_def_property_ui_text(prop, N_("Enabled"), N_("Enable diffuse subsurface scatting effects in a material"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -1396,23 -1396,23 +1398,23 @@@ static void rna_def_material_specularit
        PropertyRNA *prop;
        
        static EnumPropertyItem prop_specular_shader_items[] = {
--              {MA_SPEC_COOKTORR, "COOKTORR", 0, "CookTorr", "Use a Cook-Torrance shader"},
--              {MA_SPEC_PHONG, "PHONG", 0, "Phong", "Use a Phong shader"},
--              {MA_SPEC_BLINN, "BLINN", 0, "Blinn", "Use a Blinn shader"},
--              {MA_SPEC_TOON, "TOON", 0, "Toon", "Use a toon shader"},
--              {MA_SPEC_WARDISO, "WARDISO", 0, "WardIso", "Use a Ward anisotropic shader"},
++              {MA_SPEC_COOKTORR, "COOKTORR", 0, N_("CookTorr"), N_("Use a Cook-Torrance shader")},
++              {MA_SPEC_PHONG, "PHONG", 0, N_("Phong"), N_("Use a Phong shader")},
++              {MA_SPEC_BLINN, "BLINN", 0, N_("Blinn"), N_("Use a Blinn shader")},
++              {MA_SPEC_TOON, "TOON", 0, N_("Toon"), N_("Use a toon shader")},
++              {MA_SPEC_WARDISO, "WARDISO", 0, N_("WardIso"), N_("Use a Ward anisotropic shader")},
                {0, NULL, 0, NULL, NULL}};
        
        prop= RNA_def_property(srna, "specular_shader", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "spec_shader");
        RNA_def_property_enum_items(prop, prop_specular_shader_items);
--      RNA_def_property_ui_text(prop, "Specular Shader Model", "");
++      RNA_def_property_ui_text(prop, N_("Specular Shader Model"), "");
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "specular_intensity", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "spec");
        RNA_def_property_range(prop, 0, 1);
--      RNA_def_property_ui_text(prop, "Specular Intensity", "How intense (bright) the specular reflection is");
++      RNA_def_property_ui_text(prop, N_("Specular Intensity"), N_("How intense (bright) the specular reflection is"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
  
        /* NOTE: "har", "param", etc are used for multiple purposes depending on
        prop= RNA_def_property(srna, "specular_hardness", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "har");
        RNA_def_property_range(prop, 1, 511);
--      RNA_def_property_ui_text(prop, "Specular Hardness", "How hard (sharp) the specular reflection is");
++      RNA_def_property_ui_text(prop, N_("Specular Hardness"), N_("How hard (sharp) the specular reflection is"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
  
        prop= RNA_def_property(srna, "specular_ior", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "refrac");
        RNA_def_property_range(prop, 1, 10);
--      RNA_def_property_ui_text(prop, "Specular IOR", "Specular index of refraction");
++      RNA_def_property_ui_text(prop, N_("Specular IOR"), N_("Specular index of refraction"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_toon_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "param[2]");
        RNA_def_property_range(prop, 0.0f, 1.53f);
--      RNA_def_property_ui_text(prop, "Specular Toon Size", "Size of specular toon area");
++      RNA_def_property_ui_text(prop, N_("Specular Toon Size"), N_("Size of specular toon area"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_toon_smooth", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "param[3]");
        RNA_def_property_range(prop, 0.0f, 1.0f);
--      RNA_def_property_ui_text(prop, "Specular Toon Smooth", "Smoothness of specular toon area");
++      RNA_def_property_ui_text(prop, N_("Specular Toon Smooth"), N_("Smoothness of specular toon area"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "specular_slope", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "rms");
        RNA_def_property_range(prop, 0, 0.4);
--      RNA_def_property_ui_text(prop, "Specular Slope", "The standard deviation of surface slope");
++      RNA_def_property_ui_text(prop, N_("Specular Slope"), N_("The standard deviation of surface slope"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -1459,66 -1459,66 +1461,66 @@@ static void rna_def_material_strand(Ble
        srna= RNA_def_struct(brna, "MaterialStrand", NULL);
        RNA_def_struct_sdna(srna, "Material");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Strand", "Strand settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Strand"), N_("Strand settings for a Material datablock"));
  
        prop= RNA_def_property(srna, "use_tangent_shading", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TANGENT_STR);
--      RNA_def_property_ui_text(prop, "Tangent Shading", "Uses direction of strands as normal for tangent-shading");
++      RNA_def_property_ui_text(prop, N_("Tangent Shading"), N_("Uses direction of strands as normal for tangent-shading"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        /* this flag is only set when rendering, not to be edited manually */
        prop= RNA_def_property(srna, "use_surface_diffuse", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STR_SURFDIFF);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
--      RNA_def_property_ui_text(prop, "Surface Diffuse", "Make diffuse shading more similar to shading the surface");
++      RNA_def_property_ui_text(prop, N_("Surface Diffuse"), N_("Make diffuse shading more similar to shading the surface"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "blend_distance", PROP_FLOAT, PROP_DISTANCE);
        RNA_def_property_float_sdna(prop, NULL, "strand_surfnor");
        RNA_def_property_range(prop, 0, 10);
--      RNA_def_property_ui_text(prop, "Blend Distance", "Worldspace distance over which to blend in the surface normal");
++      RNA_def_property_ui_text(prop, N_("Blend Distance"), N_("Worldspace distance over which to blend in the surface normal"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_blender_units", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STR_B_UNITS);
--      RNA_def_property_ui_text(prop, "Blender Units", "Use Blender units for widths instead of pixels");
++      RNA_def_property_ui_text(prop, N_("Blender Units"), N_("Use Blender units for widths instead of pixels"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "root_size", PROP_FLOAT, PROP_UNSIGNED);
        RNA_def_property_float_sdna(prop, NULL, "strand_sta");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_MaterialStrand_start_size_range");
        RNA_def_property_ui_range(prop, 0, 10.0f, 10, 5);
--      RNA_def_property_ui_text(prop, "Root Size", "Start size of strands in pixels or Blender units");
++      RNA_def_property_ui_text(prop, N_("Root Size"), N_("Start size of strands in pixels or Blender units"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "tip_size", PROP_FLOAT, PROP_UNSIGNED);
        RNA_def_property_float_sdna(prop, NULL, "strand_end");
        RNA_def_property_ui_range(prop, 0, 10.0f, 10, 5);
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_MaterialStrand_end_size_range");
--      RNA_def_property_ui_text(prop, "Tip Size", "End size of strands in pixels or Blender units");
++      RNA_def_property_ui_text(prop, N_("Tip Size"), N_("End size of strands in pixels or Blender units"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "size_min", PROP_FLOAT, PROP_UNSIGNED);
        RNA_def_property_float_sdna(prop, NULL, "strand_min");
        RNA_def_property_range(prop, 0.001, 10);
--      RNA_def_property_ui_text(prop, "Minimum Size", "Minimum size of strands in pixels");
++      RNA_def_property_ui_text(prop, N_("Minimum Size"), N_("Minimum size of strands in pixels"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "shape", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "strand_ease");
        RNA_def_property_range(prop, -0.9, 0.9);
--      RNA_def_property_ui_text(prop, "Shape", "Positive values make strands rounder, negative makes strands spiky");
++      RNA_def_property_ui_text(prop, N_("Shape"), N_("Positive values make strands rounder, negative makes strands spiky"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "width_fade", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "strand_widthfade");
        RNA_def_property_range(prop, 0, 2);
--      RNA_def_property_ui_text(prop, "Width Fade", "Transparency along the width of the strand");
++      RNA_def_property_ui_text(prop, N_("Width Fade"), N_("Transparency along the width of the strand"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "strand_uvname");
--      RNA_def_property_ui_text(prop, "UV Layer", "Name of UV layer to override");
++      RNA_def_property_ui_text(prop, N_("UV Layer"), N_("Name of UV layer to override"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  }
  
@@@ -1530,38 -1530,38 +1532,38 @@@ static void rna_def_material_physics(Bl
        srna= RNA_def_struct(brna, "MaterialPhysics", NULL);
        RNA_def_struct_sdna(srna, "Material");
        RNA_def_struct_nested(brna, srna, "Material");
--      RNA_def_struct_ui_text(srna, "Material Physics", "Physics settings for a Material datablock");
++      RNA_def_struct_ui_text(srna, N_("Material Physics"), N_("Physics settings for a Material datablock"));
        
        prop= RNA_def_property(srna, "friction", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "friction");
        RNA_def_property_range(prop, 0, 100);
--      RNA_def_property_ui_text(prop, "Friction", "Coulomb friction coefficient, when inside the physics distance area");
++      RNA_def_property_ui_text(prop, N_("Friction"), N_("Coulomb friction coefficient, when inside the physics distance area"));
  
        prop= RNA_def_property(srna, "elasticity", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "reflect");
        RNA_def_property_range(prop, 0, 1);
--      RNA_def_property_ui_text(prop, "Elasticity", "Elasticity of collisions");
++      RNA_def_property_ui_text(prop, N_("Elasticity"), N_("Elasticity of collisions"));
  
        /* FH/Force Field Settings */
        prop= RNA_def_property(srna, "use_fh_normal", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "dynamode", MA_FH_NOR);
--      RNA_def_property_ui_text(prop, "Align to Normal", "Align dynamic game objects along the surface normal, when inside the physics distance area");
++      RNA_def_property_ui_text(prop, N_("Align to Normal"), N_("Align dynamic game objects along the surface normal, when inside the physics distance area"));
  
        prop= RNA_def_property(srna, "fh_force", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fh");
        RNA_def_property_range(prop, 0, 1);
        RNA_def_property_ui_range(prop, 0.0, 1.0, 10, 2);
--      RNA_def_property_ui_text(prop, "Force", "Upward spring force, when inside the physics distance area");
++      RNA_def_property_ui_text(prop, N_("Force"), N_("Upward spring force, when inside the physics distance area"));
        
        prop= RNA_def_property(srna, "fh_distance", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fhdist");
        RNA_def_property_range(prop, 0, 20);
--      RNA_def_property_ui_text(prop, "Distance", "Distance of the physics area");
++      RNA_def_property_ui_text(prop, N_("Distance"), N_("Distance of the physics area"));
        
        prop= RNA_def_property(srna, "fh_damping", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "xyfrict");
        RNA_def_property_range(prop, 0, 1);
--      RNA_def_property_ui_text(prop, "Damping", "Damping of the spring force, when inside the physics distance area");
++      RNA_def_property_ui_text(prop, N_("Damping"), N_("Damping of the spring force, when inside the physics distance area"));
  }
  
  void RNA_def_material(BlenderRNA *brna)
        PropertyRNA *prop;
  
        static EnumPropertyItem prop_type_items[] = {
--              {MA_TYPE_SURFACE, "SURFACE", 0, "Surface", "Render object as a surface"},
--              {MA_TYPE_WIRE, "WIRE", 0, "Wire", "Render the edges of faces as wires (not supported in ray tracing)"},
--              {MA_TYPE_VOLUME, "VOLUME", 0, "Volume", "Render object as a volume"},
--              {MA_TYPE_HALO, "HALO", 0, "Halo", "Render object as halo particles"},
++              {MA_TYPE_SURFACE, "SURFACE", 0, N_("Surface"), N_("Render object as a surface")},
++              {MA_TYPE_WIRE, "WIRE", 0, N_("Wire"), N_("Render the edges of faces as wires (not supported in ray tracing)")},
++              {MA_TYPE_VOLUME, "VOLUME", 0, N_("Volume"), N_("Render object as a volume")},
++              {MA_TYPE_HALO, "HALO", 0, N_("Halo"), N_("Render object as halo particles")},
                {0, NULL, 0, NULL, NULL}};
        static EnumPropertyItem transparency_items[] = {
--              {0, "MASK", 0, "Mask", "Mask the background"},
--              {MA_ZTRANSP, "Z_TRANSPARENCY", 0, "Z Transparency", "Use alpha buffer for transparent faces"},
--              {MA_RAYTRANSP, "RAYTRACE", 0, "Raytrace", "Use raytracing for transparent refraction rendering"},
++              {0, "MASK", 0, N_("Mask"), N_("Mask the background")},
++              {MA_ZTRANSP, "Z_TRANSPARENCY", 0, N_("Z Transparency"), N_("Use alpha buffer for transparent faces")},
++              {MA_RAYTRANSP, "RAYTRACE", 0, N_("Raytrace"), N_("Use raytracing for transparent refraction rendering")},
                {0, NULL, 0, NULL, NULL}};
        
        /* Render Preview Types */
        static EnumPropertyItem preview_type_items[] = {
--              {MA_FLAT, "FLAT", ICON_MATPLANE, "Flat", "Preview type: Flat XY plane"},
--              {MA_SPHERE, "SPHERE", ICON_MATSPHERE, "Sphere", "Preview type: Sphere"},
--              {MA_CUBE, "CUBE", ICON_MATCUBE, "Flat", "Preview type: Cube"},
--              {MA_MONKEY, "MONKEY", ICON_MONKEY, "Flat", "Preview type: Monkey"},
--              {MA_HAIR, "HAIR", ICON_HAIR, "Flat", "Preview type: Hair strands"},
--              {MA_SPHERE_A, "SPHERE_A", ICON_MAT_SPHERE_SKY, "Flat", "Preview type: Large sphere with sky"},
++              {MA_FLAT, "FLAT", ICON_MATPLANE, N_("Flat"), N_("Preview type: Flat XY plane")},
++              {MA_SPHERE, "SPHERE", ICON_MATSPHERE, N_("Sphere"), N_("Preview type: Sphere")},
++              {MA_CUBE, "CUBE", ICON_MATCUBE, N_("Flat"), N_("Preview type: Cube")},
++              {MA_MONKEY, "MONKEY", ICON_MONKEY, N_("Flat"), N_("Preview type: Monkey")},
++              {MA_HAIR, "HAIR", ICON_HAIR, N_("Flat"), N_("Preview type: Hair strands")},
++              {MA_SPHERE_A, "SPHERE_A", ICON_MAT_SPHERE_SKY, N_("Flat"), N_("Preview type: Large sphere with sky")},
                {0, NULL, 0, NULL, NULL}};
  
        static EnumPropertyItem prop_shadows_only_items[] = {
--              {MA_SO_OLD, "SHADOW_ONLY_OLD", 0, "Shadow and Distance", "Old shadow only method"},
--              {MA_SO_SHADOW, "SHADOW_ONLY", 0, "Shadow Only", "Improved shadow only method"},
--              {MA_SO_SHADED, "SHADOW_ONLY_SHADED", 0, "Shadow and Shading", "Improved shadow only method which also renders lightless areas as shadows"},
++              {MA_SO_OLD, "SHADOW_ONLY_OLD", 0, N_("Shadow and Distance"), N_("Old shadow only method")},
++              {MA_SO_SHADOW, "SHADOW_ONLY", 0, N_("Shadow Only"), N_("Improved shadow only method")},
++              {MA_SO_SHADED, "SHADOW_ONLY_SHADED", 0, N_("Shadow and Shading"), N_("Improved shadow only method which also renders lightless areas as shadows")},
                {0, NULL, 0, NULL, NULL}};
  
        srna= RNA_def_struct(brna, "Material", "ID");
--      RNA_def_struct_ui_text(srna, "Material", "Material datablock to defined the appearance of geometric objects for rendering");
++      RNA_def_struct_ui_text(srna, N_("Material"), N_("Material datablock to defined the appearance of geometric objects for rendering"));
        RNA_def_struct_ui_icon(srna, ICON_MATERIAL_DATA);
        
        prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "material_type");
        RNA_def_property_enum_items(prop, prop_type_items);
--      RNA_def_property_ui_text(prop, "Type", "Material type defining how the object is rendered");
++      RNA_def_property_ui_text(prop, N_("Type"), N_("Material type defining how the object is rendered"));
        RNA_def_property_enum_funcs(prop, NULL, "rna_Material_type_set", NULL);
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
  
        prop= RNA_def_property(srna, "use_transparency", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TRANSP);
--      RNA_def_property_ui_text(prop, "Transparency", "Render material as transparent");
++      RNA_def_property_ui_text(prop, N_("Transparency"), N_("Render material as transparent"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "transparency_method", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "mode");
        RNA_def_property_enum_items(prop, transparency_items);
--      RNA_def_property_ui_text(prop, "Transparency Method", "Method to use for rendering transparency");
++      RNA_def_property_ui_text(prop, N_("Transparency Method"), N_("Method to use for rendering transparency"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        /* For Preview Render */
        prop= RNA_def_property(srna, "preview_render_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "pr_type");
        RNA_def_property_enum_items(prop, preview_type_items);
--      RNA_def_property_ui_text(prop, "Preview render type", "Type of preview render");
++      RNA_def_property_ui_text(prop, N_("Preview render type"), N_("Type of preview render"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "ambient", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "amb");
        RNA_def_property_range(prop, 0, 1);
--      RNA_def_property_ui_text(prop, "Ambient", "Amount of global ambient color the material receives");
++      RNA_def_property_ui_text(prop, N_("Ambient"), N_("Amount of global ambient color the material receives"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "emit", PROP_FLOAT, PROP_NONE);
        RNA_def_property_range(prop, 0, FLT_MAX);
        RNA_def_property_ui_range(prop, 0, 2.0f, 1, 2);
--      RNA_def_property_ui_text(prop, "Emit", "Amount of light to emit");
++      RNA_def_property_ui_text(prop, N_("Emit"), N_("Amount of light to emit"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
  
        prop= RNA_def_property(srna, "translucency", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_range(prop, 0, 1);
--      RNA_def_property_ui_text(prop, "Translucency", "Amount of diffuse shading on the back side");
++      RNA_def_property_ui_text(prop, N_("Translucency"), N_("Amount of diffuse shading on the back side"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
                
        prop= RNA_def_property(srna, "use_cubic", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_CUBIC);
--      RNA_def_property_ui_text(prop, "Cubic Interpolation", "Use cubic interpolation for diffuse values, for smoother transitions");
++      RNA_def_property_ui_text(prop, N_("Cubic Interpolation"), N_("Use cubic interpolation for diffuse values, for smoother transitions"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_object_color", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_OBCOLOR);
--      RNA_def_property_ui_text(prop, "Object Color", "Modulate the result with a per-object color");
++      RNA_def_property_ui_text(prop, N_("Object Color"), N_("Modulate the result with a per-object color"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
  
        prop= RNA_def_property(srna, "shadow_ray_bias", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sbias");
        RNA_def_property_range(prop, 0, 0.25);
--      RNA_def_property_ui_text(prop, "Shadow Ray Bias", "Shadow raytracing bias to prevent terminator problems on shadow boundary");
++      RNA_def_property_ui_text(prop, N_("Shadow Ray Bias"), N_("Shadow raytracing bias to prevent terminator problems on shadow boundary"));
  
        prop= RNA_def_property(srna, "shadow_buffer_bias", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "lbias");
        RNA_def_property_range(prop, 0, 10);
--      RNA_def_property_ui_text(prop, "Shadow Buffer Bias", "Factor to multiply shadow buffer bias with (0 is ignore.)");
++      RNA_def_property_ui_text(prop, N_("Shadow Buffer Bias"), N_("Factor to multiply shadow buffer bias with (0 is ignore.)"));
  
        prop= RNA_def_property(srna, "shadow_cast_alpha", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "shad_alpha");
        RNA_def_property_range(prop, 0.001, 1);
--      RNA_def_property_ui_text(prop, "Shadow Casting Alpha", "Shadow casting alpha, in use for Irregular and Deep shadow buffer");
++      RNA_def_property_ui_text(prop, N_("Shadow Casting Alpha"), N_("Shadow casting alpha, in use for Irregular and Deep shadow buffer"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "light_group", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "group");
        RNA_def_property_struct_type(prop, "Group");
        RNA_def_property_flag(prop, PROP_EDITABLE);
--      RNA_def_property_ui_text(prop, "Light Group", "Limit lighting to lamps in this Group");
++      RNA_def_property_ui_text(prop, N_("Light Group"), N_("Limit lighting to lamps in this Group"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
-       
+       prop= RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
+       RNA_def_property_int_sdna(prop, NULL, "index");
 -      RNA_def_property_ui_text(prop, "Pass Index", "Index # for the IndexMA render pass");
++      RNA_def_property_ui_text(prop, N_("Pass Index"), N_("Index # for the IndexMA render pass"));
+       RNA_def_property_update(prop, NC_OBJECT, NULL);
        /* flags */
        
        prop= RNA_def_property(srna, "use_light_group_exclusive", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_GROUP_NOLAY);
--      RNA_def_property_ui_text(prop, "Light Group Exclusive", "Material uses the light group exclusively - these lamps are excluded from other scene lighting");
++      RNA_def_property_ui_text(prop, N_("Light Group Exclusive"), N_("Material uses the light group exclusively - these lamps are excluded from other scene lighting"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_raytrace", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TRACEBLE);
--      RNA_def_property_ui_text(prop, "Traceable", "Include this material and geometry that uses it in ray tracing calculations");
++      RNA_def_property_ui_text(prop, N_("Traceable"), N_("Include this material and geometry that uses it in ray tracing calculations"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_shadows", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADOW);
--      RNA_def_property_ui_text(prop, "Shadows", "Allows this material to receive shadows");
++      RNA_def_property_ui_text(prop, N_("Shadows"), N_("Allows this material to receive shadows"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_shadeless", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHLESS);
--      RNA_def_property_ui_text(prop, "Shadeless", "Makes this material insensitive to light or shadow");
++      RNA_def_property_ui_text(prop, N_("Shadeless"), N_("Makes this material insensitive to light or shadow"));
        RNA_def_property_update(prop, 0, "rna_Material_draw_update");
        
        prop= RNA_def_property(srna, "use_vertex_color_light", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_VERTEXCOL);
--      RNA_def_property_ui_text(prop, "Vertex Color Light", "Add vertex colors as additional lighting");
++      RNA_def_property_ui_text(prop, N_("Vertex Color Light"), N_("Add vertex colors as additional lighting"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_vertex_color_paint", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_VERTEXCOLP);
--      RNA_def_property_ui_text(prop, "Vertex Color Paint", "Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures)");
++      RNA_def_property_ui_text(prop, N_("Vertex Color Paint"), N_("Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "invert_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ZINV);
--      RNA_def_property_ui_text(prop, "Invert Z Depth", "Renders material's faces with an inverted Z buffer (scanline only)");
++      RNA_def_property_ui_text(prop, N_("Invert Z Depth"), N_("Renders material's faces with an inverted Z buffer (scanline only)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "offset_z", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "zoffs");
--      RNA_def_property_ui_text(prop, "Z Offset", "Gives faces an artificial offset in the Z buffer for Z transparency");
++      RNA_def_property_ui_text(prop, N_("Z Offset"), N_("Gives faces an artificial offset in the Z buffer for Z transparency"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_sky", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ENV);
--      RNA_def_property_ui_text(prop, "Sky", "Renders this material with zero alpha, with sky background in place (scanline only)");
++      RNA_def_property_ui_text(prop, N_("Sky"), N_("Renders this material with zero alpha, with sky background in place (scanline only)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_only_shadow", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ONLYSHADOW);
--      RNA_def_property_ui_text(prop, "Only Shadow", "Renders shadows as the material's alpha value, making materials transparent except for shadowed areas");
++      RNA_def_property_ui_text(prop, N_("Only Shadow"), N_("Renders shadows as the material's alpha value, making materials transparent except for shadowed areas"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "shadow_only_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "shadowonly_flag");
        RNA_def_property_enum_items(prop, prop_shadows_only_items);
--      RNA_def_property_ui_text(prop, "Shadow Type", "How to draw shadows");
++      RNA_def_property_ui_text(prop, N_("Shadow Type"), N_("How to draw shadows"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_face_texture", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FACETEXTURE);
--      RNA_def_property_ui_text(prop, "Face Textures", "Replaces the object's base color with color from face assigned image textures");
++      RNA_def_property_ui_text(prop, N_("Face Textures"), N_("Replaces the object's base color with color from face assigned image textures"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_face_texture_alpha", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FACETEXTURE_ALPHA);
--      RNA_def_property_ui_text(prop, "Face Textures Alpha", "Replaces the object's base alpha value with alpha from face assigned image textures");
++      RNA_def_property_ui_text(prop, N_("Face Textures Alpha"), N_("Replaces the object's base alpha value with alpha from face assigned image textures"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_cast_shadows_only", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_ONLYCAST);
--      RNA_def_property_ui_text(prop, "Cast Shadows Only", "Makes objects with this material appear invisible, only casting shadows (not rendered)");
++      RNA_def_property_ui_text(prop, N_("Cast Shadows Only"), N_("Makes objects with this material appear invisible, only casting shadows (not rendered)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_mist", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "mode", MA_NOMIST);
--      RNA_def_property_ui_text(prop, "Use Mist", "Use mist with this material (in world settings)");
++      RNA_def_property_ui_text(prop, N_("Use Mist"), N_("Use mist with this material (in world settings)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_transparent_shadows", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADOW_TRA);
--      RNA_def_property_ui_text(prop, "Receive Transparent Shadows", "Allow this object to receive transparent shadows cast through other objects");
++      RNA_def_property_ui_text(prop, N_("Receive Transparent Shadows"), N_("Allow this object to receive transparent shadows cast through other objects"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_ray_shadow_bias", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_RAYBIAS);
--      RNA_def_property_ui_text(prop, "Ray Shadow Bias", "Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)");
++      RNA_def_property_ui_text(prop, N_("Ray Shadow Bias"), N_("Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_full_oversampling", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_FULL_OSA);
--      RNA_def_property_ui_text(prop, "Full Oversampling", "Force this material to render full shading/textures for all anti-aliasing samples");
++      RNA_def_property_ui_text(prop, N_("Full Oversampling"), N_("Force this material to render full shading/textures for all anti-aliasing samples"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_cast_buffer_shadows", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADBUF);
--      RNA_def_property_ui_text(prop, "Cast Buffer Shadows", "Allow this material to cast shadows from shadow buffer lamps");
++      RNA_def_property_ui_text(prop, N_("Cast Buffer Shadows"), N_("Allow this material to cast shadows from shadow buffer lamps"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "use_cast_approximate", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_APPROX_OCCLUSION);
--      RNA_def_property_ui_text(prop, "Cast Approximate", "Allow this material to cast shadows when using approximate ambient occlusion.");
++      RNA_def_property_ui_text(prop, N_("Cast Approximate"), N_("Allow this material to cast shadows when using approximate ambient occlusion."));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        prop= RNA_def_property(srna, "use_tangent_shading", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_TANGENT_V);
--      RNA_def_property_ui_text(prop, "Tangent Shading", "Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects");
++      RNA_def_property_ui_text(prop, N_("Tangent Shading"), N_("Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
        
        /* nested structs */
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_struct_type(prop, "MaterialRaytraceMirror");
        RNA_def_property_pointer_funcs(prop, "rna_Material_mirror_get", NULL, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Raytrace Mirror", "Raytraced reflection settings for the material");
++      RNA_def_property_ui_text(prop, N_("Raytrace Mirror"), N_("Raytraced reflection settings for the material"));
  
        prop= RNA_def_property(srna, "raytrace_transparency", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_struct_type(prop, "MaterialRaytraceTransparency");
        RNA_def_property_pointer_funcs(prop, "rna_Material_transp_get", NULL, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Raytrace Transparency", "Raytraced transparency settings for the material");
++      RNA_def_property_ui_text(prop, N_("Raytrace Transparency"), N_("Raytraced transparency settings for the material"));
  
        prop= RNA_def_property(srna, "volume", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_pointer_sdna(prop, NULL, "vol");
        RNA_def_property_struct_type(prop, "MaterialVolume");
--      RNA_def_property_ui_text(prop, "Volume", "Volume settings for the material");
++      RNA_def_property_ui_text(prop, N_("Volume"), N_("Volume settings for the material"));
  
        prop= RNA_def_property(srna, "halo", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_struct_type(prop, "MaterialHalo");
        RNA_def_property_pointer_funcs(prop, "rna_Material_halo_get", NULL, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Halo", "Halo settings for the material");
++      RNA_def_property_ui_text(prop, N_("Halo"), N_("Halo settings for the material"));
  
        prop= RNA_def_property(srna, "subsurface_scattering", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_struct_type(prop, "MaterialSubsurfaceScattering");
        RNA_def_property_pointer_funcs(prop, "rna_Material_sss_get", NULL, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Subsurface Scattering", "Subsurface scattering settings for the material");
++      RNA_def_property_ui_text(prop, N_("Subsurface Scattering"), N_("Subsurface scattering settings for the material"));
  
        prop= RNA_def_property(srna, "strand", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_struct_type(prop, "MaterialStrand");
        RNA_def_property_pointer_funcs(prop, "rna_Material_strand_get", NULL, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Strand", "Strand settings for the material");
++      RNA_def_property_ui_text(prop, N_("Strand"), N_("Strand settings for the material"));
        
        prop= RNA_def_property(srna, "physics", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
        RNA_def_property_struct_type(prop, "MaterialPhysics");
        RNA_def_property_pointer_funcs(prop, "rna_Material_physics_get", NULL, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Physics", "Game physics settings");
++      RNA_def_property_ui_text(prop, N_("Physics"), N_("Game physics settings"));
  
        /* nodetree */
        prop= RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
--      RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based materials");
++      RNA_def_property_ui_text(prop, N_("Node Tree"), N_("Node tree for node based materials"));
  
        prop= RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "use_nodes", 1);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_Material_use_nodes_set");
--      RNA_def_property_ui_text(prop, "Use Nodes", "Use shader nodes to render the material");
++      RNA_def_property_ui_text(prop, N_("Use Nodes"), N_("Use shader nodes to render the material"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        prop= RNA_def_property(srna, "active_node_material", PROP_POINTER, PROP_NONE);
        RNA_def_property_struct_type(prop, "Material");
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_pointer_funcs(prop, "rna_Material_active_node_material_get", "rna_Material_active_node_material_set", NULL, NULL);
--      RNA_def_property_ui_text(prop, "Material", "Active node material");
++      RNA_def_property_ui_text(prop, N_("Material"), N_("Active node material"));
        RNA_def_property_update(prop, NC_MATERIAL, NULL);
  
        /* common */
        prop= RNA_def_property(srna, "use_textures", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "septex", 1);
        RNA_def_property_array(prop, 18);
--      RNA_def_property_ui_text(prop, "Use Textures", "Enable/Disable each texture");
++      RNA_def_property_ui_text(prop, N_("Use Textures"), N_("Enable/Disable each texture"));
        RNA_def_property_update(prop, 0, "rna_Material_update");
  
        rna_def_material_colors(srna);
@@@ -1886,24 -1891,24 +1893,24 @@@ static void rna_def_texture_slots(Blend
        RNA_def_property_srna(cprop, structname_slots);
        srna= RNA_def_struct(brna, structname_slots, NULL);
        RNA_def_struct_sdna(srna, "ID");
--      RNA_def_struct_ui_text(srna, "Texture Slots", "Collection of texture slots");
++      RNA_def_struct_ui_text(srna, N_("Texture Slots"), N_("Collection of texture slots"));
  
        /* functions */
        func= RNA_def_function(srna, "add", "rna_mtex_texture_slots_add");
        RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_NO_SELF|FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
--      parm= RNA_def_pointer(func, "mtex", structname, "", "The newly initialized mtex.");
++      parm= RNA_def_pointer(func, "mtex", structname, "", N_("The newly initialized mtex."));
        RNA_def_function_return(func, parm);
        
        func= RNA_def_function(srna, "create", "rna_mtex_texture_slots_create");
        RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_NO_SELF|FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
--      parm= RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "Slot index to initialize.", 0, INT_MAX);
++      parm= RNA_def_int(func, "index", 0, 0, INT_MAX, N_("Index"), N_("Slot index to initialize."), 0, INT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
--      parm= RNA_def_pointer(func, "mtex", structname, "", "The newly initialized mtex.");
++      parm= RNA_def_pointer(func, "mtex", structname, "", N_("The newly initialized mtex."));
        RNA_def_function_return(func, parm);
        
        func= RNA_def_function(srna, "clear", "rna_mtex_texture_slots_clear");
        RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_NO_SELF|FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
--      parm= RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "Slot index to clear.", 0, INT_MAX);
++      parm= RNA_def_int(func, "index", 0, 0, INT_MAX, N_("Index"), N_("Slot index to clear."), 0, INT_MAX);
        RNA_def_property_flag(parm, PROP_REQUIRED);
  }
  
@@@ -1917,7 -1922,7 +1924,7 @@@ void rna_def_mtex_common(BlenderRNA *br
        prop= RNA_def_property(srna, "texture_slots", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_struct_type(prop, structname);
        RNA_def_property_collection_funcs(prop, begin, "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_dereference_get", 0, 0, 0);
--      RNA_def_property_ui_text(prop, "Textures", "Texture slots defining the mapping and influence of textures");
++      RNA_def_property_ui_text(prop, N_("Textures"), N_("Texture slots defining the mapping and influence of textures"));
        rna_def_texture_slots(brna, prop, structname, structname_slots);
  
        prop= RNA_def_property(srna, "active_texture", PROP_POINTER, PROP_NONE);
        if(activeeditable)
                RNA_def_property_editable_func(prop, activeeditable);
        RNA_def_property_pointer_funcs(prop, activeget, activeset, NULL, NULL);
--      RNA_def_property_ui_text(prop, "Active Texture", "Active texture slot being displayed");
++      RNA_def_property_ui_text(prop, N_("Active Texture"), N_("Active texture slot being displayed"));
        RNA_def_property_update(prop, 0, update);
  
        prop= RNA_def_property(srna, "active_texture_index", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "texact");
        RNA_def_property_range(prop, 0, MAX_MTEX-1);
--      RNA_def_property_ui_text(prop, "Active Texture Index", "Index of active texture slot");
++      RNA_def_property_ui_text(prop, N_("Active Texture Index"), N_("Index of active texture slot"));
        RNA_def_property_update(prop, 0, update);
  }
  
index 97a5ea47a6dcebcd8b9cbcb5882b20db5f0c88e0,b79d5395eec7a668e757a3e68b5cbff9070c4a10..833f45ec4cc824bc2cdd0d4add7650c52524d0e9
@@@ -990,9 -988,14 +990,14 @@@ static void rna_def_space_image_uv(Blen
  
        prop= RNA_def_property(srna, "show_normalized_coords", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_COORDFLOATS);
 -      RNA_def_property_ui_text(prop, "Normalized Coordinates", "Display UV coordinates from 0.0 to 1.0 rather than in pixels");
 +      RNA_def_property_ui_text(prop, N_("Normalized Coordinates"), N_("Display UV coordinates from 0.0 to 1.0 rather than in pixels"));
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_IMAGE, NULL);
-       
+       prop= RNA_def_property(srna, "show_faces", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", SI_NO_DRAWFACES);
 -      RNA_def_property_ui_text(prop, "Draw Faces", "Draw faces over the image");
++      RNA_def_property_ui_text(prop, N_("Draw Faces"), N_("Draw faces over the image"));
+       RNA_def_property_update(prop, NC_SPACE|ND_SPACE_IMAGE, NULL);
        prop= RNA_def_property(srna, "cursor_location", PROP_FLOAT, PROP_XYZ);
        RNA_def_property_array(prop, 2);
        RNA_def_property_float_funcs(prop, "rna_SpaceImageEditor_cursor_location_get", "rna_SpaceImageEditor_cursor_location_set", NULL);
index 0000000000000000000000000000000000000000,26d9ca76e3fa62d1381c43e2c5e8878278f7b0cc..77ba6031da5cf8936cf940596b8d1da4be345bb5
mode 000000,100644..100755
--- /dev/null
@@@ -1,0 -1,170 +1,170 @@@
 - * $Id$
+ /*
++ * $Id: bpy_app_handlers.c 37799 2011-06-24 23:14:26Z gsrb3d $
+  *
+  * ***** 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.
+  *
+  * Contributor(s): Campbell Barton
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /** \file blender/python/intern/bpy_app_handlers.c
+  *  \ingroup pythonintern
+  */
+ #include <Python.h>
+ #include "BLI_utildefines.h"
+ #include "BLI_callbacks.h"
+ #include "RNA_types.h"
+ #include "RNA_access.h"
+ #include "bpy_rna.h"
+ #include "bpy_app_handlers.h"
+ void bpy_app_generic_callback(struct Main *main, struct ID *id, void *arg);
+ static PyTypeObject BlenderAppCbType;
+ static PyStructSequence_Field app_cb_info_fields[]= {
+       {(char *)"render_pre", NULL},
+       {(char *)"render_post", NULL},
+     {(char *)"load_pre", NULL},
+       {(char *)"load_post", NULL},
+     {(char *)"save_pre", NULL},
+       {(char *)"save_post", NULL},
+       {NULL}
+ };
+ static PyStructSequence_Desc app_cb_info_desc= {
+       (char *)"bpy.app.handlers",     /* name */
+       (char *)"This module contains callbacks",    /* doc */
+       app_cb_info_fields,    /* fields */
+       (sizeof(app_cb_info_fields)/sizeof(PyStructSequence_Field)) - 1
+ };
+ /*
+ #if (BLI_CB_EVT_TOT != ((sizeof(app_cb_info_fields)/sizeof(PyStructSequence_Field))))
+ #  error "Callbacks are out of sync"
+ #endif
+ */
+ static PyObject *py_cb_array[BLI_CB_EVT_TOT]= {0};
+ static PyObject *make_app_cb_info(void)
+ {
+       PyObject *app_cb_info;
+       int pos= 0;
+       app_cb_info= PyStructSequence_New(&BlenderAppCbType);
+       if (app_cb_info == NULL) {
+               return NULL;
+       }
+       for(pos= 0; pos < BLI_CB_EVT_TOT; pos++) {
+               if(app_cb_info_fields[pos].name == NULL) {
+                       Py_FatalError("invalid callback slots 1");
+               }
+               PyStructSequence_SET_ITEM(app_cb_info, pos, (py_cb_array[pos]= PyList_New(0)));
+       }
+       if(app_cb_info_fields[pos].name != NULL) {
+               Py_FatalError("invalid callback slots 2");
+       }
+       return app_cb_info;
+ }
+ PyObject *BPY_app_handlers_struct(void)
+ {
+       PyObject *ret;
+       PyStructSequence_InitType(&BlenderAppCbType, &app_cb_info_desc);
+       ret= make_app_cb_info();
+       /* prevent user from creating new instances */
+       BlenderAppCbType.tp_init= NULL;
+       BlenderAppCbType.tp_new= NULL;
+       /* assign the C callbacks */
+       if(ret) {
+               static bCallbackFuncStore funcstore_array[BLI_CB_EVT_TOT]= {{0}};
+               bCallbackFuncStore *funcstore;
+               int pos= 0;
+               for(pos= 0; pos < BLI_CB_EVT_TOT; pos++) {
+                       funcstore= &funcstore_array[pos];
+                       funcstore->func= bpy_app_generic_callback;
+                       funcstore->alloc= 0;
+                       funcstore->arg= SET_INT_IN_POINTER(pos);
+                       BLI_add_cb(funcstore, pos);
+               }
+       }
+       return ret;
+ }
+ void BPY_app_handlers_reset(void)
+ {
+       int pos= 0;
+       for(pos= 0; pos < BLI_CB_EVT_TOT; pos++) {
+               PyList_SetSlice(py_cb_array[pos], 0, PY_SSIZE_T_MAX, NULL);
+       }
+ }
+ /* the actual callback - not necessarily called from py */
+ void bpy_app_generic_callback(struct Main *UNUSED(main), struct ID *id, void *arg)
+ {
+       PyObject *cb_list= py_cb_array[GET_INT_FROM_POINTER(arg)];
+       Py_ssize_t cb_list_len;
+       if((cb_list_len= PyList_GET_SIZE(cb_list)) > 0) {
+               PyGILState_STATE gilstate= PyGILState_Ensure();
+               PyObject* args= PyTuple_New(1); // save python creating each call
+               PyObject* func;
+               PyObject* ret;
+               Py_ssize_t pos;
+               /* setup arguments */
+               if(id) {
+                       PointerRNA id_ptr;
+                       RNA_id_pointer_create(id, &id_ptr);
+                       PyTuple_SET_ITEM(args, 0, pyrna_struct_CreatePyObject(&id_ptr));
+               }
+               else {
+                       PyTuple_SET_ITEM(args, 0, Py_None);
+                       Py_INCREF(Py_None);
+               }
+               // Iterate the list and run the callbacks
+               for (pos=0; pos < cb_list_len; pos++) {
+                       func= PyList_GET_ITEM(cb_list, pos);
+                       ret= PyObject_Call(func, args, NULL);
+                       if (ret==NULL) {
+                               PyErr_Print();
+                               PyErr_Clear();
+                       }
+                       else {
+                               Py_DECREF(ret);
+                       }
+               }
+               Py_DECREF(args);
+               PyGILState_Release(gilstate);
+       }
+ }
index ad09339e61a1176c80aae6803fd364ad4c2352fb,bfa413438b17fc1854395109c8c29c78b269ac4c..8c1faa19c542d6bb37839a7accb57b1467dca034
mode 100644,100644..100755
@@@ -1,9 -1,5 +1,5 @@@
  /*
-  * blenlib/BLI_editVert.h    mar 2001 Nzc
-  *
-  * These callbacks are needed in the lib
-  *
-- * $Id$
++ * $Id: bpy_app_handlers.h 37799 2011-06-24 23:14:26Z gsrb3d $
   *
   * ***** BEGIN GPL LICENSE BLOCK *****
   *
index 6bec3b60df1d009a9b60056488ed58bc589526f6,27fc0caecccc11996f8b25cdeffc6bb9f2c2b1e0..df00c2b83cbc1cba57ef3d3e86825e065cff26dc
  #include "BLI_blenlib.h"
  #include "BLI_linklist.h"
  #include "BLI_utildefines.h"
+ #include "BLI_callbacks.h"
  
 +#include "BLF_api.h"
 +
  #include "DNA_anim_types.h"
  #include "DNA_ipo_types.h" // XXX old animation system
  #include "DNA_object_types.h"
index 8313f2f85bcd2577c51648b24f057a1ac13cc6a2,35afdf29b53f4b25b468c68e93db4f2704345158..41838052b4736173f0a69c52069052c1bc356c47
@@@ -2045,6 -2049,8 +2049,8 @@@ static void WM_OT_collada_export(wmOper
        ot->poll= WM_operator_winactive;
        
        WM_operator_properties_filesel(ot, FOLDERFILE|COLLADAFILE, FILE_BLENDER, FILE_SAVE, WM_FILESEL_FILEPATH);
 -      RNA_def_boolean(ot->srna, "selected", 0, "Export only selected",
 -              "Export only selected elements");
++      RNA_def_boolean(ot->srna, "selected", 0, _("Export only selected"),
++              _("Export only selected elements"));
  }
  
  /* function used for WM_OT_save_mainfile too */
index 910baff6b8a5b174edb24fdbeae333e88a32d584,dc19742c057b2539b377f99d6ca6c72f7654c27e..3ad0ec8efa4f0682f6a41873ae22e50b1bf5475a
@@@ -350,9 -358,7 +358,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
++                              ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
++                              ${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts
                        DESTINATION ${TARGETDIR_VER}/datafiles
                        PATTERN ".svn" EXCLUDE
                )
@@@ -424,12 -429,10 +431,12 @@@ elseif(WIN32
        if(WITH_INTERNATIONAL) # same as linux!, deduplicate
                install(
                        FILES ${CMAKE_SOURCE_DIR}/release/bin/.blender/.Blanguages
-                       DESTINATION ${TARGETDIR_VER}/config
+                       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
++                              ${CMAKE_SOURCE_DIR}/release/bin/.blender/locale
++                              ${CMAKE_SOURCE_DIR}/release/bin/.blender/fonts
                        DESTINATION ${TARGETDIR_VER}/datafiles
                        PATTERN ".svn" EXCLUDE
                )
index 0e3cfc58e0937bdd85754a4e060b5b399166b5e4,cbbeb9419d185483d64fdde5fb312d3d6c4b874b..42856a3dad29c41e05a2dbe2569596aeaa395084
@@@ -399,16 -400,12 +400,19 @@@ int main(int argc, char** argv
                  ::DisposeNibReference(nibRef);
      */
  #endif // __APPLE__
+       
+       // 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();
 -      
 +      // 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();
 +      // use default settings
 +      BLF_lang_encoding("");
 +      BLF_lang_set("");
 +
        RNA_init();
 +      RNA_structs_gettexted()
  
        init_nodesystem();