Merging r49953 through r50015 into from trunk into soc-2011-tomato
authorSergey Sharybin <sergey.vfx@gmail.com>
Sun, 19 Aug 2012 13:57:55 +0000 (13:57 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Sun, 19 Aug 2012 13:57:55 +0000 (13:57 +0000)
131 files changed:
CMakeLists.txt
build_files/cmake/config/blender_lite.cmake
intern/CMakeLists.txt
intern/ghost/GHOST_C-api.h
intern/iksolver/CMakeLists.txt
intern/iksolver/SConscript
release/scripts/modules/bpy/path.py
release/scripts/startup/bl_operators/node.py
release/scripts/startup/bl_ui/properties_animviz.py
release/scripts/startup/bl_ui/properties_data_curve.py
release/scripts/startup/bl_ui/properties_data_lamp.py
release/scripts/startup/bl_ui/properties_mask_common.py
release/scripts/startup/bl_ui/properties_particle.py
release/scripts/startup/bl_ui/properties_physics_field.py
release/scripts/startup/bl_ui/space_sequencer.py
release/scripts/startup/bl_ui/space_userpref.py
release/scripts/startup/bl_ui/space_view3d.py
release/scripts/startup/bl_ui/space_view3d_toolbar.py
source/blender/blenkernel/BKE_fcurve.h
source/blender/blenkernel/BKE_mball.h
source/blender/blenkernel/BKE_object.h
source/blender/blenkernel/BKE_sequencer.h
source/blender/blenkernel/intern/CCGSubSurf.c
source/blender/blenkernel/intern/CCGSubSurf.h
source/blender/blenkernel/intern/DerivedMesh.c
source/blender/blenkernel/intern/anim.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/boids.c
source/blender/blenkernel/intern/cdderivedmesh.c
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/dynamicpaint.c
source/blender/blenkernel/intern/editderivedmesh.c
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/font.c
source/blender/blenkernel/intern/gpencil.c
source/blender/blenkernel/intern/group.c
source/blender/blenkernel/intern/idprop.c
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/ipo.c
source/blender/blenkernel/intern/key.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/mball.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/seqeffects.c
source/blender/blenkernel/intern/sequencer.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenlib/BLI_listbase.h
source/blender/blenlib/BLI_rect.h
source/blender/blenlib/intern/listbase.c
source/blender/blenlib/intern/rct.c
source/blender/blenlib/intern/voronoi.c
source/blender/blenloader/intern/writefile.c
source/blender/bmesh/intern/bmesh_core.c
source/blender/bmesh/intern/bmesh_error.h
source/blender/bmesh/intern/bmesh_marking.c
source/blender/bmesh/intern/bmesh_mods.c
source/blender/bmesh/intern/bmesh_operator_api.h
source/blender/bmesh/intern/bmesh_polygon.c
source/blender/bmesh/intern/bmesh_queries.c
source/blender/compositor/CMakeLists.txt
source/blender/compositor/intern/COM_ChunkOrder.cpp
source/blender/compositor/intern/COM_ChunkOrder.h
source/blender/compositor/intern/COM_ExecutionGroup.cpp
source/blender/compositor/intern/COM_ExecutionSystem.h
source/blender/compositor/nodes/COM_DistanceMatteNode.cpp
source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cpp [moved from source/blender/compositor/operations/COM_DistanceMatteOperation.cpp with 76% similarity]
source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h [moved from source/blender/compositor/operations/COM_DistanceMatteOperation.h with 84% similarity]
source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cpp [new file with mode: 0644]
source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h [new file with mode: 0644]
source/blender/editors/animation/anim_deps.c
source/blender/editors/animation/anim_filter.c
source/blender/editors/animation/fmodifier_ui.c
source/blender/editors/armature/editarmature.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/UI_interface.h
source/blender/editors/interface/interface.c
source/blender/editors/interface/interface_draw.c
source/blender/editors/interface/interface_handlers.c
source/blender/editors/interface/interface_icons.c
source/blender/editors/interface/interface_intern.h
source/blender/editors/interface/interface_layout.c
source/blender/editors/interface/interface_ops.c
source/blender/editors/interface/interface_panel.c
source/blender/editors/interface/interface_regions.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/interface_widgets.c
source/blender/editors/interface/resources.c
source/blender/editors/object/object_edit.c
source/blender/editors/object/object_modifier.c
source/blender/editors/object/object_select.c
source/blender/editors/object/object_transform.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/physics/particle_edit.c
source/blender/editors/screen/area.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/sculpt_undo.c
source/blender/editors/space_graph/graph_edit.c
source/blender/editors/space_image/image_buttons.c
source/blender/editors/space_image/image_edit.c
source/blender/editors/space_logic/logic_buttons.c
source/blender/editors/space_node/node_templates.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_intern.h
source/blender/editors/space_view3d/view3d_ops.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/transform/transform_orientations.c
source/blender/editors/uvedit/uvedit_unwrap_ops.c
source/blender/gpu/intern/gpu_draw.c
source/blender/ikplugin/CMakeLists.txt
source/blender/ikplugin/intern/ikplugin_api.c
source/blender/imbuf/IMB_imbuf_types.h
source/blender/makesdna/DNA_userdef_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_userdef.c
source/blender/modifiers/intern/MOD_displace.c
source/blender/nodes/composite/nodes/node_composite_trackpos.c
source/blender/render/intern/source/shadbuf.c
source/blender/windowmanager/intern/wm_event_system.c
source/blenderplayer/CMakeLists.txt
source/creator/CMakeLists.txt
source/gameengine/GamePlayer/ghost/GPG_Application.cpp
source/gameengine/GamePlayer/ghost/GPG_Application.h
source/gameengine/GamePlayer/ghost/GPG_ghost.cpp
source/gameengine/Ketsji/BL_Texture.cpp
source/gameengine/Ketsji/KX_SCA_AddObjectActuator.h
source/gameengine/Ketsji/KX_SCA_EndObjectActuator.h
source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.h

index 3ac95833b4efec0225973ac6e086b8a1cbc5ed8d..e33a24d4eab6a3db289cf554f9e1258e849315ca 100644 (file)
@@ -126,6 +126,7 @@ option(WITH_PYTHON_SAFETY "Enable internal API error checking to track invalid d
 option(WITH_PYTHON_MODULE "Enable building as a python module which runs without a user interface, like running regular blender in background mode (experimental, only enable for development)" OFF)
 option(WITH_BUILDINFO     "Include extra build details (only disable for development & faster builds)" ON)
 option(WITH_IK_ITASC      "Enable ITASC IK solver (only disable for development & for incompatible C++ compilers)" ON)
+option(WITH_IK_SOLVER     "Enable Legacy IK solver (only disable for development)" ON)
 option(WITH_FFTW3         "Enable FFTW3 support (Used for smoke and audio effects)" OFF)
 option(WITH_BULLET        "Enable Bullet (Physics Engine)" ON)
 option(WITH_GAMEENGINE    "Enable Game Engine" ON)
index 06a822617958bf8a54488d4cd252c487329c7b71..b834cd37a8a27f67236cc4c3d87f5b63a5c62793 100644 (file)
@@ -18,6 +18,7 @@ set(WITH_LIBMV               OFF CACHE FORCE BOOL)
 set(WITH_GAMEENGINE          OFF CACHE FORCE BOOL)
 set(WITH_COMPOSITOR          OFF CACHE FORCE BOOL)
 set(WITH_GHOST_XDND          OFF CACHE FORCE BOOL)
+set(WITH_IK_SOLVER           OFF CACHE FORCE BOOL)
 set(WITH_IK_ITASC            OFF CACHE FORCE BOOL)
 set(WITH_IMAGE_CINEON        OFF CACHE FORCE BOOL)
 set(WITH_IMAGE_DDS           OFF CACHE FORCE BOOL)
index d60df5e26c6b65806c113caff26b585c52c5a859..1609bd35fa6966695e6c243fd9e0e12152bcc505 100644 (file)
@@ -28,7 +28,6 @@ add_subdirectory(ghost)
 add_subdirectory(guardedalloc)
 add_subdirectory(moto)
 add_subdirectory(memutil)
-add_subdirectory(iksolver)
 add_subdirectory(opennl)
 add_subdirectory(mikktspace)
 add_subdirectory(raskter)
@@ -58,6 +57,10 @@ if(WITH_MOD_BOOLEAN)
        add_subdirectory(bsp)
 endif()
 
+if(WITH_IK_SOLVER)
+       add_subdirectory(iksolver)
+endif()
+
 if(WITH_IK_ITASC)
        add_subdirectory(itasc)
 endif()
index 4466d614ee9169a71d6d08800b4fc0e50577778f..ae30458a5e59a1625ec92552b5872b5283510148 100644 (file)
@@ -26,7 +26,7 @@
  */
 /** \ingroup GHOST
  *
- * \file       GHOST_C-api.h
+ * \file GHOST_C-api.h
  * \brief GHOST C-API function and type declarations.
  */
 
@@ -43,7 +43,7 @@ extern "C" {
  * Creates a &quot;handle&quot; for a C++ GHOST object.
  * A handle is just an opaque pointer to an empty struct.
  * In the API the pointer is casted to the actual C++ class.
- * \param      name    Name of the handle to create.
+ * \param name Name of the handle to create.
  */
 
 GHOST_DECLARE_HANDLE(GHOST_SystemHandle);
@@ -56,48 +56,47 @@ GHOST_DECLARE_HANDLE(GHOST_EventConsumerHandle);
 
 /**
  * Definition of a callback routine that receives events.
- * @param event The event received.
- * @param userdata The callback's user data, supplied to GHOST_CreateSystem.
+ * \param event The event received.
+ * \param userdata The callback's user data, supplied to GHOST_CreateSystem.
  */
 typedef int (*GHOST_EventCallbackProcPtr)(GHOST_EventHandle event, GHOST_TUserDataPtr userdata);
 
 
 /**
  * Creates the one and only system.
- * @return a handle to the system.
+ * \return a handle to the system.
  */
 extern GHOST_SystemHandle GHOST_CreateSystem(void);
 
 /**
  * Disposes the one and only system.
- * @param systemhandle The handle to the system
- * @return An indication of success.
+ * \param systemhandle The handle to the system
+ * \return An indication of success.
  */
 extern GHOST_TSuccess GHOST_DisposeSystem(GHOST_SystemHandle systemhandle);
 
 
 /**
  * Creates an event consumer object
- * @param eventCallback The event callback routine.
- * @param userdata             Pointer to user data returned to the callback routine.
+ * \param eventCallback The event callback routine.
+ * \param userdata Pointer to user data returned to the callback routine.
  */
 extern GHOST_EventConsumerHandle GHOST_CreateEventConsumer(GHOST_EventCallbackProcPtr eventCallback,
                                                            GHOST_TUserDataPtr userdata);
 
 /**
  * Disposes an event consumer object
- * @param consumerhandle       Handle to the event consumer.
- * @return An indication of success.
+ * \param consumerhandle Handle to the event consumer.
+ * \return An indication of success.
  */
 extern GHOST_TSuccess GHOST_DisposeEventConsumer(GHOST_EventConsumerHandle consumerhandle);
 
-
 /**
  * Returns the system time.
  * Returns the number of milliseconds since the start of the system process.
  * Based on ANSI clock() routine.
- * @param systemhandle The handle to the system
- * @return The number of milliseconds.
+ * \param systemhandle The handle to the system
+ * \return The number of milliseconds.
  */
 extern GHOST_TUns64 GHOST_GetMilliSeconds(GHOST_SystemHandle systemhandle);
 
@@ -105,12 +104,12 @@ extern GHOST_TUns64 GHOST_GetMilliSeconds(GHOST_SystemHandle systemhandle);
  * Installs a timer.
  * Note that, on most operating systems, messages need to be processed in order 
  * for the timer callbacks to be invoked.
- * @param systemhandle The handle to the system
- * @param delay                The time to wait for the first call to the timerProc (in milliseconds)
- * @param interval     The interval between calls to the timerProc (in milliseconds)
- * @param timerProc    The callback invoked when the interval expires,
- * @param userData     Placeholder for user data.
- * @return A timer task (0 if timer task installation failed).
+ * \param systemhandle The handle to the system
+ * \param delay The time to wait for the first call to the timerProc (in milliseconds)
+ * \param interval The interval between calls to the timerProc (in milliseconds)
+ * \param timerProc The callback invoked when the interval expires,
+ * \param userData Placeholder for user data.
+ * \return A timer task (0 if timer task installation failed).
  */
 extern GHOST_TimerTaskHandle GHOST_InstallTimer(GHOST_SystemHandle systemhandle,
                                                 GHOST_TUns64 delay,
@@ -120,9 +119,9 @@ extern GHOST_TimerTaskHandle GHOST_InstallTimer(GHOST_SystemHandle systemhandle,
 
 /**
  * Removes a timer.
- * @param systemhandle The handle to the system
- * @param timerTask Timer task to be removed.
- * @return Indication of success.
+ * \param systemhandle The handle to the system
+ * \param timerTask Timer task to be removed.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_RemoveTimer(GHOST_SystemHandle systemhandle,
                                         GHOST_TimerTaskHandle timertaskhandle);
@@ -133,17 +132,17 @@ extern GHOST_TSuccess GHOST_RemoveTimer(GHOST_SystemHandle systemhandle,
 
 /**
  * Returns the number of displays on this system.
- * @param systemhandle The handle to the system
- * @return The number of displays.
+ * \param systemhandle The handle to the system
+ * \return The number of displays.
  */
 extern GHOST_TUns8 GHOST_GetNumDisplays(GHOST_SystemHandle systemhandle);
 
 /**
  * Returns the dimensions of the main display on this system.
- * @param systemhandle The handle to the system
- * @param width                A pointer the width gets put in
- * @param height       A pointer the height gets put in
- * @return void.
+ * \param systemhandle The handle to the system
+ * \param width A pointer the width gets put in
+ * \param height A pointer the height gets put in
+ * \return void.
  */
 extern void GHOST_GetMainDisplayDimensions(GHOST_SystemHandle systemhandle,
                                            GHOST_TUns32 *width,
@@ -153,17 +152,17 @@ extern void GHOST_GetMainDisplayDimensions(GHOST_SystemHandle systemhandle,
  * Create a new window.
  * The new window is added to the list of windows managed. 
  * Never explicitly delete the window, use disposeWindow() instead.
- * @param systemhandle The handle to the system
- * @param      title   The name of the window (displayed in the title bar of the window if the OS supports it).
- * @param      left    The coordinate of the left edge of the window.
- * @param      top             The coordinate of the top edge of the window.
- * @param      width   The width the window.
- * @param      height  The height the window.
- * @param      state   The state of the window when opened.
- * @param      type    The type of drawing context installed in this window.
- * @param stereoVisual         Stereo visual for quad buffered stereo.
- * @param numOfAASamples       Number of samples used for AA (zero if no AA)
- * @return     A handle to the new window ( == NULL if creation failed).
+ * \param systemhandle The handle to the system
+ * \param title The name of the window (displayed in the title bar of the window if the OS supports it).
+ * \param left The coordinate of the left edge of the window.
+ * \param top The coordinate of the top edge of the window.
+ * \param width The width the window.
+ * \param height The height the window.
+ * \param state The state of the window when opened.
+ * \param type The type of drawing context installed in this window.
+ * \param stereoVisual Stereo visual for quad buffered stereo.
+ * \param numOfAASamples Number of samples used for AA (zero if no AA)
+ * \return A handle to the new window ( == NULL if creation failed).
  */
 extern GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle,
                                              const char *title,
@@ -178,43 +177,43 @@ extern GHOST_WindowHandle GHOST_CreateWindow(GHOST_SystemHandle systemhandle,
 
 /**
  * Returns the window user data.
- * @param windowhandle The handle to the window
- * @return The window user data.
+ * \param windowhandle The handle to the window
+ * \return The window user data.
  */
 extern GHOST_TUserDataPtr GHOST_GetWindowUserData(GHOST_WindowHandle windowhandle);
-       
+
 /**
  * Changes the window user data.
- * @param windowhandle The handle to the window
- * @param data The window user data.
+ * \param windowhandle The handle to the window
+ * \param data The window user data.
  */
 extern void GHOST_SetWindowUserData(GHOST_WindowHandle windowhandle, 
                                     GHOST_TUserDataPtr userdata);
 
 /**
  * Dispose a window.
- * @param systemhandle The handle to the system
- * @param      window Handle to the window to be disposed.
- * @return     Indication of success.
+ * \param systemhandle The handle to the system
+ * \param windowhandle Handle to the window to be disposed.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_DisposeWindow(GHOST_SystemHandle systemhandle,
                                           GHOST_WindowHandle windowhandle);
 
 /**
  * Returns whether a window is valid.
- * @param systemhandle The handle to the system
- * @param      window Handle to the window to be checked.
- * @return     Indication of validity.
+ * \param systemhandle The handle to the system
+ * \param windowhandle Handle to the window to be checked.
+ * \return Indication of validity.
  */
 extern int GHOST_ValidWindow(GHOST_SystemHandle systemhandle,
                              GHOST_WindowHandle windowhandle);
 
 /**
  * Begins full screen mode.
- * @param systemhandle The handle to the system
- * @param setting      The new setting of the display.
- * @return                     A handle to the window displayed in full screen.
- *                                     This window is invalid after full screen has been ended.
+ * \param systemhandle The handle to the system
+ * \param setting The new setting of the display.
+ * \return A handle to the window displayed in full screen.
+ *         This window is invalid after full screen has been ended.
  */
 extern GHOST_WindowHandle GHOST_BeginFullScreen(GHOST_SystemHandle systemhandle,
                                                 GHOST_DisplaySetting *setting,
@@ -222,15 +221,15 @@ extern GHOST_WindowHandle GHOST_BeginFullScreen(GHOST_SystemHandle systemhandle,
 
 /**
  * Ends full screen mode.
- * @param systemhandle The handle to the system
- * @return     Indication of success.
+ * \param systemhandle The handle to the system
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_EndFullScreen(GHOST_SystemHandle systemhandle);
 
 /**
  * Returns current full screen mode status.
- * @param systemhandle The handle to the system
- * @return The current status.
+ * \param systemhandle The handle to the system
+ * \return The current status.
  */
 extern int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle);
 
@@ -240,34 +239,34 @@ extern int GHOST_GetFullScreen(GHOST_SystemHandle systemhandle);
 
 /**
  * Retrieves events from the system and stores them in the queue.
- * @param systemhandle The handle to the system
- * @param waitForEvent Boolean to indicate that ProcessEvents should
+ * \param systemhandle The handle to the system
+ * \param waitForEvent Boolean to indicate that ProcessEvents should
  * wait (block) until the next event before returning.
- * @return Indication of the presence of events.
+ * \return Indication of the presence of events.
  */
 extern int GHOST_ProcessEvents(GHOST_SystemHandle systemhandle, int waitForEvent);
 
 /**
  * Retrieves events from the queue and send them to the event consumers.
- * @param systemhandle The handle to the system
- * @return Indication of the presence of events.
+ * \param systemhandle The handle to the system
+ * \return Indication of the presence of events.
  */
 extern int GHOST_DispatchEvents(GHOST_SystemHandle systemhandle);
 
 /**
  * Adds the given event consumer to our list.
- * @param systemhandle The handle to the system
- * @param consumerhandle The event consumer to add.
- * @return Indication of success.
+ * \param systemhandle The handle to the system
+ * \param consumerhandle The event consumer to add.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_AddEventConsumer(GHOST_SystemHandle systemhandle,
                                              GHOST_EventConsumerHandle consumerhandle);
 
 /**
  * Remove the given event consumer to our list.
- * @param systemhandle The handle to the system
- * @param consumerhandle The event consumer to remove.
- * @return Indication of success.
+ * \param systemhandle The handle to the system
+ * \param consumerhandle The event consumer to remove.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_RemoveEventConsumer(GHOST_SystemHandle systemhandle,
                                                 GHOST_EventConsumerHandle consumerhandle);
@@ -278,14 +277,14 @@ extern GHOST_TSuccess GHOST_RemoveEventConsumer(GHOST_SystemHandle systemhandle,
 
 /**
  * Sets the progress bar value displayed in the window/application icon
- * @param windowhandle The handle to the window
- * @param progress The progress % (0.0 to 1.0)
+ * \param windowhandle The handle to the window
+ * \param progress The progress % (0.0 to 1.0)
  */
 extern GHOST_TSuccess GHOST_SetProgressBar(GHOST_WindowHandle windowhandle, float progress);
 
 /**
  * Hides the progress bar in the icon
- * @param windowhandle The handle to the window
+ * \param windowhandle The handle to the window
  */
 extern GHOST_TSuccess GHOST_EndProgressBar(GHOST_WindowHandle windowhandle);
 
@@ -295,28 +294,28 @@ extern GHOST_TSuccess GHOST_EndProgressBar(GHOST_WindowHandle windowhandle);
 
 /**
  * Returns the current cursor shape.
- * @param windowhandle The handle to the window
- * @return     The current cursor shape.
+ * \param windowhandle The handle to the window
+ * \return The current cursor shape.
  */
 extern GHOST_TStandardCursor GHOST_GetCursorShape(GHOST_WindowHandle windowhandle);
 
 /**
  * Set the shape of the cursor.
- * @param windowhandle The handle to the window
- * @param      cursor  The new cursor shape type id.
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param cursor The new cursor shape type id.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetCursorShape(GHOST_WindowHandle windowhandle,
                                            GHOST_TStandardCursor cursorshape);
 
 /**
  * Set the shape of the cursor to a custom cursor.
- * @param windowhandle The handle to the window
- * @param      bitmap  The bitmap data for the cursor.
- * @param      mask    The mask data for the cursor.
- * @param      hotX    The X coordinate of the cursor hotspot.
- * @param      hotY    The Y coordinate of the cursor hotspot.
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param bitmap The bitmap data for the cursor.
+ * \param  mask The mask data for the cursor.
+ * \param hotX The X coordinate of the cursor hotspot.
+ * \param hotY The Y coordinate of the cursor hotspot.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetCustomCursorShape(GHOST_WindowHandle windowhandle,
                                                  GHOST_TUns8 bitmap[16][2],
@@ -325,15 +324,15 @@ extern GHOST_TSuccess GHOST_SetCustomCursorShape(GHOST_WindowHandle windowhandle
                                                  int hotY);
 /**
  * Set the shape of the cursor to a custom cursor of specified size.
- * @param windowhandle The handle to the window
- * @param      bitmap  The bitmap data for the cursor.
- * @param      mask    The mask data for the cursor.
- * @param      sizex   The width of the cursor
- * @param      sizey   The height of the cursor
- * @param      hotX    The X coordinate of the cursor hotspot.
- * @param      hotY    The Y coordinate of the cursor hotspot.
- * @param   fg_color, bg_color  Colors of the cursor
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param bitmap The bitmap data for the cursor.
+ * \param mask The mask data for the cursor.
+ * \param sizex The width of the cursor
+ * \param sizey The height of the cursor
+ * \param hotX The X coordinate of the cursor hotspot.
+ * \param hotY The Y coordinate of the cursor hotspot.
+ * \param   fg_color, bg_color  Colors of the cursor
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetCustomCursorShapeEx(GHOST_WindowHandle windowhandle,
                                                    GHOST_TUns8 *bitmap,
@@ -344,26 +343,26 @@ extern GHOST_TSuccess GHOST_SetCustomCursorShapeEx(GHOST_WindowHandle windowhand
 
 /**
  * Returns the visibility state of the cursor.
- * @param windowhandle The handle to the window
- * @return     The visibility state of the cursor.
+ * \param windowhandle The handle to the window
+ * \return The visibility state of the cursor.
  */
 extern int GHOST_GetCursorVisibility(GHOST_WindowHandle windowhandle);
 
 /**
  * Shows or hides the cursor.
- * @param windowhandle The handle to the window
- * @param      visible The new visibility state of the cursor.
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param visible The new visibility state of the cursor.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetCursorVisibility(GHOST_WindowHandle windowhandle,
                                                 int visible);
 
 /**
  * Returns the current location of the cursor (location in screen coordinates)
- * @param systemhandle The handle to the system
- * @param x                    The x-coordinate of the cursor.
- * @param y                    The y-coordinate of the cursor.
- * @return                     Indication of success.
+ * \param systemhandle The handle to the system
+ * \param x The x-coordinate of the cursor.
+ * \param y The y-coordinate of the cursor.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_GetCursorPosition(GHOST_SystemHandle systemhandle,
                                               GHOST_TInt32 *x,
@@ -372,10 +371,10 @@ extern GHOST_TSuccess GHOST_GetCursorPosition(GHOST_SystemHandle systemhandle,
 /**
  * Updates the location of the cursor (location in screen coordinates).
  * Not all operating systems allow the cursor to be moved (without the input device being moved).
- * @param systemhandle The handle to the system
- * @param x                    The x-coordinate of the cursor.
- * @param y                    The y-coordinate of the cursor.
- * @return                     Indication of success.
+ * \param systemhandle The handle to the system
+ * \param x The x-coordinate of the cursor.
+ * \param y The y-coordinate of the cursor.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetCursorPosition(GHOST_SystemHandle systemhandle,
                                               GHOST_TInt32 x,
@@ -385,10 +384,10 @@ extern GHOST_TSuccess GHOST_SetCursorPosition(GHOST_SystemHandle systemhandle,
  * Grabs the cursor for a modal operation, to keep receiving
  * events when the mouse is outside the window. X11 only, others
  * do this automatically.
- * @param windowhandle The handle to the window
- * @param      mode The new grab state of the cursor.
- * @param      bounds The grab ragion (optional) - left,top,right,bottom
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param mode The new grab state of the cursor.
+ * \param bounds The grab ragion (optional) - left,top,right,bottom
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetCursorGrab(GHOST_WindowHandle windowhandle,
                                           GHOST_TGrabCursorMode mode,
@@ -400,10 +399,10 @@ extern GHOST_TSuccess GHOST_SetCursorGrab(GHOST_WindowHandle windowhandle,
 
 /**
  * Returns the state of a modifier key (ouside the message queue).
- * @param systemhandle The handle to the system
- * @param mask         The modifier key state to retrieve.
- * @param isDown       Pointer to return modifier state in.
- * @return                     Indication of success.
+ * \param systemhandle The handle to the system
+ * \param mask The modifier key state to retrieve.
+ * \param isDown Pointer to return modifier state in.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_GetModifierKeyState(GHOST_SystemHandle systemhandle,
                                                 GHOST_TModifierKeyMask mask,
@@ -411,10 +410,10 @@ extern GHOST_TSuccess GHOST_GetModifierKeyState(GHOST_SystemHandle systemhandle,
 
 /**
  * Returns the state of a mouse button (ouside the message queue).
- * @param systemhandle The handle to the system
- * @param mask         The button state to retrieve.
- * @param isDown       Pointer to return button state in.
- * @return                     Indication of success.
+ * \param systemhandle The handle to the system
+ * \param mask The button state to retrieve.
+ * \param isDown Pointer to return button state in.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
                                            GHOST_TButtonMask mask,
@@ -429,94 +428,93 @@ extern GHOST_TSuccess GHOST_GetButtonState(GHOST_SystemHandle systemhandle,
  * Tells if the ongoing drag'n'drop object can be accepted upon mouse drop
  */
 extern void GHOST_setAcceptDragOperation(GHOST_WindowHandle windowhandle, GHOST_TInt8 canAccept);
-       
-       
+
 /**
  * Returns the event type.
- * @param eventhandle The handle to the event
- * @return The event type.
+ * \param eventhandle The handle to the event
+ * \return The event type.
  */
 extern GHOST_TEventType GHOST_GetEventType(GHOST_EventHandle eventhandle);
 
 /**
  * Returns the time this event was generated.
- * @param eventhandle The handle to the event
- * @return The event generation time.
+ * \param eventhandle The handle to the event
+ * \return The event generation time.
  */
 extern GHOST_TUns64 GHOST_GetEventTime(GHOST_EventHandle eventhandle);
 
 /**
  * Returns the window this event was generated on, 
  * or NULL if it is a 'system' event.
- * @param eventhandle The handle to the event
- * @return The generating window.
+ * \param eventhandle The handle to the event
+ * \return The generating window.
  */
 extern GHOST_WindowHandle GHOST_GetEventWindow(GHOST_EventHandle eventhandle);
 
 /**
  * Returns the event data.
- * @param eventhandle The handle to the event
- * @return The event data.
+ * \param eventhandle The handle to the event
+ * \return The event data.
  */
 extern GHOST_TEventDataPtr GHOST_GetEventData(GHOST_EventHandle eventhandle);
 
 /**
  * Returns the timer callback.
- * @param timertaskhandle      The handle to the timertask
- * @return The timer callback.
+ * \param timertaskhandle The handle to the timertask
+ * \return The timer callback.
  */
 extern GHOST_TimerProcPtr GHOST_GetTimerProc(GHOST_TimerTaskHandle timertaskhandle);
 
 /**
  * Changes the timer callback.
- * @param timertaskhandle The handle to the timertask
- * @param timerProc The timer callback.
+ * \param timertaskhandle The handle to the timertask
+ * \param timerProc The timer callback.
  */
 extern void GHOST_SetTimerProc(GHOST_TimerTaskHandle timertaskhandle,
                                GHOST_TimerProcPtr timerProc);
 
 /**
  * Returns the timer user data.
- * @param timertaskhandle      The handle to the timertask
- * @return The timer user data.
+ * \param timertaskhandle The handle to the timertask
+ * \return The timer user data.
  */
 extern GHOST_TUserDataPtr GHOST_GetTimerTaskUserData(GHOST_TimerTaskHandle timertaskhandle);
-       
+
 /**
  * Changes the time user data.
- * @param timertaskhandle      The handle to the timertask
- * @param data The timer user data.
+ * \param timertaskhandle The handle to the timertask
+ * \param data The timer user data.
  */
 extern void GHOST_SetTimerTaskUserData(GHOST_TimerTaskHandle timertaskhandle,
                                        GHOST_TUserDataPtr userData);
 
 /**
  * Returns indication as to whether the window is valid.
- * @param windowhandle The handle to the window
- * @return The validity of the window.
+ * \param windowhandle The handle to the window
+ * \return The validity of the window.
  */
 extern int GHOST_GetValid(GHOST_WindowHandle windowhandle);
 
 /**
  * Returns the type of drawing context used in this window.
- * @param windowhandle The handle to the window
- * @return The current type of drawing context.
+ * \param windowhandle The handle to the window
+ * \return The current type of drawing context.
  */
 extern GHOST_TDrawingContextType GHOST_GetDrawingContextType(GHOST_WindowHandle windowhandle);
 
 /**
  * Tries to install a rendering context in this window.
- * @param windowhandle The handle to the window
- * @param type The type of rendering context installed.
- * @return Indication as to whether installation has succeeded.
+ * \param windowhandle The handle to the window
+ * \param type The type of rendering context installed.
+ * \return Indication as to whether installation has succeeded.
  */
 extern GHOST_TSuccess GHOST_SetDrawingContextType(GHOST_WindowHandle windowhandle,
                                                   GHOST_TDrawingContextType type);
 
 /**
  * Sets the title displayed in the title bar.
- * @param windowhandle The handle to the window
- * @param title        The title to display in the title bar.
+ * \param windowhandle The handle to the window
+ * \param title The title to display in the title bar.
  */
 extern void GHOST_SetTitle(GHOST_WindowHandle windowhandle,
                            const char *title);
@@ -525,57 +523,57 @@ extern void GHOST_SetTitle(GHOST_WindowHandle windowhandle,
  * Returns the title displayed in the title bar. The title
  * should be free'd with free().
  * 
- * @param windowhandle The handle to the window
- * @return The title, free with free().
+ * \param windowhandle The handle to the window
+ * \return The title, free with free().
  */
 extern char *GHOST_GetTitle(GHOST_WindowHandle windowhandle);
 
 /**
  * Returns the window rectangle dimensions.
  * These are screen coordinates.
- * @param windowhandle The handle to the window
- * @return A handle to the bounding rectangle of the window.
+ * \param windowhandle The handle to the window
+ * \return A handle to the bounding rectangle of the window.
  */
 extern GHOST_RectangleHandle GHOST_GetWindowBounds(GHOST_WindowHandle windowhandle);
 
 /**
  * Returns the client rectangle dimensions.
  * The left and top members of the rectangle are always zero.
- * @param windowhandle The handle to the window
- * @return A handle to the bounding rectangle of the window.
+ * \param windowhandle The handle to the window
+ * \return A handle to the bounding rectangle of the window.
  */
 extern GHOST_RectangleHandle GHOST_GetClientBounds(GHOST_WindowHandle windowhandle);
 
 /**
  * Disposes a rectangle object
- * @param rectanglehandle      Handle to the rectangle.
+ * \param rectanglehandle Handle to the rectangle.
  */
 void GHOST_DisposeRectangle(GHOST_RectangleHandle rectanglehandle);
 
 /**
  * Resizes client rectangle width.
- * @param windowhandle The handle to the window
- * @param width The new width of the client area of the window.
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param width The new width of the client area of the window.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetClientWidth(GHOST_WindowHandle windowhandle,
                                            GHOST_TUns32 width);
 
 /**
  * Resizes client rectangle height.
- * @param windowhandle The handle to the window
- * @param height The new height of the client area of the window.
- * @return     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param height The new height of the client area of the window.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetClientHeight(GHOST_WindowHandle windowhandle,
                                             GHOST_TUns32 height);
 
 /**
  * Resizes client rectangle.
- * @param windowhandle The handle to the window
- * @param width                The new width of the client area of the window.
- * @param height       The new height of the client area of the window.
- * @return                     Indication of success.
+ * \param windowhandle The handle to the window
+ * \param width The new width of the client area of the window.
+ * \param height The new height of the client area of the window.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetClientSize(GHOST_WindowHandle windowhandle,
                                           GHOST_TUns32 width,
@@ -583,11 +581,11 @@ extern GHOST_TSuccess GHOST_SetClientSize(GHOST_WindowHandle windowhandle,
 
 /**
  * Converts a point in screen coordinates to client rectangle coordinates
- * @param windowhandle The handle to the window
- * @param inX  The x-coordinate on the screen.
- * @param inY  The y-coordinate on the screen.
- * @param outX The x-coordinate in the client rectangle.
- * @param outY The y-coordinate in the client rectangle.
+ * \param windowhandle The handle to the window
+ * \param inX The x-coordinate on the screen.
+ * \param inY The y-coordinate on the screen.
+ * \param outX The x-coordinate in the client rectangle.
+ * \param outY The y-coordinate in the client rectangle.
  */
 extern void GHOST_ScreenToClient(GHOST_WindowHandle windowhandle,
                                  GHOST_TInt32 inX,
@@ -597,11 +595,11 @@ extern void GHOST_ScreenToClient(GHOST_WindowHandle windowhandle,
 
 /**
  * Converts a point in screen coordinates to client rectangle coordinates
- * @param windowhandle The handle to the window
- * @param inX  The x-coordinate in the client rectangle.
- * @param inY  The y-coordinate in the client rectangle.
- * @param outX The x-coordinate on the screen.
- * @param outY The y-coordinate on the screen.
+ * \param windowhandle The handle to the window
+ * \param inX The x-coordinate in the client rectangle.
+ * \param inY The y-coordinate in the client rectangle.
+ * \param outX The x-coordinate on the screen.
+ * \param outY The y-coordinate on the screen.
  */
 extern void GHOST_ClientToScreen(GHOST_WindowHandle windowhandle,
                                  GHOST_TInt32 inX,
@@ -611,88 +609,88 @@ extern void GHOST_ClientToScreen(GHOST_WindowHandle windowhandle,
 
 /**
  * Returns the state of the window (normal, minimized, maximized).
- * @param windowhandle The handle to the window
- * @return The state of the window.
+ * \param windowhandle The handle to the window
+ * \return The state of the window.
  */
 extern GHOST_TWindowState GHOST_GetWindowState(GHOST_WindowHandle windowhandle);
 
 /**
  * Sets the state of the window (normal, minimized, maximized).
- * @param windowhandle The handle to the window
- * @param state The state of the window.
- * @return Indication of success.
+ * \param windowhandle The handle to the window
+ * \param state The state of the window.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetWindowState(GHOST_WindowHandle windowhandle,
                                            GHOST_TWindowState state);
 
-       
+
 /**
  * Sets the window "modified" status, indicating unsaved changes
- * @param windowhandle The handle to the window
- * @param isUnsavedChanges Unsaved changes or not
- * @return Indication of success.
+ * \param windowhandle The handle to the window
+ * \param isUnsavedChanges Unsaved changes or not
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetWindowModifiedState(GHOST_WindowHandle windowhandle,
                                                    GHOST_TUns8 isUnsavedChanges);
-       
+
 /**
  * Sets the order of the window (bottom, top).
- * @param windowhandle The handle to the window
- * @param order The order of the window.
- * @return Indication of success.
+ * \param windowhandle The handle to the window
+ * \param order The order of the window.
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_SetWindowOrder(GHOST_WindowHandle windowhandle,
                                            GHOST_TWindowOrder order);
 
 /**
  * Swaps front and back buffers of a window.
- * @param windowhandle The handle to the window
- * @return     An intean success indicator.
+ * \param windowhandle The handle to the window
+ * \return An intean success indicator.
  */
 extern GHOST_TSuccess GHOST_SwapWindowBuffers(GHOST_WindowHandle windowhandle);
 
 /**
  * Activates the drawing context of this window.
- * @param windowhandle The handle to the window
- * @return     An intean success indicator.
+ * \param windowhandle The handle to the window
+ * \return An intean success indicator.
  */
 extern GHOST_TSuccess GHOST_ActivateWindowDrawingContext(GHOST_WindowHandle windowhandle);
 
 /**
  * Invalidates the contents of this window.
- * @param windowhandle The handle to the window
- * @return Indication of success.
+ * \param windowhandle The handle to the window
+ * \return Indication of success.
  */
 extern GHOST_TSuccess GHOST_InvalidateWindow(GHOST_WindowHandle windowhandle);
 
 /**
  * Returns the status of the tablet
- * @param windowhandle The handle to the window
- * @return Status of tablet
+ * \param windowhandle The handle to the window
+ * \return Status of tablet
  */
 extern const GHOST_TabletData *GHOST_GetTabletData(GHOST_WindowHandle windowhandle);
 
 /**
  * Access to rectangle width.
- * @param rectanglehandle The handle to the rectangle
- * @return     width of the rectangle
+ * \param rectanglehandle The handle to the rectangle
+ * \return width of the rectangle
  */
 extern GHOST_TInt32 GHOST_GetWidthRectangle(GHOST_RectangleHandle rectanglehandle);
 
 /**
  * Access to rectangle height.
- * @param rectanglehandle The handle to the rectangle
- * @return     height of the rectangle
+ * \param rectanglehandle The handle to the rectangle
+ * \return height of the rectangle
  */
 extern GHOST_TInt32 GHOST_GetHeightRectangle(GHOST_RectangleHandle rectanglehandle);
 
 /**
  * Gets all members of the rectangle.
- * @param rectanglehandle The handle to the rectangle
- * @param      l       Pointer to return left coordinate in.
- * @param      t       Pointer to return top coordinate in.
- * @param      r       Pointer to return right coordinate in.
- * @param      b       Pointer to return bottom coordinate in.
+ * \param rectanglehandle The handle to the rectangle
+ * \param l Pointer to return left coordinate in.
+ * \param t Pointer to return top coordinate in.
+ * \param r Pointer to return right coordinate in.
+ * \param b Pointer to return bottom coordinate in.
  */
 extern void GHOST_GetRectangle(GHOST_RectangleHandle rectanglehandle,
                                GHOST_TInt32 *l,
@@ -702,11 +700,11 @@ extern void GHOST_GetRectangle(GHOST_RectangleHandle rectanglehandle,
 
 /**
  * Sets all members of the rectangle.
- * @param rectanglehandle The handle to the rectangle
- * @param      l       requested left coordinate of the rectangle
- * @param      t       requested top coordinate of the rectangle
- * @param      r       requested right coordinate of the rectangle
- * @param      b       requested bottom coordinate of the rectangle
+ * \param rectanglehandle The handle to the rectangle
+ * \param l requested left coordinate of the rectangle
+ * \param t requested top coordinate of the rectangle
+ * \param r requested right coordinate of the rectangle
+ * \param b requested bottom coordinate of the rectangle
  */
 extern void GHOST_SetRectangle(GHOST_RectangleHandle rectanglehandle,
                                GHOST_TInt32 l,
@@ -717,24 +715,24 @@ extern void GHOST_SetRectangle(GHOST_RectangleHandle rectanglehandle,
 /**
  * Returns whether this rectangle is empty.
  * Empty rectangles are rectangles that have width==0 and/or height==0.
- * @param rectanglehandle The handle to the rectangle
- * @return     intean value (true == empty rectangle)
+ * \param rectanglehandle The handle to the rectangle
+ * \return intean value (true == empty rectangle)
  */
 extern GHOST_TSuccess GHOST_IsEmptyRectangle(GHOST_RectangleHandle rectanglehandle);
 
 /**
  * Returns whether this rectangle is valid.
  * Valid rectangles are rectangles that have m_l <= m_r and m_t <= m_b. Thus, emapty rectangles are valid.
- * @param rectanglehandle The handle to the rectangle
- * @return     intean value (true==valid rectangle)
+ * \param rectanglehandle The handle to the rectangle
+ * \return intean value (true == valid rectangle)
  */
 extern GHOST_TSuccess GHOST_IsValidRectangle(GHOST_RectangleHandle rectanglehandle);
 
 /**
  * Grows (or shrinks the rectangle).
  * The method avoids negative insets making the rectangle invalid
- * @param rectanglehandle The handle to the rectangle
- * @param      i       The amount of offset given to each extreme (negative values shrink the rectangle).
+ * \param rectanglehandle The handle to the rectangle
+ * \param i The amount of offset given to each extreme (negative values shrink the rectangle).
  */
 extern void GHOST_InsetRectangle(GHOST_RectangleHandle rectanglehandle,
                                  GHOST_TInt32 i);
@@ -742,17 +740,17 @@ extern void GHOST_InsetRectangle(GHOST_RectangleHandle rectanglehandle,
 /**
  * Does a union of the rectangle given and this rectangle.
  * The result is stored in this rectangle.
- * @param rectanglehandle The handle to the rectangle
- * @param      r       The rectangle that is input for the union operation.
+ * \param rectanglehandle The handle to the rectangle
+ * \param anotherrectanglehandle The rectangle that is input for the union operation.
  */
 extern void GHOST_UnionRectangle(GHOST_RectangleHandle rectanglehandle,
                                  GHOST_RectangleHandle anotherrectanglehandle);
 
 /**
  * Grows the rectangle to included a point.
- * @param rectanglehandle The handle to the rectangle
- * @param      x       The x-coordinate of the point.
- * @param      y       The y-coordinate of the point.
+ * \param rectanglehandle The handle to the rectangle
+ * \param x The x-coordinate of the point.
+ * \param y The y-coordinate of the point.
  */
 extern void GHOST_UnionPointRectangle(GHOST_RectangleHandle rectanglehandle,
                                       GHOST_TInt32 x,
@@ -761,10 +759,10 @@ extern void GHOST_UnionPointRectangle(GHOST_RectangleHandle rectanglehandle,
 /**
  * Returns whether the point is inside this rectangle.
  * Point on the boundary is considered inside.
- * @param rectanglehandle The handle to the rectangle
- * @param x    x-coordinate of point to test.
- * @param y y-coordinate of point to test.
- * @return intean value (true if point is inside).
+ * \param rectanglehandle The handle to the rectangle
+ * \param x x-coordinate of point to test.
+ * \param y y-coordinate of point to test.
+ * \return intean value (true if point is inside).
  */
 extern GHOST_TSuccess GHOST_IsInsideRectangle(GHOST_RectangleHandle rectanglehandle,
                                               GHOST_TInt32 x,
@@ -772,9 +770,9 @@ extern GHOST_TSuccess GHOST_IsInsideRectangle(GHOST_RectangleHandle rectanglehan
 
 /**
  * Returns whether the rectangle is inside this rectangle.
- * @param rectanglehandle The handle to the rectangle
- * @param      r       rectangle to test.
- * @return     visibility (not, partially or fully visible).
+ * \param rectanglehandle The handle to the rectangle
+ * \param anotherrectanglehandle The rectangle to test.
+ * \return visibility (not, partially or fully visible).
  */
 extern GHOST_TVisibility GHOST_GetRectangleVisibility(GHOST_RectangleHandle rectanglehandle,
                                                       GHOST_RectangleHandle anotherrectanglehandle);
@@ -782,9 +780,9 @@ extern GHOST_TVisibility GHOST_GetRectangleVisibility(GHOST_RectangleHandle rect
 /**
  * Sets rectangle members.
  * Sets rectangle members such that it is centered at the given location.
- * @param rectanglehandle The handle to the rectangle
- * @param      cx      requested center x-coordinate of the rectangle
- * @param      cy      requested center y-coordinate of the rectangle
+ * \param rectanglehandle The handle to the rectangle
+ * \param cx Requested center x-coordinate of the rectangle
+ * \param cy Requested center y-coordinate of the rectangle
  */
 extern void GHOST_SetCenterRectangle(GHOST_RectangleHandle rectanglehandle,
                                      GHOST_TInt32 cx,
@@ -794,11 +792,11 @@ extern void GHOST_SetCenterRectangle(GHOST_RectangleHandle rectanglehandle,
  * Sets rectangle members.
  * Sets rectangle members such that it is centered at the given location,
  * with the width requested.
- * @param rectanglehandle The handle to the rectangle
- * @param      cx      requested center x-coordinate of the rectangle
- * @param      cy      requested center y-coordinate of the rectangle
- * @param      w       requested width of the rectangle
- * @param      h       requested height of the rectangle
+ * \param rectanglehandle The handle to the rectangle
+ * \param cx requested center x-coordinate of the rectangle
+ * \param cy requested center y-coordinate of the rectangle
+ * \param w requested width of the rectangle
+ * \param h requested height of the rectangle
  */
 extern void GHOST_SetRectangleCenter(GHOST_RectangleHandle rectanglehandle,
                                      GHOST_TInt32 cx,
@@ -810,23 +808,23 @@ extern void GHOST_SetRectangleCenter(GHOST_RectangleHandle rectanglehandle,
  * Clips a rectangle.
  * Updates the rectangle given such that it will fit within this one.
  * This can result in an empty rectangle.
- * @param rectanglehandle The handle to the rectangle
- * @param      r       the rectangle to clip
- * @return     whether clipping has occurred
+ * \param rectanglehandle The handle to the rectangle
+ * \param anotherrectanglehandle The rectangle to clip
+ * \return Whether clipping has occurred
  */
 extern GHOST_TSuccess GHOST_ClipRectangle(GHOST_RectangleHandle rectanglehandle,
                                           GHOST_RectangleHandle anotherrectanglehandle);
 
 /**
  * Return the data from the clipboad
- * @param      return the selection instead, X11 only feature
- * @return     clipboard data
+ * \param selection Boolean to return the selection instead, X11 only feature.
+ * \return clipboard data
  */
 extern GHOST_TUns8 *GHOST_getClipboard(int selection);
 
 /**
  * Put data to the Clipboard
- * @param      set the selection instead, X11 only feature
+ * \param set the selection instead, X11 only feature
  */
 extern void GHOST_putClipboard(GHOST_TInt8 *buffer, int selection);
 
@@ -834,12 +832,13 @@ extern void GHOST_putClipboard(GHOST_TInt8 *buffer, int selection);
 
 /**
  * Toggles console
- * @action     0 - Hides
- *                     1 - Shows
- *                     2 - Toggles
- *                     3 - Hides if it runs not from  command line
- *                     * - Does nothing
- * @return current status (1 -visible, 0 - hidden)
+ * \param action
+ * - 0: Hides
+ * - 1: Shows
+ * - 2: Toggles
+ * - 3: Hides if it runs not from  command line
+ * - *: Does nothing
+ * \return current status (1 -visible, 0 - hidden)
  */
 extern int GHOST_toggleConsole(int action);
 
index 119cb6eaff007a5e19ce4a0e782f215f322dd883..711a70ff2600f09b8ca4d95687f35b6c14caf7e1 100644 (file)
@@ -73,4 +73,4 @@ set(SRC
        intern/TNT/version.h
 )
 
-blender_add_lib(bf_intern_ik "${SRC}" "${INC}" "${INC_SYS}")
+blender_add_lib(bf_intern_iksolver "${SRC}" "${INC}" "${INC_SYS}")
index bdf7cd350ffc513e4ee0b9586ec6a483990c9f71..b88d3b1b71378d6866bc85beacdbf20a1aa01a8e 100644 (file)
@@ -5,5 +5,5 @@ sources = env.Glob('intern/*.cpp')
 
 incs = 'intern ../moto/include ../memutil'
 
-env.BlenderLib ('bf_intern_ik', sources, Split(incs), [], libtype=['intern','player'], priority=[100,90] )
+env.BlenderLib ('bf_intern_iksolver', sources, Split(incs), [], libtype=['intern','player'], priority=[100,90] )
 
index f1313b583f764720ba923c11bb04e74db279bb57..41fe052c434b36eabdc73d832b974521dcf72d65 100644 (file)
@@ -256,7 +256,7 @@ def module_names(path, recursive=False):
         elif filename.endswith(".py") and filename != "__init__.py":
             fullpath = join(path, filename)
             modules.append((filename[0:-3], fullpath))
-        elif ("." not in filename):
+        elif "." not in filename:
             directory = join(path, filename)
             fullpath = join(directory, "__init__.py")
             if isfile(fullpath):
index a15688200b06d2a1bc29b5a3cf7893be76115dcc..ee005fcb8bb276a26a9773e3fb7a35c52f17aaad 100644 (file)
@@ -100,10 +100,10 @@ class NODE_OT_add_search(Operator):
 
         # Enum item identifier has an additional prefix to distinguish base node types from node groups
         item = self.type
-        if (item.startswith(node_type_prefix)):
+        if item.startswith(node_type_prefix):
             # item means base node type
             node = tree.nodes.new(type=item[len(node_type_prefix):])
-        elif (item.startswith(node_group_prefix)):
+        elif item.startswith(node_group_prefix):
             # item means node group type
             node = tree.nodes.new(type='GROUP', group=bpy.data.node_groups[item[len(node_group_prefix):]])
         else:
index 3011f55fcb32bcacd294e295d5f0e4a375df221e..2d15c534e9f2ad294ef4199ab83b4d6e0a2b2ccf 100644 (file)
@@ -44,10 +44,10 @@ class MotionPathButtonsPanel():
         col = split.column()
         col.label(text="Display Range:")
         sub = col.column(align=True)
-        if (mps.type == 'CURRENT_FRAME'):
+        if mps.type == 'CURRENT_FRAME':
             sub.prop(mps, "frame_before", text="Before")
             sub.prop(mps, "frame_after", text="After")
-        elif (mps.type == 'RANGE'):
+        elif mps.type == 'RANGE':
             sub.prop(mps, "frame_start", text="Start")
             sub.prop(mps, "frame_end", text="End")
 
index 1e9fd5dd8a9aefc0966a0f4ee37a1c4cfd8a71db..a8f4aa30e95efc30ab63068294aeb4636ed98218 100644 (file)
@@ -106,7 +106,7 @@ class DATA_PT_shape_curve(CurveButtonsPanel, Panel):
             sub.prop(curve, "resolution_v", text="Preview V")
             sub.prop(curve, "render_resolution_v", text="Render V")
 
-        if (is_curve or is_text):
+        if is_curve or is_text:
             col.label(text="Fill:")
             sub = col.column()
             sub.active = (curve.dimensions == '2D' or (curve.bevel_object is None and curve.dimensions == '3D'))
index 25b855918733f9413b24de51620a91afe45fc2cb..769715ef1b9a77d67bfd877e185fc241c273d1e5 100644 (file)
@@ -322,9 +322,9 @@ class DATA_PT_area(DataButtonsPanel, Panel):
         col.row().prop(lamp, "shape", expand=True)
         sub = col.row(align=True)
 
-        if (lamp.shape == 'SQUARE'):
+        if lamp.shape == 'SQUARE':
             sub.prop(lamp, "size")
-        elif (lamp.shape == 'RECTANGLE'):
+        elif lamp.shape == 'RECTANGLE':
             sub.prop(lamp, "size", text="Size X")
             sub.prop(lamp, "size_y", text="Size Y")
 
index bb25f8fa0763b9929e229fd5b871cd0c71d25ad1..67980c388b5d3a41a3d7cd7c143dd84f5ef71355 100644 (file)
@@ -223,7 +223,7 @@ class MASK_PT_tools():
         col.operator("transform.translate")
         col.operator("transform.rotate")
         col.operator("transform.resize", text="Scale")
-        props = col.operator("transform.transform", text="Shrink/Fatten")
+        props = col.operator("transform.transform", text="Scale Feather")
         props.mode = 'MASK_SHRINKFATTEN'
 
         col = layout.column(align=True)
@@ -291,7 +291,7 @@ class MASK_MT_transform(Menu):
         layout.operator("transform.translate")
         layout.operator("transform.rotate")
         layout.operator("transform.resize")
-        props = layout.operator("transform.transform", text="Shrink/Fatten")
+        props = layout.operator("transform.transform", text="Scale Feather")
         props.mode = 'MASK_SHRINKFATTEN'
 
 
index 8d220e5aae63386d269c8616981d2975257883f3..2c9bcefd2f831ce45a5479f407cc8e86069f4d21 100644 (file)
@@ -1008,7 +1008,7 @@ class PARTICLE_PT_draw(ParticleButtonsPanel, Panel):
         sub.active = (part.draw_color in {'VELOCITY', 'ACCELERATION'})
         sub.prop(part, "color_maximum", text="Max")
 
-        if (path):
+        if path:
             col.prop(part, "draw_step")
 
 
index 70499b18f41d20389e3dff47d4989c1c8d50d6c8..569037cb0da0233c64e07b204680502d8212c5a2 100644 (file)
@@ -92,7 +92,7 @@ class PHYSICS_PT_field(PhysicButtonsPanel, Panel):
             layout.separator()
 
             layout.prop(field, "guide_kink_type")
-            if (field.guide_kink_type != 'NONE'):
+            if field.guide_kink_type != 'NONE':
                 layout.prop(field, "guide_kink_axis")
 
                 split = layout.split()
index bcadd47cea3a28542c59e85be6396cf2ce57e07d..c5034ae403497514388af72ab96f8093e3fc5453 100644 (file)
@@ -497,7 +497,7 @@ class SEQUENCER_PT_effect(SequencerButtonsPanel, Panel):
 
             col = layout.column(align=True)
             col.prop(strip, "use_uniform_scale")
-            if (strip.use_uniform_scale):
+            if strip.use_uniform_scale:
                 col = layout.column(align=True)
                 col.prop(strip, "scale_start_x", text="Scale")
             else:
index e7dd9fb47515ccf306b3a17cc2e235ab76c7257f..b0b587056b1345ca0b997c45b30858401470a8d4 100644 (file)
@@ -858,6 +858,7 @@ class USERPREF_MT_ndof_settings(Menu):
 
         layout.separator()
         layout.prop(input_prefs, "ndof_sensitivity")
+        layout.prop(input_prefs, "ndof_orbit_sensitivity")
 
         if context.space_data.type == 'VIEW_3D':
             layout.separator()
@@ -865,11 +866,10 @@ class USERPREF_MT_ndof_settings(Menu):
 
             layout.separator()
             layout.label(text="Orbit options")
-            if input_prefs.view_rotate_method == 'TRACKBALL':
-                layout.prop(input_prefs, "ndof_roll_invert_axis")
+            layout.prop(input_prefs, "ndof_turntable")
+            layout.prop(input_prefs, "ndof_roll_invert_axis")
             layout.prop(input_prefs, "ndof_tilt_invert_axis")
             layout.prop(input_prefs, "ndof_rotate_invert_axis")
-            layout.prop(input_prefs, "ndof_zoom_invert")
 
             layout.separator()
             layout.label(text="Pan options")
@@ -878,6 +878,7 @@ class USERPREF_MT_ndof_settings(Menu):
             layout.prop(input_prefs, "ndof_panz_invert_axis")
 
             layout.label(text="Zoom options")
+            layout.prop(input_prefs, "ndof_zoom_invert")
             layout.prop(input_prefs, "ndof_zoom_updown")
 
             layout.separator()
index 9368d3ab5db4d50db88497354e5cbd1b385ba04a..d81f53d4fa670bb089e624f6b9de234c87a0d02a 100644 (file)
@@ -2557,7 +2557,7 @@ class VIEW3D_PT_background_image(Panel):
                 if bg.source == 'IMAGE':
                     row = box.row()
                     row.template_ID(bg, "image", open="image.open")
-                    if (bg.image):
+                    if bg.image is not None:
                         box.template_image(bg, "image", bg.image_user, compact=True)
                         has_bg = True
 
index ac962ab509756c7120f35a1e7b6edd60d3b77f46..2c1e963dcfef8feb52dd312c39260a34897ab807 100644 (file)
@@ -228,7 +228,7 @@ class VIEW3D_PT_tools_curveedit(View3DPanel, Panel):
 
         col = layout.column(align=True)
         col.operator("transform.tilt", text="Tilt")
-        col.operator("transform.transform", text="Shrink/Fatten").mode = 'CURVE_SHRINKFATTEN'
+        col.operator("transform.transform", text="Scale Feather").mode = 'CURVE_SHRINKFATTEN'
 
         col = layout.column(align=True)
         col.label(text="Curve:")
index ad1a63fd1e6d229ccdda37d7b416526ffc08ab91..bf2f1262eee809e1a6fc284f180435628951e73b 100644 (file)
@@ -217,8 +217,8 @@ void calc_fcurve_range(struct FCurve *fcu, float *min, float *max,
                        const short do_sel_only, const short do_min_length);
 
 /* get the bounding-box extents for F-Curve */
-void calc_fcurve_bounds(struct FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax,
-                        const short do_sel_only, const short include_handles);
+short calc_fcurve_bounds(struct FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax,
+                         const short do_sel_only, const short include_handles);
 
 /* .............. */
 
index 356f2c8901c8967d0eff25cffd20ec88a52cef5c..913e8653b9b777ca50a31e4b358d4f1f56be7398 100644 (file)
@@ -57,8 +57,8 @@ float *BKE_mball_make_orco(struct Object *ob, struct ListBase *dispbase);
 void BKE_mball_properties_copy(struct Scene *scene, struct Object *active_object);
 
 int BKE_mball_minmax(struct MetaBall *mb, float min[3], float max[3]);
-int BKE_mball_center_median(struct MetaBall *mb, float cent[3]);
-int BKE_mball_center_bounds(struct MetaBall *mb, float cent[3]);
+int BKE_mball_center_median(struct MetaBall *mb, float r_cent[3]);
+int BKE_mball_center_bounds(struct MetaBall *mb, float r_cent[3]);
 void BKE_mball_translate(struct MetaBall *mb, float offset[3]);
 
 struct MetaElem *BKE_mball_element_add(struct MetaBall *mb, const int type);
index 3aa7148d821d11795815234db83f83985e5c17b6..31642dad60dc9fb92ea14acd83b29e1784aef3b3 100644 (file)
@@ -109,8 +109,8 @@ struct BoundBox *BKE_object_boundbox_get(struct Object *ob);
 void BKE_object_dimensions_get(struct Object *ob, float vec[3]);
 void BKE_object_dimensions_set(struct Object *ob, const float *value);
 void BKE_object_boundbox_flag(struct Object *ob, int flag, int set);
-void BKE_object_minmax(struct Object *ob, float r_min[3], float r_max[3]);
-int BKE_object_minmax_dupli(struct Scene *scene, struct Object *ob, float r_min[3], float r_max[3]);
+void BKE_object_minmax(struct Object *ob, float r_min[3], float r_max[3], const short use_hidden);
+int BKE_object_minmax_dupli(struct Scene *scene, struct Object *ob, float r_min[3], float r_max[3], const short use_hidden);
 
 /* sometimes min-max isn't enough, we need to loop over each point */
 void BKE_object_foreach_display_point(struct Object *ob, float obmat[4][4],
index 718daf1454ec69040aa7729a0b2d5001cee572ee..823b1dd14da96ca150d41651d173c7aab9b4cfcc 100644 (file)
@@ -301,7 +301,7 @@ int  BKE_seqence_is_valid_check(struct Sequence *seq);
 
 void BKE_sequencer_clear_scene_in_allseqs(struct Main *bmain, struct Scene *sce);
 
-struct Sequence *BKE_sequwnce_get_by_name(struct ListBase *seqbase, const char *name, int recursive);
+struct Sequence *BKE_sequence_get_by_name(struct ListBase *seqbase, const char *name, int recursive);
 
 /* api for adding new sequence strips */
 typedef struct SeqLoadInfo {
index c456840637ad5a4da28b26375deda174f2bcfd5b..387d4775ad43a84bfca4aefa93217a3df6a783ae 100644 (file)
@@ -1798,7 +1798,7 @@ static void ccgSubSurf__calcSubdivLevel(CCGSubSurf *ss,
                if (seamEdges < 2 || seamEdges != v->numEdges)
                        seam = 0;
 
-               if (!v->numEdges) {
+               if (!v->numEdges || ss->meshIFC.simpleSubdiv) {
                        VertDataCopy(nCo, co, ss);
                }
                else if (_vert_isBoundary(v)) {
@@ -2246,7 +2246,7 @@ static void ccgSubSurf__sync(CCGSubSurf *ss)
                if (seamEdges < 2 || seamEdges != v->numEdges)
                        seam = 0;
 
-               if (!v->numEdges) {
+               if (!v->numEdges || ss->meshIFC.simpleSubdiv) {
                        VertDataCopy(nCo, co, ss);
                }
                else if (_vert_isBoundary(v)) {
@@ -2827,6 +2827,11 @@ int ccgSubSurf_getGridLevelSize(const CCGSubSurf *ss, int level)
        }
 }
 
+int ccgSubSurf_getSimpleSubdiv(const CCGSubSurf *ss)
+{
+       return ss->meshIFC.simpleSubdiv;
+}
+
 /* Vert accessors */
 
 CCGVertHDL ccgSubSurf_getVertVertHandle(CCGVert *v)
index 33b37ac281cf4e613afb777f3245417def58b7c2..0f96bcf172daa3c2a4d471ca2c1ada04591c321c 100644 (file)
@@ -17,6 +17,7 @@ typedef struct CCGMeshIFC {
        int                     vertUserSize, edgeUserSize, faceUserSize;
        int                     numLayers;
        int                     vertDataSize;
+       int                     simpleSubdiv;
 } CCGMeshIFC;
 
 /***/
@@ -91,6 +92,7 @@ int                   ccgSubSurf_getEdgeSize                          (const CCGSubSurf *ss);
 int                    ccgSubSurf_getEdgeLevelSize                     (const CCGSubSurf *ss, int level);
 int                    ccgSubSurf_getGridSize                          (const CCGSubSurf *ss);
 int                    ccgSubSurf_getGridLevelSize                     (const CCGSubSurf *ss, int level);
+int                    ccgSubSurf_getSimpleSubdiv                      (const CCGSubSurf *ss);
 
 CCGVert*       ccgSubSurf_getVert                                      (CCGSubSurf *ss, CCGVertHDL v);
 CCGVertHDL     ccgSubSurf_getVertVertHandle            (CCGVert *v);
index 120a0b2ba2761813c9f550334fd46acfbbecae10..a8a3d0cdbcbbf3e801543c38de509459a8bc8eef 100644 (file)
@@ -498,7 +498,7 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
                        }
                }
                else {
-                       /*if no object, set to INT_MAX so we don't mess up any shapekey layers*/
+                       /* if no object, set to INT_MAX so we don't mess up any shapekey layers */
                        uid = INT_MAX;
                }
 
@@ -1188,7 +1188,7 @@ void DM_update_weight_mcol(Object *ob, DerivedMesh *dm, int const draw_flag,
                        wtcol_v = calc_weightpaint_vert_array(ob, dm, draw_flag, coba);
 
                /* Now copy colors in all face verts. */
-               /*first add colors to the tessellation faces*/
+               /* first add colors to the tessellation faces */
                /* XXX Why update that layer? We have to update WEIGHT_MLOOPCOL anyway, 
                 *     and tessellation recreates mface layers from mloop/mpoly ones, so no
                 *     need to fill WEIGHT_MCOL here. */
index 111ac68b3456b18d8ce262f496e109d900749530..33cdede6fced35ff1d47e89acd416a0bcc4b4479 100644 (file)
@@ -1279,9 +1279,9 @@ static void new_particle_duplilist(ListBase *lb, ID *id, Scene *scene, Object *p
                        if (part->dup_group == NULL || part->dup_group->gobject.first == NULL)
                                return;
 
-                       for (go = part->dup_group->gobject.first; go; go = go->next)
-                               if (go->ob == par)
-                                       return;
+                       if (BLI_findptr(&part->dup_group->gobject, par, offsetof(GroupObject, ob))) {
+                               return;
+                       }
                }
 
                /* if we have a hair particle system, use the path cache */
index c10b1e2d4f4cb17024c8a9061307e5f0bdcd8a24..79ee0e96450283f623b9b698ec62d563f5c2fbeb 100644 (file)
@@ -210,7 +210,7 @@ bArmature *BKE_armature_copy(bArmature *arm)
        newArm = BKE_libblock_copy(&arm->id);
        BLI_duplicatelist(&newArm->bonebase, &arm->bonebase);
 
-       /* Duplicate the childrens' lists*/
+       /* Duplicate the childrens' lists */
        newBone = newArm->bonebase.first;
        for (oldBone = arm->bonebase.first; oldBone; oldBone = oldBone->next) {
                newBone->parent = NULL;
index e6259cc9faf823652bf0f2444be3ab9cec7728af..79d5e092a1015ac771b82217735b888673883a63 100644 (file)
@@ -425,7 +425,7 @@ static int rule_follow_leader(BoidRule *rule, BoidBrainData *bbd, BoidValues *va
        if (flbr->ob) {
                float vec2[3], t;
 
-               /* first check we're not blocking the leader*/
+               /* first check we're not blocking the leader */
                sub_v3_v3v3(vec, flbr->loc, flbr->oloc);
                mul_v3_fl(vec, 1.0f/bbd->timestep);
 
index 88748d5f0b875e4aff75c8d77e012a8b68583457..881caec8a58705f45c465d5b7481957f38e84d68 100644 (file)
@@ -1869,7 +1869,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
        
        dm->deformedOnly = 1;
        
-       /*don't add origindex layer if one already exists*/
+       /* don't add origindex layer if one already exists */
        add_orig = !CustomData_has_layer(&bm->pdata, CD_ORIGINDEX);
 
        mask = use_mdisps ? CD_MASK_DERIVEDMESH | CD_MASK_MDISPS : CD_MASK_DERIVEDMESH;
@@ -1886,7 +1886,7 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
        CustomData_merge(&bm->pdata, &dm->polyData, mask,
                         CD_CALLOC, dm->numPolyData);
        
-       /*add tessellation mface layers*/
+       /* add tessellation mface layers */
        if (use_tessface) {
                CustomData_from_bmeshpoly(&dm->faceData, &dm->polyData, &dm->loopData, em->tottri);
        }
@@ -2260,7 +2260,7 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap)
        newe = MEM_callocN(sizeof(int) * dm->numEdgeData, "newv etable CDDM_merge_verts");
        newl = MEM_callocN(sizeof(int) * totloop, "newv ltable CDDM_merge_verts");
        
-       /*fill newl with destination vertex indices*/
+       /* fill newl with destination vertex indices */
        mv = cddm->mvert;
        c = 0;
        for (i = 0; i < dm->numVertData; i++, mv++) {
@@ -2271,14 +2271,14 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap)
                }
        }
        
-       /*now link target vertices to destination indices*/
+       /* now link target vertices to destination indices */
        for (i = 0; i < dm->numVertData; i++) {
                if (vtargetmap[i] != -1) {
                        newv[i] = newv[vtargetmap[i]];
                }
        }
        
-       /*find-replace merged vertices with target vertices*/   
+       /* find-replace merged vertices with target vertices */
        ml = cddm->mloop;
        for (i = 0; i < totloop; i++, ml++) {
                if (vtargetmap[ml->v] != -1) {
@@ -2286,7 +2286,7 @@ DerivedMesh *CDDM_merge_verts(DerivedMesh *dm, const int *vtargetmap)
                }
        }
 
-       /*now go through and fix edges and faces*/
+       /* now go through and fix edges and faces */
        med = cddm->medge;
        c = 0;
        for (i = 0; i < dm->numEdgeData; i++, med++) {
index 16edbc3f0a98658d90b4d7bb3ccd91c963aa3a63..00130dd3583f07e4535dad6a8fa9f1c762d1a32f 100644 (file)
@@ -3114,7 +3114,8 @@ static void clampto_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *tar
                copy_v3_v3(ownLoc, obmat[3]);
                
                INIT_MINMAX(curveMin, curveMax);
-               BKE_object_minmax(ct->tar, curveMin, curveMax);
+               /* XXX - don't think this is good calling this here - campbell */
+               BKE_object_minmax(ct->tar, curveMin, curveMax, TRUE);
                
                /* get targetmatrix */
                if (cu->path && cu->path->data) {
index d92c4ca863255eedbccc621e2f7b8e176b5ac7be..b04bd5bc47fcd4e9646de4e417d728ad305751c4 100644 (file)
@@ -1898,7 +1898,7 @@ void CustomData_copy_data(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
-                       ++dest_i;
+                       dest_i++;
                }
 
                /* if there are no more dest layers, we're done */
@@ -1936,7 +1936,7 @@ void CustomData_copy_data(const CustomData *source, CustomData *dest,
                         * we don't want to copy all source layers to the same dest, so
                         * increment dest_i
                         */
-                       ++dest_i;
+                       dest_i++;
                }
        }
 }
@@ -1989,7 +1989,7 @@ void CustomData_interp(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
-                       ++dest_i;
+                       dest_i++;
                }
 
                /* if there are no more dest layers, we're done */
@@ -2011,7 +2011,7 @@ void CustomData_interp(const CustomData *source, CustomData *dest,
                         * we don't want to copy all source layers to the same dest, so
                         * increment dest_i
                         */
-                       ++dest_i;
+                       dest_i++;
                }
        }
 
@@ -2139,8 +2139,8 @@ void CustomData_set(const CustomData *data, int index, int type, void *source)
                memcpy(dest, source, typeInfo->size);
 }
 
-/*Bmesh functions*/
-/*needed to convert to/from different face reps*/
+/* BMesh functions */
+/* needed to convert to/from different face reps */
 void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata,
                              int totloop, int totpoly)
 {
@@ -2401,7 +2401,7 @@ void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
-                       ++dest_i;
+                       dest_i++;
                }
 
                /* if there are no more dest layers, we're done */
@@ -2425,7 +2425,7 @@ void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
                         * we don't want to copy all source layers to the same dest, so
                         * increment dest_i
                         */
-                       ++dest_i;
+                       dest_i++;
                }
        }
 }
@@ -2637,7 +2637,7 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
-                       ++dest_i;
+                       dest_i++;
                }
 
                /* if there are no more dest layers, we're done */
@@ -2661,7 +2661,7 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
                         * we don't want to copy all source layers to the same dest, so
                         * increment dest_i
                         */
-                       ++dest_i;
+                       dest_i++;
                }
        }
 }
@@ -2680,7 +2680,7 @@ void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
                 * (this should work because layers are ordered by type)
                 */
                while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
-                       ++dest_i;
+                       dest_i++;
                }
 
                /* if there are no more dest layers, we're done */
@@ -2704,7 +2704,7 @@ void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
                         * we don't want to copy all source layers to the same dest, so
                         * increment dest_i
                         */
-                       ++dest_i;
+                       dest_i++;
                }
        }
 
index b22e24e15d4af9c6df486067706ee1b1444836bb..1b53f8980cb8eb60ec3c00eb1af7e7fd21e13b3a 100644 (file)
@@ -570,12 +570,14 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
 
        /* softbody collision  */
        if ((ob->type == OB_MESH) || (ob->type == OB_CURVE) || (ob->type == OB_LATTICE)) {
-               if (modifiers_isModifierEnabled(ob, eModifierType_Softbody) 
-                       || modifiers_isModifierEnabled(ob, eModifierType_Cloth)
-                       || modifiers_isModifierEnabled(ob, eModifierType_Smoke)
-                       || modifiers_isModifierEnabled(ob, eModifierType_DynamicPaint)
-                       || ob->particlesystem.first)
+               if (ob->particlesystem.first ||
+                       modifiers_isModifierEnabled(ob, eModifierType_Softbody) ||
+                       modifiers_isModifierEnabled(ob, eModifierType_Cloth) ||
+                       modifiers_isModifierEnabled(ob, eModifierType_Smoke) ||
+                       modifiers_isModifierEnabled(ob, eModifierType_DynamicPaint))
+               {
                        dag_add_collision_field_relation(dag, scene, ob, node);  /* TODO: use effectorweight->group */
+               }
        }
        
        /* object data drivers */
index 0daf06c63059bd0ad5bcc5ce12660b78fc82329b..8db93f8b44a2462ad652b2271e05ff365001c607 100644 (file)
@@ -4318,7 +4318,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
                                        dir_factor = dir_dot * MIN2(speed_scale, 1.0f) * w_factor;
                                        if (dir_factor > 0.5f) dir_factor = 0.5f;
 
-                                       /* mix new wetness*/
+                                       /* mix new wetness */
                                        ePoint->wetness += dir_factor;
                                        CLAMP(ePoint->wetness, 0.0f, MAX_WETNESS);
 
index 32c6caffff75d15e04526467fc0cd6dbb2172967..c6ba6a0d8411bf747d999d948f81b19f2b324614 100644 (file)
@@ -151,7 +151,7 @@ static void BMEdit_RecalcTessellation_intern(BMEditMesh *tm)
 #endif
 
        BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
-               /*don't consider two-edged faces*/
+               /* don't consider two-edged faces */
                if (efa->len < 3) {
                        /* do nothing */
                }
@@ -198,7 +198,7 @@ static void BMEdit_RecalcTessellation_intern(BMEditMesh *tm)
 
                        /* scanfill time */
                        BM_ITER_ELEM_INDEX (l, &liter, efa, BM_LOOPS_OF_FACE, j) {
-                               /*mark order*/
+                               /*mark order */
                                BM_elem_index_set(l, j); /* set_loop */
 
                                sf_vert = BLI_scanfill_vert_add(&sf_ctx, l->v->co);
@@ -334,7 +334,7 @@ typedef struct EditDerivedBMesh {
        float (*polyNos)[3];
 
        /* private variables, for number of verts/edges/faces
-        * within the above hash/table members*/
+        * within the above hash/table members */
        int tv, te, tf;
 } EditDerivedBMesh;
 
index 97b245bd067637e1c712c7bad6e378c058f4e836..67e7743c8a4504270c173db5b736759830d465c7 100644 (file)
@@ -433,16 +433,18 @@ int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short
 /* ...................................... */
 
 /* helper for calc_fcurve_* functions -> find first and last BezTriple to be used */
-static void get_fcurve_end_keyframes(FCurve *fcu, BezTriple **first, BezTriple **last,
-                                     const short do_sel_only)
+static short get_fcurve_end_keyframes(FCurve *fcu, BezTriple **first, BezTriple **last,
+                                      const short do_sel_only)
 {
+       short found = FALSE;
+       
        /* init outputs */
        *first = NULL;
        *last = NULL;
        
        /* sanity checks */
        if (fcu->bezt == NULL)
-               return;
+               return found;
        
        /* only include selected items? */
        if (do_sel_only) {
@@ -454,6 +456,7 @@ static void get_fcurve_end_keyframes(FCurve *fcu, BezTriple **first, BezTriple *
                for (i = 0; i < fcu->totvert; bezt++, i++) {
                        if (BEZSELECTED(bezt)) {
                                *first = bezt;
+                               found = TRUE;
                                break;
                        }
                }
@@ -463,6 +466,7 @@ static void get_fcurve_end_keyframes(FCurve *fcu, BezTriple **first, BezTriple *
                for (i = 0; i < fcu->totvert; bezt--, i++) {
                        if (BEZSELECTED(bezt)) {
                                *last = bezt;
+                               found = TRUE;
                                break;
                        }
                }
@@ -471,13 +475,16 @@ static void get_fcurve_end_keyframes(FCurve *fcu, BezTriple **first, BezTriple *
                /* just full array */
                *first = fcu->bezt;
                *last = ARRAY_LAST_ITEM(fcu->bezt, BezTriple, sizeof(BezTriple), fcu->totvert);
+               found = TRUE;
        }
+       
+       return found;
 }
 
 
 /* Calculate the extents of F-Curve's data */
-void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax,
-                        const short do_sel_only, const short include_handles)
+short calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax,
+                         const short do_sel_only, const short include_handles)
 {
        float xminv = 999999999.0f, xmaxv = -999999999.0f;
        float yminv = 999999999.0f, ymaxv = -999999999.0f;
@@ -490,7 +497,7 @@ void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, floa
                        
                        if (xmin || xmax) {
                                /* get endpoint keyframes */
-                               get_fcurve_end_keyframes(fcu, &bezt_first, &bezt_last, do_sel_only);
+                               foundvert = get_fcurve_end_keyframes(fcu, &bezt_first, &bezt_last, do_sel_only);
                                
                                if (bezt_first) {
                                        BLI_assert(bezt_last != NULL);
@@ -566,6 +573,8 @@ void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, floa
                if (ymin) *ymin = 0.0f;
                if (ymax) *ymax = 1.0f;
        }
+       
+       return foundvert;
 }
 
 /* Calculate the extents of F-Curve's keyframes */
index 02e5dc02746b47d4a27253978ee2b72dab9a6924..49c3d77a527cdabe42863e0e7bf2ffe7eb0e5a44 100644 (file)
@@ -422,7 +422,7 @@ static void buildchar(Main *bmain, Curve *cu, unsigned long character, CharInfo
        }
 #endif
 
-       /* make a copy at distance ofsx, ofsy with shear*/
+       /* make a copy at distance ofsx, ofsy with shear */
        fsize = cu->fsize;
        shear = cu->shear;
        si = sinf(rot);
index c317dc63ef7e167c3e14a2f13b594d77a6d822e7..2ec5801746c0aa78bf76f7c866d0d169062de276 100644 (file)
@@ -97,7 +97,7 @@ void free_gpencil_layers(ListBase *list)
        /* error checking */
        if (list == NULL) return;
        
-       /* delete layers*/
+       /* delete layers */
        for (gpl = list->first; gpl; gpl = gpln) {
                gpln = gpl->next;
                
index 89341845615d5ae82b2f328769910795d077f1fc..500df1b7b757fc4aad752e74f9e5ed9c566757f0 100644 (file)
@@ -161,11 +161,13 @@ static int add_to_group_internal(Group *group, Object *ob)
 {
        GroupObject *go;
        
-       if (group == NULL || ob == NULL) return 0;
+       if (group == NULL || ob == NULL) {
+               return FALSE;
+       }
        
        /* check if the object has been added already */
-       for (go = group->gobject.first; go; go = go->next) {
-               if (go->ob == ob) return 0;
+       if (BLI_findptr(&group->gobject, ob, offsetof(GroupObject, ob))) {
+               return FALSE;
        }
        
        go = MEM_callocN(sizeof(GroupObject), "groupobject");
@@ -173,7 +175,7 @@ static int add_to_group_internal(Group *group, Object *ob)
        
        go->ob = ob;
        
-       return 1;
+       return TRUE;
 }
 
 int add_to_group(Group *group, Object *object, Scene *scene, Base *base)
@@ -239,15 +241,11 @@ int rem_from_group(Group *group, Object *object, Scene *scene, Base *base)
 
 int object_in_group(Object *ob, Group *group)
 {
-       GroupObject *go;
-       
-       if (group == NULL || ob == NULL) return 0;
-       
-       for (go = group->gobject.first; go; go = go->next) {
-               if (go->ob == ob)
-                       return 1;
+       if (group == NULL || ob == NULL) {
+               return FALSE;
        }
-       return 0;
+
+       return (BLI_findptr(&group->gobject, ob, offsetof(GroupObject, ob)) != NULL);
 }
 
 Group *find_group(Object *ob, Group *group)
index a65d03e64cf51dda60f450090dbe7d2cd427a34c..7456f9aab8be4fa57488925bfb65178b6306296a 100644 (file)
@@ -159,12 +159,12 @@ void IDP_ResizeIDPArray(IDProperty *prop, int newlen)
 
        newarr = MEM_callocN(sizeof(IDProperty) * newsize, "idproperty array resized");
        if (newlen >= prop->len) {
-               /* newlen is bigger*/
+               /* newlen is bigger */
                memcpy(newarr, prop->data.pointer, prop->len * sizeof(IDProperty));
        }
        else {
                int i;
-               /* newlen is smaller*/
+               /* newlen is smaller */
                for (i = newlen; i < prop->len; i++) {
                        IDP_FreeProperty(GETPROP(prop, i));
                }
@@ -233,12 +233,12 @@ void IDP_ResizeArray(IDProperty *prop, int newlen)
 
        newarr = MEM_callocN(idp_size_table[(int)prop->subtype] * newsize, "idproperty array resized");
        if (newlen >= prop->len) {
-               /* newlen is bigger*/
+               /* newlen is bigger */
                memcpy(newarr, prop->data.pointer, prop->len * idp_size_table[(int)prop->subtype]);
                idp_resize_group_array(prop, newlen, newarr);
        }
        else {
-               /* newlen is smaller*/
+               /* newlen is smaller */
                idp_resize_group_array(prop, newlen, newarr);
                memcpy(newarr, prop->data.pointer, newlen * idp_size_table[(int)prop->subtype]);
        }
@@ -694,7 +694,7 @@ IDProperty *IDP_New(const int type, const IDPropertyTemplate *val, const char *n
                        break;          
                case IDP_ARRAY:
                {
-                       /*for now, we only support float and int and double arrays*/
+                       /* for now, we only support float and int and double arrays */
                        if ( (val->array.type == IDP_FLOAT) ||
                             (val->array.type == IDP_INT) ||
                             (val->array.type == IDP_DOUBLE) ||
index 8042c4d2807e3f34f8f8b54648d21559dab9e1c8..1a401f4c5183cd0064cc179ba007e52d67fe0a87 100644 (file)
@@ -1232,43 +1232,46 @@ void BKE_imformat_defaults(ImageFormatData *im_format)
 
 void BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const ImBuf *imbuf)
 {
+       int ftype        = imbuf->ftype & ~IB_CUSTOM_FLAGS_MASK;
+       int custom_flags = imbuf->ftype & IB_CUSTOM_FLAGS_MASK;
+
        BKE_imformat_defaults(im_format);
 
        /* file type */
 
-       if (imbuf->ftype == IMAGIC)
+       if (ftype == IMAGIC)
                im_format->imtype = R_IMF_IMTYPE_IRIS;
 
 #ifdef WITH_HDR
-       else if (imbuf->ftype == RADHDR)
+       else if (ftype == RADHDR)
                im_format->imtype = R_IMF_IMTYPE_RADHDR;
 #endif
 
-       else if (imbuf->ftype == PNG)
+       else if (ftype == PNG)
                im_format->imtype = R_IMF_IMTYPE_PNG;
 
 #ifdef WITH_DDS
-       else if (imbuf->ftype == DDS)
+       else if (ftype == DDS)
                im_format->imtype = R_IMF_IMTYPE_DDS;
 #endif
 
-       else if (imbuf->ftype == BMP)
+       else if (ftype == BMP)
                im_format->imtype = R_IMF_IMTYPE_BMP;
 
 #ifdef WITH_TIFF
-       else if (imbuf->ftype & TIF) {
+       else if (ftype == TIF) {
                im_format->imtype = R_IMF_IMTYPE_TIFF;
-               if (imbuf->ftype & TIF_16BIT)
+               if (custom_flags & TIF_16BIT)
                        im_format->depth = R_IMF_CHAN_DEPTH_16;
        }
 #endif
 
 #ifdef WITH_OPENEXR
-       else if (imbuf->ftype & OPENEXR) {
+       else if (ftype == OPENEXR) {
                im_format->imtype = R_IMF_IMTYPE_OPENEXR;
-               if (imbuf->ftype & OPENEXR_HALF)
+               if (custom_flags & OPENEXR_HALF)
                        im_format->depth = R_IMF_CHAN_DEPTH_16;
-               if (imbuf->ftype & OPENEXR_COMPRESS)
+               if (custom_flags & OPENEXR_COMPRESS)
                        im_format->exr_codec = R_IMF_EXR_CODEC_ZIP;  // Can't determine compression
                if (imbuf->zbuf_float)
                        im_format->flag |= R_IMF_FLAG_ZBUF;
@@ -1276,35 +1279,35 @@ void BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const ImBuf *i
 #endif
 
 #ifdef WITH_CINEON
-       else if (imbuf->ftype == CINEON)
+       else if (ftype == CINEON)
                im_format->imtype = R_IMF_IMTYPE_CINEON;
-       else if (imbuf->ftype == DPX)
+       else if (ftype == DPX)
                im_format->imtype = R_IMF_IMTYPE_DPX;
 #endif
 
-       else if (imbuf->ftype == TGA) {
+       else if (ftype == TGA) {
                im_format->imtype = R_IMF_IMTYPE_TARGA;
        }
-       else if (imbuf->ftype == RAWTGA) {
+       else if (ftype == RAWTGA) {
                im_format->imtype = R_IMF_IMTYPE_RAWTGA;
        }
 
 #ifdef WITH_OPENJPEG
-       else if (imbuf->ftype & JP2) {
+       else if (ftype & JP2) {
                im_format->imtype = R_IMF_IMTYPE_JP2;
-               im_format->quality = imbuf->ftype & ~JPG_MSK;
+               im_format->quality = custom_flags & ~JPG_MSK;
 
-               if (imbuf->ftype & JP2_16BIT)
+               if (ftype & JP2_16BIT)
                        im_format->depth = R_IMF_CHAN_DEPTH_16;
-               else if (imbuf->ftype & JP2_12BIT)
+               else if (ftype & JP2_12BIT)
                        im_format->depth = R_IMF_CHAN_DEPTH_12;
 
-               if (imbuf->ftype & JP2_YCC)
+               if (ftype & JP2_YCC)
                        im_format->jp2_flag |= R_IMF_JP2_FLAG_YCC;
 
-               if (imbuf->ftype & JP2_CINE) {
+               if (ftype & JP2_CINE) {
                        im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_PRESET;
-                       if (imbuf->ftype & JP2_CINE_48FPS)
+                       if (ftype & JP2_CINE_48FPS)
                                im_format->jp2_flag |= R_IMF_JP2_FLAG_CINE_48;
                }
        }
@@ -1312,7 +1315,7 @@ void BKE_imbuf_to_image_format(struct ImageFormatData *im_format, const ImBuf *i
 
        else {
                im_format->imtype = R_IMF_IMTYPE_JPEG90;
-               im_format->quality = imbuf->ftype & ~JPG_MSK;
+               im_format->quality = custom_flags & ~JPG_MSK;
        }
 
        /* planes */
index 8de9640eb359646cd4f4c4bf983a7676637deed9..b2a9e229be9520e7e6babf9d48676b696bbee0f5 100644 (file)
@@ -1764,8 +1764,7 @@ void do_versions_ipos_to_animato(Main *main)
                                        for (act = ob->actuators.first; act; act = act->next) {
                                                /* Any actuators set to ACT_IPO at this point are actually Action Actuators that
                                                   need this converted IPO to finish converting the actuator. */
-                                               if (act->type == ACT_IPO)
-                                               {
+                                               if (act->type == ACT_IPO) {
                                                        aa = (bActionActuator*)act->data;
                                                        aa->act = ob->adt->action;
                                                        act->type = ACT_ACTION;
index 60be0a60dcb9d1bb64558809b1e3589d0549fe15..17a3c595ea72fbb7b10f59d6edf01d2aebbe7c35 100644 (file)
@@ -1449,6 +1449,8 @@ KeyBlock *add_keyblock(Key *key, const char *name)
  * \note sorting is a problematic side effect in some cases,
  * better only do this explicitly by having its own function,
  *
+ * \param key The key datablock to add to.
+ * \param name Optional name for the new keyblock.
  * \param do_force always use ctime even for relative keys.
  */
 KeyBlock *add_keyblock_ctime(Key *key, const char *name, const short do_force)
index 21811c19d24a25eb196af44e85448fe5dc0aa80d..e5f392e4bced3c96e7511f7dd25add06d6f257aa 100644 (file)
@@ -779,7 +779,7 @@ void assign_material(Object *ob, Material *ma, short act, int assign_type)
        Material *mao, **matar, ***matarar;
        char *matbits;
        short *totcolp;
-       char bit=0;
+       char bit = 0;
 
        if (act > MAXMAT) return;
        if (act < 1) act = 1;
@@ -813,7 +813,7 @@ void assign_material(Object *ob, Material *ma, short act, int assign_type)
                bit = ob->matbits[ob->actcol - 1];
        }
        else {
-               switch(assign_type) {
+               switch (assign_type) {
                        case BKE_MAT_ASSIGN_OBDATA:
                                bit = 0;
                                break;
index fa5304b081a8cbd83455d98af9fe8f1d369fbb19..039fb2c22f3996fe66fa38f3bd77ab6465ff2fdb 100644 (file)
 
 /* Data types */
 
-typedef struct point {          /* a three-dimensional point */
-       float x, y, z;              /* its coordinates */
-} MB_POINT;
-
 typedef struct vertex {         /* surface vertex */
-       MB_POINT position, normal;  /* position and surface normal */
+       float co[3];  /* position and surface normal */
+       float no[3];
 } VERTEX;
 
 typedef struct vertices {       /* list of vertices in polygonization */
@@ -82,7 +79,7 @@ typedef struct vertices {       /* list of vertices in polygonization */
 
 typedef struct corner {         /* corner of a cube */
        int i, j, k;                /* (i, j, k) is index within lattice */
-       float x, y, z, value;       /* location and function value */
+       float co[3], value;       /* location and function value */
        struct corner *next;
 } CORNER;
 
@@ -159,11 +156,11 @@ struct pgn_elements {
 };
 
 /* Forward declarations */
-static int vertid(CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb);
+static int vertid(const CORNER *c1, const CORNER *c2, PROCESS *p, MetaBall *mb);
 static int setcenter(CENTERLIST *table[], int i, int j, int k);
 static CORNER *setcorner(PROCESS *p, int i, int j, int k);
-static void converge(MB_POINT *p1, MB_POINT *p2, float v1, float v2,
-                     float (*function)(float, float, float), MB_POINT *p, MetaBall *mb, int f);
+static void converge(const float p1[3], const float p2[3], float v1, float v2,
+                     float (*function)(float, float, float), float p[3], MetaBall *mb, int f);
 
 /* Global variables */
 
@@ -631,65 +628,59 @@ static void calc_mballco(MetaElem *ml, float vec[3])
 
 static float densfunc(MetaElem *ball, float x, float y, float z)
 {
-       float dist2 = 0.0, dx, dy, dz;
-       float vec[3];
+       float dist2;
+       float dvec[3] = {x, y, z};
 
-       vec[0] = x;
-       vec[1] = y;
-       vec[2] = z;
-       mul_m4_v3((float (*)[4])ball->imat, vec);
-       dx = vec[0];
-       dy = vec[1];
-       dz = vec[2];
+       mul_m4_v3((float (*)[4])ball->imat, dvec);
 
        if (ball->type == MB_BALL) {
        }
        else if (ball->type == MB_TUBEX) {
-               if (dx > ball->len) dx -= ball->len;
-               else if (dx < -ball->len) dx += ball->len;
-               else dx = 0.0;
+               if      (dvec[0] >  ball->len) dvec[0] -= ball->len;
+               else if (dvec[0] < -ball->len) dvec[0] += ball->len;
+               else                           dvec[0] = 0.0;
        }
        else if (ball->type == MB_TUBEY) {
-               if (dy > ball->len) dy -= ball->len;
-               else if (dy < -ball->len) dy += ball->len;
-               else dy = 0.0;
+               if      (dvec[1] >  ball->len) dvec[1] -= ball->len;
+               else if (dvec[1] < -ball->len) dvec[1] += ball->len;
+               else                           dvec[1] = 0.0;
        }
        else if (ball->type == MB_TUBEZ) {
-               if (dz > ball->len) dz -= ball->len;
-               else if (dz < -ball->len) dz += ball->len;
-               else dz = 0.0;
+               if      (dvec[2] >  ball->len) dvec[2] -= ball->len;
+               else if (dvec[2] < -ball->len) dvec[2] += ball->len;
+               else                           dvec[2] = 0.0;
        }
        else if (ball->type == MB_TUBE) {
-               if (dx > ball->expx) dx -= ball->expx;
-               else if (dx < -ball->expx) dx += ball->expx;
-               else dx = 0.0;
+               if      (dvec[0] >  ball->expx) dvec[0] -= ball->expx;
+               else if (dvec[0] < -ball->expx) dvec[0] += ball->expx;
+               else                            dvec[0] = 0.0;
        }
        else if (ball->type == MB_PLANE) {
-               if (dx > ball->expx) dx -= ball->expx;
-               else if (dx < -ball->expx) dx += ball->expx;
-               else dx = 0.0;
-               if (dy > ball->expy) dy -= ball->expy;
-               else if (dy < -ball->expy) dy += ball->expy;
-               else dy = 0.0;
+               if      (dvec[0] >  ball->expx) dvec[0] -= ball->expx;
+               else if (dvec[0] < -ball->expx) dvec[0] += ball->expx;
+               else                            dvec[0] = 0.0;
+               if      (dvec[1] >  ball->expy) dvec[1] -= ball->expy;
+               else if (dvec[1] < -ball->expy) dvec[1] += ball->expy;
+               else                            dvec[1] = 0.0;
        }
        else if (ball->type == MB_ELIPSOID) {
-               dx *= 1 / ball->expx;
-               dy *= 1 / ball->expy;
-               dz *= 1 / ball->expz;
+               dvec[0] *= 1 / ball->expx;
+               dvec[1] *= 1 / ball->expy;
+               dvec[2] *= 1 / ball->expz;
        }
        else if (ball->type == MB_CUBE) {
-               if (dx > ball->expx) dx -= ball->expx;
-               else if (dx < -ball->expx) dx += ball->expx;
-               else dx = 0.0;
-               if (dy > ball->expy) dy -= ball->expy;
-               else if (dy < -ball->expy) dy += ball->expy;
-               else dy = 0.0;
-               if (dz > ball->expz) dz -= ball->expz;
-               else if (dz < -ball->expz) dz += ball->expz;
-               else dz = 0.0;
+               if      (dvec[0] >  ball->expx) dvec[0] -= ball->expx;
+               else if (dvec[0] < -ball->expx) dvec[0] += ball->expx;
+               else                            dvec[0] = 0.0;
+               if      (dvec[1] >  ball->expy) dvec[1] -= ball->expy;
+               else if (dvec[1] < -ball->expy) dvec[1] += ball->expy;
+               else                            dvec[1] = 0.0;
+               if      (dvec[2] >  ball->expz) dvec[2] -= ball->expz;
+               else if (dvec[2] < -ball->expz) dvec[2] += ball->expz;
+               else                            dvec[2] = 0.0;
        }
 
-       dist2 = (dx * dx + dy * dy + dz * dz);
+       dist2 = len_v3(dvec);
 
        if (ball->flag & MB_NEGATIVE) {
                dist2 = 1.0f - (dist2 / ball->rad2);
@@ -1074,12 +1065,12 @@ static CORNER *setcorner(PROCESS *p, int i, int j, int k)
        c = (CORNER *) new_pgn_element(sizeof(CORNER));
 
        c->i = i; 
-       c->x = ((float)i - 0.5f) * p->size;
+       c->co[0] = ((float)i - 0.5f) * p->size;
        c->j = j; 
-       c->y = ((float)j - 0.5f) * p->size;
+       c->co[1] = ((float)j - 0.5f) * p->size;
        c->k = k; 
-       c->z = ((float)k - 0.5f) * p->size;
-       c->value = p->function(c->x, c->y, c->z);
+       c->co[2] = ((float)k - 0.5f) * p->size;
+       c->value = p->function(c->co[0], c->co[1], c->co[2]);
        
        c->next = p->corners[index];
        p->corners[index] = c;
@@ -1204,7 +1195,7 @@ void BKE_mball_cubeTable_free(void)
 /* setcenter: set (i, j, k) entry of table[]
  * return 1 if already set; otherwise, set and return 0 */
 
-static int setcenter(CENTERLIST *table[], int i, int j, int k)
+static int setcenter(CENTERLIST *table[], const int i, const int j, const int k)
 {
        int index;
        CENTERLIST *newc, *l, *q;
@@ -1324,72 +1315,46 @@ static void addtovertices(VERTICES *vertices, VERTEX v)
 
 /* vnormal: compute unit length surface normal at point */
 
-static void vnormal(MB_POINT *point, PROCESS *p, MB_POINT *v)
+static void vnormal(const float point[3], PROCESS *p, float r_no[3])
 {
        float delta = 0.2f * p->delta;
-       float f = p->function(point->x, point->y, point->z);
-
-       v->x = p->function(point->x + delta, point->y, point->z) - f;
-       v->y = p->function(point->x, point->y + delta, point->z) - f;
-       v->z = p->function(point->x, point->y, point->z + delta) - f;
-       f = sqrtf(v->x * v->x + v->y * v->y + v->z * v->z);
+       float f = p->function(point[0], point[1], point[2]);
 
-       if (f != 0.0f) {
-               v->x /= f; 
-               v->y /= f; 
-               v->z /= f;
-       }
+       r_no[0] = p->function(point[0] + delta, point[1], point[2]) - f;
+       r_no[1] = p->function(point[0], point[1] + delta, point[2]) - f;
+       r_no[2] = p->function(point[0], point[1], point[2] + delta) - f;
+       f = normalize_v3(r_no);
        
-       if (FALSE) {
-               MB_POINT temp;
+       if (0) {
+               float tvec[3];
                
                delta *= 2.0f;
                
-               f = p->function(point->x, point->y, point->z);
+               f = p->function(point[0], point[1], point[2]);
        
-               temp.x = p->function(point->x + delta, point->y, point->z) - f;
-               temp.y = p->function(point->x, point->y + delta, point->z) - f;
-               temp.z = p->function(point->x, point->y, point->z + delta) - f;
-               f = sqrtf(temp.x * temp.x + temp.y * temp.y + temp.z * temp.z);
+               tvec[0] = p->function(point[0] + delta, point[1], point[2]) - f;
+               tvec[1] = p->function(point[0], point[1] + delta, point[2]) - f;
+               tvec[2] = p->function(point[0], point[1], point[2] + delta) - f;
        
-               if (f != 0.0f) {
-                       temp.x /= f; 
-                       temp.y /= f; 
-                       temp.z /= f;
-                       
-                       v->x += temp.x;
-                       v->y += temp.y;
-                       v->z += temp.z;
-                       
-                       f = sqrtf(v->x * v->x + v->y * v->y + v->z * v->z);
-               
-                       if (f != 0.0f) {
-                               v->x /= f; 
-                               v->y /= f; 
-                               v->z /= f;
-                       }
+               if (normalize_v3(tvec) != 0.0f) {
+                       add_v3_v3(r_no, tvec);
+                       normalize_v3(r_no);
                }
        }
-       
 }
 
 
-static int vertid(CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb)
+static int vertid(const CORNER *c1, const CORNER *c2, PROCESS *p, MetaBall *mb)
 {
        VERTEX v;
-       MB_POINT a, b;
        int vid = getedge(p->edges, c1->i, c1->j, c1->k, c2->i, c2->j, c2->k);
 
-       if (vid != -1) return vid;               /* previously computed */
-       a.x = c1->x; 
-       a.y = c1->y; 
-       a.z = c1->z;
-       b.x = c2->x; 
-       b.y = c2->y; 
-       b.z = c2->z;
+       if (vid != -1) {
+               return vid;  /* previously computed */
+       }
 
-       converge(&a, &b, c1->value, c2->value, p->function, &v.position, mb, 1); /* position */
-       vnormal(&v.position, p, &v.normal);
+       converge(c1->co, c2->co, c1->value, c2->value, p->function, v.co, mb, 1); /* position */
+       vnormal(v.co, p, v.no);
 
        addtovertices(&p->vertices, v);            /* save vertex */
        vid = p->vertices.count - 1;
@@ -1403,101 +1368,95 @@ static int vertid(CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb)
 
 /* converge: from two points of differing sign, converge to zero crossing */
 /* watch it: p1 and p2 are used to calculate */
-static void converge(MB_POINT *p1, MB_POINT *p2, float v1, float v2,
-                     float (*function)(float, float, float), MB_POINT *p, MetaBall *mb, int f)
+static void converge(const float p1[3], const float p2[3], float v1, float v2,
+                     float (*function)(float, float, float), float p[3], MetaBall *mb, int f)
 {
        int i = 0;
-       MB_POINT pos, neg;
+       float pos[3], neg[3];
        float positive = 0.0f, negative = 0.0f;
-       float dx = 0.0f, dy = 0.0f, dz = 0.0f;
+       float dvec[3];
        
        if (v1 < 0) {
-               pos = *p2;
-               neg = *p1;
+               copy_v3_v3(pos, p2);
+               copy_v3_v3(neg, p1);
                positive = v2;
                negative = v1;
        }
        else {
-               pos = *p1;
-               neg = *p2;
+               copy_v3_v3(pos, p1);
+               copy_v3_v3(neg, p2);
                positive = v1;
                negative = v2;
        }
 
-       dx = pos.x - neg.x;
-       dy = pos.y - neg.y;
-       dz = pos.z - neg.z;
+       sub_v3_v3v3(dvec, pos, neg);
 
 /* Approximation by linear interpolation is faster then binary subdivision,
  * but it results sometimes (mb->thresh < 0.2) into the strange results */
        if ((mb->thresh > 0.2f) && (f == 1)) {
-               if ((dy == 0.0f) && (dz == 0.0f)) {
-                       p->x = neg.x - negative * dx / (positive - negative);
-                       p->y = neg.y;
-                       p->z = neg.z;
+               if ((dvec[1] == 0.0f) && (dvec[2] == 0.0f)) {
+                       p[0] = neg[0] - negative * dvec[0] / (positive - negative);
+                       p[1] = neg[1];
+                       p[2] = neg[2];
                        return;
                }
-               if ((dx == 0.0f) && (dz == 0.0f)) {
-                       p->x = neg.x;
-                       p->y = neg.y - negative * dy / (positive - negative);
-                       p->z = neg.z;
+               if ((dvec[0] == 0.0f) && (dvec[2] == 0.0f)) {
+                       p[0] = neg[0];
+                       p[1] = neg[1] - negative * dvec[1] / (positive - negative);
+                       p[2] = neg[2];
                        return;
                }
-               if ((dx == 0.0f) && (dy == 0.0f)) {
-                       p->x = neg.x;
-                       p->y = neg.y;
-                       p->z = neg.z - negative * dz / (positive - negative);
+               if ((dvec[0] == 0.0f) && (dvec[1] == 0.0f)) {
+                       p[0] = neg[0];
+                       p[1] = neg[1];
+                       p[2] = neg[2] - negative * dvec[2] / (positive - negative);
                        return;
                }
        }
 
-       if ((dy == 0.0f) && (dz == 0.0f)) {
-               p->y = neg.y;
-               p->z = neg.z;
+       if ((dvec[1] == 0.0f) && (dvec[2] == 0.0f)) {
+               p[1] = neg[1];
+               p[2] = neg[2];
                while (1) {
                        if (i++ == RES) return;
-                       p->x = 0.5f * (pos.x + neg.x);
-                       if ((function(p->x, p->y, p->z)) > 0.0f) pos.x = p->x; else neg.x = p->x;
+                       p[0] = 0.5f * (pos[0] + neg[0]);
+                       if ((function(p[0], p[1], p[2])) > 0.0f) pos[0] = p[0]; else neg[0] = p[0];
                }
        }
 
-       if ((dx == 0.0f) && (dz == 0.0f)) {
-               p->x = neg.x;
-               p->z = neg.z;
+       if ((dvec[0] == 0.0f) && (dvec[2] == 0.0f)) {
+               p[0] = neg[0];
+               p[2] = neg[2];
                while (1) {
                        if (i++ == RES) return;
-                       p->y = 0.5f * (pos.y + neg.y);
-                       if ((function(p->x, p->y, p->z)) > 0.0f) pos.y = p->y; else neg.y = p->y;
+                       p[1] = 0.5f * (pos[1] + neg[1]);
+                       if ((function(p[0], p[1], p[2])) > 0.0f) pos[1] = p[1]; else neg[1] = p[1];
                }
        }
-   
-       if ((dx == 0.0f) && (dy == 0.0f)) {
-               p->x = neg.x;
-               p->y = neg.y;
+
+       if ((dvec[0] == 0.0f) && (dvec[1] == 0.0f)) {
+               p[0] = neg[0];
+               p[1] = neg[1];
                while (1) {
                        if (i++ == RES) return;
-                       p->z = 0.5f * (pos.z + neg.z);
-                       if ((function(p->x, p->y, p->z)) > 0.0f) pos.z = p->z; else neg.z = p->z;
+                       p[2] = 0.5f * (pos[2] + neg[2]);
+                       if ((function(p[0], p[1], p[2])) > 0.0f) pos[2] = p[2]; else neg[2] = p[2];
                }
        }
 
        /* This is necessary to find start point */
        while (1) {
-               p->x = 0.5f * (pos.x + neg.x);
-               p->y = 0.5f * (pos.y + neg.y);
-               p->z = 0.5f * (pos.z + neg.z);
-
-               if (i++ == RES) return;
-   
-               if ((function(p->x, p->y, p->z)) > 0.0f) {
-                       pos.x = p->x;
-                       pos.y = p->y;
-                       pos.z = p->z;
+               mid_v3_v3v3(&p[0], pos, neg);
+
+               if (i++ == RES) {
+                       return;
+               }
+
+               if ((function(p[0], p[1], p[2])) > 0.0f) {
+                       copy_v3_v3(pos, &p[0]);
                }
                else {
-                       neg.x = p->x;
-                       neg.y = p->y;
-                       neg.z = p->z;
+                       copy_v3_v3(neg, &p[0]);
                }
        }
 }
@@ -1535,105 +1494,100 @@ static void add_cube(PROCESS *mbproc, int i, int j, int k, int count)
 
 static void find_first_points(PROCESS *mbproc, MetaBall *mb, int a)
 {
-       MB_POINT IN, in, OUT, out; /*point;*/
        MetaElem *ml;
-       int i, j, k, c_i, c_j, c_k;
-       int index[3] = {1, 0, -1};
        float f = 0.0f;
-       float in_v /*, out_v*/;
-       MB_POINT workp;
-       float tmp_v, workp_v, max_len, len, dx, dy, dz, nx, ny, nz, MAXN;
 
        ml = mainb[a];
-
-       f = 1 - (mb->thresh / ml->s);
+       f = 1.0 - (mb->thresh / ml->s);
 
        /* Skip, when Stiffness of MetaElement is too small ... MetaElement can't be
         * visible alone ... but still can influence others MetaElements :-) */
        if (f > 0.0f) {
-               OUT.x = IN.x = in.x = 0.0;
-               OUT.y = IN.y = in.y = 0.0;
-               OUT.z = IN.z = in.z = 0.0;
+               float IN[3] = {0.0f}, OUT[3] = {0.0f}, in[3] = {0.0f}, out[3];
+               int i, j, k, c_i, c_j, c_k;
+               int index[3] = {1, 0, -1};
+               float in_v /*, out_v*/;
+               float workp[3];
+               float dvec[3];
+               float tmp_v, workp_v, max_len, len, nx, ny, nz, MAXN;
 
-               calc_mballco(ml, (float *)&in);
-               in_v = mbproc->function(in.x, in.y, in.z);
+               calc_mballco(ml, in);
+               in_v = mbproc->function(in[0], in[1], in[2]);
 
                for (i = 0; i < 3; i++) {
                        switch (ml->type) {
                                case MB_BALL:
-                                       OUT.x = out.x = IN.x + index[i] * ml->rad;
+                                       OUT[0] = out[0] = IN[0] + index[i] * ml->rad;
                                        break;
                                case MB_TUBE:
                                case MB_PLANE:
                                case MB_ELIPSOID:
                                case MB_CUBE:
-                                       OUT.x = out.x = IN.x + index[i] * (ml->expx + ml->rad);
+                                       OUT[0] = out[0] = IN[0] + index[i] * (ml->expx + ml->rad);
                                        break;
                        }
 
                        for (j = 0; j < 3; j++) {
                                switch (ml->type) {
                                        case MB_BALL:
-                                               OUT.y = out.y = IN.y + index[j] * ml->rad;
+                                               OUT[1] = out[1] = IN[1] + index[j] * ml->rad;
                                                break;
                                        case MB_TUBE:
                                        case MB_PLANE:
                                        case MB_ELIPSOID:
                                        case MB_CUBE:
-                                               OUT.y = out.y = IN.y + index[j] * (ml->expy + ml->rad);
+                                               OUT[1] = out[1] = IN[1] + index[j] * (ml->expy + ml->rad);
                                                break;
                                }
                        
                                for (k = 0; k < 3; k++) {
-                                       out.x = OUT.x;
-                                       out.y = OUT.y;
+                                       out[0] = OUT[0];
+                                       out[1] = OUT[1];
                                        switch (ml->type) {
                                                case MB_BALL:
                                                case MB_TUBE:
                                                case MB_PLANE:
-                                                       out.z = IN.z + index[k] * ml->rad;
+                                                       out[2] = IN[2] + index[k] * ml->rad;
                                                        break;
                                                case MB_ELIPSOID:
                                                case MB_CUBE:
-                                                       out.z = IN.z + index[k] * (ml->expz + ml->rad);
+                                                       out[2] = IN[2] + index[k] * (ml->expz + ml->rad);
                                                        break;
                                        }
 
-                                       calc_mballco(ml, (float *)&out);
+                                       calc_mballco(ml, out);
 
-                                       /*out_v = mbproc->function(out.x, out.y, out.z);*/ /*UNUSED*/
+                                       /*out_v = mbproc->function(out[0], out[1], out[2]);*/ /*UNUSED*/
 
                                        /* find "first points" on Implicit Surface of MetaElemnt ml */
-                                       workp.x = in.x;
-                                       workp.y = in.y;
-                                       workp.z = in.z;
+                                       copy_v3_v3(workp, in);
                                        workp_v = in_v;
-                                       max_len = sqrtf((out.x - in.x) * (out.x - in.x) + (out.y - in.y) * (out.y - in.y) + (out.z - in.z) * (out.z - in.z));
+                                       max_len = len_v3v3(out, in);
 
-                                       nx = abs((out.x - in.x) / mbproc->size);
-                                       ny = abs((out.y - in.y) / mbproc->size);
-                                       nz = abs((out.z - in.z) / mbproc->size);
+                                       nx = abs((out[0] - in[0]) / mbproc->size);
+                                       ny = abs((out[1] - in[1]) / mbproc->size);
+                                       nz = abs((out[2] - in[2]) / mbproc->size);
                                        
                                        MAXN = MAX3(nx, ny, nz);
                                        if (MAXN != 0.0f) {
-                                               dx = (out.x - in.x) / MAXN;
-                                               dy = (out.y - in.y) / MAXN;
-                                               dz = (out.z - in.z) / MAXN;
+                                               dvec[0] = (out[0] - in[0]) / MAXN;
+                                               dvec[1] = (out[1] - in[1]) / MAXN;
+                                               dvec[2] = (out[2] - in[2]) / MAXN;
 
                                                len = 0.0;
                                                while (len <= max_len) {
-                                                       workp.x += dx;
-                                                       workp.y += dy;
-                                                       workp.z += dz;
+                                                       workp[0] += dvec[0];
+                                                       workp[1] += dvec[1];
+                                                       workp[2] += dvec[2];
                                                        /* compute value of implicite function */
-                                                       tmp_v = mbproc->function(workp.x, workp.y, workp.z);
+                                                       tmp_v = mbproc->function(workp[0], workp[1], workp[2]);
                                                        /* add cube to the stack, when value of implicite function crosses zero value */
                                                        if ((tmp_v < 0.0f && workp_v >= 0.0f) || (tmp_v > 0.0f && workp_v <= 0.0f)) {
 
                                                                /* indexes of CUBE, which includes "first point" */
-                                                               c_i = (int)floor(workp.x / mbproc->size);
-                                                               c_j = (int)floor(workp.y / mbproc->size);
-                                                               c_k = (int)floor(workp.z / mbproc->size);
+                                                               c_i = (int)floor(workp[0] / mbproc->size);
+                                                               c_j = (int)floor(workp[1] / mbproc->size);
+                                                               c_k = (int)floor(workp[2] / mbproc->size);
                                                                
                                                                /* add CUBE (with indexes c_i, c_j, c_k) to the stack,
                                                                 * this cube includes found point of Implicit Surface */
@@ -1642,7 +1596,7 @@ static void find_first_points(PROCESS *mbproc, MetaBall *mb, int a)
                                                                else
                                                                        add_cube(mbproc, c_i, c_j, c_k, 1);
                                                        }
-                                                       len = sqrtf((workp.x - in.x) * (workp.x - in.x) + (workp.y - in.y) * (workp.y - in.y) + (workp.z - in.z) * (workp.z - in.z));
+                                                       len = len_v3v3(workp, in);
                                                        workp_v = tmp_v;
 
                                                }
@@ -2283,7 +2237,7 @@ void BKE_mball_polygonize(Scene *scene, Object *ob, ListBase *dispbase)
        MetaBall *mb;
        DispList *dl;
        int a, nr_cubes;
-       float *ve, *no, totsize, width;
+       float *co, *no, totsize, width;
 
        mb = ob->data;
 
@@ -2362,6 +2316,8 @@ void BKE_mball_polygonize(Scene *scene, Object *ob, ListBase *dispbase)
        }
 
        if (curindex) {
+               VERTEX *ptr = mbproc.vertices.ptr;
+
                dl = MEM_callocN(sizeof(DispList), "mbaldisp");
                BLI_addtail(dispbase, dl);
                dl->type = DL_INDEX4;
@@ -2372,17 +2328,12 @@ void BKE_mball_polygonize(Scene *scene, Object *ob, ListBase *dispbase)
                indices = NULL;
 
                a = mbproc.vertices.count;
-               dl->verts = ve = MEM_mallocN(sizeof(float) * 3 * a, "mballverts");
+               dl->verts = co = MEM_mallocN(sizeof(float) * 3 * a, "mballverts");
                dl->nors = no = MEM_mallocN(sizeof(float) * 3 * a, "mballnors");
 
-               for (a = 0; a < mbproc.vertices.count; a++, no += 3, ve += 3) {
-                       ve[0] = mbproc.vertices.ptr[a].position.x;
-                       ve[1] = mbproc.vertices.ptr[a].position.y;
-                       ve[2] = mbproc.vertices.ptr[a].position.z;
-
-                       no[0] = mbproc.vertices.ptr[a].normal.x;
-                       no[1] = mbproc.vertices.ptr[a].normal.y;
-                       no[2] = mbproc.vertices.ptr[a].normal.z;
+               for (a = 0; a < mbproc.vertices.count; ptr++, a++, no += 3, co += 3) {
+                       copy_v3_v3(co, ptr->co);
+                       copy_v3_v3(no, ptr->no);
                }
        }
 
@@ -2403,29 +2354,30 @@ int BKE_mball_minmax(MetaBall *mb, float min[3], float max[3])
        return (mb->elems.first != NULL);
 }
 
-int BKE_mball_center_median(MetaBall *mb, float cent[3])
+int BKE_mball_center_median(MetaBall *mb, float r_cent[3])
 {
        MetaElem *ml;
        int total = 0;
 
-       zero_v3(cent);
+       zero_v3(r_cent);
 
        for (ml = mb->elems.first; ml; ml = ml->next) {
-               add_v3_v3(cent, &ml->x);
+               add_v3_v3(r_cent, &ml->x);
        }
 
-       if (total)
-               mul_v3_fl(cent, 1.0f / (float)total);
+       if (total) {
+               mul_v3_fl(r_cent, 1.0f / (float)total);
+       }
 
        return (total != 0);
 }
 
-int BKE_mball_center_bounds(MetaBall *mb, float cent[3])
+int BKE_mball_center_bounds(MetaBall *mb, float r_cent[3])
 {
        float min[3], max[3];
 
        if (BKE_mball_minmax(mb, min, max)) {
-               mid_v3_v3v3(cent, min, max);
+               mid_v3_v3v3(r_cent, min, max);
                return 1;
        }
 
index 77cd127e6ea6c77bff40969d9d3b6b2e78aaba8d..f5ae3c7da2b3613b54739b838ad2d12412a0a6d9 100644 (file)
@@ -167,7 +167,7 @@ static int customdata_compare(CustomData *c1, CustomData *c2, Mesh *m1, Mesh *m2
                        for (j = 0; j < vtot; j++, v1++, v2++) {
                                if (len_v3v3(v1->co, v2->co) > thresh)
                                        return MESHCMP_VERTCOMISMATCH;
-                               /*I don't care about normals, let's just do coodinates*/
+                               /* I don't care about normals, let's just do coodinates */
                        }
                }
                
@@ -990,7 +990,7 @@ static void make_edges_mdata(MVert *UNUSED(allvert), MFace *allface, MLoop *alll
 
        MEM_freeN(edsort);
        
-       /*set edge members of mloops*/
+       /* set edge members of mloops */
        medge = *alledge;
        for (a = 0; a < *_totedge; a++, medge++) {
                BLI_edgehash_insert(hash, medge->v1, medge->v2, SET_INT_IN_POINTER(a));
@@ -1846,7 +1846,7 @@ void BKE_mesh_calc_normals_mapping_ex(MVert *mverts, int numVerts,
                return;
        }
 
-       /* if we are not calculating verts and no verts were passes thene we have nothign to do */
+       /* if we are not calculating verts and no verts were passes then we have nothing to do */
        if ((only_face_normals == TRUE) && (polyNors_r == NULL) && (faceNors_r == NULL)) {
                printf("%s: called with nothing to do\n", __func__);
                return;
@@ -1910,7 +1910,7 @@ void BKE_mesh_calc_normals(MVert *mverts, int numVerts, MLoop *mloop, MPoly *mpo
 
        if (!pnors) pnors = MEM_callocN(sizeof(float) * 3 * numPolys, "poly_nors mesh.c");
 
-       /*first go through and calculate normals for all the polys*/
+       /* first go through and calculate normals for all the polys */
        tnorms = MEM_callocN(sizeof(float) * 3 * numVerts, "tnorms mesh.c");
 
        mp = mpolys;
@@ -2820,7 +2820,7 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
                        mf = &mface[k];
 
                        if (mf->edcode == 3) {
-                               /*sort loop indices to ensure winding is correct*/
+                               /* sort loop indices to ensure winding is correct */
                                /* NO SORT - looks like we can skip this */
 
                                lindex[0] = mf->v1;
@@ -2828,7 +2828,7 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
                                lindex[2] = mf->v3;
                                lindex[3] = 0; /* unused */
 
-                               /*transform loop indices to vert indices*/
+                               /* transform loop indices to vert indices */
                                mf->v1 = mloop[mf->v1].v;
                                mf->v2 = mloop[mf->v2].v;
                                mf->v3 = mloop[mf->v3].v;
@@ -2839,7 +2839,7 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
                                test_index_face(mf, fdata, k, 3);
                        }
                        else {
-                               /*sort loop indices to ensure winding is correct*/
+                               /* sort loop indices to ensure winding is correct */
                                /* NO SORT - looks like we can skip this */
 
                                lindex[0] = mf->v1;
@@ -2847,7 +2847,7 @@ int BKE_mesh_mpoly_to_mface(struct CustomData *fdata, struct CustomData *ldata,
                                lindex[2] = mf->v3;
                                lindex[3] = mf->v4;
 
-                               /*transform loop indices to vert indices*/
+                               /* transform loop indices to vert indices */
                                mf->v1 = mloop[mf->v1].v;
                                mf->v2 = mloop[mf->v2].v;
                                mf->v3 = mloop[mf->v3].v;
index 4f4ee3f8433c55c406287c9e952e0a8361557632..914e19bd1dcac45d3b6ae6efac03bbcbeb27ae3c 100644 (file)
@@ -2234,7 +2234,7 @@ void BKE_object_dimensions_set(Object *ob, const float *value)
        }
 }
 
-void BKE_object_minmax(Object *ob, float min_r[3], float max_r[3])
+void BKE_object_minmax(Object *ob, float min_r[3], float max_r[3], const short use_hidden)
 {
        BoundBox bb;
        float vec[3];
@@ -2284,14 +2284,23 @@ void BKE_object_minmax(Object *ob, float min_r[3], float max_r[3])
                break;
                case OB_ARMATURE:
                        if (ob->pose) {
+                               bArmature *arm = ob->data;
                                bPoseChannel *pchan;
+
                                for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
-                                       mul_v3_m4v3(vec, ob->obmat, pchan->pose_head);
-                                       minmax_v3v3_v3(min_r, max_r, vec);
-                                       mul_v3_m4v3(vec, ob->obmat, pchan->pose_tail);
-                                       minmax_v3v3_v3(min_r, max_r, vec);
+
+                                       if ((use_hidden == FALSE) && (PBONE_VISIBLE(arm, pchan->bone) == FALSE)) {
+                                               /* pass */
+                                       }
+                                       else {
+                                               mul_v3_m4v3(vec, ob->obmat, pchan->pose_head);
+                                               minmax_v3v3_v3(min_r, max_r, vec);
+                                               mul_v3_m4v3(vec, ob->obmat, pchan->pose_tail);
+                                               minmax_v3v3_v3(min_r, max_r, vec);
+
+                                               change = TRUE;
+                                       }
                                }
-                               change = TRUE;
                        }
                        break;
                case OB_MESH:
@@ -2331,9 +2340,9 @@ void BKE_object_minmax(Object *ob, float min_r[3], float max_r[3])
        }
 }
 
-int BKE_object_minmax_dupli(Scene *scene, Object *ob, float r_min[3], float r_max[3])
+int BKE_object_minmax_dupli(Scene *scene, Object *ob, float r_min[3], float r_max[3], const short use_hidden)
 {
-       int ok = 0;
+       int ok = FALSE;
        if ((ob->transflag & OB_DUPLI) == 0) {
                return ok;
        }
@@ -2343,7 +2352,10 @@ int BKE_object_minmax_dupli(Scene *scene, Object *ob, float r_min[3], float r_ma
                
                lb = object_duplilist(scene, ob);
                for (dob = lb->first; dob; dob = dob->next) {
-                       if (dob->no_draw == 0) {
+                       if ((use_hidden == FALSE) && (dob->no_draw != 0)) {
+                               /* pass */
+                       }
+                       else {
                                BoundBox *bb = BKE_object_boundbox_get(dob->ob);
 
                                if (bb) {
@@ -2354,7 +2366,7 @@ int BKE_object_minmax_dupli(Scene *scene, Object *ob, float r_min[3], float r_ma
                                                minmax_v3v3_v3(r_min, r_max, vec);
                                        }
 
-                                       ok = 1;
+                                       ok = TRUE;
                                }
                        }
                }
index 444fbb2fc9f4ed643d3480e0ed2954bcbf666bdc..fc261d48132e74ff5d0f66521622c853e5c69c89 100644 (file)
@@ -563,14 +563,7 @@ Scene *BKE_scene_add(const char *name)
 
 Base *BKE_scene_base_find(Scene *scene, Object *ob)
 {
-       Base *base;
-       
-       base = scene->base.first;
-       while (base) {
-               if (base->object == ob) return base;
-               base = base->next;
-       }
-       return NULL;
+       return BLI_findptr(&scene->base, ob, offsetof(Base, object));
 }
 
 void BKE_scene_set_background(Main *bmain, Scene *scene)
@@ -595,10 +588,10 @@ void BKE_scene_set_background(Main *bmain, Scene *scene)
 
        /* group flags again */
        for (group = bmain->group.first; group; group = group->id.next) {
-               go = group->gobject.first;
-               while (go) {
-                       if (go->ob) go->ob->flag |= OB_FROMGROUP;
-                       go = go->next;
+               for (go = group->gobject.first; go; go = go->next) {
+                       if (go->ob) {
+                               go->ob->flag |= OB_FROMGROUP;
+                       }
                }
        }
 
index 2380596c6adfd41e51fc1c64c3d4c4921976476c..87906337ca21863483757f406fc777a2090aea47 100644 (file)
@@ -284,14 +284,14 @@ static void do_alphaover_effect(SeqRenderData context, Sequence *UNUSED(seq), fl
                                 int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_alphaover_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -446,14 +446,14 @@ static void do_alphaunder_effect(SeqRenderData context, Sequence *UNUSED(seq), f
                                  int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_alphaunder_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -556,14 +556,14 @@ static void do_cross_effect(SeqRenderData context, Sequence *UNUSED(seq), float
                             int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_cross_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -805,14 +805,14 @@ static void do_gammacross_effect(SeqRenderData context, Sequence *UNUSED(seq), f
                                  int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_gammacross_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -911,14 +911,14 @@ static void do_add_effect(SeqRenderData context, Sequence *UNUSED(seq), float UN
                           ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_add_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -1015,14 +1015,14 @@ static void do_sub_effect(SeqRenderData context, Sequence *UNUSED(seq), float UN
                           ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_sub_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -1212,14 +1212,14 @@ static void do_mul_effect(SeqRenderData context, Sequence *UNUSED(seq), float UN
                           ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *UNUSED(ibuf3), int start_line, int total_lines, ImBuf *out)
 {
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
                do_mul_effect_float(facf0, facf1, context.rectx, total_lines, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -2746,7 +2746,7 @@ static void do_overdrop_effect(SeqRenderData context, Sequence *UNUSED(seq), flo
        int y = total_lines;
 
        if (out->rect_float) {
-               float *rect1, *rect2, *rect_out;
+               float *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_float_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
@@ -2754,7 +2754,7 @@ static void do_overdrop_effect(SeqRenderData context, Sequence *UNUSED(seq), flo
                do_alphaover_effect_float(facf0, facf1, x, y, rect1, rect2, rect_out);
        }
        else {
-               unsigned char *rect1, *rect2, *rect_out;
+               unsigned char *rect1 = NULL, *rect2 = NULL, *rect_out = NULL;
 
                slize_get_byte_buffers(&context, ibuf1, ibuf2, NULL, out, start_line, &rect1, &rect2, NULL, &rect_out);
 
index f342ea088f71c38b5acd1d80249d37655434ce59..bd5415f591beede5705b824e296b85f0b80cbd0e 100644 (file)
@@ -3626,7 +3626,7 @@ static void seq_free_animdata(Scene *scene, Sequence *seq)
        }
 }
 
-Sequence *BKE_sequwnce_get_by_name(ListBase *seqbase, const char *name, int recursive)
+Sequence *BKE_sequence_get_by_name(ListBase *seqbase, const char *name, int recursive)
 {
        Sequence *iseq = NULL;
        Sequence *rseq = NULL;
@@ -3634,7 +3634,7 @@ Sequence *BKE_sequwnce_get_by_name(ListBase *seqbase, const char *name, int recu
        for (iseq = seqbase->first; iseq; iseq = iseq->next) {
                if (strcmp(name, iseq->name + 2) == 0)
                        return iseq;
-               else if (recursive && (iseq->seqbase.first) && (rseq = BKE_sequwnce_get_by_name(&iseq->seqbase, name, 1))) {
+               else if (recursive && (iseq->seqbase.first) && (rseq = BKE_sequence_get_by_name(&iseq->seqbase, name, 1))) {
                        return rseq;
                }
        }
index 5c387e8cee0fa2469c73cb693811696dfd559048..b2762d23ef342b08e8151b9c01e2a3a9a986fc0f 100644 (file)
@@ -113,7 +113,8 @@ typedef enum {
        CCG_USE_ARENA = 2,
        CCG_CALC_NORMALS = 4,
        /* add an extra four bytes for a mask layer */
-       CCG_ALLOC_MASK = 8
+       CCG_ALLOC_MASK = 8,
+       CCG_SIMPLE_SUBDIV = 16
 } CCGFlags;
 
 static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels,
@@ -133,7 +134,10 @@ static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels,
 
                ccgSubSurf_getUseAgeCounts(prevSS, &oldUseAging, NULL, NULL, NULL);
 
-               if (oldUseAging != useAging) {
+               if ((oldUseAging != useAging) ||
+                       (ccgSubSurf_getSimpleSubdiv(prevSS) !=
+                        !!(flags & CCG_SIMPLE_SUBDIV)))
+               {
                        ccgSubSurf_free(prevSS);
                }
                else {
@@ -156,6 +160,7 @@ static CCGSubSurf *_getSubSurf(CCGSubSurf *prevSS, int subdivLevels,
                ifc.vertDataSize += sizeof(float) * 3;
        if (flags & CCG_ALLOC_MASK)
                ifc.vertDataSize += sizeof(float);
+       ifc.simpleSubdiv = !!(flags & CCG_SIMPLE_SUBDIV);
 
        if (useArena) {
                CCGAllocatorIFC allocatorIFC;
@@ -3474,7 +3479,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
         float (*vertCos)[3],
         SubsurfFlags flags)
 {
-       int useSimple = smd->subdivType == ME_SIMPLE_SUBSURF;
+       int useSimple = (smd->subdivType == ME_SIMPLE_SUBSURF) ? CCG_SIMPLE_SUBDIV : 0;
        CCGFlags useAging = smd->flags & eSubsurfModifierFlag_DebugIncr ? CCG_USE_AGING : 0;
        int useSubsurfUv = smd->flags & eSubsurfModifierFlag_SubsurfUv;
        int drawInteriorEdges = !(smd->flags & eSubsurfModifierFlag_ControlEdges);
@@ -3483,7 +3488,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
        if (flags & SUBSURF_FOR_EDIT_MODE) {
                int levels = (smd->modifier.scene) ? get_render_subsurf_level(&smd->modifier.scene->r, smd->levels) : smd->levels;
 
-               smd->emCache = _getSubSurf(smd->emCache, levels, 3, useAging | CCG_CALC_NORMALS);
+               smd->emCache = _getSubSurf(smd->emCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
                ss_sync_from_derivedmesh(smd->emCache, dm, vertCos, useSimple);
 
                result = getCCGDerivedMesh(smd->emCache,
@@ -3498,7 +3503,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
                if (levels == 0)
                        return dm;
                
-               ss = _getSubSurf(NULL, levels, 3, CCG_USE_ARENA | CCG_CALC_NORMALS);
+               ss = _getSubSurf(NULL, levels, 3, useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS);
 
                ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple);
 
@@ -3529,7 +3534,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
                }
 
                if (useIncremental && (flags & SUBSURF_IS_FINAL_CALC)) {
-                       smd->mCache = ss = _getSubSurf(smd->mCache, levels, 3, useAging | CCG_CALC_NORMALS);
+                       smd->mCache = ss = _getSubSurf(smd->mCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
 
                        ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple);
 
@@ -3538,7 +3543,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
                                                   useSubsurfUv, dm);
                }
                else {
-                       CCGFlags ccg_flags = CCG_USE_ARENA | CCG_CALC_NORMALS;
+                       CCGFlags ccg_flags = useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS;
                        
                        if (smd->mCache && (flags & SUBSURF_IS_FINAL_CALC)) {
                                ccgSubSurf_free(smd->mCache);
index abe7eacb1ac0c89b87f82d68768c9ccc138ccfb8..1330a74bea3ae4aaeab823af2cb683c795d52876 100644 (file)
@@ -48,11 +48,13 @@ int BLI_findstringindex(const struct ListBase *listbase, const char *id, const i
 void *BLI_findlink(const struct ListBase *listbase, int number);
 void *BLI_findstring(const struct ListBase *listbase, const char *id, const int offset);
 void *BLI_findstring_ptr(const struct ListBase *listbase, const char *id, const int offset);
+void *BLI_findptr(const struct ListBase *listbase, const void *ptr, const int offset);
 
 /* find backwards */
 void *BLI_rfindlink(const struct ListBase *listbase, int number);
 void *BLI_rfindstring(const struct ListBase *listbase, const char *id, const int offset);
 void *BLI_rfindstring_ptr(const struct ListBase *listbase, const char *id, const int offset);
+void *BLI_rfindptr(const struct ListBase *listbase, const void *ptr, const int offset);
 
 void BLI_freelistN(struct ListBase *listbase);
 void BLI_addtail(struct ListBase *listbase, void *vlink);
index 55ab961cc534e19b9cc4679ca882e2ce040b4cd5..d6579afcd0d11ebfcf8219384342d97ccff21c58 100644 (file)
@@ -69,7 +69,8 @@ int  BLI_rctf_isect(const struct rctf *src1, const struct rctf *src2, struct rct
 int  BLI_rcti_isect(const struct rcti *src1, const struct rcti *src2, struct rcti *dest);
 void BLI_rctf_union(struct rctf *rctf1, const struct rctf *rctf2);
 void BLI_rcti_union(struct rcti *rcti1, const struct rcti *rcti2);
-void BLI_rcti_rctf_copy(struct rcti *tar, const struct rctf *src);
+void BLI_rcti_rctf_copy(struct rcti *dst, const struct rctf *src);
+void BLI_rctf_rcti_copy(struct rctf *dst, const struct rcti *src);
 
 void print_rctf(const char *str, const struct rctf *rect);
 void print_rcti(const char *str, const struct rcti *rect);
index 8fe9a94b466bd1f80754eaafe951d34034fe0585..ad718ed8e114f48d3b962e0a4eebd7f72bb3e72b 100644 (file)
@@ -439,6 +439,44 @@ void *BLI_rfindstring_ptr(const ListBase *listbase, const char *id, const int of
        return NULL;
 }
 
+void *BLI_findptr(const ListBase *listbase, const void *ptr, const int offset)
+{
+       Link *link = NULL;
+       const void *ptr_iter;
+
+       if (listbase == NULL) return NULL;
+
+       for (link = listbase->first; link; link = link->next) {
+               /* exact copy of BLI_findstring(), except for this line */
+               ptr_iter = *((const char **)(((const char *)link) + offset));
+
+               if (ptr == ptr_iter) {
+                       return link;
+               }
+       }
+
+       return NULL;
+}
+/* same as above but find reverse */
+void *BLI_rfindptr(const ListBase *listbase, const void *ptr, const int offset)
+{
+       Link *link = NULL;
+       const void *ptr_iter;
+
+       if (listbase == NULL) return NULL;
+
+       for (link = listbase->last; link; link = link->prev) {
+               /* exact copy of BLI_rfindstring(), except for this line */
+               ptr_iter = *((const char **)(((const char *)link) + offset));
+
+               if (ptr == ptr_iter) {
+                       return link;
+               }
+       }
+
+       return NULL;
+}
+
 int BLI_findstringindex(const ListBase *listbase, const char *id, const int offset)
 {
        Link *link = NULL;
index e22becddfd6683395bbf6054c7b6430a55477e3b..9c65c26c72bfa2ff80b0aba09e1d6cdefeedbd74 100644 (file)
@@ -363,12 +363,20 @@ int BLI_rcti_isect(const rcti *src1, const rcti *src2, rcti *dest)
        }
 }
 
-void BLI_rcti_rctf_copy(rcti *tar, const rctf *src)
+void BLI_rcti_rctf_copy(rcti *dst, const rctf *src)
 {
-       tar->xmin = floorf(src->xmin + 0.5f);
-       tar->xmax = floorf((src->xmax - src->xmin) + 0.5f);
-       tar->ymin = floorf(src->ymin + 0.5f);
-       tar->ymax = floorf((src->ymax - src->ymin) + 0.5f);
+       dst->xmin = floorf(src->xmin + 0.5f);
+       dst->xmax = dst->xmin + floorf((src->xmax - src->xmin) + 0.5f);
+       dst->ymin = floorf(src->ymin + 0.5f);
+       dst->ymax = dst->ymin + floorf((src->ymax - src->ymin) + 0.5f);
+}
+
+void BLI_rctf_rcti_copy(rctf *dst, const rcti *src)
+{
+       dst->xmin = src->xmin;
+       dst->xmax = src->xmax;
+       dst->ymin = src->ymin;
+       dst->ymax = src->ymax;
 }
 
 void print_rctf(const char *str, const rctf *rect)
index f61df9c11f591d5f3b234349bbe839acb691524e..80a4da5cacef614826764ea013335d155ff4431f 100644 (file)
@@ -28,7 +28,7 @@
  * http://blog.ivank.net/fortunes-algorithm-and-implementation.html
  */
 
-/** \file blender/blenkernel/intern/voronoi.c
+/** \file blender/blenlib/intern/voronoi.c
  *  \ingroup bli
  */
 
index 02b4537e9c851a45816d3b60ca7dc02e70fb54c0..2a68af688edc8cf633841aee0ba85183191310af 100644 (file)
@@ -1815,7 +1815,7 @@ static void write_meshs(WriteData *wd, ListBase *idbase)
                                /* backup */
 
 
-                               /* now fill in polys to mfaces*/
+                               /* now fill in polys to mfaces */
                                mesh->totface = BKE_mesh_mpoly_to_mface(&mesh->fdata, &backup_mesh.ldata, &backup_mesh.pdata,
                                                                        mesh->totface, backup_mesh.totloop, backup_mesh.totpoly);
 
index 188d35c6829ce5be8364f4f6c071e06b20fcd59f..8c8cc216e96a4bbe7b2bd9377e8e48148944d128 100644 (file)
@@ -1946,7 +1946,7 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len)
 }
 
 /**
- * High level function which wraps both #bm_vert_separate and #bm_edge_separate
+ * High level function which wraps both #bmesh_vert_separate and #bmesh_edge_separate
  */
 int BM_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len,
                      BMEdge **e_in, int e_in_len)
index 606e9eeb23bc72dfef9e7d17e6af0142ebf54ca9..c3cedcb0e13f02ad0d94750d5608128b7719fb01 100644 (file)
@@ -23,7 +23,7 @@
 #ifndef __BMESH_ERROR_H__
 #define __BMESH_ERROR_H__
 
-/** \file blender/bmesh/bmesh_error.h
+/** \file blender/bmesh/intern/bmesh_error.h
  *  \ingroup bmesh
  */
 
index d16dacaf5cfdd8ce78a5faca740f8407bf232baf..58ccfa79a02d18a301418fa156001ff25ad5140a 100644 (file)
@@ -31,6 +31,8 @@
  * that should be addressed eventually.
  */
 
+#include <stddef.h>
+
 #include "MEM_guardedalloc.h"
 
 #include "DNA_scene_types.h"
@@ -567,9 +569,9 @@ BMFace *BM_active_face_get(BMesh *bm, int sloppy)
  * These functions were written to be used by the Modifier widget
  * when in Rotate about active mode, but can be used anywhere.
  *
- * - #EM_editselection_center
- * - #EM_editselection_normal
- * - #EM_editselection_plane
+ * - #BM_editselection_center
+ * - #BM_editselection_normal
+ * - #BM_editselection_plane
  */
 void BM_editselection_center(BMEditSelection *ese, float r_center[3])
 {
@@ -708,28 +710,19 @@ void BM_editselection_plane(BMEditSelection *ese, float r_plane[3])
 /* --- macro wrapped funcs --- */
 int _bm_select_history_check(BMesh *bm, const BMHeader *ele)
 {
-       BMEditSelection *ese;
-       
-       for (ese = bm->selected.first; ese; ese = ese->next) {
-               if (ese->ele == (BMElem *)ele) {
-                       return TRUE;
-               }
-       }
-       
-       return FALSE;
+       return (BLI_findptr(&bm->selected, ele, offsetof(BMEditSelection, ele)) != NULL);
 }
 
 int _bm_select_history_remove(BMesh *bm, BMHeader *ele)
 {
-       BMEditSelection *ese;
-       for (ese = bm->selected.first; ese; ese = ese->next) {
-               if (ese->ele == (BMElem *)ele) {
-                       BLI_freelinkN(&(bm->selected), ese);
-                       return TRUE;
-               }
+       BMEditSelection *ese = BLI_findptr(&bm->selected, ele, offsetof(BMEditSelection, ele));
+       if (ese) {
+               BLI_freelinkN(&bm->selected, ese);
+               return TRUE;
+       }
+       else {
+               return FALSE;
        }
-
-       return FALSE;
 }
 
 void _bm_select_history_store_notest(BMesh *bm, BMHeader *ele)
index a549c700c07850c9f0f9cfcf7b46466ed836bd56..fc270c61113dcbad18446b8cf00924ae69a51497 100644 (file)
@@ -384,7 +384,7 @@ BMFace *BM_face_split(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **r_l
  * \param bm The bmesh
  * \param f the original face
  * \param v1, v2 vertices which define the split edge, must be different
- * \param co Array of coordinates for intermediate points
+ * \param cos Array of coordinates for intermediate points
  * \param n Length of \a cos (must be > 0)
  * \param r_l pointer which will receive the BMLoop for the first split edge (from \a v1) in the new face
  * \param example Edge used for attributes of splitting edge, if non-NULL
@@ -888,6 +888,7 @@ int BM_edge_rotate_check(BMEdge *e)
  * 1) does the newly forms edge form a flipped face (compare with previous cross product)
  * 2) does the newly formed edge cause a zero area corner (or close enough to be almost zero)
  *
+ * \param e The edge to test rotation.
  * \param l1,l2 are the loops of the proposed verts to rotate too and should
  * be the result of calling #BM_edge_calc_rotate
  */
index a2f14ef838896dd0813e2b0459f11c39c8f2c55d..91a48c782f0780a9a9e4864d929dcb5bdb74ced7 100644 (file)
@@ -23,7 +23,7 @@
 #ifndef __BMESH_OPERATOR_API_H__
 #define __BMESH_OPERATOR_API_H__
 
-/** \file blender/bmesh/bmesh_operator_api.h
+/** \file blender/bmesh/intern/bmesh_operator_api.h
  *  \ingroup bmesh
  */
 
index 5d63172dbfab5d24aaecb6ad33c6ace6c97517ac..807570f0d868b0ce17a3d02ed6fa7c333a4fdcc2 100644 (file)
@@ -646,8 +646,7 @@ static int bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i,
                        continue;
                }
 
-               if (isect_point_tri_v2(pv1, v1, v2, v3) || isect_point_tri_v2(pv1, v3, v2, v1))
-               {
+               if (isect_point_tri_v2(pv1, v1, v2, v3) || isect_point_tri_v2(pv1, v3, v2, v1)) {
 #if 0
                        if (isect_point_tri_v2(pv1, v1, v2, v3))
                                printf("%d in (%d, %d, %d)\n", v3i, i, v1i, v2i);
@@ -664,7 +663,8 @@ static int bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i,
  * \brief Find Ear
  *
  * Used by tessellator to find the next triangle to 'clip off' of a polygon while tessellating.
- *
+ * \param f The face to search.
+ * \param verts an array of face vert coords.
  * \param use_beauty Currently only applies to quads, can be extended later on.
  * \param abscoss Must be allocated by caller, and at least f->len length
  *        (allow to avoid allocating a new one for each tri!).
index ef5145d6582d8131f59ca5f840c4fcf1fc15ecbb..a439eff36f604ea9b5a25e85581ccfd18224d2af 100644 (file)
@@ -797,7 +797,6 @@ float BM_loop_calc_face_angle(BMLoop *l)
  *
  * Calculate the normal at this loop corner or fallback to the face normal on straight lines.
  *
- * \param bm The BMesh
  * \param l The loop to calculate the normal at
  * \param r_normal Resulting normal
  */
@@ -821,7 +820,6 @@ void BM_loop_calc_face_normal(BMLoop *l, float r_normal[3])
  * Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
  * This vector always points inward into the face.
  *
- * \param bm The BMesh
  * \param l The loop to calculate the tangent at
  * \param r_tangent Resulting tangent
  */
@@ -881,6 +879,7 @@ float BM_edge_calc_face_angle(BMEdge *e)
  * \param e
  * \param e_loop The loop to calculate the tangent at,
  * used to get the face and winding direction.
+ * \param r_tangent The loop corner tangent to set
  */
 
 void BM_edge_calc_face_tangent(BMEdge *e, BMLoop *e_loop, float r_tangent[3])
index 65d46bf515ace85b60230557c822b67c441b04ad..c110d4f077e96f1fb168df38bcb291fc1ca417ef 100644 (file)
@@ -473,8 +473,10 @@ set(SRC
        operations/COM_DifferenceMatteOperation.h
        operations/COM_LuminanceMatteOperation.cpp
        operations/COM_LuminanceMatteOperation.h
-       operations/COM_DistanceMatteOperation.cpp
-       operations/COM_DistanceMatteOperation.h
+       operations/COM_DistanceRGBMatteOperation.cpp
+       operations/COM_DistanceRGBMatteOperation.h
+       operations/COM_DistanceYCCMatteOperation.cpp
+       operations/COM_DistanceYCCMatteOperation.h
        operations/COM_ChromaMatteOperation.cpp
        operations/COM_ChromaMatteOperation.h
        operations/COM_ColorMatteOperation.cpp
index 38a3350c2635decbab0478bf23fb216163aa3b38..1b7c435eceae44ae461eb876f396a5d6181e30fa 100644 (file)
@@ -45,7 +45,7 @@ void ChunkOrder::determineDistance(ChunkOrderHotspot **hotspots, unsigned int nu
        this->m_distance = distance;
 }
 
-bool operator<(const ChunkOrder& a, const ChunkOrder& b)
+bool operator<(const ChunkOrder &a, const ChunkOrder &b)
 {
        return a.m_distance < b.m_distance;
 }
index 190ecb9c380f2c347ca0e85c7161d9ccae257993..108836d5299a342b145090e8bc76aa3c8b792465 100644 (file)
@@ -33,7 +33,7 @@ private:
 public:
        ChunkOrder();
        void determineDistance(ChunkOrderHotspot **hotspots, unsigned int numberOfHotspots);
-       friend bool operator<(const ChunkOrder& a, const ChunkOrder& b);
+       friend bool operator<(const ChunkOrder &a, const ChunkOrder &b);
        
        void setChunkNumber(unsigned int chunknumber) { this->m_number = chunknumber; }
        void setX(int x) { this->m_x = x; }
index 97afb7b6bc3c58143315f83f2ade8a2fe2a8c44a..5c89170508954eb931dcbc2056be0f452b3c4117 100644 (file)
@@ -218,7 +218,7 @@ void ExecutionGroup::determineNumberOfChunks()
  */
 void ExecutionGroup::execute(ExecutionSystem *graph)
 {
-       CompositorContextcontext = graph->getContext();
+       CompositorContext &context = graph->getContext();
        const bNodeTree *bTree = context.getbNodeTree();
        if (this->m_width == 0 || this->m_height == 0) {return; } /// @note: break out... no pixels to calculate.
        if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// @note: early break out for blur and preview nodes
index ac849bf4f6cae1b1dae6132933f654f1ba79a817..39e7bc8027976dff17b2ac4cbe4439bb0a7c9e69 100644 (file)
@@ -200,12 +200,12 @@ public:
        /**
         * @brief get the reference to the compositor context
         */
-       CompositorContextgetContext() { return this->m_context; }
+       CompositorContext &getContext() { return this->m_context; }
 
        /**
         * @brief get the reference to the compositor nodes
         */
-       vector<Node *>getNodes() { return this->m_nodes; }
+       vector<Node *> &getNodes() { return this->m_nodes; }
 
        /**
         * @brief get the reference to the compositor connections
index d6730ef6a007fed49b9509a73515b7d573346023..87e7b9d078868732a3af7244fcd20c9d79617d7b 100644 (file)
 
 #include "COM_DistanceMatteNode.h"
 #include "BKE_node.h"
-#include "COM_DistanceMatteOperation.h"
+#include "COM_DistanceRGBMatteOperation.h"
+#include "COM_DistanceYCCMatteOperation.h"
 #include "COM_SetAlphaOperation.h"
+#include "COM_ConvertRGBToYCCOperation.h"
 
 DistanceMatteNode::DistanceMatteNode(bNode *editorNode) : Node(editorNode)
 {
@@ -36,12 +38,33 @@ void DistanceMatteNode::convertToOperations(ExecutionSystem *graph, CompositorCo
        OutputSocket *outputSocketImage = this->getOutputSocket(0);
        OutputSocket *outputSocketMatte = this->getOutputSocket(1);
 
-       DistanceMatteOperation *operation = new DistanceMatteOperation();
+       NodeOperation *operation;
        bNode *editorsnode = getbNode();
-       operation->setSettings((NodeChroma *)editorsnode->storage);
+       NodeChroma *storage = (NodeChroma *)editorsnode->storage;
 
-       inputSocketImage->relinkConnections(operation->getInputSocket(0), 0, graph);
-       inputSocketKey->relinkConnections(operation->getInputSocket(1), 1, graph);
+       /* work in RGB color space */
+       if (storage->channel == 1) {
+               operation = new DistanceRGBMatteOperation();
+               ((DistanceRGBMatteOperation *) operation)->setSettings(storage);
+
+               inputSocketImage->relinkConnections(operation->getInputSocket(0), 0, graph);
+               inputSocketKey->relinkConnections(operation->getInputSocket(1), 1, graph);
+       }
+       /* work in YCbCr color space */
+       else {
+               operation = new DistanceYCCMatteOperation();
+               ((DistanceYCCMatteOperation *) operation)->setSettings(storage);
+
+               ConvertRGBToYCCOperation *operationYCCImage = new ConvertRGBToYCCOperation();
+               inputSocketImage->relinkConnections(operationYCCImage->getInputSocket(0), 0, graph);
+               addLink(graph, operationYCCImage->getOutputSocket(), operation->getInputSocket(0));
+               graph->addOperation(operationYCCImage);
+
+               ConvertRGBToYCCOperation *operationYCCMatte = new ConvertRGBToYCCOperation();
+               inputSocketKey->relinkConnections(operationYCCMatte->getInputSocket(0), 1, graph);
+               addLink(graph, operationYCCMatte->getOutputSocket(), operation->getInputSocket(1));
+               graph->addOperation(operationYCCMatte);
+       }
 
        if (outputSocketMatte->isConnected()) {
                outputSocketMatte->relinkConnections(operation->getOutputSocket());
similarity index 76%
rename from source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
rename to source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cpp
index b65b5e0f224d8810c1ec444968dc56ad21f43e81..d3309e0c97807855d9b020138fff05e50724e64d 100644 (file)
  *             Dalai Felinto
  */
 
-#include "COM_DistanceMatteOperation.h"
+#include "COM_DistanceRGBMatteOperation.h"
 #include "BLI_math.h"
 
-DistanceMatteOperation::DistanceMatteOperation() : NodeOperation()
+DistanceRGBMatteOperation::DistanceRGBMatteOperation() : NodeOperation()
 {
-       addInputSocket(COM_DT_COLOR);
-       addInputSocket(COM_DT_COLOR);
-       addOutputSocket(COM_DT_VALUE);
+       this->addInputSocket(COM_DT_COLOR);
+       this->addInputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VALUE);
 
        this->m_inputImageProgram = NULL;
        this->m_inputKeyProgram = NULL;
 }
 
-void DistanceMatteOperation::initExecution()
+void DistanceRGBMatteOperation::initExecution()
 {
        this->m_inputImageProgram = this->getInputSocketReader(0);
        this->m_inputKeyProgram = this->getInputSocketReader(1);
 }
 
-void DistanceMatteOperation::deinitExecution()
+void DistanceRGBMatteOperation::deinitExecution()
 {
        this->m_inputImageProgram = NULL;
        this->m_inputKeyProgram = NULL;
 }
 
-void DistanceMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+float DistanceRGBMatteOperation::calculateDistance(float key[4], float image[4])
+{
+       return len_v3v3(key, image);
+}
+
+void DistanceRGBMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
 {
        float inKey[4];
        float inImage[4];
@@ -58,9 +63,7 @@ void DistanceMatteOperation::executePixel(float output[4], float x, float y, Pix
        this->m_inputKeyProgram->read(inKey, x, y, sampler);
        this->m_inputImageProgram->read(inImage, x, y, sampler);
        
-       distance = sqrt(pow((inKey[0] - inImage[0]), 2) +
-                       pow((inKey[1] - inImage[1]), 2) +
-                       pow((inKey[2] - inImage[2]), 2));
+       distance = this->calculateDistance(inKey, inImage);
 
        /* store matte(alpha) value in [0] to go with
         * COM_SetAlphaOperation and the Value output
@@ -87,4 +90,3 @@ void DistanceMatteOperation::executePixel(float output[4], float x, float y, Pix
                output[0] = inImage[3];
        }
 }
-
similarity index 84%
rename from source/blender/compositor/operations/COM_DistanceMatteOperation.h
rename to source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h
index a176e5da888cfb23e49e94bd20e9ebeaf80fa4d1..5a34135b1a4a639dcf17063792b364d602954e6a 100644 (file)
@@ -19,8 +19,8 @@
  *             Dalai Felinto
  */
 
-#ifndef _COM_DistanceMatteOperation_h
-#define _COM_DistanceMatteOperation_h
+#ifndef _COM_DistanceRGBMatteOperation_h
+#define _COM_DistanceRGBMatteOperation_h
 #include "COM_MixBaseOperation.h"
 
 
  * this program converts an input color to an output value.
  * it assumes we are in sRGB color space.
  */
-class DistanceMatteOperation : public NodeOperation {
-private:
+class DistanceRGBMatteOperation : public NodeOperation {
+protected:
        NodeChroma *m_settings;
        SocketReader *m_inputImageProgram;
        SocketReader *m_inputKeyProgram;
+
+       virtual float calculateDistance(float key[4], float image[4]);
+
 public:
        /**
         * Default constructor
         */
-       DistanceMatteOperation();
+       DistanceRGBMatteOperation();
        
        /**
         * the inner loop of this program
diff --git a/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cpp b/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.cpp
new file mode 100644 (file)
index 0000000..0a6f1fd
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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:
+ *             Dalai Felinto
+ */
+
+#include "COM_DistanceYCCMatteOperation.h"
+#include "BLI_math.h"
+
+DistanceYCCMatteOperation::DistanceYCCMatteOperation() : DistanceRGBMatteOperation()
+{
+       /* pass */
+}
+
+float DistanceYCCMatteOperation::calculateDistance(float key[4], float image[4])
+{
+       /* only measure the second 2 values */
+       return len_v2v2(key + 1, image + 1);
+}
+
diff --git a/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h b/source/blender/compositor/operations/COM_DistanceYCCMatteOperation.h
new file mode 100644 (file)
index 0000000..f4866a3
--- /dev/null
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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:
+ *             Dalai Felinto
+ */
+
+#ifndef _COM_DistanceYCCMatteOperation_h
+#define _COM_DistanceYCCMatteOperation_h
+#include "COM_MixBaseOperation.h"
+#include "COM_DistanceRGBMatteOperation.h"
+
+
+/**
+ * this program converts an input color to an output value.
+ * it assumes we are in sRGB color space.
+ */
+class DistanceYCCMatteOperation : public DistanceRGBMatteOperation {
+protected:
+       virtual float calculateDistance(float key[4], float image[4]);
+
+public:
+       /**
+        * Default constructor
+        */
+       DistanceYCCMatteOperation();
+
+};
+#endif
index 3cc3923871325a5e24d8cb618b32249716041252..3255bc471488086f463a4a7a375ea12fdead1b19 100644 (file)
@@ -125,7 +125,7 @@ void ANIM_id_update(Scene *UNUSED(scene), ID *id)
  */
 
 /* perform syncing updates for Action Groups */
-static void animchan_sync_group(bAnimContext *UNUSED(ac), bAnimListElem *ale)
+static void animchan_sync_group(bAnimContext *ac, bAnimListElem *ale, bActionGroup **active_agrp)
 {
        bActionGroup *agrp = (bActionGroup *)ale->data;
        ID *owner_id = ale->id;
@@ -143,22 +143,50 @@ static void animchan_sync_group(bAnimContext *UNUSED(ac), bAnimListElem *ale)
                /* check if there are bones, and whether the name matches any 
                 * NOTE: this feature will only really work if groups by default contain the F-Curves for a single bone
                 */
+               // TODO: if bone gets renamed, it would be best to be able to rename the group
                if (ob->pose) {
                        bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, agrp->name);
+                       bArmature *arm = ob->data;
                        
-                       /* if one matches, sync the selection status */
                        if (pchan) {
-                               if (pchan->bone && pchan->bone->flag & BONE_SELECTED)
+                               bActionGroup *bgrp;
+                               
+                               /* if one matches, sync the selection status */
+                               if ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED))
                                        agrp->flag |= AGRP_SELECTED;
                                else
                                        agrp->flag &= ~AGRP_SELECTED;
+                                       
+                               /* also sync active group status */
+                               if ((ob == ac->obact) && (pchan->bone == arm->act_bone)) {
+                                       /* if no previous F-Curve has active flag, then we're the first and only one to get it */
+                                       if (*active_agrp == NULL) {
+                                               agrp->flag |= AGRP_ACTIVE;
+                                               *active_agrp = agrp;
+                                       }
+                                       else {
+                                               /* someone else has already taken it - set as not active */
+                                               agrp->flag &= ~AGRP_ACTIVE;
+                                       }
+                               }
+                               else {
+                                       /* this can't possibly be active now */
+                                       agrp->flag &= ~AGRP_ACTIVE;
+                               }
+                               
+                               /* sync group colors */
+                               bgrp = (bActionGroup *)BLI_findlink(&ob->pose->agroups, (pchan->agrp_index - 1));
+                               if (bgrp) {
+                                       agrp->customCol = bgrp->customCol;
+                                       action_group_colors_sync(agrp, bgrp);
+                               }
                        }
                }
        }
 }
  
 /* perform syncing updates for F-Curves */
-static void animchan_sync_fcurve(bAnimContext *UNUSED(ac), bAnimListElem *ale)
+static void animchan_sync_fcurve(bAnimContext *ac, bAnimListElem *ale, FCurve **active_fcurve)
 {
        FCurve *fcu = (FCurve *)ale->data;
        ID *owner_id = ale->id;
@@ -168,12 +196,13 @@ static void animchan_sync_fcurve(bAnimContext *UNUSED(ac), bAnimListElem *ale)
         */
        if (ELEM3(NULL, fcu, fcu->rna_path, owner_id))
                return;
-               
+       
        if (GS(owner_id->name) == ID_OB) {
                Object *ob = (Object *)owner_id;
                
                /* only affect if F-Curve involves pose.bones */
                if ((fcu->rna_path) && strstr(fcu->rna_path, "pose.bones")) {
+                       bArmature *arm = (bArmature *)ob->data;
                        bPoseChannel *pchan;
                        char *bone_name;
                        
@@ -184,10 +213,30 @@ static void animchan_sync_fcurve(bAnimContext *UNUSED(ac), bAnimListElem *ale)
                        
                        /* F-Curve selection depends on whether the bone is selected */
                        if ((pchan) && (pchan->bone)) {
+                               /* F-Curve selection */
                                if (pchan->bone->flag & BONE_SELECTED)
                                        fcu->flag |= FCURVE_SELECTED;
                                else
                                        fcu->flag &= ~FCURVE_SELECTED;
+                                       
+                               /* Active F-Curve - it should be the first one for this bone on the 
+                                * active object to be considered as active
+                                */
+                               if ((ob == ac->obact) && (pchan->bone == arm->act_bone)) {
+                                       /* if no previous F-Curve has active flag, then we're the first and only one to get it */
+                                       if (*active_fcurve == NULL) {
+                                               fcu->flag |= FCURVE_ACTIVE;
+                                               *active_fcurve = fcu;
+                                       }
+                                       else {
+                                               /* someone else has already taken it - set as not active */
+                                               fcu->flag &= ~FCURVE_ACTIVE;
+                                       }
+                               }
+                               else {
+                                       /* this can't possibly be active now */
+                                       fcu->flag &= ~FCURVE_ACTIVE;
+                               }
                        }
                }
        }
@@ -202,10 +251,10 @@ static void animchan_sync_fcurve(bAnimContext *UNUSED(ac), bAnimListElem *ale)
                        
                        /* get strip name, and check if this strip is selected */
                        seq_name = BLI_str_quoted_substrN(fcu->rna_path, "sequences_all[");
-                       seq = BKE_sequwnce_get_by_name(ed->seqbasep, seq_name, FALSE);
+                       seq = BKE_sequence_get_by_name(ed->seqbasep, seq_name, FALSE);
                        if (seq_name) MEM_freeN(seq_name);
                        
-                       /* can only add this F-Curve if it is selected */
+                       /* update selection status */
                        if (seq) {
                                if (seq->flag & SELECT)
                                        fcu->flag |= FCURVE_SELECTED;
@@ -227,12 +276,31 @@ static void animchan_sync_fcurve(bAnimContext *UNUSED(ac), bAnimListElem *ale)
                        node = nodeFindNodebyName(ntree, node_name);
                        if (node_name) MEM_freeN(node_name);
                        
-                       /* can only add this F-Curve if it is selected */
+                       /* update selection/active status */
                        if (node) {
+                               /* update selection status */
                                if (node->flag & NODE_SELECT)
                                        fcu->flag |= FCURVE_SELECTED;
                                else
                                        fcu->flag &= ~FCURVE_SELECTED;
+                                       
+                               /* update active status */
+                               /* XXX: this may interfere with setting bones as active if both exist at once;
+                                * then again, if that's the case, production setups aren't likely to be animating
+                                * nodes while working with bones?
+                                */
+                               if (node->flag & NODE_ACTIVE) {
+                                       if (*active_fcurve == NULL) {
+                                               fcu->flag |= FCURVE_ACTIVE;
+                                               *active_fcurve = fcu;
+                                       }
+                                       else {
+                                               fcu->flag &= ~FCURVE_ACTIVE;
+                                       }
+                               }
+                               else {
+                                       fcu->flag &= ~FCURVE_ACTIVE;
+                               }
                        }
                }
        }
@@ -248,25 +316,30 @@ void ANIM_sync_animchannels_to_data(const bContext *C)
        bAnimListElem *ale;
        int filter;
        
+       bActionGroup *active_agrp = NULL;
+       FCurve *active_fcurve = NULL;
+       
        /* get animation context info for filtering the channels */
        // TODO: check on whether we need to set the area specially instead, since active area might not be ok?
        if (ANIM_animdata_get_context(C, &ac) == 0)
                return;
        
        /* filter data */
-       /* NOTE: we want all channels, since we want to be able to set selection status on some of them even when collapsed */
-       filter = ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_CHANNELS;
+       /* NOTE: we want all channels, since we want to be able to set selection status on some of them even when collapsed 
+        *       However, don't include duplicates so that selection statuses don't override each other
+        */
+       filter = ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_CHANNELS | ANIMFILTER_NODUPLIS;
        ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
        
        /* flush settings as appropriate depending on the types of the channels */
        for (ale = anim_data.first; ale; ale = ale->next) {
                switch (ale->type) {
                        case ANIMTYPE_GROUP:
-                               animchan_sync_group(&ac, ale);
+                               animchan_sync_group(&ac, ale, &active_agrp);
                                break;
                        
                        case ANIMTYPE_FCURVE:
-                               animchan_sync_fcurve(&ac, ale);
+                               animchan_sync_fcurve(&ac, ale, &active_fcurve);
                                break;
                }
        }
index b1497712aedbb3ad047c30963ccc253b0ab6151c..a0acdd710e08ab239471fbefa50195921f8b11ab 100644 (file)
@@ -917,7 +917,7 @@ static short skip_fcurve_selected_data(bDopeSheet *ads, FCurve *fcu, ID *owner_i
                        
                        /* get strip name, and check if this strip is selected */
                        seq_name = BLI_str_quoted_substrN(fcu->rna_path, "sequences_all[");
-                       seq = BKE_sequwnce_get_by_name(ed->seqbasep, seq_name, FALSE);
+                       seq = BKE_sequence_get_by_name(ed->seqbasep, seq_name, FALSE);
                        if (seq_name) MEM_freeN(seq_name);
                        
                        /* can only add this F-Curve if it is selected */
index 91cc602c838f603f04cf8e15f5cc6e7a583c0702..83cb0db4978630f62f74ef55e0f5483b66d82dfd 100644 (file)
@@ -229,7 +229,7 @@ static void draw_modifier__generator(uiLayout *layout, ID *id, FModifier *fcm, s
                                if ( (i != (data->poly_order - 1)) || ((i == 0) && data->poly_order == 2) ) {
                                        uiDefBut(block, LABEL, 1, ") +", 0, 0, 30, 20, NULL, 0.0, 0.0, 0, 0, "");
                                        
-                                       /* set up new row for the next pair of coefficients*/
+                                       /* set up new row for the next pair of coefficients */
                                        row = uiLayoutRow(layout, TRUE);
                                        block = uiLayoutGetBlock(row);
                                }
index dd2400ca302d1c327fbace05b0797af9c653f003..738fdc229fbdbfd9d3311803687102746e2ecd40 100644 (file)
@@ -1585,7 +1585,7 @@ void ARMATURE_OT_select_linked(wmOperatorType *ot)
        /* flags */
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
        
-       /* properties s*/
+       /* properties */
        RNA_def_boolean(ot->srna, "extend", FALSE, "Extend", "Extend selection instead of deselecting everything first");
 }
 
index fd98dd83a7d8b6d4b3320282cae7b89a329beed3..d98f4891dc5b1524cb94532681c3a6215b4b2e68 100644 (file)
@@ -1667,14 +1667,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, wmEvent *event)
 static int gpencil_area_exists(bContext *C, ScrArea *sa_test)
 {
        bScreen *sc = CTX_wm_screen(C);
-       ScrArea *sa;
-       
-       for (sa = sc->areabase.first; sa; sa = sa->next) {
-               if (sa == sa_test)
-                       return 1;
-       }
-       
-       return 0;
+       return (BLI_findindex(&sc->areabase, sa_test) != -1);
 }
 
 static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
index 0cdc93fd9d0db959ef071eecff0d9f51fbc3b1ae..199469714115977130cd75332a12278c40dabf2c 100644 (file)
@@ -456,19 +456,19 @@ uiBut *uiDefBut(uiBlock *block,
                 void *poin,
                 float min, float max,
                 float a1, float a2, const char *tip);
-uiBut *uiDefButF(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButBitF(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButI(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButBitI(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButS(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButBitS(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButC(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButBitC(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButR(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, struct PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButR_prop(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, struct PointerRNA *ptr, struct PropertyRNA *prop, int index, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefButO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefButO_ptr(uiBlock *block, int type, struct wmOperatorType *ot, int opcontext, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefButTextO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButF(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButBitF(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButI(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButBitI(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButS(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButBitS(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButC(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButBitC(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButR(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, struct PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButR_prop(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, struct PointerRNA *ptr, struct PropertyRNA *prop, int index, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefButO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefButO_ptr(uiBlock *block, int type, struct wmOperatorType *ot, int opcontext, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefButTextO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2, const char *tip);
 
 uiBut *uiDefIconBut(uiBlock *block, 
                     int type, int retval, int icon,
@@ -477,18 +477,18 @@ uiBut *uiDefIconBut(uiBlock *block,
                     void *poin,
                     float min, float max,
                     float a1, float a2,  const char *tip);
-uiBut *uiDefIconButF(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButBitF(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButI(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButBitI(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButS(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButBitS(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButC(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButBitC(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButR(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, struct PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButR_prop(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, struct PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconButO(uiBlock *block, int type, const char *opname, int opcontext, int icon, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefIconButO_ptr(uiBlock *block, int type, struct wmOperatorType *ot, int opcontext, int icon, int x1, int y1, short x2, short y2, const char *tip);
+uiBut *uiDefIconButF(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButBitF(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButI(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButBitI(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButS(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButBitS(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButC(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButBitC(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButR(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, struct PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButR_prop(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, struct PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconButO(uiBlock *block, int type, const char *opname, int opcontext, int icon, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefIconButO_ptr(uiBlock *block, int type, struct wmOperatorType *ot, int opcontext, int icon, int x, int y, short width, short height, const char *tip);
 
 uiBut *uiDefIconTextBut(uiBlock *block,
                         int type, int retval, int icon, const char *str,
@@ -497,18 +497,18 @@ uiBut *uiDefIconTextBut(uiBlock *block,
                         void *poin,
                         float min, float max,
                         float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButF(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButBitF(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButI(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButBitI(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButS(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButBitS(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButC(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButBitC(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButR(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, struct PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButR_prop(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, struct PointerRNA *ptr, struct PropertyRNA *prop, int index, float min, float max, float a1, float a2, const char *tip);
-uiBut *uiDefIconTextButO(uiBlock *block, int type, const char *opname, int opcontext, int icon, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefIconTextButO_ptr(uiBlock *block, int type, struct wmOperatorType *ot, int opcontext, int icon, const char *str, int x1, int y1, short x2, short y2, const char *tip);
+uiBut *uiDefIconTextButF(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButBitF(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButI(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButBitI(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButS(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButBitS(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButC(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButBitC(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButR(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, struct PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButR_prop(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, struct PointerRNA *ptr, struct PropertyRNA *prop, int index, float min, float max, float a1, float a2, const char *tip);
+uiBut *uiDefIconTextButO(uiBlock *block, int type, const char *opname, int opcontext, int icon, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefIconTextButO_ptr(uiBlock *block, int type, struct wmOperatorType *ot, int opcontext, int icon, const char *str, int x, int y, short width, short height, const char *tip);
 
 /* for passing inputs to ButO buttons */
 struct PointerRNA *uiButGetOperatorPtrRNA(uiBut *but);
@@ -573,25 +573,25 @@ typedef void (*uiIDPoinFuncFP)(struct bContext *C, const char *str, struct ID **
 typedef void (*uiIDPoinFunc)(struct bContext *C, struct ID *id, int event);
 
 uiBut *uiDefIDPoinBut(uiBlock *block, uiIDPoinFuncFP func, short blocktype, int retval, const char *str,
-                      int x1, int y1, short x2, short y2, void *idpp, const char *tip);
+                                         int x, int y, short width, short height, void *idpp, const char *tip);
 
 int uiIconFromID(struct ID *id);
 
-uiBut *uiDefPulldownBut(uiBlock *block, uiBlockCreateFunc func, void *arg, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefMenuBut(uiBlock *block, uiMenuCreateFunc func, void *arg, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefIconTextMenuBut(uiBlock *block, uiMenuCreateFunc func, void *arg, int icon, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefIconMenuBut(uiBlock *block, uiMenuCreateFunc func, void *arg, int icon, int x1, int y1, short x2, short y2, const char *tip);
+uiBut *uiDefPulldownBut(uiBlock *block, uiBlockCreateFunc func, void *arg, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefMenuBut(uiBlock *block, uiMenuCreateFunc func, void *arg, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefIconTextMenuBut(uiBlock *block, uiMenuCreateFunc func, void *arg, int icon, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefIconMenuBut(uiBlock *block, uiMenuCreateFunc func, void *arg, int icon, int x, int y, short width, short height, const char *tip);
 
-uiBut *uiDefBlockBut(uiBlock *block, uiBlockCreateFunc func, void *func_arg1, const char *str, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefBlockButN(uiBlock *block, uiBlockCreateFunc func, void *argN, const char *str, int x1, int y1, short x2, short y2, const char *tip);
+uiBut *uiDefBlockBut(uiBlock *block, uiBlockCreateFunc func, void *func_arg1, const char *str, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefBlockButN(uiBlock *block, uiBlockCreateFunc func, void *argN, const char *str, int x, int y, short width, short height, const char *tip);
 
-uiBut *uiDefIconBlockBut(uiBlock *block, uiBlockCreateFunc func, void *arg, int retval, int icon, int x1, int y1, short x2, short y2, const char *tip);
-uiBut *uiDefIconTextBlockBut(uiBlock *block, uiBlockCreateFunc func, void *arg, int icon, const char *str, int x1, int y1, short x2, short y2, const char *tip);
+uiBut *uiDefIconBlockBut(uiBlock *block, uiBlockCreateFunc func, void *arg, int retval, int icon, int x, int y, short width, short height, const char *tip);
+uiBut *uiDefIconTextBlockBut(uiBlock *block, uiBlockCreateFunc func, void *arg, int icon, const char *str, int x, int y, short width, short height, const char *tip);
 
-uiBut *uiDefKeyevtButS(uiBlock *block, int retval, const char *str, int x1, int y1, short x2, short y2, short *spoin, const char *tip);
-uiBut *uiDefHotKeyevtButS(uiBlock *block, int retval, const char *str, int x1, int y1, short x2, short y2, short *keypoin, short *modkeypoin, const char *tip);
+uiBut *uiDefKeyevtButS(uiBlock *block, int retval, const char *str, int x, int y, short width, short height, short *spoin, const char *tip);
+uiBut *uiDefHotKeyevtButS(uiBlock *block, int retval, const char *str, int x, int y, short width, short height, short *keypoin, short *modkeypoin, const char *tip);
 
-uiBut *uiDefSearchBut(uiBlock *block, void *arg, int retval, int icon, int maxlen, int x1, int y1, short x2, short y2, float a1, float a2, const char *tip);
+uiBut *uiDefSearchBut(uiBlock *block, void *arg, int retval, int icon, int maxlen, int x, int y, short width, short height, float a1, float a2, const char *tip);
 
 uiBut *uiDefAutoButR(uiBlock *block, struct PointerRNA *ptr, struct PropertyRNA *prop, int index, const char *name, int icon, int x1, int y1, int x2, int y2);
 int uiDefAutoButsRNA(uiLayout *layout, struct PointerRNA *ptr, int (*check_prop)(struct PointerRNA *, struct PropertyRNA *), const char label_align);
index 7b1150669e8cad168c71e2a310224189447db448..62b26f5a8c1d52ee5dc8232d90d8f31d709a52aa 100644 (file)
@@ -137,10 +137,7 @@ void ui_block_to_window_rct(const ARegion *ar, uiBlock *block, rctf *graph, rcti
        ui_block_to_window_fl(ar, block, &tmpr.xmin, &tmpr.ymin);
        ui_block_to_window_fl(ar, block, &tmpr.xmax, &tmpr.ymax);
 
-       winr->xmin = tmpr.xmin;
-       winr->ymin = tmpr.ymin;
-       winr->xmax = tmpr.xmax;
-       winr->ymax = tmpr.ymax;
+       BLI_rcti_rctf_copy(winr, &tmpr);
 }
 
 void ui_window_to_block_fl(const ARegion *ar, uiBlock *block, float *x, float *y)   /* for mouse cursor */
@@ -196,19 +193,13 @@ void ui_window_to_region(const ARegion *ar, int *x, int *y)
 
 void ui_block_translate(uiBlock *block, int x, int y)
 {
-       uiBut *bt;
+       uiBut *but;
 
-       for (bt = block->buttons.first; bt; bt = bt->next) {
-               bt->x1 += x;
-               bt->y1 += y;
-               bt->x2 += x;
-               bt->y2 += y;
+       for (but = block->buttons.first; but; but = but->next) {
+               BLI_rctf_translate(&but->rect, x, y);
        }
 
-       block->minx += x;
-       block->miny += y;
-       block->maxx += x;
-       block->maxy += y;
+       BLI_rctf_translate(&block->rect, x, y);
 }
 
 static void ui_text_bounds_block(uiBlock *block, float offset)
@@ -227,26 +218,27 @@ static void ui_text_bounds_block(uiBlock *block, float offset)
                        if (j > i) i = j;
                }
 
-               if (bt->next && bt->x1 < bt->next->x1)
+               if (bt->next && bt->rect.xmin < bt->next->rect.xmin)
                        lastcol++;
        }
 
        /* cope with multi collumns */
        bt = block->buttons.first;
        while (bt) {
-               if (bt->next && bt->x1 < bt->next->x1) {
+               if (bt->next && bt->rect.xmin < bt->next->rect.xmin) {
                        nextcol = 1;
                        col++;
                }
                else nextcol = 0;
                
-               bt->x1 = x1addval;
-               bt->x2 = bt->x1 + i + block->bounds;
+               bt->rect.xmin = x1addval;
+               bt->rect.xmax = bt->rect.xmin + i + block->bounds;
                
-               if (col == lastcol)
-                       bt->x2 = MAX2(bt->x2, offset + block->minbounds);
+               if (col == lastcol) {
+                       bt->rect.xmax = maxf(bt->rect.xmax, offset + block->minbounds);
+               }
 
-               ui_check_but(bt);   // clips text again
+               ui_check_but(bt);  /* clips text again */
                
                if (nextcol)
                        x1addval += i + block->bounds;
@@ -262,43 +254,35 @@ void ui_bounds_block(uiBlock *block)
        
        if (block->buttons.first == NULL) {
                if (block->panel) {
-                       block->minx = 0.0; block->maxx = block->panel->sizex;
-                       block->miny = 0.0; block->maxy = block->panel->sizey;
+                       block->rect.xmin = 0.0; block->rect.xmax = block->panel->sizex;
+                       block->rect.ymin = 0.0; block->rect.ymax = block->panel->sizey;
                }
        }
        else {
        
-               block->minx = block->miny = 10000;
-               block->maxx = block->maxy = -10000;
-               
-               bt = block->buttons.first;
-               while (bt) {
-                       if (bt->x1 < block->minx) block->minx = bt->x1;
-                       if (bt->y1 < block->miny) block->miny = bt->y1;
-       
-                       if (bt->x2 > block->maxx) block->maxx = bt->x2;
-                       if (bt->y2 > block->maxy) block->maxy = bt->y2;
+               BLI_rctf_init_minmax(&block->rect);
 
-                       bt = bt->next;
+               for (bt = block->buttons.first; bt; bt = bt->next) {
+                       BLI_rctf_union(&block->rect, &bt->rect);
                }
                
-               block->minx -= block->bounds;
-               block->miny -= block->bounds;
-               block->maxx += block->bounds;
-               block->maxy += block->bounds;
+               block->rect.xmin -= block->bounds;
+               block->rect.ymin -= block->bounds;
+               block->rect.xmax += block->bounds;
+               block->rect.ymax += block->bounds;
        }
 
-       block->maxx = block->minx + MAX2(block->maxx - block->minx, block->minbounds);
+       block->rect.xmax = block->rect.xmin + maxf(block->rect.xmax - block->rect.xmin, block->minbounds);
 
        /* hardcoded exception... but that one is annoying with larger safety */ 
        bt = block->buttons.first;
        if (bt && strncmp(bt->str, "ERROR", 5) == 0) xof = 10;
        else xof = 40;
 
-       block->safety.xmin = block->minx - xof;
-       block->safety.ymin = block->miny - xof;
-       block->safety.xmax = block->maxx + xof;
-       block->safety.ymax = block->maxy + xof;
+       block->safety.xmin = block->rect.xmin - xof;
+       block->safety.ymin = block->rect.ymin - xof;
+       block->safety.xmax = block->rect.xmax + xof;
+       block->safety.ymax = block->rect.ymax + xof;
 }
 
 static void ui_centered_bounds_block(const bContext *C, uiBlock *block)
@@ -316,13 +300,13 @@ static void ui_centered_bounds_block(const bContext *C, uiBlock *block)
        
        ui_bounds_block(block);
        
-       width = block->maxx - block->minx;
-       height = block->maxy - block->miny;
+       width = block->rect.xmax - block->rect.xmin;
+       height = block->rect.ymax - block->rect.ymin;
        
        startx = (xmax * 0.5f) - (width * 0.5f);
        starty = (ymax * 0.5f) - (height * 0.5f);
        
-       ui_block_translate(block, startx - block->minx, starty - block->miny);
+       ui_block_translate(block, startx - block->rect.xmin, starty - block->rect.ymin);
        
        /* now recompute bounds and safety */
        ui_bounds_block(block);
@@ -341,14 +325,14 @@ static void ui_popup_bounds_block(const bContext *C, uiBlock *block, int bounds_
        
        wm_window_get_size(window, &xmax, &ymax);
 
-       oldwidth = block->maxx - block->minx;
-       oldheight = block->maxy - block->miny;
+       oldwidth = block->rect.xmax - block->rect.xmin;
+       oldheight = block->rect.ymax - block->rect.ymin;
 
        /* first we ensure wide enough text bounds */
        if (bounds_calc == UI_BLOCK_BOUNDS_POPUP_MENU) {
                if (block->flag & UI_BLOCK_LOOP) {
                        block->bounds = 50;
-                       ui_text_bounds_block(block, block->minx);
+                       ui_text_bounds_block(block, block->rect.xmin);
                }
        }
 
@@ -357,8 +341,8 @@ static void ui_popup_bounds_block(const bContext *C, uiBlock *block, int bounds_
        ui_bounds_block(block);
 
        /* and we adjust the position to fit within window */
-       width = block->maxx - block->minx;
-       height = block->maxy - block->miny;
+       width = block->rect.xmax - block->rect.xmin;
+       height = block->rect.ymax - block->rect.ymin;
 
        /* avoid divide by zero below, caused by calling with no UI, but better not crash */
        oldwidth = oldwidth > 0 ? oldwidth : MAX2(1, width);
@@ -366,8 +350,8 @@ static void ui_popup_bounds_block(const bContext *C, uiBlock *block, int bounds_
 
        /* offset block based on mouse position, user offset is scaled
         * along in case we resized the block in ui_text_bounds_block */
-       startx = window->eventstate->x + block->minx + (block->mx * width) / oldwidth;
-       starty = window->eventstate->y + block->miny + (block->my * height) / oldheight;
+       startx = window->eventstate->x + block->rect.xmin + (block->mx * width) / oldwidth;
+       starty = window->eventstate->y + block->rect.ymin + (block->my * height) / oldheight;
 
        if (startx < 10)
                startx = 10;
@@ -386,7 +370,7 @@ static void ui_popup_bounds_block(const bContext *C, uiBlock *block, int bounds_
                starty = endy - height;
        }
 
-       ui_block_translate(block, startx - block->minx, starty - block->miny);
+       ui_block_translate(block, startx - block->rect.xmin, starty - block->rect.ymin);
 
        /* now recompute bounds and safety */
        ui_bounds_block(block);
@@ -436,10 +420,10 @@ void uiCenteredBoundsBlock(uiBlock *block, int addval)
 
 void uiExplicitBoundsBlock(uiBlock *block, int minx, int miny, int maxx, int maxy)
 {
-       block->minx = minx;
-       block->miny = miny;
-       block->maxx = maxx;
-       block->maxy = maxy;
+       block->rect.xmin = minx;
+       block->rect.ymin = miny;
+       block->rect.xmax = maxx;
+       block->rect.ymax = maxy;
        block->dobounds = 0;
 }
 
@@ -504,10 +488,10 @@ static void ui_draw_linkline(uiLinkLine *line, int highlightActiveLines)
 
        if (line->from == NULL || line->to == NULL) return;
        
-       rect.xmin = (line->from->x1 + line->from->x2) / 2.0f;
-       rect.ymin = (line->from->y1 + line->from->y2) / 2.0f;
-       rect.xmax = (line->to->x1 + line->to->x2) / 2.0f;
-       rect.ymax = (line->to->y1 + line->to->y2) / 2.0f;
+       rect.xmin = (line->from->rect.xmin + line->from->rect.xmax) / 2.0f;
+       rect.ymin = (line->from->rect.ymin + line->from->rect.ymax) / 2.0f;
+       rect.xmax = (line->to->rect.xmin + line->to->rect.xmax) / 2.0f;
+       rect.ymax = (line->to->rect.ymin + line->to->rect.ymax) / 2.0f;
        
        if (line->flag & UI_SELECT)
                glColor3ub(100, 100, 100);
@@ -653,8 +637,7 @@ static int ui_but_update_from_old_block(const bContext *C, uiBlock *block, uiBut
                                *butpp = oldbut;
                                
                                /* still stuff needs to be copied */
-                               oldbut->x1 = but->x1; oldbut->y1 = but->y1;
-                               oldbut->x2 = but->x2; oldbut->y2 = but->y2;
+                               oldbut->rect = but->rect;
                                oldbut->context = but->context; /* set by Layout */
                                
                                /* typically the same pointers, but not on undo/redo */
@@ -764,7 +747,7 @@ static void ui_menu_block_set_keyaccels(uiBlock *block)
        int tot_missing = 0;
 
        /* only do it before bounding */
-       if (block->minx != block->maxx)
+       if (block->rect.xmin != block->rect.xmax)
                return;
 
        for (pass = 0; pass < 2; pass++) {
@@ -865,7 +848,7 @@ static void ui_menu_block_set_keymaps(const bContext *C, uiBlock *block)
        IDProperty *prop_menu_name = NULL;
 
        /* only do it before bounding */
-       if (block->minx != block->maxx)
+       if (block->rect.xmin != block->rect.xmax)
                return;
 
        for (but = block->buttons.first; but; but = but->next) {
@@ -960,7 +943,7 @@ void uiEndBlock(const bContext *C, uiBlock *block)
        else if (block->dobounds == UI_BLOCK_BOUNDS_POPUP_CENTER) ui_centered_bounds_block(C, block);
        else if (block->dobounds) ui_popup_bounds_block(C, block, block->dobounds);
 
-       if (block->minx == 0.0f && block->maxx == 0.0f) uiBoundsBlock(block, 0);
+       if (block->rect.xmin == 0.0f && block->rect.xmax == 0.0f) uiBoundsBlock(block, 0);
        if (block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block);
 
        block->endblock = 1;
@@ -993,14 +976,14 @@ static void ui_but_to_pixelrect(rcti *rect, const ARegion *ar, uiBlock *block, u
        getsizex = ar->winx;
        getsizey = ar->winy;
 
-       gx = (but ? but->x1 : block->minx) + (block->panel ? block->panel->ofsx : 0.0f);
-       gy = (but ? but->y1 : block->miny) + (block->panel ? block->panel->ofsy : 0.0f);
+       gx = (but ? but->rect.xmin : block->rect.xmin) + (block->panel ? block->panel->ofsx : 0.0f);
+       gy = (but ? but->rect.ymin : block->rect.ymin) + (block->panel ? block->panel->ofsy : 0.0f);
        
        rect->xmin = floorf(getsizex * (0.5f + 0.5f * (gx * block->winmat[0][0] + gy * block->winmat[1][0] + block->winmat[3][0])));
        rect->ymin = floorf(getsizey * (0.5f + 0.5f * (gx * block->winmat[0][1] + gy * block->winmat[1][1] + block->winmat[3][1])));
        
-       gx = (but ? but->x2 : block->maxx) + (block->panel ? block->panel->ofsx : 0.0f);
-       gy = (but ? but->y2 : block->maxy) + (block->panel ? block->panel->ofsy : 0.0f);
+       gx = (but ? but->rect.xmax : block->rect.xmax) + (block->panel ? block->panel->ofsx : 0.0f);
+       gy = (but ? but->rect.ymax : block->rect.ymax) + (block->panel ? block->panel->ofsy : 0.0f);
        
        rect->xmax = floorf(getsizex * (0.5f + 0.5f * (gx * block->winmat[0][0] + gy * block->winmat[1][0] + block->winmat[3][0])));
        rect->ymax = floorf(getsizey * (0.5f + 0.5f * (gx * block->winmat[0][1] + gy * block->winmat[1][1] + block->winmat[3][1])));
@@ -1010,7 +993,7 @@ static void ui_but_to_pixelrect(rcti *rect, const ARegion *ar, uiBlock *block, u
 /* uses local copy of style, to scale things down, and allow widgets to change stuff */
 void uiDrawBlock(const bContext *C, uiBlock *block)
 {
-       uiStyle style = *UI_GetStyle();  // XXX pass on as arg
+       uiStyle style = *UI_GetStyle();  /* XXX pass on as arg */
        ARegion *ar;
        uiBut *but;
        rcti rect;
@@ -1369,7 +1352,7 @@ int ui_is_but_unit(uiBut *but)
        if (unit_type == PROP_UNIT_NONE)
                return 0;
 
-#if 1 // removed so angle buttons get correct snapping
+#if 1 /* removed so angle buttons get correct snapping */
        if (unit->system_rotation == USER_UNIT_ROT_RADIANS && unit_type == PROP_UNIT_ROTATION)
                return 0;
 #endif
@@ -2112,7 +2095,7 @@ uiBlock *uiBeginBlock(const bContext *C, ARegion *region, const char *name, shor
        block = MEM_callocN(sizeof(uiBlock), "uiBlock");
        block->active = 1;
        block->dt = dt;
-       block->evil_C = (void *)C; // XXX
+       block->evil_C = (void *)C;  /* XXX */
 
        if (scn) {
                block->color_profile = (scn->r.color_mgt_flag & R_COLOR_MANAGEMENT);
@@ -2221,7 +2204,7 @@ void ui_check_but(uiBut *but)
        
        
        /* safety is 4 to enable small number buttons (like 'users') */
-       // okwidth= -4 + (but->x2 - but->x1); // UNUSED
+       // okwidth= -4 + (but->rect.xmax - but->rect.xmin); // UNUSED
        
        /* name: */
        switch (but->type) {
@@ -2229,7 +2212,7 @@ void ui_check_but(uiBut *but)
                case MENU:
                case ICONTEXTROW:
                
-                       if (but->x2 - but->x1 > 24) {
+                       if (but->rect.xmax - but->rect.xmin > 24) {
                                UI_GET_BUT_VALUE_INIT(but, value);
                                ui_set_name_menu(but, (int)value);
                        }
@@ -2373,8 +2356,8 @@ static int buts_are_horiz(uiBut *but1, uiBut *but2)
 {
        float dx, dy;
        
-       dx = fabs(but1->x2 - but2->x1);
-       dy = fabs(but1->y1 - but2->y2);
+       dx = fabs(but1->rect.xmax - but2->rect.xmin);
+       dy = fabs(but1->rect.ymin - but2->rect.ymax);
        
        if (dx > dy) return 0;
        return 1;
@@ -2382,7 +2365,7 @@ static int buts_are_horiz(uiBut *but1, uiBut *but2)
 
 void uiBlockEndAlign(uiBlock *block)
 {
-       block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
+       block->flag &= ~UI_BUT_ALIGN;  /* all 4 flags */
 }
 
 int ui_but_can_align(uiBut *but)
@@ -2492,32 +2475,32 @@ static void ui_block_do_align_but(uiBut *first, short nr)
                if (prev) {
                        /* simple cases */
                        if (rows == 0) {
-                               but->x1 = (prev->x2 + but->x1) / 2.0f;
-                               prev->x2 = but->x1;
+                               but->rect.xmin = (prev->rect.xmax + but->rect.xmin) / 2.0f;
+                               prev->rect.xmax = but->rect.xmin;
                        }
                        else if (cols == 0) {
-                               but->y2 = (prev->y1 + but->y2) / 2.0f;
-                               prev->y1 = but->y2;
+                               but->rect.ymax = (prev->rect.ymin + but->rect.ymax) / 2.0f;
+                               prev->rect.ymin = but->rect.ymax;
                        }
                        else {
                                if (buts_are_horiz(prev, but)) {
-                                       but->x1 = (prev->x2 + but->x1) / 2.0f;
-                                       prev->x2 = but->x1;
+                                       but->rect.xmin = (prev->rect.xmax + but->rect.xmin) / 2.0f;
+                                       prev->rect.xmax = but->rect.xmin;
                                        /* copy height too */
-                                       but->y2 = prev->y2;
+                                       but->rect.ymax = prev->rect.ymax;
                                }
                                else if (prev->prev && buts_are_horiz(prev->prev, prev) == 0) {
                                        /* the previous button is a single one in its row */
-                                       but->y2 = (prev->y1 + but->y2) / 2.0f;
-                                       prev->y1 = but->y2;
+                                       but->rect.ymax = (prev->rect.ymin + but->rect.ymax) / 2.0f;
+                                       prev->rect.ymin = but->rect.ymax;
                                        
-                                       but->x1 = prev->x1;
+                                       but->rect.xmin = prev->rect.xmin;
                                        if (next && buts_are_horiz(but, next) == 0)
-                                               but->x2 = prev->x2;
+                                               but->rect.xmax = prev->rect.xmax;
                                }
                                else {
                                        /* the previous button is not a single one in its row */
-                                       but->y2 = prev->y1;
+                                       but->rect.ymax = prev->rect.ymin;
                                }
                        }
                }
@@ -2549,13 +2532,16 @@ void ui_block_do_align(uiBlock *block)
 /**
  * \brief ui_def_but is the function that draws many button types
  *
+ * \param x,y The lower left hand corner of the button (X axis)
+ * \param width,height The size of the button.
+ *
  * for float buttons:
  * - \a a1 Click Step (how much to change the value each click)
  * - \a a2 Number of decimal point values to display. 0 defaults to 3 (0.000)
  *      1,2,3, and a maximum of 4, all greater values will be clamped to 4.
  */
 static uiBut *ui_def_but(uiBlock *block, int type, int retval, const char *str,
-                         int x1, int y1, short x2, short y2,
+                                                int x, int y, short width, short height,
                          void *poin, float min, float max, float a1, float a2, const char *tip)
 {
        uiBut *but;
@@ -2586,10 +2572,10 @@ static uiBut *ui_def_but(uiBlock *block, int type, int retval, const char *str,
        }
        memcpy(but->str, str, slen + 1);
 
-       but->x1 = x1;
-       but->y1 = y1;
-       but->x2 = (x1 + x2);
-       but->y2 = (y1 + y2);
+       but->rect.xmin = x;
+       but->rect.ymin = y;
+       but->rect.xmax = but->rect.xmin + width;
+       but->rect.ymax = but->rect.ymin + height;
 
        but->poin = poin;
        but->hardmin = but->softmin = min;
@@ -2602,8 +2588,8 @@ static uiBut *ui_def_but(uiBlock *block, int type, int retval, const char *str,
        but->lockstr = block->lockstr;
        but->dt = block->dt;
 
-       but->aspect = 1.0f; //XXX block->aspect;
-       but->block = block;      // pointer back, used for frontbuffer status, and picker
+       but->aspect = 1.0f;  /* XXX block->aspect; */
+       but->block = block;  /* pointer back, used for frontbuffer status, and picker */
 
        if ((block->flag & UI_BUT_ALIGN) && ui_but_can_align(but))
                but->alignnr = block->alignnr;
@@ -2682,7 +2668,7 @@ static uiBut *ui_def_but(uiBlock *block, int type, int retval, const char *str,
 
 
 static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *str,
-                             int x1, int y1, short x2, short y2,
+                                                        int x, int y, short width, short height,
                              PointerRNA *ptr, PropertyRNA *prop, int index,
                              float min, float max, float a1, float a2,  const char *tip)
 {
@@ -2794,7 +2780,7 @@ static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *s
        }
 
        /* now create button */
-       but = ui_def_but(block, type, retval, str, x1, y1, x2, y2, NULL, min, max, a1, a2, tip);
+       but = ui_def_but(block, type, retval, str, x, y, width, height, NULL, min, max, a1, a2, tip);
 
        but->rnapoin = *ptr;
        but->rnaprop = prop;
@@ -2830,16 +2816,16 @@ static uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, const char *s
        return but;
 }
 
-static uiBut *ui_def_but_rna_propname(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  const char *tip)
+static uiBut *ui_def_but_rna_propname(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  const char *tip)
 {
        PropertyRNA *prop = RNA_struct_find_property(ptr, propname);
        uiBut *but;
 
        if (prop) {
-               but = ui_def_but_rna(block, type, retval, str, x1, y1, x2, y2, ptr, prop, index, min, max, a1, a2,  tip);
+               but = ui_def_but_rna(block, type, retval, str, x, y, width, height, ptr, prop, index, min, max, a1, a2,  tip);
        }
        else {
-               but = ui_def_but(block, type, retval, propname, x1, y1, x2, y2, NULL, min, max, a1, a2, tip);
+               but = ui_def_but(block, type, retval, propname, x, y, width, height, NULL, min, max, a1, a2, tip);
 
                UI_DEF_BUT_RNA_DISABLE(but);
        }
@@ -2847,7 +2833,7 @@ static uiBut *ui_def_but_rna_propname(uiBlock *block, int type, int retval, cons
        return but;
 }
 
-static uiBut *ui_def_but_operator_ptr(uiBlock *block, int type, wmOperatorType *ot, int opcontext, const char *str, int x1, int y1, short x2, short y2, const char *tip)
+static uiBut *ui_def_but_operator_ptr(uiBlock *block, int type, wmOperatorType *ot, int opcontext, const char *str, int x, int y, short width, short height, const char *tip)
 {
        uiBut *but;
 
@@ -2862,7 +2848,7 @@ static uiBut *ui_def_but_operator_ptr(uiBlock *block, int type, wmOperatorType *
                tip = RNA_struct_ui_description(ot->srna);
        }
 
-       but = ui_def_but(block, type, -1, str, x1, y1, x2, y2, NULL, 0, 0, 0, 0, tip);
+       but = ui_def_but(block, type, -1, str, x, y, width, height, NULL, 0, 0, 0, 0, tip);
        but->optype = ot;
        but->opcontext = opcontext;
        but->flag &= ~UI_BUT_UNDO; /* no need for ui_but_is_undo(), we never need undo here */
@@ -2877,15 +2863,15 @@ static uiBut *ui_def_but_operator_ptr(uiBlock *block, int type, wmOperatorType *
 }
 
 #if 0 /* UNUSED */
-static uiBut *UNUSED_FUNCTION(ui_def_but_operator) (uiBlock * block, int type, const char *opname, int opcontext, const char *str, int x1, int y1, short x2, short y2, const char *tip)
+static uiBut *UNUSED_FUNCTION(ui_def_but_operator) (uiBlock * block, int type, const char *opname, int opcontext, const char *str, int x, int y, short width, short height, const char *tip)
 {
        wmOperatorType *ot = WM_operatortype_find(opname, 0);
        if (str == NULL && ot == NULL) str = opname;
-       return ui_def_but_operator_ptr(block, type, ot, opcontext, str, x1, y1, x2, y2, tip);
+       return ui_def_but_operator_ptr(block, type, ot, opcontext, str, x, y, width, height, tip);
 }
 #endif
 
-static uiBut *ui_def_but_operator_text(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2, const char *tip)
+static uiBut *ui_def_but_operator_text(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2, const char *tip)
 {
        uiBut *but;
        wmOperatorType *ot;
@@ -2901,7 +2887,7 @@ static uiBut *ui_def_but_operator_text(uiBlock *block, int type, const char *opn
                tip = ot->description;
        }
 
-       but = ui_def_but(block, type, -1, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+       but = ui_def_but(block, type, -1, str, x, y, width, height, poin, min, max, a1, a2, tip);
        but->optype = ot;
        but->opcontext = opcontext;
        but->flag &= ~UI_BUT_UNDO; /* no need for ui_but_is_undo(), we never need undo here */
@@ -2915,9 +2901,9 @@ static uiBut *ui_def_but_operator_text(uiBlock *block, int type, const char *opn
        return but;
 }
 
-uiBut *uiDefBut(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2, const char *tip)
+uiBut *uiDefBut(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2, const char *tip)
 {
-       uiBut *but = ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+       uiBut *but = ui_def_but(block, type, retval, str, x, y, width, height, poin, min, max, a1, a2, tip);
 
        ui_check_but(but);
        
@@ -3036,241 +3022,241 @@ static void ui_check_but_and_iconize(uiBut *but, int icon)
        ui_check_but(but);
 }
 
-static uiBut *uiDefButBit(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  const char *tip)
+static uiBut *uiDefButBit(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2,  const char *tip)
 {
        int bitIdx = findBitIndex(bit);
        if (bitIdx == -1) {
                return NULL;
        }
        else {
-               return uiDefBut(block, type | BIT | bitIdx, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+               return uiDefBut(block, type | BIT | bitIdx, retval, str, x, y, width, height, poin, min, max, a1, a2, tip);
        }
 }
-uiBut *uiDefButF(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButF(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefBut(block, type | FLO, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefBut(block, type | FLO, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButBitF(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButBitF(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefButBit(block, type | FLO, bit, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefButBit(block, type | FLO, bit, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButI(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButI(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefBut(block, type | INT, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefBut(block, type | INT, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButBitI(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButBitI(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefButBit(block, type | INT, bit, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefButBit(block, type | INT, bit, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButS(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButS(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefBut(block, type | SHO, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefBut(block, type | SHO, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButBitS(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButBitS(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefButBit(block, type | SHO, bit, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefButBit(block, type | SHO, bit, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButC(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButC(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefBut(block, type | CHA, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefBut(block, type | CHA, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButBitC(uiBlock *block, int type, int bit, int retval, const char *str, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButBitC(uiBlock *block, int type, int bit, int retval, const char *str, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefButBit(block, type | CHA, bit, retval, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefButBit(block, type | CHA, bit, retval, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefButR(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButR(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  const char *tip)
 {
        uiBut *but;
-       but = ui_def_but_rna_propname(block, type, retval, str, x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
+       but = ui_def_but_rna_propname(block, type, retval, str, x, y, width, height, ptr, propname, index, min, max, a1, a2, tip);
        ui_check_but(but);
        return but;
 }
-uiBut *uiDefButR_prop(uiBlock *block, int type, int retval, const char *str, int x1, int y1, short x2, short y2, PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButR_prop(uiBlock *block, int type, int retval, const char *str, int x, int y, short width, short height, PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, float a1, float a2,  const char *tip)
 {
        uiBut *but;
-       but = ui_def_but_rna(block, type, retval, str, x1, y1, x2, y2, ptr, prop, index, min, max, a1, a2, tip);
+       but = ui_def_but_rna(block, type, retval, str, x, y, width, height, ptr, prop, index, min, max, a1, a2, tip);
        ui_check_but(but);
        return but;
 }
 
-uiBut *uiDefButO_ptr(uiBlock *block, int type, wmOperatorType *ot, int opcontext, const char *str, int x1, int y1, short x2, short y2, const char *tip)
+uiBut *uiDefButO_ptr(uiBlock *block, int type, wmOperatorType *ot, int opcontext, const char *str, int x, int y, short width, short height, const char *tip)
 {
        uiBut *but;
-       but = ui_def_but_operator_ptr(block, type, ot, opcontext, str, x1, y1, x2, y2, tip);
+       but = ui_def_but_operator_ptr(block, type, ot, opcontext, str, x, y, width, height, tip);
        ui_check_but(but);
        return but;
 }
-uiBut *uiDefButO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x1, int y1, short x2, short y2, const char *tip)
+uiBut *uiDefButO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x, int y, short width, short height, const char *tip)
 {
        wmOperatorType *ot = WM_operatortype_find(opname, 0);
        if (str == NULL && ot == NULL) str = opname;
-       return uiDefButO_ptr(block, type, ot, opcontext, str, x1, y1, x2, y2, tip);
+       return uiDefButO_ptr(block, type, ot, opcontext, str, x, y, width, height, tip);
 }
 
-uiBut *uiDefButTextO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefButTextO(uiBlock *block, int type, const char *opname, int opcontext, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       uiBut *but = ui_def_but_operator_text(block, type, opname, opcontext, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+       uiBut *but = ui_def_but_operator_text(block, type, opname, opcontext, str, x, y, width, height, poin, min, max, a1, a2, tip);
        ui_check_but(but);
        return but;
 }
 
 /* if a1==1.0 then a2 is an extra icon blending factor (alpha 0.0 - 1.0) */
-uiBut *uiDefIconBut(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconBut(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       uiBut *but = ui_def_but(block, type, retval, "", x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+       uiBut *but = ui_def_but(block, type, retval, "", x, y, width, height, poin, min, max, a1, a2, tip);
        ui_check_but_and_iconize(but, icon);
        return but;
 }
-static uiBut *uiDefIconButBit(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2, const char *tip)
+static uiBut *uiDefIconButBit(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2, const char *tip)
 {
        int bitIdx = findBitIndex(bit);
        if (bitIdx == -1) {
                return NULL;
        }
        else {
-               return uiDefIconBut(block, type | BIT | bitIdx, retval, icon, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+               return uiDefIconBut(block, type | BIT | bitIdx, retval, icon, x, y, width, height, poin, min, max, a1, a2, tip);
        }
 }
 
-uiBut *uiDefIconButF(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButF(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconBut(block, type | FLO, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconBut(block, type | FLO, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButBitF(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButBitF(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconButBit(block, type | FLO, bit, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconButBit(block, type | FLO, bit, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButI(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButI(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconBut(block, type | INT, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconBut(block, type | INT, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButBitI(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButBitI(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconButBit(block, type | INT, bit, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconButBit(block, type | INT, bit, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButS(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButS(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconBut(block, type | SHO, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconBut(block, type | SHO, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButBitS(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButBitS(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconButBit(block, type | SHO, bit, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconButBit(block, type | SHO, bit, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButC(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButC(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconBut(block, type | CHA, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconBut(block, type | CHA, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButBitC(uiBlock *block, int type, int bit, int retval, int icon, int x1, int y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButBitC(uiBlock *block, int type, int bit, int retval, int icon, int x, int y, short width, short height, char *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconButBit(block, type | CHA, bit, retval, icon, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconButBit(block, type | CHA, bit, retval, icon, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconButR(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButR(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  const char *tip)
 {
        uiBut *but;
-       but = ui_def_but_rna_propname(block, type, retval, "", x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
+       but = ui_def_but_rna_propname(block, type, retval, "", x, y, width, height, ptr, propname, index, min, max, a1, a2, tip);
        ui_check_but_and_iconize(but, icon);
        return but;
 }
-uiBut *uiDefIconButR_prop(uiBlock *block, int type, int retval, int icon, int x1, int y1, short x2, short y2, PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconButR_prop(uiBlock *block, int type, int retval, int icon, int x, int y, short width, short height, PointerRNA *ptr, PropertyRNA *prop, int index, float min, float max, float a1, float a2,  const char *tip)
 {
        uiBut *but;
-       but = ui_def_but_rna(block, type, retval, "", x1, y1, x2, y2, ptr, prop, index, min, max, a1, a2, tip);
+       but = ui_def_but_rna(block, type, retval, "", x, y, width, height, ptr, prop, index, min, max, a1, a2, tip);
        ui_check_but_and_iconize(but, icon);
        return but;
 }
 
-uiBut *uiDefIconButO_ptr(uiBlock *block, int type, wmOperatorType *ot, int opcontext, int icon, int x1, int y1, short x2, short y2, const char *tip)
+uiBut *uiDefIconButO_ptr(uiBlock *block, int type, wmOperatorType *ot, int opcontext, int icon, int x, int y, short width, short height, const char *tip)
 {
        uiBut *but;
-       but = ui_def_but_operator_ptr(block, type, ot, opcontext, "", x1, y1, x2, y2, tip);
+       but = ui_def_but_operator_ptr(block, type, ot, opcontext, "", x, y, width, height, tip);
        ui_check_but_and_iconize(but, icon);
        return but;
 }
-uiBut *uiDefIconButO(uiBlock *block, int type, const char *opname, int opcontext, int icon, int x1, int y1, short x2, short y2, const char *tip)
+uiBut *uiDefIconButO(uiBlock *block, int type, const char *opname, int opcontext, int icon, int x, int y, short width, short height, const char *tip)
 {
        wmOperatorType *ot = WM_operatortype_find(opname, 0);
-       return uiDefIconButO_ptr(block, type, ot, opcontext, icon, x1, y1, x2, y2, tip);
+       return uiDefIconButO_ptr(block, type, ot, opcontext, icon, x, y, width, height, tip);
 }
 
 /* Button containing both string label and icon */
-uiBut *uiDefIconTextBut(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconTextBut(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       uiBut *but = ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+       uiBut *but = ui_def_but(block, type, retval, str, x, y, width, height, poin, min, max, a1, a2, tip);
        ui_check_but_and_iconize(but, icon);
        but->flag |= UI_ICON_LEFT;
        return but;
 }
-static uiBut *uiDefIconTextButBit(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  const char *tip)
+static uiBut *uiDefIconTextButBit(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, void *poin, float min, float max, float a1, float a2,  const char *tip)
 {
        int bitIdx = findBitIndex(bit);
        if (bitIdx == -1) {
                return NULL;
        }
        else {
-               return uiDefIconTextBut(block, type | BIT | bitIdx, retval, icon, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
+               return uiDefIconTextBut(block, type | BIT | bitIdx, retval, icon, str, x, y, width, height, poin, min, max, a1, a2, tip);
        }
 }
 
-uiBut *uiDefIconTextButF(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconTextButF(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconTextBut(block, type | FLO, retval, icon, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconTextBut(block, type | FLO, retval, icon, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconTextButBitF(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconTextButBitF(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, float *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconTextButBit(block, type | FLO, bit, retval, icon, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconTextButBit(block, type | FLO, bit, retval, icon, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconTextButI(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconTextButI(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconTextBut(block, type | INT, retval, icon, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconTextBut(block, type | INT, retval, icon, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconTextButBitI(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconTextButBitI(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int x, int y, short width, short height, int *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconTextButBit(block, type | INT, bit, retval, icon, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconTextButBit(block, type | INT, bit, retval, icon, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconTextButS(uiBlock *block, int type, int retval, int icon, const char *str, int x1, int y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  const char *tip)
+uiBut *uiDefIconTextButS(uiBlock *block, int type, int retval, int icon, const char *str, int x, int y, short width, short height, short *poin, float min, float max, float a1, float a2,  const char *tip)
 {
-       return uiDefIconTextBut(block, type | SHO, retval, icon, str, x1, y1, x2, y2, (void *) poin, min, max, a1, a2, tip);
+       return uiDefIconTextBut(block, type | SHO, retval, icon, str, x, y, width, height, (void *) poin, min, max, a1, a2, tip);
 }
-uiBut *uiDefIconTextButBitS(uiBlock *block, int type, int bit, int retval, int icon, const char *str, int&n