From a2c182e9233333fc3b8ff40d352113ec95e7e30c Mon Sep 17 00:00:00 2001
From: Campbell Barton <ideasman42@gmail.com>
Date: Sat, 3 Mar 2012 16:31:46 +0000
Subject: style cleanup - use aligned * prefixed blocks for descriptive
 comments (was already used a lot and part of proposed style guide).

---
 .../editors/animation/anim_channels_defines.c      |   6 +-
 source/blender/editors/animation/anim_deps.c       |   6 +-
 source/blender/editors/animation/anim_markers.c    | 109 ++++----
 source/blender/editors/animation/keyframes_edit.c  |   4 +-
 source/blender/editors/armature/armature_ops.c     |   2 +-
 source/blender/editors/armature/editarmature.c     |  66 ++---
 source/blender/editors/armature/meshlaplacian.c    |  30 +--
 source/blender/editors/armature/reeb.c             |   5 +-
 source/blender/editors/curve/editcurve.c           | 151 +++++------
 source/blender/editors/gpencil/drawgpencil.c       |   8 +-
 source/blender/editors/gpencil/gpencil_paint.c     |  12 +-
 source/blender/editors/include/BIF_glutil.h        |   4 +-
 source/blender/editors/include/ED_armature.h       |  38 +--
 source/blender/editors/include/ED_datafiles.h      |   2 +-
 source/blender/editors/include/ED_mesh.h           |  44 ++--
 source/blender/editors/include/ED_render.h         |  12 +-
 source/blender/editors/include/ED_space_api.h      |   2 +-
 source/blender/editors/include/UI_interface.h      |  10 +-
 .../blender/editors/include/UI_interface_icons.h   |   4 +-
 source/blender/editors/interface/interface.c       |  14 +-
 source/blender/editors/interface/interface_draw.c  |  31 ++-
 .../blender/editors/interface/interface_handlers.c |  20 +-
 source/blender/editors/interface/interface_icons.c |  12 +-
 .../blender/editors/interface/interface_intern.h   |   4 +-
 .../blender/editors/interface/interface_layout.c   |   8 +-
 source/blender/editors/interface/interface_panel.c |  37 +--
 .../blender/editors/interface/interface_regions.c  |  16 +-
 source/blender/editors/interface/interface_style.c |  27 +-
 .../editors/interface/interface_templates.c        |  10 +-
 source/blender/editors/interface/interface_utils.c |   2 +-
 .../blender/editors/interface/interface_widgets.c  |  68 +++--
 source/blender/editors/interface/view2d_ops.c      |   7 +-
 source/blender/editors/mesh/bmesh_select.c         |  44 ++--
 source/blender/editors/mesh/bmesh_selecthistory.c  |   4 +-
 source/blender/editors/mesh/bmesh_tools.c          |  49 ++--
 source/blender/editors/mesh/editface.c             |   6 +-
 source/blender/editors/mesh/editmesh_bvh.c         |  12 +-
 source/blender/editors/mesh/loopcut.c              |   4 +-
 source/blender/editors/mesh/mesh_data.c            |  26 +-
 source/blender/editors/mesh/mesh_intern.h          |  20 +-
 source/blender/editors/mesh/meshtools.c            |   8 +-
 source/blender/editors/object/object_add.c         |  16 +-
 source/blender/editors/object/object_bake.c        |  37 ++-
 source/blender/editors/object/object_group.c       |   4 +-
 source/blender/editors/object/object_hook.c        |   4 +-
 source/blender/editors/object/object_modifier.c    |  26 +-
 source/blender/editors/object/object_relations.c   |   2 +-
 source/blender/editors/object/object_select.c      |   2 +-
 source/blender/editors/object/object_transform.c   |   6 +-
 source/blender/editors/object/object_vgroup.c      |  46 ++--
 source/blender/editors/physics/dynamicpaint_ops.c  |  16 +-
 source/blender/editors/physics/particle_edit.c     |   2 +-
 source/blender/editors/render/render_internal.c    |  18 +-
 source/blender/editors/render/render_preview.c     |   8 +-
 source/blender/editors/render/render_update.c      |   2 +-
 source/blender/editors/render/render_view.c        |   2 +-
 source/blender/editors/screen/area.c               |  12 +-
 source/blender/editors/screen/glutil.c             |  31 +--
 source/blender/editors/screen/screen_edit.c        |  19 +-
 source/blender/editors/screen/screen_ops.c         | 281 ++++++++++-----------
 source/blender/editors/sculpt_paint/paint_cursor.c |  34 +--
 source/blender/editors/sculpt_paint/paint_image.c  | 161 ++++++------
 source/blender/editors/sculpt_paint/paint_intern.h |   8 +-
 source/blender/editors/sculpt_paint/paint_stroke.c |  16 +-
 source/blender/editors/sculpt_paint/paint_utils.c  |  14 +-
 source/blender/editors/sculpt_paint/paint_vertex.c |  59 +++--
 source/blender/editors/sculpt_paint/sculpt.c       |  97 +++----
 source/blender/editors/sculpt_paint/sculpt_undo.c  |   6 +-
 source/blender/editors/sound/sound_ops.c           |  10 +-
 source/blender/editors/space_api/spacetypes.c      |   2 +-
 .../editors/space_buttons/buttons_texture.c        |   8 +-
 source/blender/editors/space_clip/clip_draw.c      |  10 +-
 source/blender/editors/space_clip/space_clip.c     |   2 +-
 source/blender/editors/space_clip/tracking_ops.c   |  26 +-
 source/blender/editors/space_console/console_ops.c |   5 +-
 .../blender/editors/space_console/space_console.c  |   4 +-
 source/blender/editors/space_file/file_ops.c       |  10 +-
 source/blender/editors/space_file/filesel.c        |   4 +-
 source/blender/editors/space_file/fsmenu.c         |   8 +-
 source/blender/editors/space_file/space_file.c     |   2 +-
 source/blender/editors/space_image/image_buttons.c |  14 +-
 source/blender/editors/space_image/image_draw.c    |  18 +-
 source/blender/editors/space_image/space_image.c   |   6 +-
 source/blender/editors/space_info/info_report.c    |   4 +-
 source/blender/editors/space_logic/logic_ops.c     |   6 +-
 source/blender/editors/space_logic/logic_window.c  |  25 +-
 source/blender/editors/space_nla/space_nla.c       |   6 +-
 source/blender/editors/space_node/node_draw.c      |   6 +-
 source/blender/editors/space_node/node_edit.c      |   4 +-
 .../blender/editors/space_outliner/outliner_draw.c |   8 +-
 .../editors/space_outliner/outliner_intern.h       |  28 +-
 .../editors/space_outliner/outliner_select.c       |   2 +-
 .../editors/space_outliner/outliner_tools.c        |   8 +-
 .../blender/editors/space_outliner/outliner_tree.c |   6 +-
 .../editors/space_sequencer/sequencer_draw.c       |  20 +-
 .../editors/space_sequencer/sequencer_edit.c       |  18 +-
 .../editors/space_sequencer/sequencer_ops.c        |   6 +-
 .../editors/space_sequencer/space_sequencer.c      |   4 +-
 source/blender/editors/space_text/space_text.c     |   4 +-
 source/blender/editors/space_text/text_draw.c      | 100 ++++----
 source/blender/editors/space_text/text_ops.c       |  26 +-
 source/blender/editors/space_view3d/drawarmature.c |   4 +-
 source/blender/editors/space_view3d/drawmesh.c     |   6 +-
 source/blender/editors/space_view3d/drawobject.c   |  40 +--
 source/blender/editors/space_view3d/drawvolume.c   |   4 +-
 source/blender/editors/space_view3d/space_view3d.c |   4 +-
 .../blender/editors/space_view3d/view3d_buttons.c  |   4 +-
 source/blender/editors/space_view3d/view3d_draw.c  |  34 +--
 source/blender/editors/space_view3d/view3d_edit.c  |  23 +-
 source/blender/editors/space_view3d/view3d_fly.c   |  41 +--
 .../blender/editors/space_view3d/view3d_header.c   |  11 +-
 .../blender/editors/space_view3d/view3d_select.c   |  38 +--
 source/blender/editors/space_view3d/view3d_view.c  |  50 ++--
 source/blender/editors/transform/transform.c       |  18 +-
 source/blender/editors/transform/transform.h       |  24 +-
 .../editors/transform/transform_constraints.c      |  46 ++--
 .../editors/transform/transform_conversions.c      |  38 +--
 .../blender/editors/transform/transform_generics.c |  18 +-
 .../editors/transform/transform_manipulator.c      |  24 +-
 source/blender/editors/transform/transform_ops.c   |   6 +-
 source/blender/editors/transform/transform_snap.c  |   7 +-
 source/blender/editors/util/crazyspace.c           |  10 +-
 source/blender/editors/util/ed_util.c              |   4 +-
 source/blender/editors/util/editmode_undo.c        |  36 ++-
 source/blender/editors/uvedit/uvedit_draw.c        |  12 +-
 source/blender/editors/uvedit/uvedit_ops.c         |   8 +-
 .../blender/editors/uvedit/uvedit_parametrizer.c   |  38 +--
 .../blender/editors/uvedit/uvedit_parametrizer.h   |  36 +--
 .../blender/editors/uvedit/uvedit_smart_stitch.c   |   2 +-
 source/blender/editors/uvedit/uvedit_unwrap_ops.c  |   2 +-
 130 files changed, 1455 insertions(+), 1416 deletions(-)

(limited to 'source/blender')

diff --git a/source/blender/editors/animation/anim_channels_defines.c b/source/blender/editors/animation/anim_channels_defines.c
index f8bb690e31d..ae1f308369d 100644
--- a/source/blender/editors/animation/anim_channels_defines.c
+++ b/source/blender/editors/animation/anim_channels_defines.c
@@ -817,7 +817,7 @@ static int acf_group_setting_flag(bAnimContext *ac, int setting, short *neg)
 			return AGRP_MUTED;
 			
 		case ACHANNEL_SETTING_PROTECT: /* protected */
-			//*neg= 1; - if we change this to edtiability
+			// *neg= 1; - if we change this to edtiability
 			return AGRP_PROTECTED;
 			
 		case ACHANNEL_SETTING_VISIBLE: /* visiblity - graph editor */
@@ -905,7 +905,7 @@ static int acf_fcurve_setting_flag(bAnimContext *UNUSED(ac), int setting, short
 			return FCURVE_MUTED;
 			
 		case ACHANNEL_SETTING_PROTECT: /* protected */
-			//*neg= 1; - if we change this to edtiability
+			// *neg= 1; - if we change this to edtiability
 			return FCURVE_PROTECTED;
 			
 		case ACHANNEL_SETTING_VISIBLE: /* visiblity - graph editor */
@@ -2450,7 +2450,7 @@ static int acf_gpl_setting_flag(bAnimContext *UNUSED(ac), int setting, short *ne
 			return GP_LAYER_HIDE;
 			
 		case ACHANNEL_SETTING_PROTECT: /* protected */
-			//*neg= 1; - if we change this to edtiability
+			// *neg= 1; - if we change this to edtiability
 			return GP_LAYER_LOCKED;
 			
 		default: /* unsupported */
diff --git a/source/blender/editors/animation/anim_deps.c b/source/blender/editors/animation/anim_deps.c
index 8e91e575db1..be66edb8dc9 100644
--- a/source/blender/editors/animation/anim_deps.c
+++ b/source/blender/editors/animation/anim_deps.c
@@ -81,8 +81,8 @@ void ANIM_list_elem_update(Scene *scene, bAnimListElem *ale)
 		
 	if (fcu && fcu->rna_path) {
 		/* if we have an fcurve, call the update for the property we
-		   are editing, this is then expected to do the proper redraws
-		   and depsgraph updates  */
+		 * are editing, this is then expected to do the proper redraws
+		 * and depsgraph updates  */
 		PointerRNA id_ptr, ptr;
 		PropertyRNA *prop;
 		
@@ -93,7 +93,7 @@ void ANIM_list_elem_update(Scene *scene, bAnimListElem *ale)
 	}
 	else {
 		/* in other case we do standard depsgaph update, ideally
-		   we'd be calling property update functions here too ... */
+		 * we'd be calling property update functions here too ... */
 		DAG_id_tag_update(id, OB_RECALC_OB|OB_RECALC_DATA|OB_RECALC_TIME); // XXX or do we want something more restrictive?
 	}
 }
diff --git a/source/blender/editors/animation/anim_markers.c b/source/blender/editors/animation/anim_markers.c
index 7e92c9eb690..7f7b1b28319 100644
--- a/source/blender/editors/animation/anim_markers.c
+++ b/source/blender/editors/animation/anim_markers.c
@@ -597,29 +597,28 @@ static void MARKER_OT_add(wmOperatorType *ot)
 
 /* ************************** transform markers *************************** */
 
-
 /* operator state vars used:  
-	frs: delta movement
-
-functions:
-
-	init()   check selection, add customdata with old values and some lookups
-
-	apply()  do the actual movement
-
-	exit()	cleanup, send notifier
-
-	cancel() to escape from modal
-
-callbacks:
-
-	exec()	calls init, apply, exit 
-
-	invoke() calls init, adds modal handler
-
-	modal()	accept modal events while doing it, ends with apply and exit, or cancel
-
-*/
+ *     frs: delta movement
+ * 
+ * functions:
+ * 
+ *     init()   check selection, add customdata with old values and some lookups
+ * 
+ *     apply()  do the actual movement
+ * 
+ *     exit()    cleanup, send notifier
+ * 
+ *     cancel() to escape from modal
+ * 
+ * callbacks:
+ * 
+ *     exec()    calls init, apply, exit 
+ * 
+ *     invoke() calls init, adds modal handler
+ * 
+ *     modal()    accept modal events while doing it, ends with apply and exit, or cancel
+ * 
+ */
 
 typedef struct MarkerMove {
 	SpaceLink *slink;
@@ -905,23 +904,21 @@ static void MARKER_OT_move(wmOperatorType *ot)
 
 /* ************************** duplicate markers *************************** */
 
-/* operator state vars used:  
-	frs: delta movement
-
-functions:
-
-	apply()  do the actual duplicate
-
-callbacks:
-
-	exec()	calls apply, move_exec
-
-	invoke() calls apply, move_invoke
-
-	modal()	uses move_modal
-
-*/
-
+/* operator state vars used:
+ *     frs: delta movement
+ *
+ * functions:
+ *
+ *     apply()  do the actual duplicate
+ *
+ * callbacks:
+ *
+ *     exec()    calls apply, move_exec
+ *
+ *     invoke() calls apply, move_invoke
+ *
+ *     modal()    uses move_modal
+ */
 
 /* duplicate selected TimeMarkers */
 static void ed_marker_duplicate_apply(bContext *C)
@@ -1125,23 +1122,23 @@ static void MARKER_OT_select(wmOperatorType *ot)
 /* *************************** border select markers **************** */
 
 /* operator state vars used: (added by default WM callbacks)   
-	xmin, ymin     
-	xmax, ymax     
-
-customdata: the wmGesture pointer, with subwindow
-
-callbacks:
-
-	exec()	has to be filled in by user
-
-	invoke() default WM function
-			adds modal handler
-
-	modal()	default WM function 
-			accept modal events while doing it, calls exec(), handles ESC and border drawing
-
-	poll()	has to be filled in by user for context
-*/
+ * xmin, ymin
+ * xmax, ymax
+ *
+ * customdata: the wmGesture pointer, with subwindow
+ *
+ * callbacks:
+ *
+ * 	exec()	has to be filled in by user
+ *
+ * 	invoke() default WM function
+ * 			adds modal handler
+ *
+ * 	modal()	default WM function 
+ * 			accept modal events while doing it, calls exec(), handles ESC and border drawing
+ *
+ * 	poll()	has to be filled in by user for context
+ */
 
 static int ed_marker_border_select_exec(bContext *C, wmOperator *op)
 {
diff --git a/source/blender/editors/animation/keyframes_edit.c b/source/blender/editors/animation/keyframes_edit.c
index af78fe739cc..a99276db122 100644
--- a/source/blender/editors/animation/keyframes_edit.c
+++ b/source/blender/editors/animation/keyframes_edit.c
@@ -136,8 +136,8 @@ short ANIM_fcurve_keyframes_loop(KeyframeEditData *ked, FCurve *fcu, KeyframeEdi
 				if (ked) ked->curIndex= i;
 				
 				/* Exit with return-code '1' if function returns positive
-				* This is useful if finding if some BezTriple satisfies a condition.
-				*/
+				 * This is useful if finding if some BezTriple satisfies a condition.
+				 */
 				if (key_cb(ked, bezt)) return 1;
 			}
 		}
diff --git a/source/blender/editors/armature/armature_ops.c b/source/blender/editors/armature/armature_ops.c
index 7379a278d01..ad52f4e61cb 100644
--- a/source/blender/editors/armature/armature_ops.c
+++ b/source/blender/editors/armature/armature_ops.c
@@ -301,7 +301,7 @@ void ED_keymap_armature(wmKeyConfig *keyconf)
 	keymap->poll= ED_operator_posemode;
 	
 	/* set parent and add object are object-based operators, but we make them
-	   available here because it's useful to do in pose mode too */
+	 * available here because it's useful to do in pose mode too */
 	WM_keymap_add_item(keymap, "OBJECT_OT_parent_set", PKEY, KM_PRESS, KM_CTRL, 0);
 	WM_keymap_add_menu(keymap, "INFO_MT_add", AKEY, KM_PRESS, KM_SHIFT, 0);
 	
diff --git a/source/blender/editors/armature/editarmature.c b/source/blender/editors/armature/editarmature.c
index ba542d5d801..357a53eacb3 100644
--- a/source/blender/editors/armature/editarmature.c
+++ b/source/blender/editors/armature/editarmature.c
@@ -179,7 +179,7 @@ EditBone *ED_armature_bone_get_mirrored(ListBase *edbo, EditBone *ebo)
 }
 
 /* helper function for tools to work on mirrored parts.
-   it leaves mirrored bones selected then too, which is a good indication of what happened */
+ * it leaves mirrored bones selected then too, which is a good indication of what happened */
 static void armature_select_mirrored(bArmature *arm)
 {
 	/* Select mirrored bones */
@@ -438,8 +438,8 @@ void ED_armature_from_edit(Object *obedit)
 			newBone->prop= IDP_CopyProperty(eBone->prop);
 	}
 	
-	/*	Fix parenting in a separate pass to ensure ebone->bone connections
-		are valid at this point */
+	/* Fix parenting in a separate pass to ensure ebone->bone connections
+	 * are valid at this point */
 	for (eBone=arm->edbo->first;eBone;eBone=eBone->next) {
 		newBone= (Bone *)eBone->temp;
 		if (eBone->parent) {
@@ -1770,8 +1770,8 @@ void ED_armature_deselect_all(Object *obedit, int toggle)
 	int			sel=1;
 	
 	if(toggle==1) {
-		/*	Determine if there are any selected bones
-		And therefore whether we are selecting or deselecting */
+		/* Determine if there are any selected bones
+		 * and therefore whether we are selecting or deselecting */
 		for (eBone=arm->edbo->first;eBone;eBone=eBone->next){
 			//			if(arm->layer & eBone->layer) {
 			if (eBone->flag & (BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL)){
@@ -1858,7 +1858,7 @@ int mouse_armature(bContext *C, const int mval[2], int extend)
 			ED_armature_deselect_all(obedit, 0);
 		
 		/* by definition the non-root connected bones have no root point drawn,
-		   so a root selection needs to be delivered to the parent tip */
+		 * so a root selection needs to be delivered to the parent tip */
 		
 		if(selmask & BONE_SELECTED) {
 			if(nearBone->parent && (nearBone->flag & BONE_CONNECTED)) {
@@ -2375,7 +2375,7 @@ static int armature_click_extrude_exec(bContext *C, wmOperator *UNUSED(op))
 static int armature_click_extrude_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
 	/* TODO most of this code is copied from set3dcursor_invoke,
-	   it would be better to reuse code in set3dcursor_invoke */
+	 * it would be better to reuse code in set3dcursor_invoke */
 
 	/* temporarily change 3d cursor position */
 	Scene *scene;
@@ -3783,10 +3783,10 @@ static int armature_parent_set_exec(bContext *C, wmOperator *op)
 	else if (arm->flag & ARM_MIRROR_EDIT) {
 		/* For X-Axis Mirror Editing option, we may need a mirror copy of actbone
 		 * - if there's a mirrored copy of selbone, try to find a mirrored copy of actbone 
-		 *	(i.e.  selbone="child.L" and actbone="parent.L", find "child.R" and "parent.R").
-		 *	This is useful for arm-chains, for example parenting lower arm to upper arm
+		 *   (i.e.  selbone="child.L" and actbone="parent.L", find "child.R" and "parent.R").
+		 * This is useful for arm-chains, for example parenting lower arm to upper arm
 		 * - if there's no mirrored copy of actbone (i.e. actbone = "parent.C" or "parent")
-		 *	then just use actbone. Useful when doing upper arm to spine.
+		 *   then just use actbone. Useful when doing upper arm to spine.
 		 */
 		actmirb= ED_armature_bone_get_mirrored(arm->edbo, actbone);
 		if (actmirb == NULL) 
@@ -3972,8 +3972,8 @@ static int armature_de_select_all_exec(bContext *C, wmOperator *op)
 
 	if (action == SEL_TOGGLE) {
 		action = SEL_SELECT;
-		/*	Determine if there are any selected bones
-		And therefore whether we are selecting or deselecting */
+		/* Determine if there are any selected bones
+		 * And therefore whether we are selecting or deselecting */
 		if (CTX_DATA_COUNT(C, selected_bones) > 0)
 			action = SEL_DESELECT;
 	}
@@ -4158,8 +4158,8 @@ static void bone_align_to_bone(ListBase *edbo, EditBone *selbone, EditBone *actb
 	selbone->roll = actbone->roll;
 	
 	/* if the bone being aligned has connected descendants they must be moved
-	according to their parent new position, otherwise they would be left
-	in an unconsistent state: connected but away from the parent*/
+	 * according to their parent new position, otherwise they would be left
+	 * in an unconsistent state: connected but away from the parent*/
 	fix_editbone_connected_children(edbo, selbone);
 	return;
 }
@@ -4179,10 +4179,10 @@ static int armature_align_bones_exec(bContext *C, wmOperator *op)
 	else if (arm->flag & ARM_MIRROR_EDIT) {
 		/* For X-Axis Mirror Editing option, we may need a mirror copy of actbone
 		 * - if there's a mirrored copy of selbone, try to find a mirrored copy of actbone 
-		 *	(i.e.  selbone="child.L" and actbone="parent.L", find "child.R" and "parent.R").
-		 *	This is useful for arm-chains, for example parenting lower arm to upper arm
+		 *   (i.e.  selbone="child.L" and actbone="parent.L", find "child.R" and "parent.R").
+		 *   This is useful for arm-chains, for example parenting lower arm to upper arm
 		 * - if there's no mirrored copy of actbone (i.e. actbone = "parent.C" or "parent")
-		 *	then just use actbone. Useful when doing upper arm to spine.
+		 *   then just use actbone. Useful when doing upper arm to spine.
 		 */
 		actmirb= ED_armature_bone_get_mirrored(arm->edbo, actbone);
 		if (actmirb == NULL) 
@@ -4208,8 +4208,8 @@ static int armature_align_bones_exec(bContext *C, wmOperator *op)
 		 * - the context iterator contains both selected bones and their mirrored copies,
 		 *   so we assume that unselected bones are mirrored copies of some selected bone
 		 * - since the active one (and/or its mirror) will also be selected, we also need 
-		 * 	to check that we are not trying to opearate on them, since such an operation 
-		 *	would cause errors
+		 *   to check that we are not trying to opearate on them, since such an operation 
+		 *   would cause errors
 		 */
 		
 		/* align selected bones to the active one */
@@ -4254,11 +4254,11 @@ static int bone_looper(Object *ob, Bone *bone, void *data,
 				int (*bone_func)(Object *, Bone *, void *)) 
 {
 	/* We want to apply the function bone_func to every bone 
-	* in an armature -- feed bone_looper the first bone and 
-	* a pointer to the bone_func and watch it go!. The int count 
-	* can be useful for counting bones with a certain property
-	* (e.g. skinnable)
-	*/
+	 * in an armature -- feed bone_looper the first bone and 
+	 * a pointer to the bone_func and watch it go!. The int count 
+	 * can be useful for counting bones with a certain property
+	 * (e.g. skinnable)
+	 */
 	int count = 0;
 	
 	if (bone) {
@@ -4269,8 +4269,8 @@ static int bone_looper(Object *ob, Bone *bone, void *data,
 		count += bone_looper(ob, bone->childbase.first, data, bone_func);
 		
 		/* try to execute bone_func for the next bone at this
-			* depth of the recursion.
-			*/
+		 * depth of the recursion.
+		 */
 		count += bone_looper(ob, bone->next, data, bone_func);
 	}
 	
@@ -4342,10 +4342,10 @@ int ED_do_pose_selectbuffer(Scene *scene, Base *base, unsigned int *buffer, shor
 }
 
 /* test==0: deselect all
-   test==1: swap select (apply to all the opposite of current situation) 
-   test==2: only clear active tag
-   test==3: swap select (no test / inverse selection status of all independently)
-*/
+ * test==1: swap select (apply to all the opposite of current situation) 
+ * test==2: only clear active tag
+ * test==3: swap select (no test / inverse selection status of all independently)
+ */
 void ED_pose_deselectall (Object *ob, int test)
 {
 	bArmature *arm= ob->data;
@@ -4437,9 +4437,9 @@ static int bone_skinnable_cb(Object *ob, Bone *bone, void *datap)
 static int vgroup_add_unique_bone_cb(Object *ob, Bone *bone, void *UNUSED(ptr)) 
 {
 	/* This group creates a vertex group to ob that has the
-	  * same name as bone (provided the bone is skinnable). 
+	 * same name as bone (provided the bone is skinnable). 
 	 * If such a vertex group aleady exist the routine exits.
-	  */
+	 */
 	if (!(bone->flag & BONE_NO_DEFORM)) {
 		if (!defgroup_find_name(ob,bone->name)) {
 			ED_vgroup_add_name(ob, bone->name);
@@ -4688,7 +4688,7 @@ static void add_verts_to_dgroups(ReportList *reports, Scene *scene, Object *ob,
 	}
 	else if (modifiers_findByType(ob, eModifierType_Subsurf)) {
 		/* is subsurf on? Lets use the verts on the limit surface then.
-		  * = same amount of vertices as mesh, but vertices  moved to the
+		 * = same amount of vertices as mesh, but vertices  moved to the
 		 * subsurfed position, like for 'optimal'. */
 		subsurf_calculate_limit_positions(mesh, verts);
 		vertsfilled = 1;
diff --git a/source/blender/editors/armature/meshlaplacian.c b/source/blender/editors/armature/meshlaplacian.c
index a592e727988..74c44ea1f0d 100644
--- a/source/blender/editors/armature/meshlaplacian.c
+++ b/source/blender/editors/armature/meshlaplacian.c
@@ -129,12 +129,12 @@ struct LaplacianSystem {
 /* Laplacian matrix construction */
 
 /* Computation of these weights for the laplacian is based on:
-   "Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
-   Meyer et al, 2002. Section 3.5, formula (8).
-   
-   We do it a bit different by going over faces instead of going over each
-   vertex and adjacent faces, since we don't store this adjacency. Also, the
-   formulas are tweaked a bit to work for non-manifold meshes. */
+ * "Discrete Differential-Geometry Operators for Triangulated 2-Manifolds",
+ * Meyer et al, 2002. Section 3.5, formula (8).
+ * 
+ * We do it a bit different by going over faces instead of going over each
+ * vertex and adjacent faces, since we don't store this adjacency. Also, the
+ * formulas are tweaked a bit to work for non-manifold meshes. */
 
 static void laplacian_increase_edge_count(EdgeHash *edgehash, int v1, int v2)
 {
@@ -217,7 +217,7 @@ static void laplacian_triangle_weights(LaplacianSystem *sys, int f, int i1, int
 	v3= sys->verts[i3];
 
 	/* instead of *0.5 we divided by the number of faces of the edge, it still
-	   needs to be verified that this is indeed the correct thing to do! */
+	 * needs to be verified that this is indeed the correct thing to do! */
 	t1= cotan_weight(v1, v2, v3)/laplacian_edge_count(sys->edgehash, i2, i3);
 	t2= cotan_weight(v2, v3, v1)/laplacian_edge_count(sys->edgehash, i3, i1);
 	t3= cotan_weight(v3, v1, v2)/laplacian_edge_count(sys->edgehash, i1, i2);
@@ -391,7 +391,7 @@ float laplacian_system_get_solution(int v)
 
 /************************* Heat Bone Weighting ******************************/
 /* From "Automatic Rigging and Animation of 3D Characters"
-		 Ilya Baran and Jovan Popovic, SIGGRAPH 2007 */
+ * Ilya Baran and Jovan Popovic, SIGGRAPH 2007 */
 
 #define C_WEIGHT			1.0f
 #define WEIGHT_LIMIT_START	0.05f
@@ -827,13 +827,13 @@ void heat_bone_weighting(Object *ob, Mesh *me, float (*verts)[3], int numsource,
 #ifdef RIGID_DEFORM
 /********************** As-Rigid-As-Possible Deformation ******************/
 /* From "As-Rigid-As-Possible Surface Modeling",
-		Olga Sorkine and Marc Alexa, ESGP 2007. */
+ * Olga Sorkine and Marc Alexa, ESGP 2007. */
 
 /* investigate:
-   - transpose R in orthogonal
-   - flipped normals and per face adding
-   - move cancelling to transform, make origco pointer
-*/
+ * - transpose R in orthogonal
+ * - flipped normals and per face adding
+ * - move cancelling to transform, make origco pointer
+ */
 
 static LaplacianSystem *RigidDeformSystem = NULL;
 
@@ -1052,8 +1052,8 @@ void rigid_deform_end(int cancel)
 
 /************************** Harmonic Coordinates ****************************/
 /* From "Harmonic Coordinates for Character Articulation",
-	Pushkar Joshi, Mark Meyer, Tony DeRose, Brian Green and Tom Sanocki,
-	SIGGRAPH 2007. */
+ * Pushkar Joshi, Mark Meyer, Tony DeRose, Brian Green and Tom Sanocki,
+ * SIGGRAPH 2007. */
 
 #define EPSILON 0.0001f
 
diff --git a/source/blender/editors/armature/reeb.c b/source/blender/editors/armature/reeb.c
index 3c84ee65ac7..08f95ecb08a 100644
--- a/source/blender/editors/armature/reeb.c
+++ b/source/blender/editors/armature/reeb.c
@@ -3479,9 +3479,8 @@ ReebGraph *BIF_ReebGraphMultiFromEditMesh(bContext *C)
 	
 	MEM_freeN(data);
 
-	/*no need to load the editmesh back into the object, just
-	  free it (avoids ngon conversion issues too going back the
-	           other way)*/
+	/* no need to load the editmesh back into the object, just
+	 * free it (avoids ngon conversion issues too going back the other way) */
 	free_editMesh(em);
 	MEM_freeN(em);
 	
diff --git a/source/blender/editors/curve/editcurve.c b/source/blender/editors/curve/editcurve.c
index c09f4d16936..28e29bf0a8c 100644
--- a/source/blender/editors/curve/editcurve.c
+++ b/source/blender/editors/curve/editcurve.c
@@ -1117,8 +1117,8 @@ static void curve_rename_fcurves(Object *obedit, ListBase *orig_curves)
 	}
 
 	/* remove pathes for removed control points
-	   need this to make further step with copying non-cv related curves copying
-	   not touching cv's f-cruves */
+	 * need this to make further step with copying non-cv related curves copying
+	 * not touching cv's f-cruves */
 	for(fcu= orig_curves->first; fcu; fcu= next) {
 		next= fcu->next;
 
@@ -1262,7 +1262,7 @@ void make_editNurb(Object *obedit)
 			editnurb->shapenr= obedit->shapenr;
 
 		/* animation could be added in editmode even if teher was no animdata i
-		   object mode hence we always need CVs index be created */
+		 * object mode hence we always need CVs index be created */
 		init_editNurb_keyIndex(editnurb, &cu->nurb);
 	}
 }
@@ -2772,10 +2772,10 @@ static void subdividenurb(Object *obedit, int number_cuts)
 		amount= 0;
 		if(nu->type == CU_BEZIER) {
 		/* 
-		   Insert a point into a 2D Bezier curve. 
-		   Endpoints are preserved. Otherwise, all selected and inserted points are 
-		   newly created. Old points are discarded.
-		*/
+		 * Insert a point into a 2D Bezier curve. 
+		 * Endpoints are preserved. Otherwise, all selected and inserted points are 
+		 * newly created. Old points are discarded.
+		 */
 			/* count */
 			if(nu->flagu & CU_NURB_CYCLIC) {
 				a= nu->pntsu;
@@ -2867,10 +2867,10 @@ static void subdividenurb(Object *obedit, int number_cuts)
 		} /* End of 'if(nu->type == CU_BEZIER)' */
 		else if (nu->pntsv==1) {
 		/* 
-		   All flat lines (ie. co-planar), except flat Nurbs. Flat NURB curves 
-		   are handled together with the regular NURB plane division, as it 
-		   should be. I split it off just now, let's see if it is
-		   stable... nzc 30-5-'00
+		 * All flat lines (ie. co-planar), except flat Nurbs. Flat NURB curves 
+		 * are handled together with the regular NURB plane division, as it 
+		 * should be. I split it off just now, let's see if it is
+		 * stable... nzc 30-5-'00
 		 */
 			/* count */
 			if(nu->flagu & CU_NURB_CYCLIC) {
@@ -2941,46 +2941,46 @@ static void subdividenurb(Object *obedit, int number_cuts)
 		else if(nu->type == CU_NURBS) {
 		/* This is a very strange test ... */
 		/** 
-		   Subdivide NURB surfaces - nzc 30-5-'00 -
-
-			 Subdivision of a NURB curve can be effected by adding a 
-		   control point (insertion of a knot), or by raising the
-		   degree of the functions used to build the NURB. The
-		   expression 
-
-			   degree = #knots - #controlpoints + 1 (J Walter piece)
-			   degree = #knots - #controlpoints     (Blender
-													  implementation)
-				 ( this is confusing.... what is true? Another concern
-				 is that the JW piece allows the curve to become
-				 explicitly 1st order derivative discontinuous, while
-				 this is not what we want here... )
-
-		   is an invariant for a single NURB curve. Raising the degree
-		   of the NURB is done elsewhere; the degree is assumed
-		   constant during this opration. Degree is a property shared
-		   by all controlpoints in a curve (even though it is stored
-		   per control point - this can be misleading).
-			 Adding a knot is done by searching for the place in the
-		   knot vector where a certain knot value must be inserted, or
-		   by picking an appropriate knot value between two existing
-		   ones. The number of controlpoints that is influenced by the
-		   insertion depends on the order of the curve. A certain
-		   minimum number of knots is needed to form high-order
-		   curves, as can be seen from the equation above. In Blender,
-		   currently NURBs may be up to 6th order, so we modify at
-		   most 6 points. One point is added. For an n-degree curve,
-		   n points are discarded, and n+1 points inserted
-		   (so effectively, n points are modified).  (that holds for
-		   the JW piece, but it seems not for our NURBs)
-			  In practice, the knot spacing is copied, but the tail
-		   (the points following the insertion point) need to be
-		   offset to keep the knot series ascending. The knot series
-		   is always a series of monotonically ascending integers in
-		   Blender. When not enough control points are available to
-		   fit the order, duplicates of the endpoints are added as
-		   needed. 
-		*/
+		 * Subdivide NURB surfaces - nzc 30-5-'00 -
+		 *
+		 * Subdivision of a NURB curve can be effected by adding a 
+		 * control point (insertion of a knot), or by raising the
+		 * degree of the functions used to build the NURB. The
+		 * expression 
+		 *
+		 *     degree = #knots - #controlpoints + 1 (J Walter piece)
+		 *     degree = #knots - #controlpoints     (Blender
+		 *                                           implementation)
+		 *       ( this is confusing.... what is true? Another concern
+		 *       is that the JW piece allows the curve to become
+		 *       explicitly 1st order derivative discontinuous, while
+		 *       this is not what we want here... )
+		 *
+		 * is an invariant for a single NURB curve. Raising the degree
+		 * of the NURB is done elsewhere; the degree is assumed
+		 * constant during this opration. Degree is a property shared
+		 * by all controlpoints in a curve (even though it is stored
+		 * per control point - this can be misleading).
+		 * Adding a knot is done by searching for the place in the
+		 * knot vector where a certain knot value must be inserted, or
+		 * by picking an appropriate knot value between two existing
+		 * ones. The number of controlpoints that is influenced by the
+		 * insertion depends on the order of the curve. A certain
+		 * minimum number of knots is needed to form high-order
+		 * curves, as can be seen from the equation above. In Blender,
+		 * currently NURBs may be up to 6th order, so we modify at
+		 * most 6 points. One point is added. For an n-degree curve,
+		 * n points are discarded, and n+1 points inserted
+		 * (so effectively, n points are modified).  (that holds for
+		 * the JW piece, but it seems not for our NURBs)
+		 * In practice, the knot spacing is copied, but the tail
+		 * (the points following the insertion point) need to be
+		 * offset to keep the knot series ascending. The knot series
+		 * is always a series of monotonically ascending integers in
+		 * Blender. When not enough control points are available to
+		 * fit the order, duplicates of the endpoints are added as
+		 * needed. 
+		 */
 			/* selection-arrays */
 			usel= MEM_callocN(sizeof(int)*nu->pntsu, "subivideNurb3");
 			vsel= MEM_callocN(sizeof(int)*nu->pntsv, "subivideNurb3");
@@ -2998,9 +2998,9 @@ static void subdividenurb(Object *obedit, int number_cuts)
 					bp++;
 				}
 			}
-			if( sel == (nu->pntsu*nu->pntsv) ) {	/* subdivide entire nurb */
-		   /* Global subdivision is a special case of partial
-			  subdivision. Strange it is considered separately... */
+			if( sel == (nu->pntsu*nu->pntsv) ) {  /* subdivide entire nurb */
+				/* Global subdivision is a special case of partial
+				 * subdivision. Strange it is considered separately... */
 
 				/* count of nodes (after subdivision) along U axis */
 				int countu= nu->pntsu + (nu->pntsu - 1) * number_cuts;
@@ -3081,12 +3081,12 @@ static void subdividenurb(Object *obedit, int number_cuts)
 								prevbp= bp- nu->pntsu;
 								for(b=0; b<nu->pntsu; b++) {
 										/*
-										  This simple bisection must be replaces by a
-										  subtle resampling of a number of points. Our
-										  task is made slightly easier because each
-										  point in our curve is a separate data
-										  node. (is it?)
-										*/
+										 * This simple bisection must be replaces by a
+										 * subtle resampling of a number of points. Our
+										 * task is made slightly easier because each
+										 * point in our curve is a separate data
+										 * node. (is it?)
+										 */
 										*bpn= *prevbp;
 										interp_v4_v4v4(bpn->vec, prevbp->vec, bp->vec, factor);
 										bpn++;
@@ -3123,12 +3123,12 @@ static void subdividenurb(Object *obedit, int number_cuts)
 								bp++;
 								if( (b<nu->pntsu-1) && usel[b]==nu->pntsv && usel[b+1]==nu->pntsv ) {
 									/*
-									   One thing that bugs me here is that the
-									   orders of things are not the same as in
-									   the JW piece. Also, this implies that we
-									   handle at most 3rd order curves? I miss
-									   some symmetry here...
-									*/
+									 * One thing that bugs me here is that the
+									 * orders of things are not the same as in
+									 * the JW piece. Also, this implies that we
+									 * handle at most 3rd order curves? I miss
+									 * some symmetry here...
+									 */
 									for (i = 0; i < number_cuts; i++) {
 										factor = (float)(i + 1) / (number_cuts + 1);
 									prevbp= bp- 1;
@@ -4353,8 +4353,8 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
 				newnu= (Nurb*)MEM_callocN(sizeof(Nurb), "addvert_Nurb newnu");
 				if(!nu) {
 					/* no selected sement -- create new one which is BEZIER tpye
-					   type couldn't be determined from Curve bt could be changed
-					   in the future, so shouldn't make much headache */
+					 * type couldn't be determined from Curve bt could be changed
+					 * in the future, so shouldn't make much headache */
 					newnu->type= CU_BEZIER;
 					newnu->resolu= cu->resolu;
 					newnu->flag |= CU_SMOOTH;
@@ -5624,12 +5624,12 @@ static int delete_exec(bContext *C, wmOperator *op)
 			}
 			
 			/* Never allow the order to exceed the number of points
-			- note, this is ok but changes unselected nurbs, disable for now */
-			/*
+			 * - note, this is ok but changes unselected nurbs, disable for now */
+#if 0
 			if ((nu!= NULL) && (nu->type == CU_NURBS)) {
 				clamp_nurb_order_u(nu);
 			}
-			*/
+#endif
 			nu= next;
 			nuindex++;
 		}
@@ -5688,12 +5688,13 @@ static int delete_exec(bContext *C, wmOperator *op)
 					MEM_freeN(nu->bp);
 					nu->bp= bp1;
 					
-					/* Never allow the order to exceed the number of points\
-					- note, this is ok but changes unselected nurbs, disable for now */
-					/*
+					/* Never allow the order to exceed the number of points
+					 * - note, this is ok but changes unselected nurbs, disable for now */
+#if 0
 					if (nu->type == CU_NURBS) {
 						clamp_nurb_order_u(nu);
-					}*/
+					}
+#endif
 				}
 				clamp_nurb_order_u(nu);
 				nurbs_knot_calc_u(nu);
diff --git a/source/blender/editors/gpencil/drawgpencil.c b/source/blender/editors/gpencil/drawgpencil.c
index 19dc25dd282..5e9acc5b84f 100644
--- a/source/blender/editors/gpencil/drawgpencil.c
+++ b/source/blender/editors/gpencil/drawgpencil.c
@@ -517,10 +517,10 @@ static void gp_draw_strokes (bGPDframe *gpf, int offsx, int offsy, int winx, int
 				
 				/* first arg is normally rv3d->dist, but this isnt available here and seems to work quite well without */
 				bglPolygonOffset(1.0f, 1.0f);
-				/*
+#if 0
 				glEnable(GL_POLYGON_OFFSET_LINE);
 				glPolygonOffset(-1.0f, -1.0f);
-				*/
+#endif
 			}
 			
 			gp_draw_stroke_3d(gps->points, gps->totpoints, lthick, debug);
@@ -530,10 +530,10 @@ static void gp_draw_strokes (bGPDframe *gpf, int offsx, int offsy, int winx, int
 				glDisable(GL_DEPTH_TEST);
 				
 				bglPolygonOffset(0.0, 0.0);
-				/*
+#if 0
 				glDisable(GL_POLYGON_OFFSET_LINE);
 				glPolygonOffset(0, 0);
-				*/
+#endif
 			}
 		}
 		else if (gps->totpoints > 1)	
diff --git a/source/blender/editors/gpencil/gpencil_paint.c b/source/blender/editors/gpencil/gpencil_paint.c
index 673d7c637ff..c9d1f70aa65 100644
--- a/source/blender/editors/gpencil/gpencil_paint.c
+++ b/source/blender/editors/gpencil/gpencil_paint.c
@@ -104,8 +104,8 @@ typedef struct tGPsdata {
 	short radius;		/* radius of influence for eraser */
 	short flags;		/* flags that can get set during runtime */
 
-	float imat[4][4];	/* inverted transformation matrix applying when converting coords from screen-space
-						 * to region space */
+	float imat[4][4];   /* inverted transformation matrix applying when converting coords from screen-space
+	                     * to region space */
 
 	float custom_color[4]; /* custom color for (?) */
 } tGPsdata;
@@ -578,8 +578,8 @@ static void gp_stroke_newfrombuffer (tGPsdata *p)
 	}
 	
 	/* special case for poly line -- for already added stroke during session
-	   coordinates are getting added to stroke immediatelly to allow more
-	   interactive behavior */
+	 * coordinates are getting added to stroke immediatelly to allow more
+	 * interactive behavior */
 	if (p->paintmode == GP_PAINTMODE_DRAW_POLY) {
 		if (p->flags & GP_PAINTFLAG_STROKEADDED)
 			return;
@@ -1148,7 +1148,7 @@ static int gp_session_initdata (bContext *C, tGPsdata *p)
 	
 	if (ED_gpencil_session_active()==0) {
 		/* initialize undo stack,
-		   also, existing undo stack would make buffer drawn */
+		 * also, existing undo stack would make buffer drawn */
 		gpencil_undo_init(p->gpd);
 	}
 	
@@ -1369,7 +1369,7 @@ static void gp_paint_strokeend (tGPsdata *p)
 static void gp_paint_cleanup (tGPsdata *p)
 {
 	/* p->gpd==NULL happens when stroke failed to initialize,
-	      for example. when GP is hidden in current space (sergey) */
+	 * for example. when GP is hidden in current space (sergey) */
 	if (p->gpd) {
 		/* finish off a stroke */
 		gp_paint_strokeend(p);
diff --git a/source/blender/editors/include/BIF_glutil.h b/source/blender/editors/include/BIF_glutil.h
index 77c50f9ca6d..d0d50aa86fa 100644
--- a/source/blender/editors/include/BIF_glutil.h
+++ b/source/blender/editors/include/BIF_glutil.h
@@ -110,7 +110,7 @@ void glaRasterPosSafe2f		(float x, float y, float known_good_x, float known_good
 	 * coordinates for would be clipped. The routine respects the
 	 * glPixelZoom values, pixel unpacking parameters are _not_ 
 	 * respected.
-
+	 *
 	 * \attention This routine makes many assumptions: the rect data
 	 * is expected to be in RGBA unsigned byte format, the coordinate
 	 * (0.375, 0.375) is assumed to be within the view frustum, and the 
@@ -131,7 +131,7 @@ void glaDrawPixelsSafe		(float x, float y, int img_w, int img_h, int row_w, int
 	 * cards, and also avoids problems with the raster position being
 	 * clipped when offscreen. The routine respects the glPixelZoom values, 
 	 * pixel unpacking parameters are _not_ respected.
-
+	 *
 	 * \attention This routine makes many assumptions: the rect data
 	 * is expected to be in RGBA byte or float format, and the 
 	 * modelview and projection matrices are assumed to define a 
diff --git a/source/blender/editors/include/ED_armature.h b/source/blender/editors/include/ED_armature.h
index a073cdddae7..851bd09dd29 100644
--- a/source/blender/editors/include/ED_armature.h
+++ b/source/blender/editors/include/ED_armature.h
@@ -56,32 +56,32 @@ struct wmOperator;
 typedef struct EditBone
 {
 	struct EditBone *next, *prev;
-	struct IDProperty 		*prop;			/* User-Defined Properties on this Bone */
-	struct EditBone *parent;/*	Editbones have a one-way link  (i.e. children refer
-									to parents.  This is converted to a two-way link for
-									normal bones when leaving editmode.	*/
-	void	*temp;			/*	Used to store temporary data */
-
-	char	name[64];		/* MAX_NAME */
-	float	roll;			/*	Roll along axis.  We'll ultimately use the axis/angle method
-								for determining the transformation matrix of the bone.  The axis
-								is tail-head while roll provides the angle. Refer to Graphics
-								Gems 1 p. 466 (section IX.6) if it's not already in here somewhere*/
-
-	float	head[3];			/*	Orientation and length is implicit during editing */
-	float	tail[3];	
-							/*	All joints are considered to have zero rotation with respect to
-							their parents.	Therefore any rotations specified during the
-							animation are automatically relative to the bones' rest positions*/
+	struct IDProperty *prop;/* User-Defined Properties on this Bone */
+	struct EditBone *parent;/* Editbones have a one-way link  (i.e. children refer
+	                         * to parents.  This is converted to a two-way link for
+	                         * normal bones when leaving editmode. */
+	void    *temp;          /* Used to store temporary data */
+
+	char    name[64];       /* MAX_NAME */
+	float   roll;           /* Roll along axis.  We'll ultimately use the axis/angle method
+	                         * for determining the transformation matrix of the bone.  The axis
+	                         * is tail-head while roll provides the angle. Refer to Graphics
+	                         * Gems 1 p. 466 (section IX.6) if it's not already in here somewhere*/
+
+	float	head[3];        /* Orientation and length is implicit during editing */
+	float	tail[3];
+	                        /* All joints are considered to have zero rotation with respect to
+	                         * their parents.	Therefore any rotations specified during the
+	                         * animation are automatically relative to the bones' rest positions*/
 	int		flag;
 	int		layer;
 	
 	float dist, weight;
-	float xwidth, length, zwidth;	/* put them in order! transform uses this as scale */
+	float xwidth, length, zwidth;  /* put them in order! transform uses this as scale */
 	float ease1, ease2;
 	float rad_head, rad_tail;
 	
-	float oldlength;				/* for envelope scaling */
+	float oldlength;        /* for envelope scaling */
 	
 	short segments;
 } EditBone;
diff --git a/source/blender/editors/include/ED_datafiles.h b/source/blender/editors/include/ED_datafiles.h
index 9fe2fe685a0..c725808ec34 100644
--- a/source/blender/editors/include/ED_datafiles.h
+++ b/source/blender/editors/include/ED_datafiles.h
@@ -56,7 +56,7 @@ extern char datatoc_bmonofont_ttf[];
 
 /* Brush icon datafiles */
 /* TODO: this could be simplified by putting all
-   the brush icons in one file */
+ * the brush icons in one file */
 extern int datatoc_add_png_size;
 extern char datatoc_add_png[];
 
diff --git a/source/blender/editors/include/ED_mesh.h b/source/blender/editors/include/ED_mesh.h
index 986c2abad69..c40048625a7 100644
--- a/source/blender/editors/include/ED_mesh.h
+++ b/source/blender/editors/include/ED_mesh.h
@@ -96,30 +96,30 @@ int         mesh_mirrtopo_table(struct Object *ob, char mode);
 
 /* bmeshutils.c */
 
-/*
- [note: I've decided to use ideasman's code for non-editmode stuff, but since
-  it has a big "not for editmode!" disclaimer, I'm going to keep what I have here
-  - joeedh]
-  
- x-mirror editing api.  usage:
-  
-  EDBM_CacheMirrorVerts(em);
-  ...
-  ...
-  BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
-     mirrorv = EDBM_GetMirrorVert(em, v);
-  }
-  ...
-  ...
-  EDBM_EndMirrorCache(em);
- 
-  note: why do we only allow x axis mirror editing?
-  */
+/**
+ * [note: I've decided to use ideasman's code for non-editmode stuff, but since
+ *  it has a big "not for editmode!" disclaimer, I'm going to keep what I have here
+ *  - joeedh]
+ *  
+ * x-mirror editing api.  usage:
+ *  
+ *  EDBM_CacheMirrorVerts(em);
+ *  ...
+ *  ...
+ *  BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
+ *     mirrorv = EDBM_GetMirrorVert(em, v);
+ *  }
+ *  ...
+ *  ...
+ *  EDBM_EndMirrorCache(em);
+ *
+ * \note why do we only allow x axis mirror editing?
+ */
 void EDBM_CacheMirrorVerts(struct BMEditMesh *em, const short use_select); /* note, replaces EM_cache_x_mirror_vert in trunk */
 
-/*retrieves mirrored cache vert, or NULL if there isn't one.
-  note: calling this without ensuring the mirror cache state
-  is bad.*/
+/* retrieves mirrored cache vert, or NULL if there isn't one.
+ * note: calling this without ensuring the mirror cache state
+ * is bad.*/
 struct BMVert *EDBM_GetMirrorVert(struct BMEditMesh *em, struct BMVert *v);
 void           EDBM_ClearMirrorVert(struct BMEditMesh *em, struct BMVert *v);
 void EDBM_EndMirrorCache(struct BMEditMesh *em);
diff --git a/source/blender/editors/include/ED_render.h b/source/blender/editors/include/ED_render.h
index c9e00b0296a..73bbd5ffef8 100644
--- a/source/blender/editors/include/ED_render.h
+++ b/source/blender/editors/include/ED_render.h
@@ -67,12 +67,12 @@ typedef struct RenderInfo {
 #define PR_ROTATED			8
 
 /* Render the preview
-
-pr_method:
-- PR_BUTS_RENDER: preview is rendered for buttons window
-- PR_ICON_RENDER: preview is rendered for icons. hopefully fast enough for at least 32x32 
-- PR_NODE_RENDER: preview is rendered for node editor.
-*/
+ *
+ * pr_method:
+ * - PR_BUTS_RENDER: preview is rendered for buttons window
+ * - PR_ICON_RENDER: preview is rendered for icons. hopefully fast enough for at least 32x32
+ * - PR_NODE_RENDER: preview is rendered for node editor
+ */
 
 #define PR_BUTS_RENDER	0
 #define PR_ICON_RENDER	1
diff --git a/source/blender/editors/include/ED_space_api.h b/source/blender/editors/include/ED_space_api.h
index 0d6e640c7bf..8023eef8370 100644
--- a/source/blender/editors/include/ED_space_api.h
+++ b/source/blender/editors/include/ED_space_api.h
@@ -57,7 +57,7 @@ void ED_spacetype_userpref(void);
 void ED_spacetype_clip(void);
 
 /* calls for instancing and freeing spacetype static data 
-   called in WM_init_exit */
+ * called in WM_init_exit */
 /* in space_file.c */
 void ED_file_init(void);
 void ED_file_exit(void);
diff --git a/source/blender/editors/include/UI_interface.h b/source/blender/editors/include/UI_interface.h
index fafd35bf911..18e2af939fd 100644
--- a/source/blender/editors/include/UI_interface.h
+++ b/source/blender/editors/include/UI_interface.h
@@ -178,11 +178,11 @@ typedef struct uiLayout uiLayout;
 #define UI_DPI_ICON_SIZE ((float)16 * UI_DPI_ICON_FAC)
 
 /* Button types, bits stored in 1 value... and a short even!
-- bits 0-4:  bitnr (0-31)
-- bits 5-7:  pointer type
-- bit  8:    for 'bit'
-- bit  9-15: button type (now 6 bits, 64 types)
-*/
+ * - bits 0-4:  bitnr (0-31)
+ * - bits 5-7:  pointer type
+ * - bit  8:    for 'bit'
+ * - bit  9-15: button type (now 6 bits, 64 types)
+ * */
 
 #define CHA	32
 #define SHO	64
diff --git a/source/blender/editors/include/UI_interface_icons.h b/source/blender/editors/include/UI_interface_icons.h
index a1b42ac39c2..c2bc2cf6af1 100644
--- a/source/blender/editors/include/UI_interface_icons.h
+++ b/source/blender/editors/include/UI_interface_icons.h
@@ -54,8 +54,8 @@ typedef struct IconFile {
 #define PREVIEW_DEFAULT_HEIGHT 96
 
 /*
- Resizable Icons for Blender
-*/
+ * Resizable Icons for Blender
+ */
 void UI_icons_init(int first_dyn_id);
 int UI_icon_get_width(int icon_id);
 int UI_icon_get_height(int icon_id);
diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c
index 1944f81ec2d..6e3e7a2a4e0 100644
--- a/source/blender/editors/interface/interface.c
+++ b/source/blender/editors/interface/interface.c
@@ -1514,7 +1514,7 @@ void ui_set_but_val(uiBut *but, double value)
 			/* gcc 3.2.1 seems to have problems 
 			 * casting a double like 32772.0 to
 			 * a short so we cast to an int, then 
-			 to a short */
+			 * to a short */
 			int gcckludge;
 			gcckludge = (int) floor(value+0.5);
 			value= (short)gcckludge;
@@ -2515,13 +2515,13 @@ void ui_block_do_align(uiBlock *block)
 	}
 }
 
-/*
- * ui_def_but is the function that draws many button types
-
+/**
+ * \brief ui_def_but is the function that draws many button types
+ *
  * for float buttons:
- *   "a1" Click Step (how much to change the value each click)
- *   "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.
+ * - \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, void *poin, float min, float max, float a1, float a2, const char *tip)
 {
diff --git a/source/blender/editors/interface/interface_draw.c b/source/blender/editors/interface/interface_draw.c
index 93cb0f8ae97..97248e8710c 100644
--- a/source/blender/editors/interface/interface_draw.c
+++ b/source/blender/editors/interface/interface_draw.c
@@ -432,7 +432,8 @@ void ui_draw_but_IMAGE(ARegion *UNUSED(ar), uiBut *but, uiWidgetColors *UNUSED(w
 
 	if (!ibuf) return;
 	
-	/* scissor doesn't seem to be doing the right thing...?
+	/* scissor doesn't seem to be doing the right thing...? */
+#if 0
 	//glColor4f(1.0, 0.f, 0.f, 1.f);
 	//fdrawbox(rect->xmin, rect->ymin, rect->xmax, rect->ymax)
 
@@ -441,7 +442,7 @@ void ui_draw_but_IMAGE(ARegion *UNUSED(ar), uiBut *but, uiWidgetColors *UNUSED(w
 	// prevent drawing outside widget area
 	glGetIntegerv(GL_SCISSOR_BOX, scissor);
 	glScissor(ar->winrct.xmin + rect->xmin, ar->winrct.ymin + rect->ymin, w, h);
-	*/
+#endif
 	
 	glEnable(GL_BLEND);
 	glColor4f(0.0, 0.0, 0.0, 0.0);
@@ -451,10 +452,10 @@ void ui_draw_but_IMAGE(ARegion *UNUSED(ar), uiBut *but, uiWidgetColors *UNUSED(w
 	
 	glDisable(GL_BLEND);
 	
-	/* 
+#if 0
 	// restore scissortest
 	glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
-	*/
+#endif
 	
 #endif
 }
@@ -1138,7 +1139,8 @@ void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *rect)
 			setlinestyle(0);
 			glBegin(GL_LINES);
 			
-			/* glColor3ub(0, 0, 0);
+#if 0
+			glColor3ub(0, 0, 0);
 			glVertex2fv(v1);
 			glVertex2fv(v1a);
 			glColor3ub(255, 255, 255);
@@ -1150,7 +1152,7 @@ void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *rect)
 			glColor3ub(255, 255, 255);
 			glVertex2fv(v2a);
 			glVertex2fv(v3);
-			*/
+#endif
 		}
 		else {
 			glColor3ub(0, 0, 0);
@@ -1367,17 +1369,21 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
 	
 	
 	/* cfra option */
-	/* XXX 2.48
+	/* XXX 2.48 */
+#if 0
 	if(cumap->flag & CUMA_DRAW_CFRA) {
 		glColor3ub(0x60, 0xc0, 0x40);
 		glBegin(GL_LINES);
 		glVertex2f(rect->xmin + zoomx*(cumap->sample[0]-offsx), rect->ymin);
 		glVertex2f(rect->xmin + zoomx*(cumap->sample[0]-offsx), rect->ymax);
 		glEnd();
-	}*/
+	}
+#endif
 	/* sample option */
-	/* XXX 2.48
-	 * if(cumap->flag & CUMA_DRAW_SAMPLE) {
+
+	/* XXX 2.48 */
+#if 0
+	if(cumap->flag & CUMA_DRAW_SAMPLE) {
 		if(cumap->cur==3) {
 			float lum= cumap->sample[0]*0.35f + cumap->sample[1]*0.45f + cumap->sample[2]*0.2f;
 			glColor3ub(240, 240, 240);
@@ -1400,8 +1406,9 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
 			glVertex2f(rect->xmin + zoomx*(cumap->sample[cumap->cur]-offsx), rect->ymax);
 			glEnd();
 		}
-	}*/
-	
+	}
+#endif
+
 	/* the curve */
 	glColor3ubv((unsigned char*)wcol->item);
 	glEnable(GL_LINE_SMOOTH);
diff --git a/source/blender/editors/interface/interface_handlers.c b/source/blender/editors/interface/interface_handlers.c
index 41385292707..f1d4d6b7277 100644
--- a/source/blender/editors/interface/interface_handlers.c
+++ b/source/blender/editors/interface/interface_handlers.c
@@ -1986,7 +1986,7 @@ static void ui_do_but_textedit(bContext *C, uiBlock *block, uiBut *but, uiHandle
 			const char *utf8_buf= event->utf8_buf;
 
 			/* exception that's useful for number buttons, some keyboard
-			   numpads have a comma instead of a period */
+			 * numpads have a comma instead of a period */
 			if(ELEM3(but->type, NUM, NUMABS, NUMSLI)) { /* could use data->min*/
 				if(event->type == PADPERIOD && ascii == ',') {
 					ascii = '.';
@@ -2980,9 +2980,10 @@ static int ui_do_but_SCROLL(bContext *C, uiBlock *block, uiBut *but, uiHandleBut
 				retval= WM_UI_HANDLER_BREAK;
 			}
 			/* UNUSED - otherwise code is ok, add back if needed */
-			/* else if(ELEM(event->type, PADENTER, RETKEY) && event->val==KM_PRESS)
+#if 0
+			else if(ELEM(event->type, PADENTER, RETKEY) && event->val==KM_PRESS)
 				click= 1;
-			*/
+#endif
 		}
 	}
 	else if(data->state == BUTTON_STATE_NUM_EDITING) {
@@ -4674,12 +4675,13 @@ static int ui_but_menu(bContext *C, uiBut *but)
 			uiItemFullO(layout, "WM_OT_doc_view", "View Docs", ICON_NONE, ptr_props.data, WM_OP_EXEC_DEFAULT, 0);
 
 			/* XXX inactive option, not for public! */
-/*			WM_operator_properties_create(&ptr_props, "WM_OT_doc_edit");
+#if 0
+			WM_operator_properties_create(&ptr_props, "WM_OT_doc_edit");
 			RNA_string_set(&ptr_props, "doc_id", buf);
 			RNA_string_set(&ptr_props, "doc_new", RNA_property_description(but->rnaprop));
 
 			uiItemFullO(layout, "WM_OT_doc_edit", "Submit Description", ICON_NONE, ptr_props.data, WM_OP_INVOKE_DEFAULT, 0);
- */
+ #endif
 		}
 		else if (but->optype) {
 			WM_operator_py_idname(buf, but->optype->idname);
@@ -5252,10 +5254,10 @@ static void button_activate_state(bContext *C, uiBut *but, uiHandleButtonState s
 
 	if(state != BUTTON_STATE_EXIT) {
 		/* When objects for eg. are removed, running ui_check_but() can access
-		   the removed data - so disable update on exit. Also in case of
-		   highlight when not in a popup menu, we remove because data used in
-		   button below popup might have been removed by action of popup. Needs
-		   a more reliable solution... */
+		 * the removed data - so disable update on exit. Also in case of
+		 * highlight when not in a popup menu, we remove because data used in
+		 * button below popup might have been removed by action of popup. Needs
+		 * a more reliable solution... */
 		if(state != BUTTON_STATE_HIGHLIGHT || (but->block->flag & UI_BLOCK_LOOP))
 			ui_check_but(but);
 	}
diff --git a/source/blender/editors/interface/interface_icons.c b/source/blender/editors/interface/interface_icons.c
index 3e6d4f31479..bde2c334444 100644
--- a/source/blender/editors/interface/interface_icons.c
+++ b/source/blender/editors/interface/interface_icons.c
@@ -607,7 +607,7 @@ static void init_iconfile_list(struct ListBase *list)
 		return;
 	
 	/* since BLI_dir_contents changes the current working directory, restore it 
-	   back to old value afterwards */
+	 * back to old value afterwards */
 	if(!BLI_current_working_dir(olddir, sizeof(olddir))) 
 		restoredir = 0;
 	totfile = BLI_dir_contents(icondir, &dir);
@@ -626,7 +626,7 @@ static void init_iconfile_list(struct ListBase *list)
 				ImBuf *bbuf= NULL;
 				/* check to see if the image is the right size, continue if not */
 				/* copying strings here should go ok, assuming that we never get back
-				   a complete path to file longer than 256 chars */
+				 * a complete path to file longer than 256 chars */
 				BLI_join_dirfile(iconfilestr, sizeof(iconfilestr), icondir, filename);
 				bbuf= IMB_loadiffname(iconfilestr, IB_rect);
 
@@ -983,7 +983,7 @@ static void icon_draw_size(float x, float y, int icon_id, float aspect, float al
 	
 	if(di->type == ICON_TYPE_VECTOR) {
 		/* vector icons use the uiBlock transformation, they are not drawn
-		with untransformed coordinates like the other icons */
+		 * with untransformed coordinates like the other icons */
 		di->data.vector.func((int)x, (int)y, ICON_DEFAULT_HEIGHT, ICON_DEFAULT_HEIGHT, 1.0f); 
 	} 
 	else if(di->type == ICON_TYPE_TEXTURE) {
@@ -1046,7 +1046,7 @@ static void ui_id_brush_render(bContext *C, ID *id)
 	
 	for(i = 0; i < NUM_ICON_SIZES; i++) {
 		/* check if rect needs to be created; changed
-		 only set by dynamic icons */
+		 * only set by dynamic icons */
 		if((pi->changed[i] || !pi->rect[i])) {
 			icon_set_image(C, id, pi, i);
 			pi->changed[i] = 0;
@@ -1070,8 +1070,8 @@ static int ui_id_brush_get_icon(bContext *C, ID *id)
 		int tool, mode = 0;
 
 		/* XXX: this is not nice, should probably make brushes
-		   be strictly in one paint mode only to avoid
-		   checking various context stuff here */
+		 * be strictly in one paint mode only to avoid
+		 * checking various context stuff here */
 
 		if(CTX_wm_view3d(C) && ob) {
 			if(ob->mode & OB_MODE_SCULPT)
diff --git a/source/blender/editors/interface/interface_intern.h b/source/blender/editors/interface/interface_intern.h
index d324018e4ba..dd4bbc75249 100644
--- a/source/blender/editors/interface/interface_intern.h
+++ b/source/blender/editors/interface/interface_intern.h
@@ -176,10 +176,10 @@ struct uiBut {
 	struct bContextStore *context;
 
 	/* not ysed yet, was used in 2.4x for ui_draw_pulldown_round & friends */
-	/*
+#if 0
 	void (*embossfunc)(int , int , float, float, float, float, float, int);
 	void (*sliderfunc)(int , float, float, float, float, float, float, int);
-	*/
+#endif
 
 	uiButCompleteFunc autocomplete_func;
 	void *autofunc_arg;
diff --git a/source/blender/editors/interface/interface_layout.c b/source/blender/editors/interface/interface_layout.c
index b3b187f92a2..a258d22a8dc 100644
--- a/source/blender/editors/interface/interface_layout.c
+++ b/source/blender/editors/interface/interface_layout.c
@@ -536,9 +536,11 @@ static uiBut *ui_item_with_label(uiLayout *layout, uiBlock *block, const char *n
 	uiBlockSetCurLayout(block, sub);
 
 	if(name[0]) {
-		/* XXX UI_GetStringWidth is not accurate
-		labelw= UI_GetStringWidth(name);
-		CLAMP(labelw, w/4, 3*w/4);*/
+		/* XXX UI_GetStringWidth is not accurate */
+#if 0
+		labelw = UI_GetStringWidth(name);
+		CLAMP(labelw, w/4, 3*w/4);
+#endif
 		labelw= w/3;
 		uiDefBut(block, LABEL, 0, name, x, y, labelw, h, NULL, 0.0, 0.0, 0, 0, "");
 		w= w-labelw;
diff --git a/source/blender/editors/interface/interface_panel.c b/source/blender/editors/interface/interface_panel.c
index d802c8640b8..769087b73ef 100644
--- a/source/blender/editors/interface/interface_panel.c
+++ b/source/blender/editors/interface/interface_panel.c
@@ -543,8 +543,8 @@ void ui_draw_aligned_panel(uiStyle *style, uiBlock *block, rcti *rect)
 	}
 	
 	/* if the panel is minimized vertically:
-		* (------)
-		*/
+	 * (------)
+	 */
 	if(panel->flag & PNL_CLOSEDY) {
 		
 	}
@@ -618,7 +618,7 @@ static int get_panel_size_y(Panel *pa)
 }
 
 /* this function is needed because uiBlock and Panel itself dont
-change sizey or location when closed */
+ * change sizey or location when closed */
 static int get_panel_real_ofsy(Panel *pa)
 {
 	if(pa->flag & PNL_CLOSEDY) return pa->ofsy+pa->sizey;
@@ -639,10 +639,10 @@ typedef struct PanelSort {
 } PanelSort;
 
 /* note about sorting;
-   the sortorder has a lower value for new panels being added.
-   however, that only works to insert a single panel, when more new panels get
-   added the coordinates of existing panels and the previously stored to-be-insterted
-   panels do not match for sorting */
+ * the sortorder has a lower value for new panels being added.
+ * however, that only works to insert a single panel, when more new panels get
+ * added the coordinates of existing panels and the previously stored to-be-insterted
+ * panels do not match for sorting */
 
 static int find_leftmost_panel(const void *a1, const void *a2)
 {
@@ -837,7 +837,7 @@ void uiBeginPanels(const bContext *UNUSED(C), ARegion *ar)
 {
 	Panel *pa;
   
-	  /* set all panels as inactive, so that at the end we know
+	/* set all panels as inactive, so that at the end we know
 	 * which ones were used */
 	for(pa=ar->panels.first; pa; pa=pa->next) {
 		if(pa->runtime_flag & PNL_ACTIVE)
@@ -1150,11 +1150,14 @@ int ui_handler_panel_region(bContext *C, wmEvent *event)
 					}
 				}
 				else if(event->type == ESCKEY) {
-					/*XXX 2.50 if(block->handler) {
+					/*XXX 2.50*/
+#if 0
+					if(block->handler) {
 						rem_blockhandler(sa, block->handler);
 						ED_region_tag_redraw(ar);
 						retval= WM_UI_HANDLER_BREAK;
-					}*/
+					}
+#endif
 				}
 				else if(event->type==PADPLUSKEY || event->type==PADMINUS) {
 #if 0 // XXX make float panel exception?
@@ -1297,13 +1300,17 @@ static void panel_activate_state(const bContext *C, Panel *pa, uiHandlePanelStat
 	ED_region_tag_redraw(ar);
 
 	/* XXX exception handling, 3d window preview panel */
-	/* if(block->drawextra==BIF_view3d_previewdraw)
-		BIF_view3d_previewrender_clear(curarea);*/
-	
+#if 0
+	if(block->drawextra==BIF_view3d_previewdraw)
+		BIF_view3d_previewrender_clear(curarea);
+#endif
+
 	/* XXX exception handling, 3d window preview panel */
-	/* if(block->drawextra==BIF_view3d_previewdraw)
+#if 0
+	if(block->drawextra==BIF_view3d_previewdraw)
 		BIF_view3d_previewrender_signal(curarea, PR_DISPRECT);
 	else if(strcmp(block->name, "image_panel_preview")==0)
-		image_preview_event(2); */
+		image_preview_event(2);
+#endif
 }
 
diff --git a/source/blender/editors/interface/interface_regions.c b/source/blender/editors/interface/interface_regions.c
index 32f284826a7..40bd332a056 100644
--- a/source/blender/editors/interface/interface_regions.c
+++ b/source/blender/editors/interface/interface_regions.c
@@ -1025,7 +1025,7 @@ ARegion *ui_searchbox_create(bContext *C, ARegion *butregion, uiBut *but)
 	ar->regiondata= data;
 	
 	/* special case, hardcoded feature, not draw backdrop when called from menus,
-	   assume for design that popup already added it */
+	 * assume for design that popup already added it */
 	if(but->block->flag & UI_BLOCK_LOOP)
 		data->noback= 1;
 	
@@ -1664,7 +1664,7 @@ static void ui_block_func_MENUSTR(bContext *UNUSED(C), uiLayout *layout, void *a
 	for(a=0; a<md->nitems; a++) {
 		if(a == column_end) {
 			/* start new column, and find out where it ends in advance, so we
-			   can flip the order of items properly per column */
+			 * can flip the order of items properly per column */
 			column_start= a;
 			column_end= md->nitems;
 
@@ -1756,7 +1756,7 @@ static void ui_warp_pointer(int x, int y)
 {
 	/* XXX 2.50 which function to use for this? */
 	/* OSX has very poor mousewarp support, it sends events;
-	   this causes a menu being pressed immediately ... */
+	 * this causes a menu being pressed immediately ... */
 	#ifndef __APPLE__
 	warp_pointer(x, y);
 	#endif
@@ -2252,7 +2252,7 @@ static uiBlock *ui_block_func_POPUP(bContext *C, uiPopupBlockHandle *handle, voi
 	block= pup->block;
 	
 	/* in some cases we create the block before the region,
-	   so we set it delayed here if necessary */
+	 * so we set it delayed here if necessary */
 	if(BLI_findindex(&handle->region->uiblocks, block) == -1)
 		uiBlockSetRegion(block, handle->region);
 
@@ -2270,15 +2270,15 @@ static uiBlock *ui_block_func_POPUP(bContext *C, uiPopupBlockHandle *handle, voi
 		if((block->flag & UI_BLOCK_POPUP_MEMORY) &&
 			(bt= ui_popup_menu_memory(block, NULL))) {
 			/* position mouse on last clicked item, at 0.8*width of the
-			   button, so it doesn't overlap the text too much, also note
-			   the offset is negative because we are inverse moving the
-			   block to be under the mouse */
+			 * button, so it doesn't overlap the text too much, also note
+			 * the offset is negative because we are inverse moving the
+			 * block to be under the mouse */
 			offset[0]= -(bt->x1 + 0.8f*(bt->x2 - bt->x1));
 			offset[1]= -(bt->y1 + 0.5f*UI_UNIT_Y);
 		}
 		else {
 			/* position mouse at 0.8*width of the button and below the tile
-			   on the first item */
+			 * on the first item */
 			offset[0]= 0;
 			for(bt=block->buttons.first; bt; bt=bt->next)
 				offset[0]= MIN2(offset[0], -(bt->x1 + 0.8f*(bt->x2 - bt->x1)));
diff --git a/source/blender/editors/interface/interface_style.c b/source/blender/editors/interface/interface_style.c
index 16b543737d0..b9c29888a64 100644
--- a/source/blender/editors/interface/interface_style.c
+++ b/source/blender/editors/interface/interface_style.c
@@ -60,20 +60,19 @@
 /* style + theme + layout-engine = UI */
 
 /* 
- This is a complete set of layout rules, the 'state' of the Layout 
- Engine. Multiple styles are possible, defined via C or Python. Styles 
- get a name, and will typically get activated per region type, like 
- "Header", or "Listview" or "Toolbar". Properties of Style definitions 
- are:
- 
- - default collumn properties, internal spacing, aligning, min/max width
- - button alignment rules (for groups)
- - label placement rules
- - internal labeling or external labeling default
- - default minimum widths for buttons/labels (in amount of characters)
- - font types, styles and relative sizes for Panel titles, labels, etc.
-
-*/
+ * This is a complete set of layout rules, the 'state' of the Layout 
+ * Engine. Multiple styles are possible, defined via C or Python. Styles 
+ * get a name, and will typically get activated per region type, like 
+ * "Header", or "Listview" or "Toolbar". Properties of Style definitions 
+ * are:
+ *
+ * - default collumn properties, internal spacing, aligning, min/max width
+ * - button alignment rules (for groups)
+ * - label placement rules
+ * - internal labeling or external labeling default
+ * - default minimum widths for buttons/labels (in amount of characters)
+ * - font types, styles and relative sizes for Panel titles, labels, etc.
+ */
 
 
 /* ********************************************** */
diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c
index 1fc9b18a0f6..70336eb9e0f 100644
--- a/source/blender/editors/interface/interface_templates.c
+++ b/source/blender/editors/interface/interface_templates.c
@@ -797,7 +797,7 @@ static uiLayout *draw_modifier(uiLayout *layout, Scene *scene, Object *ob,
 			/* some modifiers could work with pre-tesselated curves only */
 			if (ELEM3(md->type, eModifierType_Hook, eModifierType_Softbody, eModifierType_MeshDeform)) {
 				/* add disabled pre-tesselated button, so users could have
-				   message for this modifiers */
+				 * message for this modifiers */
 				but = uiDefIconButBitI(block, TOG, eModifierMode_ApplyOnSpline, 0, ICON_SURFACE_DATA, 0, 0, UI_UNIT_X-2, UI_UNIT_Y, &md->mode, 0.0, 0.0, 0.0, 0.0,
 						TIP_("This modifier could be applied on splines' points only"));
 				uiButSetFlag(but, UI_BUT_DISABLED);
@@ -1251,8 +1251,8 @@ static void rna_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
 	RNAUpdateCb *cb= (RNAUpdateCb*)arg_cb;
 
 	/* we call update here on the pointer property, this way the
-	   owner of the curve mapping can still define it's own update
-	   and notifier, even if the CurveMapping struct is shared. */
+	 * owner of the curve mapping can still define it's own update
+	 * and notifier, even if the CurveMapping struct is shared. */
 	RNA_property_update(C, &cb->ptr, cb->prop);
 }
 
@@ -1313,7 +1313,7 @@ static void colorband_update_cb(bContext *UNUSED(C), void *bt_v, void *coba_v)
 	ColorBand *coba= coba_v;
 
 	/* sneaky update here, we need to sort the colorband points to be in order,
-	   however the RNA pointer then is wrong, so we update it */
+	 * however the RNA pointer then is wrong, so we update it */
 	colorband_update_sort(coba);
 	bt->rnapoin.data = coba->data + coba->cur;
 }
@@ -2732,7 +2732,7 @@ void uiTemplateKeymapItemProperties(uiLayout *layout, PointerRNA *ptr)
 		template_keymap_item_properties(layout, NULL, &propptr);
 
 		/* attach callbacks to compensate for missing properties update,
-		   we don't know which keymap (item) is being modified there */
+		 * we don't know which keymap (item) is being modified there */
 		for(; but; but=but->next)
 			uiButSetFunc(but, keymap_item_modified, ptr->data, NULL);
 	}
diff --git a/source/blender/editors/interface/interface_utils.c b/source/blender/editors/interface/interface_utils.c
index 8335668a624..610e9f8762d 100644
--- a/source/blender/editors/interface/interface_utils.c
+++ b/source/blender/editors/interface/interface_utils.c
@@ -210,7 +210,7 @@ int uiIconFromID(ID *id)
 	}
 
 	/* otherwise get it through RNA, creating the pointer
-	   will set the right type, also with subclassing */
+	 * will set the right type, also with subclassing */
 	RNA_id_pointer_create(id, &ptr);
 
 	return (ptr.type)? RNA_struct_ui_icon(ptr.type) : ICON_NONE;
diff --git a/source/blender/editors/interface/interface_widgets.c b/source/blender/editors/interface/interface_widgets.c
index 419f13254e6..0e51932df90 100644
--- a/source/blender/editors/interface/interface_widgets.c
+++ b/source/blender/editors/interface/interface_widgets.c
@@ -62,17 +62,16 @@
 
 /* ************** widget base functions ************** */
 /*
-	 - in: roundbox codes for corner types and radius
-	 - return: array of [size][2][x,y] points, the edges of the roundbox, + UV coords
- 
-	 - draw black box with alpha 0 on exact button boundbox
-	 - for ever AA step:
-		- draw the inner part for a round filled box, with color blend codes or texture coords
-		- draw outline in outline color
-		- draw outer part, bottom half, extruded 1 pixel to bottom, for emboss shadow
-		- draw extra decorations
-	 - draw background color box with alpha 1 on exact button boundbox
- 
+ * - in: roundbox codes for corner types and radius
+ * - return: array of [size][2][x,y] points, the edges of the roundbox, + UV coords
+ *
+ * - draw black box with alpha 0 on exact button boundbox
+ * - for ever AA step:
+ *    - draw the inner part for a round filled box, with color blend codes or texture coords
+ *    - draw outline in outline color
+ *    - draw outer part, bottom half, extruded 1 pixel to bottom, for emboss shadow
+ *    - draw extra decorations
+ * - draw background color box with alpha 1 on exact button boundbox
  */
 
 /* fill this struct with polygon info to draw AA'ed */
@@ -106,8 +105,8 @@ typedef struct uiWidgetBase {
 } uiWidgetBase;
 
 /* uiWidgetType: for time being only for visual appearance,
-   later, a handling callback can be added too 
-*/
+ * later, a handling callback can be added too 
+ */
 typedef struct uiWidgetType {
 	
 	/* pointer to theme color definition */
@@ -1227,7 +1226,7 @@ static void widget_draw_text_icon(uiFontStyle *fstyle, uiWidgetColors *wcol, uiB
 		}
 		
 		/* If there's an icon too (made with uiDefIconTextBut) then draw the icon
-		and offset the text label to accommodate it */
+		 * and offset the text label to accommodate it */
 		
 		if (but->flag & UI_HAS_ICON) {
 			widget_draw_icon(but, but->icon+but->iconadd, 1.0f, rect);
@@ -1251,16 +1250,15 @@ static void widget_draw_text_icon(uiFontStyle *fstyle, uiWidgetColors *wcol, uiB
 /* *********************** widget types ************************************* */
 
 
-/*   uiWidgetStateColors
-	char inner_anim[4];
-	char inner_anim_sel[4];
-	char inner_key[4];
-	char inner_key_sel[4];
-	char inner_driven[4];
-	char inner_driven_sel[4];
-	float blend;
- 
-*/
+/* uiWidgetStateColors
+ *     char inner_anim[4];
+ *     char inner_anim_sel[4];
+ *     char inner_key[4];
+ *     char inner_key_sel[4];
+ *     char inner_driven[4];
+ *     char inner_driven_sel[4];
+ *     float blend;
+ */
 
 static struct uiWidgetStateColors wcol_state_colors= {
 	{115, 190, 76, 255},
@@ -1272,17 +1270,17 @@ static struct uiWidgetStateColors wcol_state_colors= {
 	0.5f, 0.0f
 };
 
-/*  uiWidgetColors
-	float outline[3];
-	float inner[4];
-	float inner_sel[4];
-	float item[3];
-	float text[3];
-	float text_sel[3];
-
-	short shaded;
-	float shadetop, shadedown;
-*/	
+/* uiWidgetColors
+ *     float outline[3];
+ *     float inner[4];
+ *     float inner_sel[4];
+ *     float item[3];
+ *     float text[3];
+ *     float text_sel[3];
+ *     
+ *     short shaded;
+ *     float shadetop, shadedown;
+ */
 
 static struct uiWidgetColors wcol_num= {
 	{25, 25, 25, 255},
diff --git a/source/blender/editors/interface/view2d_ops.c b/source/blender/editors/interface/view2d_ops.c
index d8f187d181a..029ca50db5b 100644
--- a/source/blender/editors/interface/view2d_ops.c
+++ b/source/blender/editors/interface/view2d_ops.c
@@ -249,7 +249,8 @@ static int view_pan_modal(bContext *C, wmOperator *op, wmEvent *event)
 		}
 			break;
 		/* XXX - Mode switching isn't implemented. See comments in 36818.
-		 * switch to zoom *
+		 * switch to zoom */
+#if 0
 		case LEFTMOUSE:
 			if (event->val==KM_PRESS) {
 				* calculate overall delta mouse-movement for redo *
@@ -260,8 +261,8 @@ static int view_pan_modal(bContext *C, wmOperator *op, wmEvent *event)
 				WM_cursor_restore(CTX_wm_window(C));
 				WM_operator_name_call(C, "VIEW2D_OT_zoom", WM_OP_INVOKE_DEFAULT, NULL);
 				return OPERATOR_FINISHED;
-			}*/
-			
+			}
+#endif
 		default:
 			if (event->type == vpd->invoke_event || event->type==ESCKEY) {
 				if (event->val==KM_RELEASE) {
diff --git a/source/blender/editors/mesh/bmesh_select.c b/source/blender/editors/mesh/bmesh_select.c
index 2e21f6d1f28..fd6242fb209 100644
--- a/source/blender/editors/mesh/bmesh_select.c
+++ b/source/blender/editors/mesh/bmesh_select.c
@@ -214,11 +214,11 @@ void EDBM_free_backbuf(void)
 }
 
 /* mcords is a polygon mask
-   - grab backbuffer,
-   - draw with black in backbuffer, 
-   - grab again and compare
-   returns 'OK' 
-*/
+ * - grab backbuffer,
+ * - draw with black in backbuffer, 
+ * - grab again and compare
+ * returns 'OK' 
+ */
 int EDBM_mask_init_backbuf_border(ViewContext *vc, int mcords[][2], short tot, short xmin, short ymin, short xmax, short ymax)
 {
 	unsigned int *dr, *drm;
@@ -626,10 +626,10 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
 }
 
 /* best distance based on screen coords. 
-   use em->selectmode to define how to use 
-   selected vertices and edges get disadvantage
-   return 1 if found one
-*/
+ * use em->selectmode to define how to use 
+ * selected vertices and edges get disadvantage
+ * return 1 if found one
+ */
 static int unified_findnearest(ViewContext *vc, BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
 {
 	BMEditMesh *em = vc->em;
@@ -770,13 +770,11 @@ static int similar_edge_select_exec(bContext *C, wmOperator *op)
 /* ********************************* */
 
 /*
-VERT GROUP
- mode 1: same normal
- mode 2: same number of face users
- mode 3: same vertex groups
-*/
-
-
+ * VERT GROUP
+ * mode 1: same normal
+ * mode 2: same number of face users
+ * mode 3: same vertex groups
+ */
 static int similar_vert_select_exec(bContext *C, wmOperator *op)
 {
 	Object *ob = CTX_data_edit_object(C);
@@ -1271,7 +1269,7 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
 	 * path to edge n found so far, Finally, heap is a priority heap which is built on the
 	 * the same data as the cost arry, but inverted: it is a worklist of edges prioritized
 	 * by the shortest path found so far to the edge.
-	*/
+	 */
 
 #if 0 /* UNUSED */ /* this block does nothing, not sure why its here? - campbell */
 	for (i = 0; i < totvert; i++) {
@@ -1995,8 +1993,8 @@ void MESH_OT_select_less(wmOperatorType *ot)
 }
 
 /* Walk all reachable elements of the same type as h_act in breadth-first
-   order, starting from h_act. Deselects elements if the depth when they
-   are reached is not a multiple of "nth". */
+ * order, starting from h_act. Deselects elements if the depth when they
+ * are reached is not a multiple of "nth". */
 static void walker_deselect_nth(BMEditMesh *em, int nth, int offset, BMHeader *h_act)
 {
 	BMElem *ele;
@@ -2203,9 +2201,9 @@ int EM_view3d_poll(bContext *C)
 static int select_sharp_edges_exec(bContext *C, wmOperator *op)
 {
 	/* Find edges that have exactly two neighboring faces,
-	* check the angle between those faces, and if angle is
-	* small enough, select the edge
-	*/
+	 * check the angle between those faces, and if angle is
+	 * small enough, select the edge
+	 */
 	Object *obedit = CTX_data_edit_object(C);
 	BMEditMesh *em = BMEdit_FromObject(obedit);
 	BMIter iter;
@@ -2543,7 +2541,7 @@ static int region_to_loop(bContext *C, wmOperator *UNUSED(op))
 	}
 
 	/* If in face-only select mode, switch to edge select mode so that
-	   an edge-only selection is not inconsistent state */
+	 * an edge-only selection is not inconsistent state */
 	if (em->selectmode == SCE_SELECT_FACE) {
 		em->selectmode = SCE_SELECT_EDGE;
 		EDBM_selectmode_set(em);
diff --git a/source/blender/editors/mesh/bmesh_selecthistory.c b/source/blender/editors/mesh/bmesh_selecthistory.c
index f0c00d0ff07..c912813ac63 100644
--- a/source/blender/editors/mesh/bmesh_selecthistory.c
+++ b/source/blender/editors/mesh/bmesh_selecthistory.c
@@ -46,8 +46,8 @@ void EDBM_editselection_normal(float *normal, BMEditSelection *ese)
 }
 
 /* Calculate a plane that is rightangles to the edge/vert/faces normal
-also make the plane run along an axis that is related to the geometry,
-because this is used for the manipulators Y axis.*/
+ * also make the plane run along an axis that is related to the geometry,
+ * because this is used for the manipulators Y axis. */
 void EDBM_editselection_plane(BMEditMesh *em, float *plane, BMEditSelection *ese)
 {
 	BM_editselection_plane(em->bm, plane, ese);
diff --git a/source/blender/editors/mesh/bmesh_tools.c b/source/blender/editors/mesh/bmesh_tools.c
index 4ea74777d89..79164d87e98 100644
--- a/source/blender/editors/mesh/bmesh_tools.c
+++ b/source/blender/editors/mesh/bmesh_tools.c
@@ -445,13 +445,14 @@ static int EDBM_Extrude_Mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOpe
 		if (em->bm->totedgesel == 0) nr = 0;
 		
 		nr = 1;
-		/* else if (em->totedgesel == 1) nr = 3;
+#if 0
+		else if (em->totedgesel == 1) nr = 3;
 		else if (em->totfacesel == 0) nr = 3;
 		else if (em->totfacesel == 1)
 			nr = 1; // pupmenu("Extrude %t|Region %x1|Only Edges%x3");
 		else
 			nr = 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2|Only Edges%x3");
-		*/
+#endif
 	}
 	else {
 		if (em->bm->totfacesel == 0) nr = 0;
@@ -475,11 +476,11 @@ static int EDBM_Extrude_Mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOpe
 	else {
 		
 			/* We need to force immediate calculation here because 
-			* transform may use derived objects (which are now stale).
-			*
-			* This shouldn't be necessary, derived queries should be
-			* automatically building this data if invalid. Or something.
-			*/
+			 * transform may use derived objects (which are now stale).
+			 *
+			 * This shouldn't be necessary, derived queries should be
+			 * automatically building this data if invalid. Or something.
+			 */
 //		DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
 		object_handle_update(scene, obedit);
 
@@ -1433,11 +1434,11 @@ void EDBM_hide_mesh(BMEditMesh *em, int swap)
 
 	/* original hide flushing comment (OUTDATED):
 	 * hide happens on least dominant select mode, and flushes up, not down! (helps preventing errors in subsurf) */
-	/*  - vertex hidden, always means edge is hidden too
-		- edge hidden, always means face is hidden too
-		- face hidden, only set face hide
-		- then only flush back down what's absolute hidden
-	*/
+	/* - vertex hidden, always means edge is hidden too
+	 * - edge hidden, always means face is hidden too
+	 * - face hidden, only set face hide
+	 * - then only flush back down what's absolute hidden
+	 */
 
 }
 
@@ -1889,9 +1890,9 @@ static int mesh_rotate_colors(bContext *C, wmOperator *op)
 	/* dependencies graph and notification stuff */
 	DAG_id_tag_update(ob->data, OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GEOM|ND_DATA, ob->data);
-/*	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
-	WM_event_add_notifier(C, NC_OBJECT | ND_GEOM_SELECT, ob);
-*/
+/* DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+ * WM_event_add_notifier(C, NC_OBJECT | ND_GEOM_SELECT, ob);
+ */
 	/* we succeeded */
 	return OPERATOR_FINISHED;
 }
@@ -2277,9 +2278,9 @@ static int select_vertex_path_exec(bContext *C, wmOperator *op)
 	EDBM_selectmode_flush(em);
 
 	/* dependencies graph and notification stuff */
-/*	DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
-	WM_event_add_notifier(C, NC_OBJECT | ND_GEOM_SELECT, ob);
-*/
+/* DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
+ * WM_event_add_notifier(C, NC_OBJECT | ND_GEOM_SELECT, ob);
+ */
 	DAG_id_tag_update(ob->data, OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_GEOM|ND_DATA, ob->data);
 
@@ -2809,8 +2810,8 @@ static int solidify_exec(bContext *C, wmOperator *op)
 	}
 
 	/* deselect only the faces in the region to be solidified (leave wire
-	   edges and loose verts selected, as there will be no corresponding
-	   geometry selected below) */
+	 * edges and loose verts selected, as there will be no corresponding
+	 * geometry selected below) */
 	BMO_slot_buffer_hflag_disable(bm, &bmop, "geom", BM_ELEM_SELECT, BM_FACE, TRUE);
 
 	/* run the solidify operator */
@@ -3945,10 +3946,10 @@ void MESH_OT_select_mirror(wmOperatorType *ot)
 }
 
 #if 0 /* UNUSED */
-/********* qsort routines.  not sure how to make these
-           work, since we aren't using linked lists for
-           geometry anymore.  might need a sortof "swap"
-           function for bmesh elements.           *********/
+/* qsort routines.  not sure how to make these
+ * work, since we aren't using linked lists for
+ * geometry anymore.  might need a sortof "swap"
+ * function for bmesh elements. */
 
 typedef struct xvertsort {
 	float x;
diff --git a/source/blender/editors/mesh/editface.c b/source/blender/editors/mesh/editface.c
index 58b5154cdff..a6ceba061f6 100644
--- a/source/blender/editors/mesh/editface.c
+++ b/source/blender/editors/mesh/editface.c
@@ -144,7 +144,7 @@ static int facesel_face_pick(struct bContext *C, Mesh *me, Object *ob, const int
 
 	if (rect) {
 		/* sample rect to increase changes of selecting, so that when clicking
-		   on an edge in the backbuf, we can still select a face */
+		 * on an edge in the backbuf, we can still select a face */
 
 		int dist;
 		*index = view3d_sample_backbuf_rect(&vc, mval, 3, 1, me->totpoly+1, &dist,0,NULL, NULL);
@@ -332,10 +332,10 @@ void paintface_select_linked(bContext *UNUSED(C), Object *ob, int UNUSED(mval[2]
 
 	if (mode==0 || mode==1) {
 		// XXX - Causes glitches, not sure why
-		/*
+#if 0
 		if (!facesel_face_pick(C, me, mval, &index, 1))
 			return;
-		*/
+#endif
 	}
 
 	select_linked_tfaces_with_seams(mode, me, index);
diff --git a/source/blender/editors/mesh/editmesh_bvh.c b/source/blender/editors/mesh/editmesh_bvh.c
index fc7818183bb..d9ba7a1b36a 100644
--- a/source/blender/editors/mesh/editmesh_bvh.c
+++ b/source/blender/editors/mesh/editmesh_bvh.c
@@ -86,8 +86,8 @@ BMBVHTree *BMBVH_NewBVH(BMEditMesh *em, int flag, Scene *scene, Object *obedit)
 	float cos[3][3], (*cagecos)[3] = NULL;
 	int i;
 
-	/*when initializing cage verts, we only want the first cage coordinate for each vertex,
-	  so that e.g. mirror or array use original vertex coordiantes and not mirrored or duplicate*/
+	/* when initializing cage verts, we only want the first cage coordinate for each vertex,
+	 * so that e.g. mirror or array use original vertex coordiantes and not mirrored or duplicate */
 	BLI_smallhash_init(&shash);
 	
 	BMEdit_RecalcTessellation(em);
@@ -381,8 +381,8 @@ int BMBVH_EdgeVisible(BMBVHTree *tree, BMEdge *e, ARegion *ar, View3D *v3d, Obje
 	scale_point(co1, co2, 0.99);
 	scale_point(co3, co2, 0.99);
 	
-	/*ok, idea is to generate rays going from the camera origin to the 
-	  three points on the edge (v1, mid, v2)*/
+	/* ok, idea is to generate rays going from the camera origin to the 
+	 * three points on the edge (v1, mid, v2)*/
 	sub_v3_v3v3(dir1, origin, co1);
 	sub_v3_v3v3(dir2, origin, co2);
 	sub_v3_v3v3(dir3, origin, co3);
@@ -395,8 +395,8 @@ int BMBVH_EdgeVisible(BMBVHTree *tree, BMEdge *e, ARegion *ar, View3D *v3d, Obje
 	mul_v3_fl(dir2, epsilon);
 	mul_v3_fl(dir3, epsilon);
 	
-	/*offset coordinates slightly along view vectors, to avoid
-	  hitting the faces that own the edge.*/
+	/* offset coordinates slightly along view vectors, to avoid
+	 * hitting the faces that own the edge.*/
 	add_v3_v3v3(co1, co1, dir1);
 	add_v3_v3v3(co2, co2, dir2);
 	add_v3_v3v3(co3, co3, dir3);
diff --git a/source/blender/editors/mesh/loopcut.c b/source/blender/editors/mesh/loopcut.c
index a82310be926..5f8c842f4f3 100644
--- a/source/blender/editors/mesh/loopcut.c
+++ b/source/blender/editors/mesh/loopcut.c
@@ -133,8 +133,8 @@ static void ringsel_draw(const bContext *C, ARegion *UNUSED(ar), void *arg)
 	}
 }
 
-/*given two opposite edges in a face, finds the ordering of their vertices so
-  that cut preview lines won't cross each other*/
+/* given two opposite edges in a face, finds the ordering of their vertices so
+ * that cut preview lines won't cross each other*/
 static void edgering_find_order(BMEditMesh *em, BMEdge *lasteed, BMEdge *eed, 
                                 BMVert *lastv1, BMVert *v[2][2])
 {
diff --git a/source/blender/editors/mesh/mesh_data.c b/source/blender/editors/mesh/mesh_data.c
index 4259f7fc558..b4b9461b3c0 100644
--- a/source/blender/editors/mesh/mesh_data.c
+++ b/source/blender/editors/mesh/mesh_data.c
@@ -95,13 +95,12 @@ static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *la
 	index = CustomData_get_layer_index(data, type);
 
 	/* ok, deleting a non-active layer needs to preserve the active layer indices.
-	  to do this, we store a pointer to the .data member of both layer and the active layer,
-	  (to detect if we're deleting the active layer or not), then use the active
-	  layer data pointer to find where the active layer has ended up.
-
-	  
-	  this is necessary because the deletion functions only support deleting the active
-	  layer. */
+	 * to do this, we store a pointer to the .data member of both layer and the active layer,
+	 * (to detect if we're deleting the active layer or not), then use the active
+	 * layer data pointer to find where the active layer has ended up.
+	 *
+	 * this is necessary because the deletion functions only support deleting the active
+	 * layer. */
 	actlayerdata = data->layers[CustomData_get_active_layer_index(data, type)].data;
 	rndlayerdata = data->layers[CustomData_get_render_layer_index(data, type)].data;
 	clonelayerdata = data->layers[CustomData_get_clone_layer_index(data, type)].data;
@@ -691,8 +690,11 @@ static int sticky_add_exec(bContext *C, wmOperator *UNUSED(op))
 	Object *ob= ED_object_context(C);
 	Mesh *me= ob->data;
 
-	/*if(me->msticky)
-		return OPERATOR_CANCELLED;*/
+	/* why is this commented out? */
+#if 0
+	if(me->msticky)
+		return OPERATOR_CANCELLED;
+#endif
 
 	RE_make_sticky(scene, v3d);
 
@@ -772,7 +774,7 @@ void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges, int calc_tessface)
 
 	polyindex = CustomData_get_layer(&mesh->fdata, CD_POLYINDEX);
 	/* add a normals layer for tesselated faces, a tessface normal will
-	   contain the normal of the poly the face was tesselated from. */
+	 * contain the normal of the poly the face was tesselated from. */
 	face_nors = CustomData_add_layer(&mesh->fdata, CD_NORMAL, CD_CALLOC, NULL, mesh->totface);
 
 	mesh_calc_normals_mapping(
@@ -987,7 +989,7 @@ static void mesh_remove_faces(Mesh *mesh, int len)
 	mesh->totface= totface;
 }
 
-/*
+#if 0
 void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges, int faces)
 {
 	if(mesh->edit_btmesh) {
@@ -1002,7 +1004,7 @@ void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges,
 	if(faces)
 		mesh_add_faces(mesh, faces);
 }
-*/
+#endif
 
 void ED_mesh_faces_add(Mesh *mesh, ReportList *reports, int count)
 {
diff --git a/source/blender/editors/mesh/mesh_intern.h b/source/blender/editors/mesh/mesh_intern.h
index b1c95da1731..1afc1796ef6 100644
--- a/source/blender/editors/mesh/mesh_intern.h
+++ b/source/blender/editors/mesh/mesh_intern.h
@@ -51,22 +51,22 @@ struct EnumPropertyItem;
 /* ******************** bmeshutils.c */
 
 /*
-ok: the EDBM module is for editmode bmesh stuff.  in contrast, the 
-    BMEdit module is for code shared with blenkernel that concerns
-    the BMEditMesh structure.
-*/
+ * ok: the EDBM module is for editmode bmesh stuff.  in contrast, the 
+ * BMEdit module is for code shared with blenkernel that concerns
+ * the BMEditMesh structure.
+ */
 
 /*calls a bmesh op, reporting errors to the user, etc*/
 int EDBM_CallOpf(struct BMEditMesh *em, struct wmOperator *op, const char *fmt, ...);
 
-/*same as above, but doesn't report errors.*/
+/* same as above, but doesn't report errors.*/
 int EDBM_CallOpfSilent(struct BMEditMesh *em, const char *fmt, ...);
 
-/*these next two functions are the split version of EDBM_CallOpf, so you can
-  do stuff with a bmesh operator, after initializing it but before executing
-  it.
-  
-  execute the operator with BM_Exec_Op*/
+/* these next two functions are the split version of EDBM_CallOpf, so you can
+ * do stuff with a bmesh operator, after initializing it but before executing
+ * it.
+ *
+ * execute the operator with BM_Exec_Op */
 int EDBM_InitOpf(struct BMEditMesh *em, struct BMOperator *bmop,
                  struct wmOperator *op, const char *fmt, ...);
 /*cleans up after a bmesh operator*/
diff --git a/source/blender/editors/mesh/meshtools.c b/source/blender/editors/mesh/meshtools.c
index 7bf41bdce00..f44af97d403 100644
--- a/source/blender/editors/mesh/meshtools.c
+++ b/source/blender/editors/mesh/meshtools.c
@@ -31,8 +31,8 @@
 
 
 /*
-	meshtools.c: no editmode (violated already :), tools operating on meshes
-*/
+ * meshtools.c: no editmode (violated already :), tools operating on meshes
+ */
 
 #include <stddef.h>
 #include <stdlib.h>
@@ -87,7 +87,7 @@
 /*********************** JOIN ***************************/
 
 /* join selected meshes into the active mesh, context sensitive
-return 0 if no join is made (error) and 1 if the join is done */
+ * return 0 if no join is made (error) and 1 if the join is done */
 
 int join_mesh_exec(bContext *C, wmOperator *op)
 {
@@ -555,7 +555,7 @@ int join_mesh_exec(bContext *C, wmOperator *op)
 /*********************** JOIN AS SHAPES ***************************/
 
 /* Append selected meshes vertex locations as shapes of the active mesh, 
-  return 0 if no join is made (error) and 1 of the join is done */
+ * return 0 if no join is made (error) and 1 of the join is done */
 
 int join_mesh_shapes_exec(bContext *C, wmOperator *op)
 {
diff --git a/source/blender/editors/object/object_add.c b/source/blender/editors/object/object_add.c
index 29526825736..0c12d701616 100644
--- a/source/blender/editors/object/object_add.c
+++ b/source/blender/editors/object/object_add.c
@@ -278,7 +278,7 @@ int ED_object_add_generic_get_opts(bContext *C, wmOperator *op, float *loc,
 	}
 
 	/* in local view we additionally add local view layers,
-	   not part of operator properties */
+	 * not part of operator properties */
 	if(v3d && v3d->localvd)
 		*layer |= v3d->lay;
 
@@ -1073,8 +1073,8 @@ static void make_object_duplilist_real(bContext *C, Scene *scene, Base *base,
 		Base *basen;
 		Object *ob= copy_object(dob->ob);
 		/* font duplis can have a totcol without material, we get them from parent
-		* should be implemented better...
-		*/
+		 * should be implemented better...
+		 */
 		if(ob->mat==NULL) ob->totcol= 0;
 		
 		basen= MEM_dupallocN(base);
@@ -1600,10 +1600,10 @@ void OBJECT_OT_convert(wmOperatorType *ot)
 /**************************** Duplicate ************************/
 
 /* 
-	dupflag: a flag made from constants declared in DNA_userdef_types.h
-	The flag tells adduplicate() weather to copy data linked to the object, or to reference the existing data.
-	U.dupflag for default operations or you can construct a flag as python does
-	if the dupflag is 0 then no data will be copied (linked duplicate) */
+ * dupflag: a flag made from constants declared in DNA_userdef_types.h
+ * The flag tells adduplicate() weather to copy data linked to the object, or to reference the existing data.
+ * U.dupflag for default operations or you can construct a flag as python does
+ * if the dupflag is 0 then no data will be copied (linked duplicate) */
 
 /* used below, assumes id.new is correct */
 /* leaves selection of base/object unaltered */
@@ -1878,7 +1878,7 @@ static int duplicate_exec(bContext *C, wmOperator *op)
 		Base *basen= object_add_duplicate_internal(bmain, scene, base, dupflag);
 		
 		/* note that this is safe to do with this context iterator,
-		   the list is made in advance */
+		 * the list is made in advance */
 		ED_base_object_select(base, BA_DESELECT);
 
 		if (basen == NULL) {
diff --git a/source/blender/editors/object/object_bake.c b/source/blender/editors/object/object_bake.c
index 340a6df8bf6..f1fbf27312a 100644
--- a/source/blender/editors/object/object_bake.c
+++ b/source/blender/editors/object/object_bake.c
@@ -30,11 +30,6 @@
  *  \ingroup edobj
  */
 
-
-/*
-	meshtools.c: no editmode (violated already :), tools operating on meshes
-*/
-
 #include <string.h>
 
 #include "MEM_guardedalloc.h"
@@ -86,7 +81,7 @@
 /* ****************** multires BAKING ********************** */
 
 /* holder of per-object data needed for bake job
-   needed to make job totally thread-safe */
+ * needed to make job totally thread-safe */
 typedef struct MultiresBakerJobData {
 	struct MultiresBakerJobData *next, *prev;
 	DerivedMesh *lores_dm, *hires_dm;
@@ -239,11 +234,11 @@ static void flush_pixel(const MResolvePixelData *data, const int x, const int y)
 	w= 1-u-v;
 
 	/* the sign is the same at all face vertices for any non degenerate face.
-	   Just in case we clamp the interpolated value though. */
+	 * Just in case we clamp the interpolated value though. */
 	sign= (tang0[3]*u + tang1[3]*v + tang2[3]*w)<0 ? (-1.0f) : 1.0f;
 
 	/* this sequence of math is designed specifically as is with great care
-	   to be compatible with our shader. Please don't change without good reason. */
+	 * to be compatible with our shader. Please don't change without good reason. */
 	for(r= 0; r<3; r++) {
 		from_tang[0][r]= tang0[r]*u + tang1[r]*v + tang2[r]*w;
 		from_tang[2][r]= no0[r]*u + no1[r]*v + no2[r]*w;
@@ -413,7 +408,7 @@ static void do_multires_bake(MultiresBakeRender *bkr, Image* ima, MPassKnownData
 			data.face_index= f;
 
 			/* might support other forms of diagonal splits later on such as
-			   split by shortest diagonal.*/
+			 * split by shortest diagonal.*/
 			verts[0][0]=0;
 			verts[1][0]=1;
 			verts[2][0]=2;
@@ -475,7 +470,7 @@ static void interp_barycentric_tri_data(float data[3][3], float u, float v, floa
 }
 
 /* mode = 0: interpolate normals,
-   mode = 1: interpolate coord */
+ * mode = 1: interpolate coord */
 static void interp_bilinear_grid(DMGridData *grid, int grid_size, float crn_x, float crn_y, int mode, float res[3])
 {
 	int x0, x1, y0, y1;
@@ -552,7 +547,7 @@ static void get_ccgdm_data(DerivedMesh *lodm, DerivedMesh *hidm, const int *orig
 }
 
 /* mode = 0: interpolate normals,
-   mode = 1: interpolate coord */
+ * mode = 1: interpolate coord */
 static void interp_bilinear_mface(DerivedMesh *dm, MFace *mface, const float u, const float v, const int mode, float res[3])
 {
 	float data[4][3];
@@ -573,7 +568,7 @@ static void interp_bilinear_mface(DerivedMesh *dm, MFace *mface, const float u,
 }
 
 /* mode = 0: interpolate normals,
-   mode = 1: interpolate coord */
+ * mode = 1: interpolate coord */
 static void interp_barycentric_mface(DerivedMesh *dm, MFace *mface, const float u, const float v, const int mode, float res[3])
 {
 	float data[3][3];
@@ -691,11 +686,11 @@ static void free_heights_data(void *bake_data)
 }
 
 /* MultiresBake callback for heights baking
-   general idea:
-     - find coord of point with specified UV in hi-res mesh (let's call it p1)
-     - find coord of point and normal with specified UV in lo-res mesh (or subdivided lo-res
-       mesh to make texture smoother) let's call this point p0 and n.
-     - height wound be dot(n, p1-p0) */
+ * general idea:
+ *   - find coord of point with specified UV in hi-res mesh (let's call it p1)
+ *   - find coord of point and normal with specified UV in lo-res mesh (or subdivided lo-res
+ *     mesh to make texture smoother) let's call this point p0 and n.
+ *   - height wound be dot(n, p1-p0) */
 static void apply_heights_callback(DerivedMesh *lores_dm, DerivedMesh *hires_dm, const void *bake_data,
                                    const int face_index, const int lvl, const float st[2],
                                    float UNUSED(tangmat[3][3]), const int x, const int y)
@@ -759,10 +754,10 @@ static void apply_heights_callback(DerivedMesh *lores_dm, DerivedMesh *hires_dm,
 }
 
 /* MultiresBake callback for normals' baking
-   general idea:
-     - find coord and normal of point with specified UV in hi-res mesh
-     - multiply it by tangmat
-     - vector in color space would be norm(vec) /2 + (0.5, 0.5, 0.5) */
+ * general idea:
+ *   - find coord and normal of point with specified UV in hi-res mesh
+ *   - multiply it by tangmat
+ *   - vector in color space would be norm(vec) /2 + (0.5, 0.5, 0.5) */
 static void apply_tangmat_callback(DerivedMesh *lores_dm, DerivedMesh *hires_dm, const void *bake_data,
                                    const int face_index, const int lvl, const float st[2],
                                    float tangmat[3][3], const int x, const int y)
diff --git a/source/blender/editors/object/object_group.c b/source/blender/editors/object/object_group.c
index 1b8c0fd0840..d5dfbda8696 100644
--- a/source/blender/editors/object/object_group.c
+++ b/source/blender/editors/object/object_group.c
@@ -70,7 +70,7 @@ static int objects_add_active_exec(bContext *C, wmOperator *op)
 	if(!ob) return OPERATOR_CANCELLED;
 	
 	/* linking to same group requires its own loop so we can avoid
-	   looking up the active objects groups each time */
+	 * looking up the active objects groups each time */
 
 	for(group= bmain->group.first; group; group=group->id.next) {
 		if(object_in_group(ob, group)) {
@@ -117,7 +117,7 @@ static int objects_remove_active_exec(bContext *C, wmOperator *op)
 	if(!ob) return OPERATOR_CANCELLED;
 	
 	/* linking to same group requires its own loop so we can avoid
-	   looking up the active objects groups each time */
+	 * looking up the active objects groups each time */
 
 	for(group= bmain->group.first; group; group=group->id.next) {
 		if(object_in_group(ob, group)) {
diff --git a/source/blender/editors/object/object_hook.c b/source/blender/editors/object/object_hook.c
index 8b5a9ae6c9b..eb128ad3025 100644
--- a/source/blender/editors/object/object_hook.c
+++ b/source/blender/editors/object/object_hook.c
@@ -613,7 +613,7 @@ void OBJECT_OT_hook_remove(wmOperatorType *ot)
 	
 	/* flags */
 	/* this operator removes modifier which isn't stored in local undo stack,
-	   so redoing it from redo panel gives totally weird results  */
+	 * so redoing it from redo panel gives totally weird results  */
 	ot->flag= /*OPTYPE_REGISTER|*/OPTYPE_UNDO;
 	
 	/* properties */
@@ -802,7 +802,7 @@ void OBJECT_OT_hook_assign(wmOperatorType *ot)
 	
 	/* flags */
 	/* this operator changes data stored in modifier which doesn't get pushed to undo stack,
-	   so redoing it from redo panel gives totally weird results  */
+	 * so redoing it from redo panel gives totally weird results  */
 	ot->flag= /*OPTYPE_REGISTER|*/OPTYPE_UNDO;
 	
 	/* properties */
diff --git a/source/blender/editors/object/object_modifier.c b/source/blender/editors/object/object_modifier.c
index c5d81969098..bda373dd441 100644
--- a/source/blender/editors/object/object_modifier.c
+++ b/source/blender/editors/object/object_modifier.c
@@ -217,7 +217,7 @@ static int object_modifier_remove(Object *ob, ModifierData *md, int *sort_depsgr
 			if(me->edit_btmesh) {
 				BMEditMesh *em= me->edit_btmesh;
 				/* CustomData_external_remove is used here only to mark layer as non-external
-				   for further free-ing, so zero element count looks safer than em->totface */
+				 * for further free-ing, so zero element count looks safer than em->totface */
 				CustomData_external_remove(&em->bm->ldata, &me->id, CD_MDISPS, 0);
 				BM_data_layer_free(em->bm, &em->bm->ldata, CD_MDISPS);
 			} else {
@@ -447,15 +447,15 @@ static int modifier_apply_shape(ReportList *reports, Scene *scene, Object *ob, M
 	}
 
 	/*
-	  It should be ridiculously easy to extract the original verts that we want
-	  and form the shape data.  We can probably use the CD KEYINDEX layer (or
-	  whatever I ended up calling it, too tired to check now), though this would
-	  by necassity have to make some potentially ugly assumptions about the order
-	  of the mesh data :-/  you can probably assume in 99% of cases that the first
-	  element of a given index is the original, and any subsequent duplicates are
-	  copies/interpolates, but that's an assumption that would need to be tested
-	  and then predominantly stated in comments in a half dozen headers.
-	*/
+	 * It should be ridiculously easy to extract the original verts that we want
+	 * and form the shape data.  We can probably use the CD KEYINDEX layer (or
+	 * whatever I ended up calling it, too tired to check now), though this would
+	 * by necassity have to make some potentially ugly assumptions about the order
+	 * of the mesh data :-/  you can probably assume in 99% of cases that the first
+	 * element of a given index is the original, and any subsequent duplicates are
+	 * copies/interpolates, but that's an assumption that would need to be tested
+	 * and then predominantly stated in comments in a half dozen headers.
+	 */
 
 	if (ob->type==OB_MESH) {
 		DerivedMesh *dm;
@@ -1654,7 +1654,7 @@ static int ocean_bake_exec(bContext *C, wmOperator *op)
 	/* precalculate time variable before baking */
 	for (f=omd->bakestart; f<=omd->bakeend; f++) {
 		/* from physics_fluid.c:
-		 
+		 *
 		 * XXX: This can't be used due to an anim sys optimization that ignores recalc object animation,
 		 * leaving it for the depgraph (this ignores object animation such as modifier properties though... :/ )
 		 * --> BKE_animsys_evaluate_all_animation(G.main, eval_time);
@@ -1680,7 +1680,7 @@ static int ocean_bake_exec(bContext *C, wmOperator *op)
 	ocean = BKE_add_ocean();
 	init_ocean_modifier_bake(ocean, omd);
 	
-	/*
+#if 0
 	 BKE_bake_ocean(ocean, och);
 	
 	omd->oceancache = och;
@@ -1690,7 +1690,7 @@ static int ocean_bake_exec(bContext *C, wmOperator *op)
 	
 	DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
 	WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, ob);
-	*/
+#endif
 	
 	/* job stuff */
 	
diff --git a/source/blender/editors/object/object_relations.c b/source/blender/editors/object/object_relations.c
index 2281d7a26d8..2945075b9de 100644
--- a/source/blender/editors/object/object_relations.c
+++ b/source/blender/editors/object/object_relations.c
@@ -134,7 +134,7 @@ static int vertex_parent_set_exec(bContext *C, wmOperator *op)
 		em= me->edit_btmesh;
 
 		/* derivedMesh might be needed for solving parenting,
-		   so re-create it here */
+		 * so re-create it here */
 		makeDerivedMesh(scene, obedit, em, CD_MASK_BAREMESH, 0);
 
 		BM_ITER(eve, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
diff --git a/source/blender/editors/object/object_select.c b/source/blender/editors/object/object_select.c
index 69372ac1a90..4377aad0c42 100644
--- a/source/blender/editors/object/object_select.c
+++ b/source/blender/editors/object/object_select.c
@@ -123,7 +123,7 @@ void ED_base_object_activate(bContext *C, Base *base)
 static int objects_selectable_poll(bContext *C)
 {
 	/* we don't check for linked scenes here, selection is
-	   still allowed then for inspection of scene */
+	 * still allowed then for inspection of scene */
 	Object *obact= CTX_data_active_object(C);
 
 	if(CTX_data_edit_object(C))
diff --git a/source/blender/editors/object/object_transform.c b/source/blender/editors/object/object_transform.c
index 45db21749a5..be41f08df8e 100644
--- a/source/blender/editors/object/object_transform.c
+++ b/source/blender/editors/object/object_transform.c
@@ -815,8 +815,10 @@ static int object_origin_set_exec(bContext *C, wmOperator *op)
 				bArmature *arm = ob->data;
 
 				if(ID_REAL_USERS(arm) > 1) {
-					/*BKE_report(op->reports, RPT_ERROR, "Can't apply to a multi user armature");
-					return;*/
+#if 0
+					BKE_report(op->reports, RPT_ERROR, "Can't apply to a multi user armature");
+					return;
+#endif
 					tot_multiuser_arm_error++;
 				}
 				else {
diff --git a/source/blender/editors/object/object_vgroup.c b/source/blender/editors/object/object_vgroup.c
index f610d758243..b545598f240 100644
--- a/source/blender/editors/object/object_vgroup.c
+++ b/source/blender/editors/object/object_vgroup.c
@@ -815,8 +815,8 @@ static int* getSurroundingVerts(Mesh *me, int vert, int *count)
 }
 
 /* get a single point in space by averaging a point cloud (vectors of size 3)
-coord is the place the average is stored, points is the point cloud, count is the number of points in the cloud
-*/
+ * coord is the place the average is stored, points is the point cloud, count is the number of points in the cloud
+ */
 static void getSingleCoordinate(MVert *points, int count, float coord[3])
 {
 	int i;
@@ -828,9 +828,9 @@ static void getSingleCoordinate(MVert *points, int count, float coord[3])
 }
 
 /* given a plane and a start and end position,
-compute the amount of vertical distance relative to the plane and store it in dists,
-then get the horizontal and vertical change and store them in changes
-*/
+ * compute the amount of vertical distance relative to the plane and store it in dists,
+ * then get the horizontal and vertical change and store them in changes
+ */
 static void getVerticalAndHorizontalChange(const float norm[3], float d, const float coord[3],
                                            const float start[3], float distToStart,
                                            float *end, float (*changes)[2], float *dists, int index)
@@ -865,21 +865,21 @@ static void dm_deform_clear(DerivedMesh *dm, Object *ob)
 	}
 }
 
-// recalculate the deformation
+/* recalculate the deformation */
 static DerivedMesh* dm_deform_recalc(Scene *scene, Object *ob)
 {
 	return mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH);
 }
 
 /* by changing nonzero weights, try to move a vertex in me->mverts with index 'index' to
-distToBe distance away from the provided plane strength can change distToBe so that it moves
-towards distToBe by that percentage cp changes how much the weights are adjusted
-to check the distance
-
-index is the index of the vertex being moved
-norm and d are the plane's properties for the equation: ax + by + cz + d = 0
-coord is a point on the plane
-*/
+ * distToBe distance away from the provided plane strength can change distToBe so that it moves
+ * towards distToBe by that percentage cp changes how much the weights are adjusted
+ * to check the distance
+ *
+ * index is the index of the vertex being moved
+ * norm and d are the plane's properties for the equation: ax + by + cz + d = 0
+ * coord is a point on the plane
+ */
 static void moveCloserToDistanceFromPlane(Scene *scene, Object *ob, Mesh *me, int index, float norm[3],
                                           float coord[3], float d, float distToBe, float strength, float cp)
 {
@@ -1049,7 +1049,7 @@ static void moveCloserToDistanceFromPlane(Scene *scene, Object *ob, Mesh *me, in
 }
 
 /* this is used to try to smooth a surface by only adjusting the nonzero weights of a vertex 
-but it could be used to raise or lower an existing 'bump.' */
+ * but it could be used to raise or lower an existing 'bump.' */
 static void vgroup_fix(Scene *scene, Object *ob, float distToBe, float strength, float cp)
 {
 	int i;
@@ -2115,8 +2115,8 @@ void OBJECT_OT_vertex_group_remove(wmOperatorType *ot)
 
 	/* flags */
 	/* redo operator will fail in this case because vertex groups aren't stored
-	   in local edit mode stack and toggling "all" property will lead to
-	   all groups deleted without way to restore them (see [#29527], sergey) */
+	 * in local edit mode stack and toggling "all" property will lead to
+	 * all groups deleted without way to restore them (see [#29527], sergey) */
 	ot->flag= /*OPTYPE_REGISTER|*/OPTYPE_UNDO;
 
 	/* properties */
@@ -2150,8 +2150,8 @@ void OBJECT_OT_vertex_group_assign(wmOperatorType *ot)
 
 	/* flags */
 	/* redo operator will fail in this case because vertex group assignment
-	   isn't stored in local edit mode stack and toggling "new" property will
-	   lead to creating plenty of new veretx groups (see [#29527], sergey) */
+	 * isn't stored in local edit mode stack and toggling "new" property will
+	 * lead to creating plenty of new veretx groups (see [#29527], sergey) */
 	ot->flag= /*OPTYPE_REGISTER|*/OPTYPE_UNDO;
 
 	/* properties */
@@ -2192,8 +2192,8 @@ void OBJECT_OT_vertex_group_remove_from(wmOperatorType *ot)
 
 	/* flags */
 	/* redo operator will fail in this case because vertex groups ssignment
-	   isn't stored in local edit mode stack and toggling "all" property will lead to
-	   removing vertices from all groups (see [#29527], sergey) */
+	 * isn't stored in local edit mode stack and toggling "all" property will lead to
+	 * removing vertices from all groups (see [#29527], sergey) */
 	ot->flag= /*OPTYPE_REGISTER|*/OPTYPE_UNDO;
 
 	/* properties */
@@ -2733,8 +2733,8 @@ void OBJECT_OT_vertex_group_set_active(wmOperatorType *ot)
 	ot->prop= prop;
 }
 
-/*creates the name_array parameter for vgroup_do_remap, call this before fiddling
-  with the order of vgroups then call vgroup_do_remap after*/
+/* creates the name_array parameter for vgroup_do_remap, call this before fiddling
+ * with the order of vgroups then call vgroup_do_remap after*/
 static char *vgroup_init_remap(Object *ob)
 {
 	bDeformGroup *def;
diff --git a/source/blender/editors/physics/dynamicpaint_ops.c b/source/blender/editors/physics/dynamicpaint_ops.c
index 7f568833866..4e9145a6ff3 100644
--- a/source/blender/editors/physics/dynamicpaint_ops.c
+++ b/source/blender/editors/physics/dynamicpaint_ops.c
@@ -268,9 +268,9 @@ void DPAINT_OT_output_toggle(wmOperatorType *ot)
 /***************************** Image Sequence Baking ******************************/
 
 /*
-*	Do actual bake operation. Loop through to-be-baked frames.
-*	Returns 0 on failture.
-*/
+ * Do actual bake operation. Loop through to-be-baked frames.
+ * Returns 0 on failture.
+ */
 static int dynamicPaint_bakeImageSequence(bContext *C, DynamicPaintSurface *surface, Object *cObject)
 {
 	DynamicPaintCanvasSettings *canvas = surface->canvas;
@@ -308,8 +308,8 @@ static int dynamicPaint_bakeImageSequence(bContext *C, DynamicPaintSurface *surf
 		if (!dynamicPaint_calculateFrame(surface, scene, cObject, frame)) return 0;
 
 		/*
-		*	Save output images
-		*/
+		 * Save output images
+		 */
 		{
 			char filename[FILE_MAX];
 
@@ -351,8 +351,8 @@ static int dynamicPaint_initBake(struct bContext *C, struct wmOperator *op)
 	DynamicPaintSurface *surface;
 
 	/*
-	*	Get modifier data
-	*/
+	 * Get modifier data
+	 */
 	pmd = (DynamicPaintModifierData *)modifiers_findByType(ob, eModifierType_DynamicPaint);
 	if (!pmd) {
 		BKE_report(op->reports, RPT_ERROR, "Bake Failed: No Dynamic Paint modifier found.");
@@ -380,7 +380,7 @@ static int dynamicPaint_initBake(struct bContext *C, struct wmOperator *op)
 	dynamicPaint_freeSurfaceData(surface);
 
 	/* Bake was successful:
-	*  Report for ended bake and how long it took */
+	 *  Report for ended bake and how long it took */
 	if (status) {
 		/* Format time string	*/
 		char time_str[30];
diff --git a/source/blender/editors/physics/particle_edit.c b/source/blender/editors/physics/particle_edit.c
index 2a7f9b2a626..8201b27a4ed 100644
--- a/source/blender/editors/physics/particle_edit.c
+++ b/source/blender/editors/physics/particle_edit.c
@@ -1218,7 +1218,7 @@ static void update_velocities(PTCacheEdit *edit)
 void PE_update_object(Scene *scene, Object *ob, int useflag)
 {
 	/* use this to do partial particle updates, not usable when adding or
-	   removing, then a full redo is necessary and calling this may crash */
+	 * removing, then a full redo is necessary and calling this may crash */
 	ParticleEditSettings *pset= PE_settings(scene);
 	PTCacheEdit *edit = PE_get_current(scene, ob);
 	POINT_P;
diff --git a/source/blender/editors/render/render_internal.c b/source/blender/editors/render/render_internal.c
index d018a8d03d3..4fbc5085b2d 100644
--- a/source/blender/editors/render/render_internal.c
+++ b/source/blender/editors/render/render_internal.c
@@ -155,7 +155,7 @@ void image_buffer_rect_update(Scene *scene, RenderResult *rr, ImBuf *ibuf, volat
 /* ****************************** render invoking ***************** */
 
 /* set callbacks, exported to sequence render too.
- Only call in foreground (UI) renders. */
+ * Only call in foreground (UI) renders. */
 
 static void screen_render_scene_layer_set(wmOperator *op, Main *mainp, Scene **scene, SceneRenderLayer **srl)
 {
@@ -221,9 +221,9 @@ static int screen_render_exec(bContext *C, wmOperator *op)
 	BKE_image_backup_render(scene, ima);
 
 	/* cleanup sequencer caches before starting user triggered render.
-	   otherwise, invalidated cache entries can make their way into
-	   the output rendering. We can't put that into RE_BlenderFrame,
-	   since sequence rendering can call that recursively... (peter) */
+	 * otherwise, invalidated cache entries can make their way into
+	 * the output rendering. We can't put that into RE_BlenderFrame,
+	 * since sequence rendering can call that recursively... (peter) */
 	seq_stripelem_cache_cleanup();
 
 	RE_SetReports(re, op->reports);
@@ -517,9 +517,9 @@ static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
 	multires_force_render_update(CTX_data_active_object(C));
 
 	/* cleanup sequencer caches before starting user triggered render.
-	   otherwise, invalidated cache entries can make their way into
-	   the output rendering. We can't put that into RE_BlenderFrame,
-	   since sequence rendering can call that recursively... (peter) */
+	 * otherwise, invalidated cache entries can make their way into
+	 * the output rendering. We can't put that into RE_BlenderFrame,
+	 * since sequence rendering can call that recursively... (peter) */
 	seq_stripelem_cache_cleanup();
 
 	/* get editmode results */
@@ -586,8 +586,8 @@ static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
 	WM_event_add_notifier(C, NC_SCENE|ND_RENDER_RESULT, scene);
 
 	/* we set G.rendering here already instead of only in the job, this ensure
-	   main loop or other scene updates are disabled in time, since they may
-	   have started before the job thread */
+	 * main loop or other scene updates are disabled in time, since they may
+	 * have started before the job thread */
 	G.rendering = 1;
 
 	/* add modal handler for ESC */
diff --git a/source/blender/editors/render/render_preview.c b/source/blender/editors/render/render_preview.c
index 3eda30e1554..f0ef7c633cb 100644
--- a/source/blender/editors/render/render_preview.c
+++ b/source/blender/editors/render/render_preview.c
@@ -902,8 +902,8 @@ static void icon_preview_startjob(void *customdata, short *stop, short *do_updat
 		iuser.scene= sp->scene;
 		
 		/* elubie: this needs to be changed: here image is always loaded if not
-		   already there. Very expensive for large images. Need to find a way to 
-		   only get existing ibuf */
+		 * already there. Very expensive for large images. Need to find a way to 
+		 * only get existing ibuf */
 		ibuf = BKE_image_get_ibuf(ima, &iuser);
 		if(ibuf==NULL || ibuf->rect==NULL)
 			return;
@@ -931,7 +931,7 @@ static void icon_preview_startjob(void *customdata, short *stop, short *do_updat
 		shader_preview_startjob(customdata, stop, do_update);
 
 		/* world is rendered with alpha=0, so it wasn't displayed 
-		   this could be render option for sky to, for later */
+		 * this could be render option for sky to, for later */
 		if(idtype == ID_WO) {
 			set_alpha((char*)sp->pr_rect, sp->sizex, sp->sizey, 255);
 		}
@@ -945,7 +945,7 @@ static void icon_preview_startjob(void *customdata, short *stop, short *do_updat
 }
 
 /* use same function for icon & shader, so the job manager
-   does not run two of them at the same time. */
+ * does not run two of them at the same time. */
 
 static void common_preview_startjob(void *customdata, short *stop, short *do_update, float *UNUSED(progress))
 {
diff --git a/source/blender/editors/render/render_update.c b/source/blender/editors/render/render_update.c
index d921308aad5..4483d7d8ba1 100644
--- a/source/blender/editors/render/render_update.c
+++ b/source/blender/editors/render/render_update.c
@@ -76,7 +76,7 @@ void ED_render_scene_update(Main *bmain, Scene *scene, int updated)
 	ARegion *ar;
 
 	/* don't do this render engine update if we're updating the scene from
-	   other threads doing e.g. rendering or baking jobs */
+	 * other threads doing e.g. rendering or baking jobs */
 	if(!BLI_thread_is_main())
 		return;
 
diff --git a/source/blender/editors/render/render_view.c b/source/blender/editors/render/render_view.c
index d8719c7d7cd..8850bef286d 100644
--- a/source/blender/editors/render/render_view.c
+++ b/source/blender/editors/render/render_view.c
@@ -309,7 +309,7 @@ static int render_view_show_invoke(bContext *C, wmOperator *UNUSED(op), wmEvent
 					}
 					else if(sima->next) {
 						/* workaround for case of double prevspace, render window
-						   with a file browser on top of it (same as in ED_area_prevspace) */
+						 * with a file browser on top of it (same as in ED_area_prevspace) */
 						if(sima->next->spacetype == SPACE_FILE && sima->next->next)
 							ED_area_newspace(C, sa, sima->next->next->spacetype);
 						else
diff --git a/source/blender/editors/screen/area.c b/source/blender/editors/screen/area.c
index e4088fe10c4..6f846b82c5f 100644
--- a/source/blender/editors/screen/area.c
+++ b/source/blender/editors/screen/area.c
@@ -496,9 +496,9 @@ void ED_region_do_draw(bContext *C, ARegion *ar)
 }
 
 /* **********************************
-   maybe silly, but let's try for now
-   to keep these tags protected
-   ********************************** */
+ * maybe silly, but let's try for now
+ * to keep these tags protected
+ * ********************************** */
 
 void ED_region_tag_redraw(ARegion *ar)
 {
@@ -658,8 +658,8 @@ static void region_azone_icon(ScrArea *sa, AZone *az, ARegion *ar)
 	int tot=0;
 	
 	/* count how many actionzones with along same edge are available.
-	   This allows for adding more action zones in the future without
-	   having to worry about correct offset */
+	 * This allows for adding more action zones in the future without
+	 * having to worry about correct offset */
 	for(azt= sa->actionzones.first; azt; azt= azt->next) {
 		if(azt->edge == az->edge) tot++;
 	}
@@ -1432,7 +1432,7 @@ void ED_area_prevspace(bContext *C, ScrArea *sa)
 
 	if(sl->next) {
 		/* workaround for case of double prevspace, render window
-		   with a file browser on top of it */
+		 * with a file browser on top of it */
 		if(sl->next->spacetype == SPACE_FILE && sl->next->next)
 			ED_area_newspace(C, sa, sl->next->next->spacetype);
 		else
diff --git a/source/blender/editors/screen/glutil.c b/source/blender/editors/screen/glutil.c
index 918df2f90e0..2608e9e3482 100644
--- a/source/blender/editors/screen/glutil.c
+++ b/source/blender/editors/screen/glutil.c
@@ -73,10 +73,11 @@ GLubyte stipple_halftone[128] = {
 
 
 /*  repeat this pattern
-	X000X000
-	00000000
-	00X000X0
-	00000000 */
+ *
+ *     X000X000
+ *     00000000
+ *     00X000X0
+ *     00000000 */
 
 
 GLubyte stipple_quarttone[128] = { 
@@ -148,8 +149,10 @@ void fdrawbezier(float vec[4][3])
 	glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, vec[0]);
 	glBegin(GL_LINE_STRIP);
 	while (spline_step < 1.000001f) {
-		/*if(do_shaded)
-			UI_ThemeColorBlend(th_col1, th_col2, spline_step);*/
+#if 0
+		if(do_shaded)
+			UI_ThemeColorBlend(th_col1, th_col2, spline_step);
+#endif
 		glEvalCoord1f(spline_step);
 		spline_step += dist;
 	}
@@ -201,14 +204,12 @@ void sdrawline(short x1, short y1, short x2, short y2)
 }
 
 /*
-
-	x1,y2
-	|  \
-	|   \
-	|    \
-	x1,y1-- x2,y1
-
-*/
+ *     x1,y2
+ *     |  \
+ *     |   \
+ *     |    \
+ *     x1,y1-- x2,y1
+ */
 
 static void sdrawtripoints(short x1, short y1, short x2, short y2)
 {
@@ -847,7 +848,7 @@ void bgl_get_mats(bglMats *mats)
 	glGetIntegerv(GL_VIEWPORT, (GLint *)mats->viewport);
 	
 	/* Very strange code here - it seems that certain bad values in the
-	   modelview matrix can cause gluUnProject to give bad results. */
+	 * modelview matrix can cause gluUnProject to give bad results. */
 	if(mats->modelview[0] < badvalue &&
 	   mats->modelview[0] > -badvalue)
 		mats->modelview[0]= 0;
diff --git a/source/blender/editors/screen/screen_edit.c b/source/blender/editors/screen/screen_edit.c
index f3a6904f8d0..7ab73c6b976 100644
--- a/source/blender/editors/screen/screen_edit.c
+++ b/source/blender/editors/screen/screen_edit.c
@@ -524,8 +524,8 @@ int area_getorientation(ScrArea *sa, ScrArea *sb)
 }
 
 /* Helper function to join 2 areas, it has a return value, 0=failed 1=success
-* 	used by the split, join operators
-*/
+ * 	used by the split, join operators
+ */
 int screen_area_join(bContext *C, bScreen* scr, ScrArea *sa1, ScrArea *sa2) 
 {
 	int dir;
@@ -1401,8 +1401,8 @@ void ED_screen_delete(bContext *C, bScreen *sc)
 	
 		
 	/* screen can only be in use by one window at a time, so as
-	   long as we are able to find a screen that is unused, we
-	   can safely assume ours is not in use anywhere an delete it */
+	 * long as we are able to find a screen that is unused, we
+	 * can safely assume ours is not in use anywhere an delete it */
 
 	for(newsc= sc->id.prev; newsc; newsc=newsc->id.prev)
 		if(!ed_screen_used(wm, newsc))
@@ -1600,8 +1600,8 @@ ScrArea *ED_screen_full_toggle(bContext *C, wmWindow *win, ScrArea *sa)
 
 	if(sa) {
 		/* ensure we don't have a button active anymore, can crash when
-		   switching screens with tooltip open because region and tooltip
-		   are no longer in the same screen */
+		 * switching screens with tooltip open because region and tooltip
+		 * are no longer in the same screen */
 		for(ar=sa->regionbase.first; ar; ar=ar->next)
 			uiFreeBlocks(C, &ar->uiblocks);
 		
@@ -1651,10 +1651,11 @@ ScrArea *ED_screen_full_toggle(bContext *C, wmWindow *win, ScrArea *sa)
 		oldscreen= win->screen;
 
 		/* nothing wrong with having only 1 area, as far as I can see...
-		// is there only 1 area?
+		 * is there only 1 area? */
+#if 0
 		if(oldscreen->areabase.first==oldscreen->areabase.last)
 			return NULL;
-		*/
+#endif
 
 		oldscreen->full = SCREENFULL;
 		BLI_snprintf(newname, sizeof(newname), "%s-%s", oldscreen->id.name+2, "full");
@@ -1670,7 +1671,7 @@ ScrArea *ED_screen_full_toggle(bContext *C, wmWindow *win, ScrArea *sa)
 		ED_area_newspace(C, newa, SPACE_INFO);
 
 		/* use random area when we have no active one, e.g. when the
-		   mouse is outside of the window and we open a file browser */
+		 * mouse is outside of the window and we open a file browser */
 		if(!sa)
 			sa= oldscreen->areabase.first;
 
diff --git a/source/blender/editors/screen/screen_ops.c b/source/blender/editors/screen/screen_ops.c
index 8818bd66b23..94d1f3c6a81 100644
--- a/source/blender/editors/screen/screen_ops.c
+++ b/source/blender/editors/screen/screen_ops.c
@@ -452,26 +452,25 @@ int ED_operator_editmball(bContext *C)
 /* *************************** action zone operator ************************** */
 
 /* operator state vars used:  
- none
- 
- functions:
- 
- apply() set actionzone event
- 
- exit()	free customdata
- 
- callbacks:
- 
- exec()	never used
- 
- invoke() check if in zone  
- add customdata, put mouseco and area in it
- add modal handler
- 
- modal()	accept modal events while doing it
- call apply() with gesture info, active window, nonactive window
- call exit() and remove handler when LMB confirm
- 
+ * none
+ * 
+ * functions:
+ * 
+ * apply() set actionzone event
+ * 
+ * exit()	free customdata
+ * 
+ * callbacks:
+ * 
+ * exec()	never used
+ * 
+ * invoke() check if in zone  
+ * add customdata, put mouseco and area in it
+ * add modal handler
+ * 
+ * modal()	accept modal events while doing it
+ * call apply() with gesture info, active window, nonactive window
+ * call exit() and remove handler when LMB confirm
  */
 
 typedef struct sActionzoneData {
@@ -664,24 +663,23 @@ static void SCREEN_OT_actionzone(wmOperatorType *ot)
 /* ************** swap area operator *********************************** */
 
 /* operator state vars used:  
- sa1		start area
- sa2		area to swap with
- 
- functions:
- 
- init()   set custom data for operator, based on actionzone event custom data
- 
- cancel()	cancel the operator
- 
- exit()	cleanup, send notifier
- 
- callbacks:
- 
- invoke() gets called on shift+lmb drag in actionzone
- call init(), add handler
- 
- modal()  accept modal events while doing it
- 
+ * sa1		start area
+ * sa2		area to swap with
+ * 
+ * functions:
+ * 
+ * init()   set custom data for operator, based on actionzone event custom data
+ * 
+ * cancel()	cancel the operator
+ * 
+ * exit()	cleanup, send notifier
+ * 
+ * callbacks:
+ * 
+ * invoke() gets called on shift+lmb drag in actionzone
+ * call init(), add handler
+ * 
+ * modal()  accept modal events while doing it
  */
 
 typedef struct sAreaSwapData {
@@ -850,32 +848,31 @@ static void SCREEN_OT_area_dupli(wmOperatorType *ot)
 /* ************** move area edge operator *********************************** */
 
 /* operator state vars used:  
- x, y   			mouse coord near edge
- delta            movement of edge
- 
- functions:
- 
- init()   set default property values, find edge based on mouse coords, test
- if the edge can be moved, select edges, calculate min and max movement
- 
- apply()	apply delta on selection
- 
- exit()	cleanup, send notifier
- 
- cancel() cancel moving
- 
- callbacks:
- 
- exec()   execute without any user interaction, based on properties
- call init(), apply(), exit()
- 
- invoke() gets called on mouse click near edge
- call init(), add handler
- 
- modal()  accept modal events while doing it
- call apply() with delta motion
- call exit() and remove handler
- 
+ * x, y   			mouse coord near edge
+ * delta            movement of edge
+ * 
+ * functions:
+ * 
+ * init()   set default property values, find edge based on mouse coords, test
+ * if the edge can be moved, select edges, calculate min and max movement
+ * 
+ * apply()	apply delta on selection
+ * 
+ * exit()	cleanup, send notifier
+ * 
+ * cancel() cancel moving
+ * 
+ * callbacks:
+ * 
+ * exec()   execute without any user interaction, based on properties
+ * call init(), apply(), exit()
+ * 
+ * invoke() gets called on mouse click near edge
+ * call init(), add handler
+ * 
+ * modal()  accept modal events while doing it
+ * call apply() with delta motion
+ * call exit() and remove handler
  */
 
 typedef struct sAreaMoveData {
@@ -1107,38 +1104,37 @@ static void SCREEN_OT_area_move(wmOperatorType *ot)
 /* ************** split area operator *********************************** */
 
 /* 
- operator state vars:  
- fac              spit point
- dir              direction 'v' or 'h'
- 
- operator customdata:
- area   			pointer to (active) area
- x, y			last used mouse pos
- (more, see below)
- 
- functions:
- 
- init()   set default property values, find area based on context
- 
- apply()	split area based on state vars
- 
- exit()	cleanup, send notifier
- 
- cancel() remove duplicated area
- 
- callbacks:
- 
- exec()   execute without any user interaction, based on state vars
- call init(), apply(), exit()
- 
- invoke() gets called on mouse click in action-widget
- call init(), add modal handler
- call apply() with initial motion
- 
- modal()  accept modal events while doing it
- call move-areas code with delta motion
- call exit() or cancel() and remove handler
- 
+ * operator state vars:  
+ * fac              spit point
+ * dir              direction 'v' or 'h'
+ * 
+ * operator customdata:
+ * area   			pointer to (active) area
+ * x, y			last used mouse pos
+ * (more, see below)
+ * 
+ * functions:
+ * 
+ * init()   set default property values, find area based on context
+ * 
+ * apply()	split area based on state vars
+ * 
+ * exit()	cleanup, send notifier
+ * 
+ * cancel() remove duplicated area
+ * 
+ * callbacks:
+ * 
+ * exec()   execute without any user interaction, based on state vars
+ * call init(), apply(), exit()
+ * 
+ * invoke() gets called on mouse click in action-widget
+ * call init(), add modal handler
+ * call apply() with initial motion
+ * 
+ * modal()  accept modal events while doing it
+ * call move-areas code with delta motion
+ * call exit() or cancel() and remove handler
  */
 
 #define SPLIT_STARTED	1
@@ -2080,31 +2076,30 @@ static void SCREEN_OT_screen_full_area(wmOperatorType *ot)
 /* ************** join area operator ********************************************** */
 
 /* operator state vars used:  
- x1, y1     mouse coord in first area, which will disappear
- x2, y2     mouse coord in 2nd area, which will become joined
- 
- functions:
- 
- init()   find edge based on state vars 
- test if the edge divides two areas, 
- store active and nonactive area,
- 
- apply()  do the actual join
- 
- exit()	cleanup, send notifier
- 
- callbacks:
- 
- exec()	calls init, apply, exit 
- 
- invoke() sets mouse coords in x,y
- call init()
- add modal handler
- 
- modal()	accept modal events while doing it
- call apply() with active window and nonactive window
- call exit() and remove handler when LMB confirm
- 
+ * x1, y1     mouse coord in first area, which will disappear
+ * x2, y2     mouse coord in 2nd area, which will become joined
+ * 
+ * functions:
+ * 
+ * init()   find edge based on state vars 
+ * test if the edge divides two areas, 
+ * store active and nonactive area,
+ * 
+ * apply()  do the actual join
+ * 
+ * exit()	cleanup, send notifier
+ * 
+ * callbacks:
+ * 
+ * exec()	calls init, apply, exit 
+ * 
+ * invoke() sets mouse coords in x,y
+ * call init()
+ * add modal handler
+ * 
+ * modal()	accept modal events while doing it
+ * call apply() with active window and nonactive window
+ * call exit() and remove handler when LMB confirm
  */
 
 typedef struct sAreaJoinData
@@ -2282,8 +2277,8 @@ static int area_join_modal(bContext *C, wmOperator *op, wmEvent *event)
 					} 
 					else {
 						/* we are not bordering on the previously selected area 
-						 we check if area has common border with the one marked for removal
-						 in this case we can swap areas.
+						 * we check if area has common border with the one marked for removal
+						 * in this case we can swap areas.
 						 */
 						dir = area_getorientation(sa, jd->sa2);
 						if (dir >= 0) {
@@ -2867,10 +2862,10 @@ static int match_region_with_redraws(int spacetype, int regiontype, int redraws)
 	else if(regiontype==RGN_TYPE_UI) {
 		if(spacetype==SPACE_CLIP) {
 			/* Track Preview button is on Properties Editor in SpaceClip,
-			   and it's very common case when users want it be refreshing
-			   during playback, so asking people to enable special option
-			   for this is a bit ticky, so add exception here for refreshing
-			   Properties Editor for SpaceClip always */
+			 * and it's very common case when users want it be refreshing
+			 * during playback, so asking people to enable special option
+			 * for this is a bit ticky, so add exception here for refreshing
+			 * Properties Editor for SpaceClip always */
 			return 1;
 		}
 
@@ -3127,22 +3122,22 @@ static void SCREEN_OT_animation_cancel(wmOperatorType *ot)
 /* ************** border select operator (template) ***************************** */
 
 /* operator state vars used: (added by default WM callbacks)   
- xmin, ymin     
- xmax, ymax     
- 
- customdata: the wmGesture pointer
- 
- callbacks:
- 
- exec()	has to be filled in by user
- 
- invoke() default WM function
- adds modal handler
- 
- modal()	default WM function 
- accept modal events while doing it, calls exec(), handles ESC and border drawing
- 
- poll()	has to be filled in by user for context
+ * xmin, ymin     
+ * xmax, ymax     
+ * 
+ * customdata: the wmGesture pointer
+ * 
+ * callbacks:
+ * 
+ * exec()	has to be filled in by user
+ * 
+ * invoke() default WM function
+ * adds modal handler
+ * 
+ * modal()	default WM function 
+ * accept modal events while doing it, calls exec(), handles ESC and border drawing
+ * 
+ * poll()	has to be filled in by user for context
  */
 #if 0
 static int border_select_do(bContext *C, wmOperator *op)
diff --git a/source/blender/editors/sculpt_paint/paint_cursor.c b/source/blender/editors/sculpt_paint/paint_cursor.c
index 0148f11b930..ea1e3eb47af 100644
--- a/source/blender/editors/sculpt_paint/paint_cursor.c
+++ b/source/blender/editors/sculpt_paint/paint_cursor.c
@@ -53,16 +53,16 @@
 
 #include "paint_intern.h"
 /* still needed for sculpt_stroke_get_location, should be
-   removed eventually (TODO) */
+ * removed eventually (TODO) */
 #include "sculpt_intern.h"
 
 /* TODOs:
-
-   Some of the cursor drawing code is doing non-draw stuff
-   (e.g. updating the brush rake angle). This should be cleaned up
-   still.
-
-   There is also some ugliness with sculpt-specific code.
+ *
+ * Some of the cursor drawing code is doing non-draw stuff
+ * (e.g. updating the brush rake angle). This should be cleaned up
+ * still.
+ *
+ * There is also some ugliness with sculpt-specific code.
  */
 
 typedef struct Snapshot {
@@ -220,8 +220,8 @@ static int load_tex(Sculpt *sd, Brush* br, ViewContext* vc)
 
 				if ((br->mtex.brush_map_mode == MTEX_MAP_MODE_TILED) || len <= 1) {
 					/* it is probably worth optimizing for those cases where 
-					   the texture is not rotated by skipping the calls to
-					   atan2, sqrtf, sin, and cos. */
+					 * the texture is not rotated by skipping the calls to
+					 * atan2, sqrtf, sin, and cos. */
 					if (br->mtex.tex && (rotation > 0.001f || rotation < -0.001f)) {
 						const float angle    = atan2f(y, x) + rotation;
 
@@ -367,7 +367,7 @@ static int sculpt_get_brush_geometry(bContext* C, ViewContext *vc,
 }
 
 /* Draw an overlay that shows what effect the brush's texture will
-   have on brush strength */
+ * have on brush strength */
 /* TODO: sculpt only for now */
 static void paint_draw_alpha_overlay(Sculpt *sd, Brush *brush,
 				     ViewContext *vc, int x, int y)
@@ -380,7 +380,7 @@ static void paint_draw_alpha_overlay(Sculpt *sd, Brush *brush,
 		return;
 
 	/* save lots of GL state
-	   TODO: check on whether all of these are needed? */
+	 * TODO: check on whether all of these are needed? */
 	glPushAttrib(GL_COLOR_BUFFER_BIT|
 	             GL_CURRENT_BIT|
 	             GL_DEPTH_BUFFER_BIT|
@@ -519,20 +519,20 @@ static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
 		return;
 
 	/* can't use stroke vc here because this will be called during
-	   mouse over too, not just during a stroke */	   
+	 * mouse over too, not just during a stroke */
 	view3d_set_viewcontext(C, &vc);
 
 	/* TODO: as sculpt and other paint modes are unified, this
-	   special mode of drawing will go away */
+	 * special mode of drawing will go away */
 	if(vc.obact->sculpt) {
 		Sculpt *sd = CTX_data_tool_settings(C)->sculpt;
 		float location[3];
 		int pixel_radius, hit;
 
 		/* this is probably here so that rake takes into
-		   account the brush movements before the stroke
-		   starts, but this doesn't really belong in draw code
-		   (TODO) */
+		 * account the brush movements before the stroke
+		 * starts, but this doesn't really belong in draw code
+		 *  TODO) */
 		{
 			const float u = 0.5f;
 			const float v = 1 - u;
@@ -560,7 +560,7 @@ static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
 
 		/* check if brush is subtracting, use different color then */
 		/* TODO: no way currently to know state of pen flip or
-		   invert key modifier without starting a stroke */
+		 * invert key modifier without starting a stroke */
 		if((!(brush->flag & BRUSH_INVERTED) ^
 		    !(brush->flag & BRUSH_DIR_IN)) &&
 		   ELEM5(brush->sculpt_tool, SCULPT_TOOL_DRAW,
diff --git a/source/blender/editors/sculpt_paint/paint_image.c b/source/blender/editors/sculpt_paint/paint_image.c
index 63e976693e3..2b111613c4b 100644
--- a/source/blender/editors/sculpt_paint/paint_image.c
+++ b/source/blender/editors/sculpt_paint/paint_image.c
@@ -478,9 +478,9 @@ static void image_undo_restore(bContext *C, ListBase *lb)
 
 		if(ima && ibuf && strcmp(tile->ibufname, ibuf->name)!=0) {
 			/* current ImBuf filename was changed, probably current frame
-			   was changed when paiting on image sequence, rather than storing
-			   full image user (which isn't so obvious, btw) try to find ImBuf with
-			   matched file name in list of already loaded images */
+			 * was changed when paiting on image sequence, rather than storing
+			 * full image user (which isn't so obvious, btw) try to find ImBuf with
+			 * matched file name in list of already loaded images */
 
 			ibuf= BLI_findstring(&ima->ibufs, tile->ibufname, offsetof(ImBuf, name));
 		}
@@ -810,7 +810,7 @@ static int project_paint_PickColor(const ProjPaintState *ps, float pt[2], float
  *  0	: no occlusion
  * -1	: no occlusion but 2D intersection is true (avoid testing the other half of a quad)
  *  1	: occluded
-	2	: occluded with w[3] weights set (need to know in some cases) */
+ *  2	: occluded with w[3] weights set (need to know in some cases) */
 
 static int project_paint_occlude_ptv(float pt[3], float v1[4], float v2[4], float v3[4], float w[3], int is_ortho)
 {
@@ -1810,10 +1810,11 @@ static int project_bucket_isect_circle(const float cent[2], const float radius_s
 	/* Would normally to a simple intersection test, however we know the bounds of these 2 already intersect 
 	 * so we only need to test if the center is inside the vertical or horizontal bounds on either axis,
 	 * this is even less work then an intersection test
-	 * 
+	 */
+#if 0
 	if (BLI_in_rctf(bucket_bounds, cent[0], cent[1]))
 		return 1;
-	 */
+#endif
 	
 	if ( (bucket_bounds->xmin <= cent[0] && bucket_bounds->xmax >= cent[0]) ||
 	     (bucket_bounds->ymin <= cent[1] && bucket_bounds->ymax >= cent[1]) )
@@ -2199,51 +2200,51 @@ static void project_bucket_clip_face(
 #endif
 }
 
-	/*
-# This script creates faces in a blender scene from printed data above.
-
-project_ls = [
-...(output from above block)...
-]
- 
-from Blender import Scene, Mesh, Window, sys, Mathutils
-
-import bpy
-
-V = Mathutils.Vector
-
-def main():
-	sce = bpy.data.scenes.active
-	
-	for item in project_ls:
-		bb = item[0]
-		uv = item[1]
-		poly = item[2]
-		
-		me = bpy.data.meshes.new()
-		ob = sce.objects.new(me)
-		
-		me.verts.extend([V(bb[0]).resize3D(), V(bb[1]).resize3D(), V(bb[2]).resize3D(), V(bb[3]).resize3D()])
-		me.faces.extend([(0,1,2,3),])
-		me.verts.extend([V(uv[0]).resize3D(), V(uv[1]).resize3D(), V(uv[2]).resize3D()])
-		me.faces.extend([(4,5,6),])
-		
-		vs = [V(p).resize3D() for p in poly]
-		print len(vs)
-		l = len(me.verts)
-		me.verts.extend(vs)
-		
-		i = l
-		while i < len(me.verts):
-			ii = i+1
-			if ii==len(me.verts):
-				ii = l
-			me.edges.extend([i, ii])
-			i+=1
-
-if __name__ == '__main__':
-	main()
- */	
+/*
+ * # This script creates faces in a blender scene from printed data above.
+ *
+ * project_ls = [
+ * ...(output from above block)...
+ * ]
+ *
+ * from Blender import Scene, Mesh, Window, sys, Mathutils
+ *
+ * import bpy
+ *
+ * V = Mathutils.Vector
+ *
+ * def main():
+ *     sce = bpy.data.scenes.active
+ *     
+ *     for item in project_ls:
+ *         bb = item[0]
+ *         uv = item[1]
+ *         poly = item[2]
+ *         
+ *         me = bpy.data.meshes.new()
+ *         ob = sce.objects.new(me)
+ *         
+ *         me.verts.extend([V(bb[0]).xyz, V(bb[1]).xyz, V(bb[2]).xyz, V(bb[3]).xyz])
+ *         me.faces.extend([(0,1,2,3),])
+ *         me.verts.extend([V(uv[0]).xyz, V(uv[1]).xyz, V(uv[2]).xyz])
+ *         me.faces.extend([(4,5,6),])
+ *         
+ *         vs = [V(p).xyz for p in poly]
+ *         print len(vs)
+ *         l = len(me.verts)
+ *         me.verts.extend(vs)
+ *         
+ *         i = l
+ *         while i < len(me.verts):
+ *             ii = i+1
+ *             if ii==len(me.verts):
+ *                 ii = l
+ *             me.edges.extend([i, ii])
+ *             i+=1
+ * 
+ * if __name__ == '__main__':
+ *     main()
+ */
 
 
 #undef ISECT_1
@@ -2341,12 +2342,12 @@ static void project_paint_face_init(const ProjPaintState *ps, const int thread_i
 	yhalfpx = (0.5f+   (PROJ_GEOM_TOLERANCE/4.0f)   ) / ibuf_yf;
 	
 	/* Note about (PROJ_GEOM_TOLERANCE/x) above...
-	  Needed to add this offset since UV coords are often quads aligned to pixels.
-	  In this case pixels can be exactly between 2 triangles causing nasty
-	  artifacts.
-	  
-	  This workaround can be removed and painting will still work on most cases
-	  but since the first thing most people try is painting onto a quad- better make it work.
+	 * Needed to add this offset since UV coords are often quads aligned to pixels.
+	 * In this case pixels can be exactly between 2 triangles causing nasty
+	 * artifacts.
+	 * 
+	 * This workaround can be removed and painting will still work on most cases
+	 * but since the first thing most people try is painting onto a quad- better make it work.
 	 */
 
 
@@ -2396,11 +2397,11 @@ static void project_paint_face_init(const ProjPaintState *ps, const int thread_i
 		);
 
 		/* sometimes this happens, better just allow for 8 intersectiosn even though there should be max 6 */
-		/*
+#if 0
 		if (uv_clip_tot>6) {
 			printf("this should never happen! %d\n", uv_clip_tot);
-		}*/
-		
+		}
+#endif
 
 		if (pixel_bounds_array(uv_clip, &bounds_px, ibuf->x, ibuf->y, uv_clip_tot)) {
 
@@ -2602,10 +2603,10 @@ static void project_paint_face_init(const ProjPaintState *ps, const int thread_i
 										 * getting the screen_px_from_*** wont work because our actual location
 										 * is not relevent, since we are outside the face, Use VecLerpf to find
 										 * our location on the side of the face's UV */
-										/*
+#if 0
 										if (is_ortho)	screen_px_from_ortho(ps, uv, v1co, v2co, v3co, uv1co, uv2co, uv3co, pixelScreenCo);
 										else					screen_px_from_persp(ps, uv, v1co, v2co, v3co, uv1co, uv2co, uv3co, pixelScreenCo);
-										*/
+#endif
 										
 										/* Since this is a seam we need to work out where on the line this pixel is */
 										//fac = line_point_factor_v2(uv, uv_seam_quad[0], uv_seam_quad[1]);
@@ -3022,11 +3023,11 @@ static void project_paint_begin(ProjPaintState *ps)
 		ps->dm_mvert= MEM_dupallocN(ps->dm_mvert);
 		ps->dm_mface= MEM_dupallocN(ps->dm_mface);
 		/* looks like these are ok for now.*/
-		/*
+#if 0
 		ps->dm_mtface= MEM_dupallocN(ps->dm_mtface);
 		ps->dm_mtface_clone= MEM_dupallocN(ps->dm_mtface_clone);
 		ps->dm_mtface_stencil= MEM_dupallocN(ps->dm_mtface_stencil);
-		 */
+#endif
 	}
 	
 	ps->viewDir[0] = 0.0f;
@@ -3509,11 +3510,11 @@ static void project_paint_end(ProjPaintState *ps)
 		if(ps->dm_mvert) MEM_freeN(ps->dm_mvert);
 		if(ps->dm_mface) MEM_freeN(ps->dm_mface);
 		/* looks like these dont need copying */
-		/*
+#if 0
 		if(ps->dm_mtface) MEM_freeN(ps->dm_mtface);
 		if(ps->dm_mtface_clone) MEM_freeN(ps->dm_mtface_clone);
 		if(ps->dm_mtface_stencil) MEM_freeN(ps->dm_mtface_stencil);
-		*/
+#endif
 	}
 
 	if(ps->dm_release)
@@ -3678,8 +3679,8 @@ typedef struct ProjectHandle {
 static void blend_color_mix(unsigned char *cp, const unsigned char *cp1, const unsigned char *cp2, const int fac)
 {
 	/* this and other blending modes previously used >>8 instead of /255. both
-	   are not equivalent (>>8 is /256), and the former results in rounding
-	   errors that can turn colors black fast after repeated blending */
+	 * are not equivalent (>>8 is /256), and the former results in rounding
+	 * errors that can turn colors black fast after repeated blending */
 	const int mfac= 255-fac;
 
 	cp[0]= (mfac*cp1[0]+fac*cp2[0])/255;
@@ -3700,8 +3701,8 @@ static void blend_color_mix_float(float *cp, const float *cp1, const float *cp2,
 static void blend_color_mix_accum(unsigned char *cp, const unsigned char *cp1, const unsigned char *cp2, const int fac)
 {
 	/* this and other blending modes previously used >>8 instead of /255. both
-	   are not equivalent (>>8 is /256), and the former results in rounding
-	   errors that can turn colors black fast after repeated blending */
+	 * are not equivalent (>>8 is /256), and the former results in rounding
+	 * errors that can turn colors black fast after repeated blending */
 	const int mfac= 255-fac;
 	const int alpha= cp1[3] + ((fac * cp2[3]) / 255);
 
@@ -4312,7 +4313,7 @@ static int imapaint_torus_split_region(ImagePaintRegion region[4], ImBuf *dbuf,
 	if (srcy < 0) srcy += sbuf->y;
 
 	/* clip width of blending area to destination imbuf, to avoid writing the
-	   same pixel twice */
+	 * same pixel twice */
 	origw = w = (width > dbuf->x)? dbuf->x: width;
 	origh = h = (height > dbuf->y)? dbuf->y: height;
 
@@ -4348,7 +4349,7 @@ static void imapaint_lift_smear(ImBuf *ibuf, ImBuf *ibufb, int *pos)
 static ImBuf *imapaint_lift_clone(ImBuf *ibuf, ImBuf *ibufb, int *pos)
 {
 	/* note: allocImbuf returns zero'd memory, so regions outside image will
-	   have zero alpha, and hence not be blended onto the image */
+	 * have zero alpha, and hence not be blended onto the image */
 	int w=ibufb->x, h=ibufb->y, destx=0, desty=0, srcx=pos[0], srcy=pos[1];
 	ImBuf *clonebuf= IMB_allocImBuf(w, h, ibufb->planes, ibufb->flags);
 
@@ -4816,7 +4817,7 @@ static int texture_paint_init(bContext *C, wmOperator *op)
 	op->customdata= pop;
 	
 	/* XXX: Soften tool does not support projection painting atm, so just disable
-	        projection for this brush */
+	 *      projection for this brush */
 	if(brush->imagepaint_tool == PAINT_TOOL_SOFTEN) {
 		settings->imapaint.flag |= IMAGEPAINT_PROJECT_DISABLE;
 		pop->restore_projection = 1;
@@ -5032,13 +5033,13 @@ static void paint_apply_event(bContext *C, wmOperator *op, wmEvent *event)
 		pop->starttime= time;
 
 		/* special exception here for too high pressure values on first touch in
-		   windows for some tablets, then we just skip first touch ..  */
+		 * windows for some tablets, then we just skip first touch ..  */
 		if (tablet && (pressure >= 0.99f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || brush_use_alpha_pressure(scene, pop->s.brush) || brush_use_size_pressure(scene, pop->s.brush)))
 			return;
 
 		/* This can be removed once fixed properly in
-		 brush_painter_paint(BrushPainter *painter, BrushFunc func, float *pos, double time, float pressure, void *user) 
-		 at zero pressure we should do nothing 1/2^12 is .0002 which is the sensitivity of the most sensitive pen tablet available*/
+		 * brush_painter_paint(BrushPainter *painter, BrushFunc func, float *pos, double time, float pressure, void *user) 
+		 * at zero pressure we should do nothing 1/2^12 is .0002 which is the sensitivity of the most sensitive pen tablet available */
 		if (tablet && (pressure < .0002f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || brush_use_alpha_pressure(scene, pop->s.brush) || brush_use_size_pressure(scene, pop->s.brush)))
 			return;
 	
@@ -5220,10 +5221,10 @@ static void toggle_paint_cursor(bContext *C, int enable)
 }
 
 /* enable the paint cursor if it isn't already.
-
-   purpose is to make sure the paint cursor is shown if paint
-   mode is enabled in the image editor. the paint poll will
-   ensure that the cursor is hidden when not in paint mode */
+ *
+ * purpose is to make sure the paint cursor is shown if paint
+ * mode is enabled in the image editor. the paint poll will
+ * ensure that the cursor is hidden when not in paint mode */
 void ED_space_image_paint_update(wmWindowManager *wm, ToolSettings *settings)
 {
 	ImagePaintSettings *imapaint = &settings->imapaint;
diff --git a/source/blender/editors/sculpt_paint/paint_intern.h b/source/blender/editors/sculpt_paint/paint_intern.h
index b4315c2847d..bae433bdb55 100644
--- a/source/blender/editors/sculpt_paint/paint_intern.h
+++ b/source/blender/editors/sculpt_paint/paint_intern.h
@@ -111,8 +111,8 @@ void SCULPT_OT_uv_sculpt_stroke(struct wmOperatorType *ot);
 /* paint_utils.c */
 
 /* Convert the object-space axis-aligned bounding box (expressed as
-   its minimum and maximum corners) into a screen-space rectangle,
-   returns zero if the result is empty */
+ * its minimum and maximum corners) into a screen-space rectangle,
+ * returns zero if the result is empty */
 int paint_convert_bb_to_rect(struct rcti *rect,
 							 const float bb_min[3],
 							 const float bb_max[3],
@@ -121,8 +121,8 @@ int paint_convert_bb_to_rect(struct rcti *rect,
 							 struct Object *ob);
 
 /* Get four planes in object-space that describe the projection of
-   screen_rect from screen into object-space (essentially converting a
-   2D screens-space bounding box into four 3D planes) */
+ * screen_rect from screen into object-space (essentially converting a
+ * 2D screens-space bounding box into four 3D planes) */
 void paint_calc_redraw_planes(float planes[4][4],
 							  const struct ARegion *ar,
 							  struct RegionView3D *rv3d,
diff --git a/source/blender/editors/sculpt_paint/paint_stroke.c b/source/blender/editors/sculpt_paint/paint_stroke.c
index cd8262f06bd..d306abef9d0 100644
--- a/source/blender/editors/sculpt_paint/paint_stroke.c
+++ b/source/blender/editors/sculpt_paint/paint_stroke.c
@@ -73,8 +73,8 @@ typedef struct PaintStroke {
 	float last_mouse_position[2];
 
 	/* Set whether any stroke step has yet occurred
-	   e.g. in sculpt mode, stroke doesn't start until cursor
-	   passes over the mesh */
+	 * e.g. in sculpt mode, stroke doesn't start until cursor
+	 * passes over the mesh */
 	int stroke_started;
 	/* event that started stroke, for modal() return */
 	int event_type;
@@ -106,7 +106,7 @@ static void paint_draw_smooth_stroke(bContext *C, int x, int y, void *customdata
 }
 
 /* if this is a tablet event, return tablet pressure and set *pen_flip
-   to 1 if the eraser tool is being used, 0 otherwise */
+ * to 1 if the eraser tool is being used, 0 otherwise */
 static float event_tablet_data(wmEvent *event, int *pen_flip)
 {
 	int erasor = 0;
@@ -142,15 +142,15 @@ static void paint_brush_stroke_add_step(bContext *C, wmOperator *op, wmEvent *ev
 	pressure = event_tablet_data(event, &pen_flip);
 
 	/* TODO: as sculpt and other paint modes are unified, this
-	   separation will go away */
+	 * separation will go away */
 	if(stroke->vc.obact->sculpt) {
 		float delta[2];
 
 		brush_jitter_pos(scene, brush, mouse_in, mouse);
 
 		/* XXX: meh, this is round about because
-		   brush_jitter_pos isn't written in the best way to
-		   be reused here */
+		 * brush_jitter_pos isn't written in the best way to
+		 * be reused here */
 		if(brush->flag & BRUSH_JITTER_PRESSURE) {
 			sub_v2_v2v2(delta, mouse, mouse_in);
 			mul_v2_fl(delta, pressure);
@@ -196,7 +196,7 @@ static int paint_smooth_stroke(PaintStroke *stroke, float output[2], wmEvent *ev
 		float dx = stroke->last_mouse_position[0] - event->x, dy = stroke->last_mouse_position[1] - event->y;
 
 		/* If the mouse is moving within the radius of the last move,
-		   don't update the mouse position. This allows sharp turns. */
+		 * don't update the mouse position. This allows sharp turns. */
 		if(dx*dx + dy*dy < stroke->brush->smooth_stroke_radius * stroke->brush->smooth_stroke_radius)
 			return 0;
 
@@ -208,7 +208,7 @@ static int paint_smooth_stroke(PaintStroke *stroke, float output[2], wmEvent *ev
 }
 
 /* For brushes with stroke spacing enabled, moves mouse in steps
-   towards the final mouse location. */
+ * towards the final mouse location. */
 static int paint_space_stroke(bContext *C, wmOperator *op, wmEvent *event, const float final_mouse[2])
 {
 	PaintStroke *stroke = op->customdata;
diff --git a/source/blender/editors/sculpt_paint/paint_utils.c b/source/blender/editors/sculpt_paint/paint_utils.c
index 0d9c0f2e38e..610c49ef27f 100644
--- a/source/blender/editors/sculpt_paint/paint_utils.c
+++ b/source/blender/editors/sculpt_paint/paint_utils.c
@@ -68,8 +68,8 @@
 #include "paint_intern.h"
 
 /* Convert the object-space axis-aligned bounding box (expressed as
-   its minimum and maximum corners) into a screen-space rectangle,
-   returns zero if the result is empty */
+ * its minimum and maximum corners) into a screen-space rectangle,
+ * returns zero if the result is empty */
 int paint_convert_bb_to_rect(rcti *rect,
 							 const float bb_min[3],
 							 const float bb_max[3],
@@ -113,8 +113,8 @@ int paint_convert_bb_to_rect(rcti *rect,
 }
 
 /* Get four planes in object-space that describe the projection of
-   screen_rect from screen into object-space (essentially converting a
-   2D screens-space bounding box into four 3D planes) */
+ * screen_rect from screen into object-space (essentially converting a
+ * 2D screens-space bounding box into four 3D planes) */
 void paint_calc_redraw_planes(float planes[4][4],
 							  const ARegion *ar,
 							  RegionView3D *rv3d,
@@ -141,7 +141,7 @@ void paint_calc_redraw_planes(float planes[4][4],
 
 /* convert a point in model coordinates to 2D screen coordinates */
 /* TODO: can be deleted once all calls are replaced with
-   view3d_project_float() */
+ * view3d_project_float() */
 void projectf(bglMats *mats, const float v[3], float p[2])
 {
 	double ux, uy, uz;
@@ -231,7 +231,7 @@ static void imapaint_tri_weights(Object *ob,
 	h[2]= 1.0f;
 
 	/* solve for(w1,w2,w3)/perspdiv in:
-	   h*perspdiv = Project*Model*(w1*v1 + w2*v2 + w3*v3) */
+	 * h * perspdiv = Project * Model * (w1 * v1 + w2 * v2 + w3 * v3) */
 
 	wmat[0][0]= pv1[0];  wmat[1][0]= pv2[0];  wmat[2][0]= pv3[0];
 	wmat[0][1]= pv1[1];  wmat[1][1]= pv2[1];  wmat[2][1]= pv3[1];
@@ -283,7 +283,7 @@ void imapaint_pick_uv(Scene *scene, Object *ob, unsigned int faceindex, const in
 
 			if(mf.v4) {
 				/* the triangle with the largest absolute values is the one
-				   with the most negative weights */
+				 * with the most negative weights */
 				imapaint_tri_weights(ob, mv[0].co, mv[1].co, mv[3].co, p, w);
 				absw= fabs(w[0]) + fabs(w[1]) + fabs(w[2]);
 				if(absw < minabsw) {
diff --git a/source/blender/editors/sculpt_paint/paint_vertex.c b/source/blender/editors/sculpt_paint/paint_vertex.c
index e84a7c623b4..1d84a0aca8e 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.c
+++ b/source/blender/editors/sculpt_paint/paint_vertex.c
@@ -186,7 +186,7 @@ static int *get_indexarray(Mesh *me)
 
 
 /* in contradiction to cpack drawing colors, the MCOL colors (vpaint colors) are per byte! 
-   so not endian sensitive. Mcol = ABGR!!! so be cautious with cpack calls */
+ * so not endian sensitive. Mcol = ABGR!!! so be cautious with cpack calls */
 
 static unsigned int rgba_to_mcol(float r, float g, float b, float a)
 {
@@ -573,8 +573,8 @@ void wpaint_fill(VPaint *wp, Object *ob, float paintweight)
 	DAG_id_tag_update(&me->id, 0);
 }
 
-/* XXX: should be re-implemented as a vertex/weight paint 'color correct' operator
-
+/* XXX: should be re-implemented as a vertex/weight paint 'color correct' operator */
+#if 0
 void vpaint_dogamma(Scene *scene)
 {
 	VPaint *vp= scene->toolsettings->vpaint;
@@ -614,7 +614,7 @@ void vpaint_dogamma(Scene *scene)
 		cp+= 4;
 	}
 }
- */
+#endif
 
 BM_INLINE unsigned int mcol_blend(unsigned int col1, unsigned int col2, int fac)
 {
@@ -725,7 +725,7 @@ BM_INLINE unsigned int mcol_lighten(unsigned int col1, unsigned int col2, int fa
 	cp=  (char *)&col;
 	
 	/* See if are lighter, if so mix, else dont do anything.
-	if the paint col is darker then the original, then ignore */
+	 * if the paint col is darker then the original, then ignore */
 	if (cp1[1]+cp1[2]+cp1[3] > cp2[1]+cp2[2]+cp2[3])
 		return col1;
 	
@@ -753,7 +753,7 @@ BM_INLINE unsigned int mcol_darken(unsigned int col1, unsigned int col2, int fac
 	cp=  (char *)&col;
 	
 	/* See if were darker, if so mix, else dont do anything.
-	if the paint col is brighter then the original, then ignore */
+	 * if the paint col is brighter then the original, then ignore */
 	if (cp1[1]+cp1[2]+cp1[3] < cp2[1]+cp2[2]+cp2[3])
 		return col1;
 	
@@ -826,7 +826,7 @@ static int sample_backbuf_area(ViewContext *vc, int *indexar, int totface, int x
 	int a, tot=0, index;
 	
 	/* brecht: disabled this because it obviously failes for
-	   brushes with size > 64, why is this here? */
+	 * brushes with size > 64, why is this here? */
 	/*if(size>64.0) size= 64.0;*/
 	
 	ibuf= view3d_read_backbuf(vc, x-size, y-size, x+size, y+size);
@@ -1302,8 +1302,8 @@ static void do_weight_paint_normalize_all_active(MDeformVert *dvert, const int d
 }
 
 /*
-See if the current deform vertex has a locked group
-*/
+ * See if the current deform vertex has a locked group
+ */
 static char has_locked_group(MDeformVert *dvert, const int defbase_tot,
                              const char *bone_groups, const char *lock_flags)
 {
@@ -1993,10 +1993,10 @@ static int set_wpaint(bContext *C, wmOperator *UNUSED(op))		/* toggle */
 	
 	
 	/* Weightpaint works by overriding colors in mesh,
-		* so need to make sure we recalc on enter and
-		* exit (exit needs doing regardless because we
-				* should redeform).
-		*/
+	 * so need to make sure we recalc on enter and
+	 * exit (exit needs doing regardless because we
+	 * should redeform).
+	 */
 	DAG_id_tag_update(&me->id, 0);
 	
 	if(ob->mode & OB_MODE_WEIGHT_PAINT) {
@@ -2605,23 +2605,22 @@ void PAINT_OT_vertex_paint_toggle(wmOperatorType *ot)
 /* ********************** vertex paint operator ******************* */
 
 /* Implementation notes:
-
-Operator->invoke()
-  - validate context (add mcol)
-  - create customdata storage
-  - call paint once (mouse click)
-  - add modal handler 
-
-Operator->modal()
-  - for every mousemove, apply vertex paint
-  - exit on mouse release, free customdata
-	(return OPERATOR_FINISHED also removes handler and operator)
-
-For future:
-  - implement a stroke event (or mousemove with past positons)
-  - revise whether op->customdata should be added in object, in set_vpaint
-
-*/
+ *
+ * Operator->invoke()
+ * - validate context (add mcol)
+ * - create customdata storage
+ * - call paint once (mouse click)
+ * - add modal handler 
+ *
+ * Operator->modal()
+ * - for every mousemove, apply vertex paint
+ * - exit on mouse release, free customdata
+ *   (return OPERATOR_FINISHED also removes handler and operator)
+ *
+ * For future:
+ * - implement a stroke event (or mousemove with past positons)
+ * - revise whether op->customdata should be added in object, in set_vpaint
+ */
 
 typedef struct polyfacemap_e {
 	struct polyfacemap_e *next, *prev;
diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index dc25f2964e0..7c3d8f0e9cd 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -101,7 +101,7 @@ void ED_sculpt_force_update(bContext *C)
 }
 
 /* Sculpt mode handles multires differently from regular meshes, but only if
-   it's the last modifier on the stack and it is not on the first level */
+ * it's the last modifier on the stack and it is not on the first level */
 struct MultiresModifierData *sculpt_multires_active(Scene *scene, Object *ob)
 {
 	Mesh *me= (Mesh*)ob->data;
@@ -178,10 +178,10 @@ typedef enum StrokeFlags {
 } StrokeFlags;
 
 /* Cache stroke properties. Used because
-   RNA property lookup isn't particularly fast.
-
-   For descriptions of these settings, check the operator properties.
-*/
+ * RNA property lookup isn't particularly fast.
+ *
+ * For descriptions of these settings, check the operator properties.
+ */
 typedef struct StrokeCache {
 	/* Invariants */
 	float initial_radius;
@@ -222,7 +222,7 @@ typedef struct StrokeCache {
 	float old_grab_location[3], orig_grab_location[3];
 
 	int symmetry; /* Symmetry index between 0 and 7 bit combo 0 is Brush only;
-		1 is X mirror; 2 is Y mirror; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
+	               * 1 is X mirror; 2 is Y mirror; 3 is XY; 4 is Z; 5 is XZ; 6 is YZ; 7 is XYZ */
 	int mirror_symmetry_pass; /* the symmetry pass we are currently on between 0 and 7*/
 	float true_view_normal[3];
 	float view_normal[3];
@@ -270,11 +270,11 @@ static int sculpt_get_redraw_rect(ARegion *ar, RegionView3D *rv3d,
 	}
 
 	/* expand redraw rect with redraw rect from previous step to
-	   prevent partial-redraw issues caused by fast strokes. This is
-	   needed here (not in sculpt_flush_update) as it was before
-	   because redraw rectangle should be the same in both of
-	   optimized PBVH draw function and 3d view redraw (if not -- some
-	   mesh parts could disapper from screen (sergey) */
+	 * prevent partial-redraw issues caused by fast strokes. This is
+	 * needed here (not in sculpt_flush_update) as it was before
+	 * because redraw rectangle should be the same in both of
+	 * optimized PBVH draw function and 3d view redraw (if not -- some
+	 * mesh parts could disapper from screen (sergey) */
 	ss = ob->sculpt;
 	if(ss->cache) {
 		if(!BLI_rcti_is_empty(&ss->cache->previous_r))
@@ -539,8 +539,8 @@ static float calc_symmetry_feather(Sculpt *sd, StrokeCache* cache)
 }
 
 /* Return modified brush strength. Includes the direction of the brush, positive
-   values pull vertices, negative values push. Uses tablet pressure and a
-   special multiplier found experimentally to scale the strength factor. */
+ * values pull vertices, negative values push. Uses tablet pressure and a
+ * special multiplier found experimentally to scale the strength factor. */
 static float brush_strength(Sculpt *sd, StrokeCache *cache, float feather)
 {
 	const Scene *scene = cache->vc->scene;
@@ -555,7 +555,7 @@ static float brush_strength(Sculpt *sd, StrokeCache *cache, float feather)
 	float invert       = cache->invert ? -1 : 1;
 	float accum        = integrate_overlap(brush);
 	/* spacing is integer percentage of radius, divide by 50 to get
-	   normalized diameter */
+	 * normalized diameter */
 	float overlap      = (brush->flag & BRUSH_SPACE_ATTEN &&
 						  brush->flag & BRUSH_SPACE &&
 						  !(brush->flag & BRUSH_ANCHORED) &&
@@ -642,7 +642,7 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
 		float jnk;
 
 		/* Get strength by feeding the vertex 
-		   location directly into a texture */
+		 * location directly into a texture */
 		externtex(mtex, point, &avg,
 			  &jnk, &jnk, &jnk, &jnk, 0);
 	}
@@ -653,9 +653,9 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
 		float radius;
 
 		/* if the active area is being applied for symmetry, flip it
-		   across the symmetry axis and rotate it back to the orignal
-		   position in order to project it. This insures that the 
-		   brush texture will be oriented correctly. */
+		 * across the symmetry axis and rotate it back to the orignal
+		 * position in order to project it. This insures that the 
+		 * brush texture will be oriented correctly. */
 
 		flip_coord(symm_point, point, ss->cache->mirror_symmetry_pass);
 
@@ -677,8 +677,8 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
 			x = point_2d[0] + ss->cache->vc->ar->winrct.xmin;
 			y = point_2d[1] + ss->cache->vc->ar->winrct.ymin;
 		}
-		else /* else (mtex->brush_map_mode == MTEX_MAP_MODE_TILED),
-		        leave the coordinates relative to the screen */
+		else /* else (mtex->brush_map_mode == MTEX_MAP_MODE_TILED) */
+			 /* leave the coordinates relative to the screen */
 		{
 			radius = brush_size(ss->cache->vc->scene, br); // use unadjusted size for tiled mode
 		
@@ -698,8 +698,8 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
 		y *= ss->cache->vc->ar->winy / radius;
 
 		/* it is probably worth optimizing for those cases where 
-		   the texture is not rotated by skipping the calls to
-		   atan2, sqrtf, sin, and cos. */
+		 * the texture is not rotated by skipping the calls to
+		 * atan2, sqrtf, sin, and cos. */
 		if (rotation > 0.001f || rotation < -0.001f) {
 			const float angle    = atan2f(y, x) + rotation;
 			const float flen     = sqrtf(x*x + y*y);
@@ -850,7 +850,7 @@ static void calc_area_normal(Sculpt *sd, Object *ob, float an[3], PBVHNode **nod
 }
 
 /* This initializes the faces to be moved for this sculpt for draw/layer/flatten; then it
- finds average normal for all active vertices - note that this is called once for each mirroring direction */
+ * finds average normal for all active vertices - note that this is called once for each mirroring direction */
 static void calc_sculpt_normal(Sculpt *sd, Object *ob, float an[3], PBVHNode **nodes, int totnode)
 {
 	SculptSession *ss = ob->sculpt;
@@ -900,8 +900,8 @@ static void calc_sculpt_normal(Sculpt *sd, Object *ob, float an[3], PBVHNode **n
 }
 
 /* For the smooth brush, uses the neighboring vertices around vert to calculate
-   a smoothed location for vert. Skips corner vertices (used by only one
-   polygon.) */
+ * a smoothed location for vert. Skips corner vertices (used by only one
+ * polygon.) */
 static void neighbor_average(SculptSession *ss, float avg[3], unsigned vert)
 {
 	const int ncount = BLI_countlist(&ss->pmap[vert]);
@@ -1677,7 +1677,7 @@ static void calc_flatten_center(Sculpt *sd, Object *ob, PBVHNode **nodes, int to
 }
 
 /* this calculates flatten center and area normal together, 
-amortizing the memory bandwidth and loop overhead to calculate both at the same time */
+ * amortizing the memory bandwidth and loop overhead to calculate both at the same time */
 static void calc_area_normal_and_flatten_center(Sculpt *sd, Object *ob,
 												PBVHNode **nodes, int totnode,
 												float an[3], float fc[3])
@@ -2471,7 +2471,7 @@ static void sculpt_update_keyblock(Object *ob)
 	float (*vertCos)[3];
 
 	/* Keyblock update happens after hadning deformation caused by modifiers,
-	   so ss->orig_cos would be updated with new stroke */
+	 * so ss->orig_cos would be updated with new stroke */
 	if(ss->orig_cos) vertCos = ss->orig_cos;
 	else vertCos = BLI_pbvh_get_vertCos(ss->pbvh);
 
@@ -2491,7 +2491,7 @@ static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob)
 
 	if(ELEM(brush->sculpt_tool, SCULPT_TOOL_SMOOTH, SCULPT_TOOL_LAYER)) {
 		/* this brushes aren't using proxies, so sculpt_combine_proxies() wouldn't
-		   propagate needed deformation to original base */
+		 * propagate needed deformation to original base */
 
 		int n, totnode;
 		Mesh *me= (Mesh*)ob->data;
@@ -2526,8 +2526,8 @@ static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob)
 		MEM_freeN(nodes);
 
 		/* Modifiers could depend on mesh normals, so we should update them/
-		   Note, then if sculpting happens on locked key, normals should be re-calculated
-		   after applying coords from keyblock on base mesh */
+		 * Note, then if sculpting happens on locked key, normals should be re-calculated
+		 * after applying coords from keyblock on base mesh */
 		mesh_calc_normals(me->mvert, me->totvert, me->mloop, me->mpoly, me->totloop, me->totpoly, NULL);
 	} else if (ss->kb)
 		sculpt_update_keyblock(ob);
@@ -2551,7 +2551,7 @@ static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob)
 //}
 
 /* Flip all the editdata across the axis/axes specified by symm. Used to
-   calculate multiple modifications to the mesh when symmetry is enabled. */
+ * calculate multiple modifications to the mesh when symmetry is enabled. */
 static void calc_brushdata_symm(Sculpt *sd, StrokeCache *cache, const char symm,
 								const char axis, const float angle,
 								const float UNUSED(feather))
@@ -2602,8 +2602,8 @@ static void do_radial_symmetry(Sculpt *sd, Object *ob, Brush *brush,
 }
 
 /* noise texture gives different values for the same input coord; this
-   can tear a multires mesh during sculpting so do a stitch in this
-   case */
+ * can tear a multires mesh during sculpting so do a stitch in this
+ * case */
 static void sculpt_fix_noise_tear(Sculpt *sd, Object *ob)
 {
 	SculptSession *ss = ob->sculpt;
@@ -2789,8 +2789,9 @@ static const char *sculpt_tool_name(Sculpt *sd)
 	}
 }
 
-/**** Operator for applying a stroke (various attributes including mouse path)
-	  using the current brush. ****/
+/**
+ * Operator for applying a stroke (various attributes including mouse path)
+ * using the current brush. */
 
 static void sculpt_cache_free(StrokeCache *cache)
 {
@@ -2867,7 +2868,7 @@ static void sculpt_update_cache_invariants(bContext* C, Sculpt *sd, SculptSessio
 	cache->alt_smooth = mode == BRUSH_STROKE_SMOOTH;
 
 	/* not very nice, but with current events system implementation
-	   we can't handle brush appearance inversion hotkey separately (sergey) */
+	 * we can't handle brush appearance inversion hotkey separately (sergey) */
 	if(cache->invert) brush->flag |= BRUSH_INVERTED;
 	else brush->flag &= ~BRUSH_INVERTED;
 
@@ -3040,10 +3041,10 @@ static void sculpt_update_cache_variants(bContext *C, Sculpt *sd, Object *ob,
 	RNA_float_get_array(ptr, "mouse", cache->mouse);
 
 	/* XXX: Use preassure value from first brush step for brushes which don't
-	        support strokes (grab, thumb). They depends on initial state and
-	        brush coord/pressure/etc.
-	        It's more an events design issue, which doesn't split coordinate/pressure/angle
-	        changing events. We should avoid this after events system re-design */
+	 *      support strokes (grab, thumb). They depends on initial state and
+	 *      brush coord/pressure/etc.
+	 *      It's more an events design issue, which doesn't split coordinate/pressure/angle
+	 *      changing events. We should avoid this after events system re-design */
 	if(paint_space_stroke_enabled(brush) || cache->first_time)
 		cache->pressure = RNA_float_get(ptr, "pressure");
 
@@ -3203,8 +3204,8 @@ static void sculpt_raycast_cb(PBVHNode *node, void *data_v, float* tmin)
 }
 
 /* Do a raycast in the tree to find the 3d brush location
-   (This allows us to ignore the GL depth buffer)
-   Returns 0 if the ray doesn't hit the mesh, non-zero otherwise
+ * (This allows us to ignore the GL depth buffer)
+ * Returns 0 if the ray doesn't hit the mesh, non-zero otherwise
  */
 int sculpt_stroke_get_location(bContext *C, float out[3], float mouse[2])
 {
@@ -3263,8 +3264,8 @@ static void sculpt_brush_init_tex(const Scene *scene, Sculpt *sd, SculptSession
 		ntreeTexBeginExecTree(mtex->tex->nodetree, 1); /* has internal flag to detect it only does it once */
 
 	/* TODO: Shouldn't really have to do this at the start of every
-	   stroke, but sculpt would need some sort of notification when
-	   changes are made to the texture. */
+	 * stroke, but sculpt would need some sort of notification when
+	 * changes are made to the texture. */
 	sculpt_update_tex(scene, sd, ss);
 }
 
@@ -3375,7 +3376,7 @@ static void sculpt_flush_update(bContext *C)
 }
 
 /* Returns whether the mouse/stylus is over the mesh (1)
-   or over the background (0) */
+ * or over the background (0) */
 static int over_mesh(bContext *C, struct wmOperator *UNUSED(op), float x, float y)
 {
 	float mouse[2], co[3];
@@ -3404,9 +3405,9 @@ static int sculpt_stroke_test_start(bContext *C, struct wmOperator *op,
 
 #ifdef _OPENMP
 		/* If using OpenMP then create a number of threads two times the
-		   number of processor cores.
-		   Justification: Empirically I've found that two threads per
-		   processor gives higher throughput. */
+		 * number of processor cores.
+		 * Justification: Empirically I've found that two threads per
+		 * processor gives higher throughput. */
 		if (sd->flags & SCULPT_USE_OPENMP) {
 			int num_procs;
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_undo.c b/source/blender/editors/sculpt_paint/sculpt_undo.c
index 46a75d3b722..84b8b5a8bce 100644
--- a/source/blender/editors/sculpt_paint/sculpt_undo.c
+++ b/source/blender/editors/sculpt_paint/sculpt_undo.c
@@ -182,7 +182,7 @@ static void sculpt_undo_restore(bContext *C, ListBase *lb)
 			continue;
 
 		/* check if undo data matches current data well enough to
-		   continue */
+		 * continue */
 		if(unode->maxvert) {
 			if(ss->totvert != unode->maxvert)
 				continue;
@@ -203,8 +203,8 @@ static void sculpt_undo_restore(bContext *C, ListBase *lb)
 	if(update) {
 		int tag_update= 0;
 		/* we update all nodes still, should be more clever, but also
-		   needs to work correct when exiting/entering sculpt mode and
-		   the nodes get recreated, though in that case it could do all */
+		 * needs to work correct when exiting/entering sculpt mode and
+		 * the nodes get recreated, though in that case it could do all */
 		BLI_pbvh_search_callback(ss->pbvh, NULL, NULL, update_cb, NULL);
 		BLI_pbvh_update(ss->pbvh, PBVH_UpdateBB|PBVH_UpdateOriginalBB|PBVH_UpdateRedraw, NULL);
 
diff --git a/source/blender/editors/sound/sound_ops.c b/source/blender/editors/sound/sound_ops.c
index 4f145a617f7..205b2064f51 100644
--- a/source/blender/editors/sound/sound_ops.c
+++ b/source/blender/editors/sound/sound_ops.c
@@ -254,11 +254,11 @@ static int sound_update_animation_flags_exec(bContext *C, wmOperator *UNUSED(op)
 static void SOUND_OT_update_animation_flags(wmOperatorType *ot)
 {
 	/*
-	  This operator is needed to set a correct state of the sound animation
-	  System. Unfortunately there's no really correct place to call the exec
-	  function, that's why I made it an operator that's only visible in the
-	  search menu. Apart from that the bake animation operator calls it too.
-	*/
+	 * This operator is needed to set a correct state of the sound animation
+	 * System. Unfortunately there's no really correct place to call the exec
+	 * function, that's why I made it an operator that's only visible in the
+	 * search menu. Apart from that the bake animation operator calls it too.
+	 */
 
 	/* identifiers */
 	ot->name= "Update animation";
diff --git a/source/blender/editors/space_api/spacetypes.c b/source/blender/editors/space_api/spacetypes.c
index 7c5361c8af0..b876003c059 100644
--- a/source/blender/editors/space_api/spacetypes.c
+++ b/source/blender/editors/space_api/spacetypes.c
@@ -145,7 +145,7 @@ void ED_spacetypes_init(void)
 
 /* called in wm.c */
 /* keymap definitions are registered only once per WM initialize, usually on file read,
-   using the keymap the actual areas/regions add the handlers */
+ * using the keymap the actual areas/regions add the handlers */
 void ED_spacetypes_keymap(wmKeyConfig *keyconf)
 {
 	const ListBase *spacetypes;
diff --git a/source/blender/editors/space_buttons/buttons_texture.c b/source/blender/editors/space_buttons/buttons_texture.c
index 6927a78332f..fb46dd55a12 100644
--- a/source/blender/editors/space_buttons/buttons_texture.c
+++ b/source/blender/editors/space_buttons/buttons_texture.c
@@ -249,7 +249,7 @@ static void buttons_texture_users_from_context(ListBase *users, const bContext *
 void buttons_texture_context_compute(const bContext *C, SpaceButs *sbuts)
 {
 	/* gatheravailable texture users in context. runs on every draw of
-	   properties editor, before the buttons are created. */
+	 * properties editor, before the buttons are created. */
 	ButsContextTexture *ct= sbuts->texuser;
 	Scene *scene= CTX_data_scene(C);
 
@@ -295,7 +295,7 @@ void buttons_texture_context_compute(const bContext *C, SpaceButs *sbuts)
 			ButsTextureUser *user;
 
 			/* detect change of active texture node in same node tree, in that
-			   case we also automatically switch to the other node */
+			 * case we also automatically switch to the other node */
 			for(user=ct->users.first; user; user=user->next) {
 				if(user->ntree == ct->user->ntree && user->node != ct->user->node) {
 					if(user->node->flag & NODE_ACTIVE_TEXTURE) {
@@ -371,8 +371,8 @@ static void template_texture_user_menu(bContext *C, uiLayout *layout, void *UNUS
 void uiTemplateTextureUser(uiLayout *layout, bContext *C)
 {
 	/* texture user selection dropdown menu. the available users have been
-	   gathered before drawing in ButsContextTexture, we merely need to
-	   display the current item. */
+	 * gathered before drawing in ButsContextTexture, we merely need to
+	 * display the current item. */
 	SpaceButs *sbuts = CTX_wm_space_buts(C);
 	ButsContextTexture *ct= (sbuts)? sbuts->texuser: NULL;
 	uiBlock *block = uiLayoutGetBlock(layout);
diff --git a/source/blender/editors/space_clip/clip_draw.c b/source/blender/editors/space_clip/clip_draw.c
index 42c127df016..af2db9697b2 100644
--- a/source/blender/editors/space_clip/clip_draw.c
+++ b/source/blender/editors/space_clip/clip_draw.c
@@ -849,9 +849,9 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
 	/* ** find window pixel coordinates of origin ** */
 
 	/* UI_view2d_to_region_no_clip return integer values, this could
-	   lead to 1px flickering when view is locked to selection during playbeck.
-	   to avoid this flickering, calclate base point in the same way as it happens
-	   in UI_view2d_to_region_no_clip, but do it in floats here */
+	 * lead to 1px flickering when view is locked to selection during playbeck.
+	 * to avoid this flickering, calclate base point in the same way as it happens
+	 * in UI_view2d_to_region_no_clip, but do it in floats here */
 
 	view2d_to_region_float(&ar->v2d, 0.0f, 0.0f, &x, &y);
 
@@ -940,7 +940,7 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
 	}
 
 	/* selected areas only, so selection wouldn't be overlapped by
-	   non-selected areas */
+	 * non-selected areas */
 	track= tracksbase->first;
 	fp= marker_pos;
 	while(track) {
@@ -1318,7 +1318,7 @@ void clip_draw_grease_pencil(bContext *C, int onlyv2d)
 
 	if(onlyv2d) {
 		/* if manual calibration is used then grase pencil data is already
-		    drawed in draw_distortion */
+		 * drawed in draw_distortion */
 		if((sc->flag&SC_MANUAL_CALIBRATION)==0 || sc->mode!=SC_MODE_DISTORTION) {
 			ibuf= ED_space_clip_get_buffer(sc);
 
diff --git a/source/blender/editors/space_clip/space_clip.c b/source/blender/editors/space_clip/space_clip.c
index 9edf4fab280..0b5cfbbc7d3 100644
--- a/source/blender/editors/space_clip/space_clip.c
+++ b/source/blender/editors/space_clip/space_clip.c
@@ -725,7 +725,7 @@ static void clip_main_area_draw(const bContext *C, ARegion *ar)
 	MovieClip *clip= ED_space_clip(sc);
 
 	/* if trcking is in progress, we should sunchronize framenr from clipuser
-	   so latest tracked frame would be shown */
+	 * so latest tracked frame would be shown */
 	if(clip && clip->tracking_context)
 		BKE_tracking_sync_user(&sc->user, clip->tracking_context);
 
diff --git a/source/blender/editors/space_clip/tracking_ops.c b/source/blender/editors/space_clip/tracking_ops.c
index 18a5d8689c8..a88296a9729 100644
--- a/source/blender/editors/space_clip/tracking_ops.c
+++ b/source/blender/editors/space_clip/tracking_ops.c
@@ -334,7 +334,7 @@ static SlideMarkerData *create_slide_marker_data(SpaceClip *sc, MovieTrackingTra
 }
 
 /* corner = 0: right-bottom corner,
-   corner = 1: left-top corner */
+ * corner = 1: left-top corner */
 static int mouse_on_corner(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
 			int area, float co[2], int corner, int width, int height)
 {
@@ -1328,10 +1328,10 @@ static int track_markers_initjob(bContext *C, TrackMarkersJob *tmj, int backward
 	tmj->lastfra= tmj->sfra;
 
 	/* XXX: silly to store this, but this data is needed to update scene and movieclip
-	        frame numbers when tracking is finished. This introduces better feedback for artists.
-	        Maybe there's another way to solve this problem, but can't think better way atm.
-	        Anyway, this way isn't more unstable as animation rendering animation
-	        which uses the same approach (except storing screen). */
+	 *      frame numbers when tracking is finished. This introduces better feedback for artists.
+	 *      Maybe there's another way to solve this problem, but can't think better way atm.
+	 *      Anyway, this way isn't more unstable as animation rendering animation
+	 *      which uses the same approach (except storing screen). */
 	tmj->scene= scene;
 	tmj->main= CTX_data_main(C);
 	tmj->screen= CTX_wm_screen(C);
@@ -1348,10 +1348,10 @@ static void track_markers_startjob(void *tmv, short *stop, short *do_update, flo
 	while(framenr != tmj->efra) {
 		if(tmj->delay>0) {
 			/* tracking should happen with fixed fps. Calculate time
-			   using current timer value before tracking frame and after.
-
-			   Small (and maybe unneeded optimization): do not calculate exec_time
-			   for "Fastest" tracking */
+			 * using current timer value before tracking frame and after.
+			 *
+			 * Small (and maybe unneeded optimization): do not calculate exec_time
+			 * for "Fastest" tracking */
 
 			double start_time= PIL_check_seconds_timer(), exec_time;
 
@@ -1493,9 +1493,9 @@ static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(eve
 	WM_jobs_customdata(steve, tmj, track_markers_freejob);
 
 	/* if there's delay set in tracking job, tracking should happen
-	   with fixed FPS. To deal with editor refresh we have to syncronize
-	   tracks from job and tracks in clip. Do this in timer callback
-	   to prevent threading conflicts. */
+	 * with fixed FPS. To deal with editor refresh we have to syncronize
+	 * tracks from job and tracks in clip. Do this in timer callback
+	 * to prevent threading conflicts. */
 	if(tmj->delay>0) WM_jobs_timer(steve, tmj->delay/1000.0f, NC_MOVIECLIP|NA_EVALUATED, 0);
 	else WM_jobs_timer(steve, 0.2, NC_MOVIECLIP|NA_EVALUATED, 0);
 
@@ -3332,7 +3332,7 @@ static int is_track_clean(MovieTrackingTrack *track, int frames, int del)
 				}
 				else if(markers[a].flag&MARKER_DISABLED) {
 					/* current segment which would be deleted was finished by disabled marker,
-					   so next segment should be started from disabled marker */
+					 * so next segment should be started from disabled marker */
 					start_disabled= 1;
 				}
 			}
diff --git a/source/blender/editors/space_console/console_ops.c b/source/blender/editors/space_console/console_ops.c
index 9640701965c..427776eca7d 100644
--- a/source/blender/editors/space_console/console_ops.c
+++ b/source/blender/editors/space_console/console_ops.c
@@ -925,12 +925,13 @@ static void console_cursor_set_exit(bContext *UNUSED(C), wmOperator *op)
 //	SpaceConsole *sc= CTX_wm_space_console(C);
 	SetConsoleCursor *scu= op->customdata;
 
-	/*
+#if 0
 	if(txt_has_sel(text)) {
 		buffer = txt_sel_to_buf(text);
 		WM_clipboard_text_set(buffer, 1);
 		MEM_freeN(buffer);
-	}*/
+	}
+#endif
 
 	MEM_freeN(scu);
 }
diff --git a/source/blender/editors/space_console/space_console.c b/source/blender/editors/space_console/space_console.c
index 3df8e98be3a..701a0bb1cb8 100644
--- a/source/blender/editors/space_console/space_console.c
+++ b/source/blender/editors/space_console/space_console.c
@@ -297,7 +297,7 @@ static void console_keymap(struct wmKeyConfig *keyconf)
 	RNA_boolean_set(kmi->ptr, "reverse", TRUE);
 	WM_keymap_add_item(keymap, "CONSOLE_OT_history_cycle", DOWNARROWKEY, KM_PRESS, 0, 0);
 	
-	/*
+#if 0
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_move", LEFTARROWKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", PREV_WORD);
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_move", RIGHTARROWKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", NEXT_WORD);
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_move", UPARROWKEY, KM_PRESS, 0, 0)->ptr, "type", PREV_LINE);
@@ -311,7 +311,7 @@ static void console_keymap(struct wmKeyConfig *keyconf)
 	//RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_PREV_CHAR);
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DELKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_NEXT_WORD);
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, KM_CTRL, 0)->ptr, "type", DEL_PREV_WORD);
-	*/
+#endif
 	
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", DELKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_NEXT_CHAR);
 	RNA_enum_set(WM_keymap_add_item(keymap, "CONSOLE_OT_delete", BACKSPACEKEY, KM_PRESS, 0, 0)->ptr, "type", DEL_PREV_CHAR);
diff --git a/source/blender/editors/space_file/file_ops.c b/source/blender/editors/space_file/file_ops.c
index 548a51d9ee2..05de70b99ab 100644
--- a/source/blender/editors/space_file/file_ops.c
+++ b/source/blender/editors/space_file/file_ops.c
@@ -735,7 +735,7 @@ int file_exec(bContext *C, wmOperator *exec_op)
 		wmOperator *op= sfile->op;
 	
 		/* when used as a macro, for doubleclick, 
-		 to prevent closing when doubleclicking on .. item */
+		 * to prevent closing when doubleclicking on .. item */
 		if (RNA_boolean_get(exec_op->ptr, "need_active")) {
 			int i, active=0;
 			
@@ -996,8 +996,8 @@ void FILE_OT_smoothscroll(wmOperatorType *ot)
 
 
 /* create a new, non-existing folder name, returns 1 if successful, 0 if name couldn't be created.
-   The actual name is returned in 'name', 'folder' contains the complete path, including the new folder name.
-*/
+ * The actual name is returned in 'name', 'folder' contains the complete path, including the new folder name.
+ */
 static int new_folder_path(const char* parent, char *folder, char *name)
 {
 	int i = 1;
@@ -1006,8 +1006,8 @@ static int new_folder_path(const char* parent, char *folder, char *name)
 	BLI_strncpy(name, "New Folder", FILE_MAXFILE);
 	BLI_join_dirfile(folder, FILE_MAX, parent, name); /* XXX, not real length */
 	/* check whether folder with the name already exists, in this case
-	   add number to the name. Check length of generated name to avoid
-	   crazy case of huge number of folders each named 'New Folder (x)' */
+	 * add number to the name. Check length of generated name to avoid
+	 * crazy case of huge number of folders each named 'New Folder (x)' */
 	while (BLI_exists(folder) && (len<FILE_MAXFILE)) {
 		len = BLI_snprintf(name, FILE_MAXFILE, "New Folder(%d)", i);
 		BLI_join_dirfile(folder, FILE_MAX, parent, name); /* XXX, not real length */
diff --git a/source/blender/editors/space_file/filesel.c b/source/blender/editors/space_file/filesel.c
index 44eadc9dee8..fa2874f4842 100644
--- a/source/blender/editors/space_file/filesel.c
+++ b/source/blender/editors/space_file/filesel.c
@@ -363,8 +363,8 @@ void ED_fileselect_layout_tilepos(FileLayout* layout, int tile, int *x, int *y)
 }
 
 /* Shorten a string to a given width w. 
-   If front is set, shorten from the front,
-   otherwise shorten from the end. */
+ * If front is set, shorten from the front,
+ * otherwise shorten from the end. */
 float file_shorten_string(char* string, float w, int front)
 {	
 	char temp[FILE_MAX];
diff --git a/source/blender/editors/space_file/fsmenu.c b/source/blender/editors/space_file/fsmenu.c
index ea894750605..4f4ad52e4a4 100644
--- a/source/blender/editors/space_file/fsmenu.c
+++ b/source/blender/editors/space_file/fsmenu.c
@@ -210,8 +210,8 @@ void fsmenu_remove_entry(struct FSMenu* fsmenu, FSMenuCategory category, int idx
 
 	if (fsme) {
 		/* you should only be able to remove entries that were 
-		   not added by default, like windows drives.
-		   also separators (where path == NULL) shouldn't be removed */
+		 * not added by default, like windows drives.
+		 * also separators (where path == NULL) shouldn't be removed */
 		if (fsme->save && fsme->path) {
 
 			/* remove fsme from list */
@@ -341,8 +341,8 @@ void fsmenu_read_system(struct FSMenu* fsmenu)
 		}
 
 		/* As 10.4 doesn't provide proper API to retrieve the favorite places,
-		 assume they are the standard ones 
-		 TODO : replace hardcoded paths with proper BLI_get_folder calls */
+		 * assume they are the standard ones 
+		 * TODO : replace hardcoded paths with proper BLI_get_folder calls */
 		home = getenv("HOME");
 		if(home) {
 			BLI_snprintf(line, 256, "%s/", home);
diff --git a/source/blender/editors/space_file/space_file.c b/source/blender/editors/space_file/space_file.c
index 02c9728348e..7821547aaf3 100644
--- a/source/blender/editors/space_file/space_file.c
+++ b/source/blender/editors/space_file/space_file.c
@@ -221,7 +221,7 @@ static void file_refresh(const bContext *C, ScrArea *UNUSED(sa))
 				}
 			} else {
 				/* stop any running thumbnail jobs if we're not 
-				 displaying them - speedup for NFS */
+				 * displaying them - speedup for NFS */
 				thumbnails_stop(sfile->files, C);
 			}
 			filelist_filter(sfile->files);
diff --git a/source/blender/editors/space_image/image_buttons.c b/source/blender/editors/space_image/image_buttons.c
index 150872813b2..d54468f64ea 100644
--- a/source/blender/editors/space_image/image_buttons.c
+++ b/source/blender/editors/space_image/image_buttons.c
@@ -212,10 +212,10 @@ static void image_panel_curves(const bContext *C, Panel *pa)
 
 #if 0
 /* 0: disable preview 
-   otherwise refresh preview
- 
-   XXX if you put this back, also check XXX in image_main_area_draw() */
-*/
+ * otherwise refresh preview
+ *
+ * XXX if you put this back, also check XXX in image_main_area_draw() */
+ */
 void image_preview_event(int event)
 {
 	int exec= 0;
@@ -602,12 +602,12 @@ static void rna_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
 	RNAUpdateCb *cb= (RNAUpdateCb*)arg_cb;
 
 	/* ideally this would be done by RNA itself, but there we have
-	   no image user available, so we just update this flag here */
+	 * no image user available, so we just update this flag here */
 	cb->iuser->ok= 1;
 
 	/* we call update here on the pointer property, this way the
-	   owner of the image pointer can still define it's own update
-	   and notifier */
+	 * owner of the image pointer can still define it's own update
+	 * and notifier */
 	RNA_property_update(C, &cb->ptr, cb->prop);
 }
 
diff --git a/source/blender/editors/space_image/image_draw.c b/source/blender/editors/space_image/image_draw.c
index 9ec9c5ef0e0..e91a44e0358 100644
--- a/source/blender/editors/space_image/image_draw.c
+++ b/source/blender/editors/space_image/image_draw.c
@@ -79,11 +79,11 @@
 static void image_verify_buffer_float(Image *ima, ImBuf *ibuf, int color_manage)
 {
 	/* detect if we need to redo the curve map.
-	   ibuf->rect is zero for compositor and render results after change 
-	   convert to 32 bits always... drawing float rects isnt supported well (atis)
-	
-	   NOTE: if float buffer changes, we have to manually remove the rect
-	*/
+	 * ibuf->rect is zero for compositor and render results after change 
+	 * convert to 32 bits always... drawing float rects isnt supported well (atis)
+	 *
+	 * NOTE: if float buffer changes, we have to manually remove the rect
+	 */
 
 	if(ibuf->rect_float && (ibuf->rect==NULL || (ibuf->userflags & IB_RECT_INVALID)) ) {
 		if(color_manage) {
@@ -531,8 +531,10 @@ static void draw_image_buffer(SpaceImage *sima, ARegion *ar, Scene *scene, Image
 
 		if(ibuf->rect)
 			glaDrawPixelsSafe(x, y, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
-		/*else
-			glaDrawPixelsSafe(x, y, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_FLOAT, ibuf->rect_float);*/
+#if 0
+		else
+			glaDrawPixelsSafe(x, y, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_FLOAT, ibuf->rect_float);
+#endif
 		
 		if(sima->flag & SI_USE_ALPHA)
 			glDisable(GL_BLEND);
@@ -734,7 +736,7 @@ static void draw_image_paint_helpers(ARegion *ar, Scene *scene, float zoomx, flo
 
 	if(brush && (brush->imagepaint_tool == PAINT_TOOL_CLONE)) {
 		/* this is not very efficient, but glDrawPixels doesn't allow
-		   drawing with alpha */
+		 * drawing with alpha */
 		clonerect= get_alpha_clone_image(scene, &w, &h);
 
 		if(clonerect) {
diff --git a/source/blender/editors/space_image/space_image.c b/source/blender/editors/space_image/space_image.c
index 7abc0c6ea71..1af37a66022 100644
--- a/source/blender/editors/space_image/space_image.c
+++ b/source/blender/editors/space_image/space_image.c
@@ -824,9 +824,11 @@ static void image_main_area_draw(const bContext *C, ARegion *ar)
 	draw_image_grease_pencil((bContext *)C, 0);
 	
 	/* scrollers? */
-	/*scrollers= UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_VALUES, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
+#if 0
+	scrollers= UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_VALUES, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
 	UI_view2d_scrollers_draw(C, v2d, scrollers);
-	UI_view2d_scrollers_free(scrollers);*/
+	UI_view2d_scrollers_free(scrollers);
+#endif
 }
 
 static void image_main_area_listener(ARegion *ar, wmNotifier *wmn)
diff --git a/source/blender/editors/space_info/info_report.c b/source/blender/editors/space_info/info_report.c
index 206639f064a..a1ea0449128 100644
--- a/source/blender/editors/space_info/info_report.c
+++ b/source/blender/editors/space_info/info_report.c
@@ -236,14 +236,14 @@ static int borderselect_exec(bContext *C, wmOperator *op)
 	rect.xmax= RNA_int_get(op->ptr, "xmax");
 	rect.ymax= RNA_int_get(op->ptr, "ymax");
 
-	/*
+#if 0
 	mval[0]= rect.xmin;
 	mval[1]= rect.ymin;
 	UI_view2d_region_to_view(v2d, mval[0], mval[1], &rectf.xmin, &rectf.ymin);
 	mval[0]= rect.xmax;
 	mval[1]= rect.ymax;
 	UI_view2d_region_to_view(v2d, mval[0], mval[1], &rectf.xmax, &rectf.ymax);
-*/
+#endif
 
 	if(!extend) {
 		for(report= reports->list.first; report; report= report->next) {
diff --git a/source/blender/editors/space_logic/logic_ops.c b/source/blender/editors/space_logic/logic_ops.c
index 0dfcafcf549..86ac2d0c369 100644
--- a/source/blender/editors/space_logic/logic_ops.c
+++ b/source/blender/editors/space_logic/logic_ops.c
@@ -119,7 +119,7 @@ static Object *edit_object_property_get(bContext *C, wmOperator *op)
 	RNA_string_get(op->ptr, "object", ob_name);
 
 	/* if ob_name is valid try to find the object with this name
-	otherwise gets the active object */
+	 * otherwise gets the active object */
 	if (BLI_strnlen(ob_name, MAX_NAME) > 0)
 		ob = BLI_findstring(&(CTX_data_main(C)->object), ob_name, offsetof(ID, name) + 2);
 	else
@@ -406,8 +406,8 @@ static int controller_add_exec(bContext *C, wmOperator *op)
 
 	make_unique_prop_names(C, cont->name);
 	/* set the controller state mask from the current object state.
-	 A controller is always in a single state, so select the lowest bit set
-	 from the object state */
+	 * A controller is always in a single state, so select the lowest bit set
+	 * from the object state */
 	for (bit=0; bit<OB_MAX_STATES; bit++) {
 		if (ob->state & (1<<bit))
 			break;
diff --git a/source/blender/editors/space_logic/logic_window.c b/source/blender/editors/space_logic/logic_window.c
index 15aab2aa9b0..ea593b57ee0 100644
--- a/source/blender/editors/space_logic/logic_window.c
+++ b/source/blender/editors/space_logic/logic_window.c
@@ -124,8 +124,8 @@ void make_unique_prop_names(bContext *C, char *str)
 	char **names;
 	
 	/* this function is called by a Button, and gives the current
-		* stringpointer as an argument, this is the one that can change
-		*/
+	 * stringpointer as an argument, this is the one that can change
+	 */
 	
 	idar= get_selected_and_linked_obs(C, &obcount, BUTS_SENS_SEL|BUTS_SENS_ACT|BUTS_ACT_SEL|BUTS_ACT_ACT|BUTS_CONT_SEL|BUTS_CONT_ACT);
 	
@@ -436,8 +436,8 @@ static void do_logic_buts(bContext *C, void *UNUSED(arg), int event)
 				ob->scaflag |= OB_SHOWCONT;
 				BLI_addtail(&(ob->controllers), cont);
 				/* set the controller state mask from the current object state.
-				   A controller is always in a single state, so select the lowest bit set
-				   from the object state */
+				 * A controller is always in a single state, so select the lowest bit set
+				 * from the object state */
 				for (bit=0; bit<32; bit++) {
 					if (ob->state & (1<<bit))
 						break;
@@ -1187,9 +1187,9 @@ static short draw_sensorbuttons(Object *ob, bSensor *sens, uiBlock *block, short
 			
 			ts= sens->data; 
 			
-			/* uiDefBut(block, TEX, 1, "Property:",	xco,yco-22,width, 19, &ts->name, 0, MAX_NAME, 0, 0, "Only look for Objects with this property"); */
+			// uiDefBut(block, TEX, 1, "Property:",	xco,yco-22,width, 19, &ts->name, 0, MAX_NAME, 0, 0, "Only look for Objects with this property");
 			uiDefIDPoinBut(block, test_matpoin_but, ID_MA, 1, "MA:",(short)(xco + 10),(short)(yco-44), (short)(width - 20), 19, &ts->ma,  "Only look for floors with this Material"); 
-			///* uiDefButF(block, NUM, 1, "Margin:",	xco+width/2,yco-44,width/2, 19, &ts->dist, 0.0, 10.0, 100, 0, "Extra margin (distance) for larger sensitivity"); 
+			// uiDefButF(block, NUM, 1, "Margin:",	xco+width/2,yco-44,width/2, 19, &ts->dist, 0.0, 10.0, 100, 0, "Extra margin (distance) for larger sensitivity"); 
 			yco-= ysize; 
 			break; 
 		}
@@ -1458,7 +1458,8 @@ static short draw_sensorbuttons(Object *ob, bSensor *sens, uiBlock *block, short
 			draw_default_sensor_header(sens, block, xco, yco, width);
 			
 			/* Line 2: type selection. The number are a bit mangled to get
-			* proper compatibility with older .blend files. */
+			 * proper compatibility with older .blend files. */
+
 			/* Any sensor type default is 0 but the ms enum starts in 1.
 			 * Therefore the mosue sensor is initialized to 1 in sca.c */
 			str= "Type %t|Left button %x1|Middle button %x2|"
@@ -2557,7 +2558,8 @@ static short draw_actuatorbuttons(Main *bmain, Object *ob, bActuator *act, uiBlo
 				   uiDefBut(block, TEX, 1, "File: ", xco+10, yco-44,width-20,19, &(gma->filename), 0, sizeof(gma->filename), 0, 0, "Load this blend file, use the \"//\" prefix for a path relative to the current blend file");
 //				uiDefBut(block, TEX, 1, "Anim: ", xco+10, yco-64,width-20,19, &(gma->loadaniname), 0, sizeof(gma->loadaniname), 0, 0, "Use this loadinganimation");
 			}
-/*			else if (gma->type == ACT_GAME_START)
+#if 0
+			else if (gma->type == ACT_GAME_START)
 			{
 				ysize = 68; 
 				glRects(xco, yco-ysize, xco+width, yco); 
@@ -2566,7 +2568,8 @@ static short draw_actuatorbuttons(Main *bmain, Object *ob, bActuator *act, uiBlo
 				   uiDefBut(block, TEX, 1, "File: ", xco+10, yco-44,width-20,19, &(gma->filename), 0, sizeof(gma->filename), 0, 0, "Load this file");
 				uiDefBut(block, TEX, 1, "Anim: ", xco+10, yco-64,width-20,19, &(gma->loadaniname), 0, sizeof(gma->loadaniname), 0, 0, "Use this loadinganimation");
 			}
-*/			else if (ELEM4(gma->type, ACT_GAME_RESTART, ACT_GAME_QUIT, ACT_GAME_SAVECFG, ACT_GAME_LOADCFG))
+#endif
+			else if (ELEM4(gma->type, ACT_GAME_RESTART, ACT_GAME_QUIT, ACT_GAME_SAVECFG, ACT_GAME_LOADCFG))
 			{
 				ysize = 28; 
 				glRects(xco, yco-ysize, xco+width, yco); 
@@ -4834,7 +4837,7 @@ void logic_buttons(bContext *C, ARegion *ar)
 	idar= get_selected_and_linked_obs(C, &count, slogic->scaflag);
 
 	/* clean ACT_LINKED and ACT_VISIBLE of all potentially visible actuators so that 
-	   we can determine which is actually linked/visible */
+	 * we can determine which is actually linked/visible */
 	for(a=0; a<count; a++) {
 		ob= (Object *)idar[a];
 		act= ob->actuators.first;
@@ -4881,7 +4884,7 @@ void logic_buttons(bContext *C, ARegion *ar)
 		
 		/* mark all actuators linked to these controllers */
 		/* note that some of these actuators could be from objects that are not in the display list.
-		   It's ok because those actuators will not be displayed here */
+		 * It's ok because those actuators will not be displayed here */
 		cont= ob->controllers.first;
 		while(cont) {
 			for (iact=0; iact<cont->totlinks; iact++) {
diff --git a/source/blender/editors/space_nla/space_nla.c b/source/blender/editors/space_nla/space_nla.c
index 48859acff6a..2f0d39c5f91 100644
--- a/source/blender/editors/space_nla/space_nla.c
+++ b/source/blender/editors/space_nla/space_nla.c
@@ -466,12 +466,14 @@ static void nla_listener(ScrArea *sa, wmNotifier *wmn)
 			ED_area_tag_refresh(sa);
 			break;
 		case NC_SCENE:
-			/*switch (wmn->data) {
+#if 0
+			switch (wmn->data) {
 				case ND_OB_ACTIVE:
 				case ND_OB_SELECT:
 					ED_area_tag_refresh(sa);
 					break;
-			}*/
+			}
+#endif
 			ED_area_tag_refresh(sa);
 			break;
 		case NC_OBJECT:
diff --git a/source/blender/editors/space_node/node_draw.c b/source/blender/editors/space_node/node_draw.c
index 5b35352417c..f7ed7d58f38 100644
--- a/source/blender/editors/space_node/node_draw.c
+++ b/source/blender/editors/space_node/node_draw.c
@@ -653,11 +653,13 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN
 		UI_DrawTriIcon(rct->xmin+10.0f, rct->ymax-NODE_DY/2.0f, 'v');
 	}
 	
-	/* this isn't doing anything for the label, so commenting out
+	/* this isn't doing anything for the label, so commenting out */
+#if 0
 	if(node->flag & SELECT) 
 		UI_ThemeColor(TH_TEXT_HI);
 	else
-		UI_ThemeColor(TH_TEXT); */
+		UI_ThemeColor(TH_TEXT);
+#endif
 	
 	BLI_strncpy(showname, nodeLabel(node), sizeof(showname));
 	
diff --git a/source/blender/editors/space_node/node_edit.c b/source/blender/editors/space_node/node_edit.c
index a6d18b58cca..bb99464e3c7 100644
--- a/source/blender/editors/space_node/node_edit.c
+++ b/source/blender/editors/space_node/node_edit.c
@@ -139,7 +139,7 @@ static void compo_freejob(void *cjv)
 }
 
 /* only now we copy the nodetree, so adding many jobs while
-   sliding buttons doesn't frustrate */
+ * sliding buttons doesn't frustrate */
 static void compo_initjob(void *cjv)
 {
 	CompoJob *cj= cjv;
@@ -2879,7 +2879,7 @@ static int node_read_fullsamplelayers_exec(bContext *C, wmOperator *UNUSED(op))
 	WM_cursor_wait(0);
 
 	/* note we are careful to send the right notifier, as otherwise the
-	   compositor would reexecute and overwrite the full sample result */
+	 * compositor would reexecute and overwrite the full sample result */
 	WM_event_add_notifier(C, NC_SCENE|ND_COMPO_RESULT, NULL);
 
 	return OPERATOR_FINISHED;
diff --git a/source/blender/editors/space_outliner/outliner_draw.c b/source/blender/editors/space_outliner/outliner_draw.c
index bb694ae5705..1a08df79664 100644
--- a/source/blender/editors/space_outliner/outliner_draw.c
+++ b/source/blender/editors/space_outliner/outliner_draw.c
@@ -127,11 +127,13 @@ static void outliner_rna_width(SpaceOops *soops, ListBase *lb, int *w, int start
 	TreeElement *te= lb->first;
 	while(te) {
 		TreeStoreElem *tselem= TREESTORE(te);
-			// XXX fixme... (currently, we're using a fixed length of 100)!
-		/*if(te->xend) {
+		// XXX fixme... (currently, we're using a fixed length of 100)!
+#if 0
+		if(te->xend) {
 			if(te->xend > *w)
 				*w = te->xend;
-		}*/
+		}
+#endif
 		if(startx+100 > *w)
 			*w = startx+100;
 
diff --git a/source/blender/editors/space_outliner/outliner_intern.h b/source/blender/editors/space_outliner/outliner_intern.h
index 8c53e9ad111..b1990d3054e 100644
--- a/source/blender/editors/space_outliner/outliner_intern.h
+++ b/source/blender/editors/space_outliner/outliner_intern.h
@@ -127,20 +127,20 @@ typedef struct TreeElement {
 
 
 /* Outliner Searching --
-
-   Are we looking for something in the outliner?
-   If so finding matches in child items makes it more useful
-
-	 - We want to flag parents to act as being open to filter child matches 
-	 - and also flag matches so we can highlight them
-	 - Flags are stored in TreeStoreElem->flag
-	 - Flag options defined in DNA_outliner_types.h
-	 - SO_SEARCH_RECURSIVE defined in DNA_space_types.h
-	 
-	 - NOT in datablocks view - searching all datablocks takes way too long 
-		to be useful
-	 - not searching into RNA items helps but isn't the complete solution
-	*/
+ *
+ * Are we looking for something in the outliner?
+ * If so finding matches in child items makes it more useful
+ *
+ * - We want to flag parents to act as being open to filter child matches 
+ * - and also flag matches so we can highlight them
+ * - Flags are stored in TreeStoreElem->flag
+ * - Flag options defined in DNA_outliner_types.h
+ * - SO_SEARCH_RECURSIVE defined in DNA_space_types.h
+ *
+ * - NOT in datablocks view - searching all datablocks takes way too long 
+ *   to be useful
+ * - not searching into RNA items helps but isn't the complete solution
+ */
 
 #define SEARCHING_OUTLINER(sov)   (sov->search_flags & SO_SEARCH_RECURSIVE)
 
diff --git a/source/blender/editors/space_outliner/outliner_select.c b/source/blender/editors/space_outliner/outliner_select.c
index 345e7a835f4..a71ea9a6d4a 100644
--- a/source/blender/editors/space_outliner/outliner_select.c
+++ b/source/blender/editors/space_outliner/outliner_select.c
@@ -664,7 +664,7 @@ int tree_element_active(bContext *C, Scene *scene, SpaceOops *soops, TreeElement
 
 	switch(te->idcode) {
 		/* Note: no ID_OB: objects are handled specially to allow multiple
-		   selection. See do_outliner_item_activate. */
+		 * selection. See do_outliner_item_activate. */
 		case ID_MA:
 			return tree_element_active_material(C, scene, soops, te, set);
 		case ID_WO:
diff --git a/source/blender/editors/space_outliner/outliner_tools.c b/source/blender/editors/space_outliner/outliner_tools.c
index 09a125692d2..c8da45270b7 100644
--- a/source/blender/editors/space_outliner/outliner_tools.c
+++ b/source/blender/editors/space_outliner/outliner_tools.c
@@ -576,10 +576,10 @@ static int outliner_object_operation_exec(bContext *C, wmOperator *op)
 		outliner_do_object_operation(C, scene, soops, &soops->tree, object_delete_cb);
 
 		/* XXX: tree management normally happens from draw_outliner(), but when
-		        you're clicking to fast on Delete object from context menu in
-		        outliner several mouse events can be handled in one cycle without
-		        handling notifiers/redraw which leads to deleting the same object twice.
-		        cleanup tree here to prevent such cases. */
+		 *      you're clicking to fast on Delete object from context menu in
+		 *      outliner several mouse events can be handled in one cycle without
+		 *      handling notifiers/redraw which leads to deleting the same object twice.
+		 *      cleanup tree here to prevent such cases. */
 		outliner_cleanup_tree(soops);
 
 		DAG_scene_sort(bmain, scene);
diff --git a/source/blender/editors/space_outliner/outliner_tree.c b/source/blender/editors/space_outliner/outliner_tree.c
index 7f3a8694d68..56cfcf9e18a 100644
--- a/source/blender/editors/space_outliner/outliner_tree.c
+++ b/source/blender/editors/space_outliner/outliner_tree.c
@@ -644,7 +644,7 @@ static void outliner_add_id_contents(SpaceOops *soops, TreeElement *te, TreeStor
 			for(a=0; a<me->totcol; a++) 
 				outliner_add_element(soops, &te->subtree, me->mat[a], te, 0, a);
 			/* could do tfaces with image links, but the images are not grouped nicely.
-			   would require going over all tfaces, sort images in use. etc... */
+			 * would require going over all tfaces, sort images in use. etc... */
 		}
 			break;
 		case ID_CU:
@@ -1412,8 +1412,8 @@ void outliner_build_tree(Main *mainvar, Scene *scene, SpaceOops *soops)
 	int show_opened= (soops->treestore==NULL); /* on first view, we open scenes */
 
 	/* Are we looking for something - we want to tag parents to filter child matches
-	 - NOT in datablocks view - searching all datablocks takes way too long to be useful
-	 - this variable is only set once per tree build */
+	 * - NOT in datablocks view - searching all datablocks takes way too long to be useful
+	 * - this variable is only set once per tree build */
 	if(soops->search_string[0]!=0 && soops->outlinevis!=SO_DATABLOCKS)
 		soops->search_flags |= SO_SEARCH_RECURSIVE;
 	else
diff --git a/source/blender/editors/space_sequencer/sequencer_draw.c b/source/blender/editors/space_sequencer/sequencer_draw.c
index 7bc8600c11c..f740a3c4875 100644
--- a/source/blender/editors/space_sequencer/sequencer_draw.c
+++ b/source/blender/editors/space_sequencer/sequencer_draw.c
@@ -167,10 +167,10 @@ static void get_seq_color3ubv(Scene *curscene, Sequence *seq, unsigned char col[
 static void drawseqwave(Scene *scene, Sequence *seq, float x1, float y1, float x2, float y2, float stepsize)
 {
 	/*
-	x1 is the starting x value to draw the wave,
-	x2 the end x value, same for y1 and y2
-	stepsize is width of a pixel.
-	*/
+	 * x1 is the starting x value to draw the wave,
+	 * x2 the end x value, same for y1 and y2
+	 * stepsize is width of a pixel.
+	 */
 	if(seq->flag & SEQ_AUDIO_DRAW_WAVEFORM)
 	{
 		int i, j, pos;
@@ -478,7 +478,7 @@ static void draw_seq_extensions(Scene *scene, ARegion *ar, Sequence *seq)
 		draw_shadedstrip(seq, col, x1, y1, (float)(seq->start), y2);
 		
 		/* feint pinstripes, helps see exactly which is extended and which isn't,
-		* especially when the extension is very small */ 
+		 * especially when the extension is very small */ 
 		if (seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 24);
 		else UI_GetColorPtrShade3ubv(col, col, -16);
 		
@@ -496,7 +496,7 @@ static void draw_seq_extensions(Scene *scene, ARegion *ar, Sequence *seq)
 		draw_shadedstrip(seq, col, (float)(seq->start+seq->len), y1, x2, y2);
 		
 		/* feint pinstripes, helps see exactly which is extended and which isn't,
-		* especially when the extension is very small */ 
+		 * especially when the extension is very small */ 
 		if (seq->flag & SELECT) UI_GetColorPtrShade3ubv(col, col, 24);
 		else UI_GetColorPtrShade3ubv(col, col, -16);
 		
@@ -637,10 +637,10 @@ static void draw_shadedstrip(Sequence *seq, unsigned char col[3], float x1, floa
 }
 
 /*
-Draw a sequence strip, bounds check already made
-ARegion is currently only used to get the windows width in pixels
-so wave file sample drawing precision is zoom adjusted
-*/
+ * Draw a sequence strip, bounds check already made
+ * ARegion is currently only used to get the windows width in pixels
+ * so wave file sample drawing precision is zoom adjusted
+ */
 static void draw_seq_strip(Scene *scene, ARegion *ar, Sequence *seq, int outline_tint, float pixelx)
 {
 	View2D *v2d= &ar->v2d;
diff --git a/source/blender/editors/space_sequencer/sequencer_edit.c b/source/blender/editors/space_sequencer/sequencer_edit.c
index fad402a6787..f05068cac59 100644
--- a/source/blender/editors/space_sequencer/sequencer_edit.c
+++ b/source/blender/editors/space_sequencer/sequencer_edit.c
@@ -414,7 +414,7 @@ Sequence *find_nearest_seq(Scene *scene, View2D *v2d, int *hand, const int mval[
 					
 					if (displen / pixelx > 16) { /* dont even try to grab the handles of small strips */
 						/* Set the max value to handle to 1/3 of the total len when its less then 28.
-						* This is important because otherwise selecting handles happens even when you click in the middle */
+						 * This is important because otherwise selecting handles happens even when you click in the middle */
 						
 						if ((displen/3) < 30*pixelx) {
 							handsize = displen/3;
@@ -515,7 +515,7 @@ int seq_effect_find_selected(Scene *scene, Sequence *activeseq, int type, Sequen
 	}
 
 	/* make sequence selection a little bit more intuitive
-	   for 3 strips: the last-strip should be sequence3 */
+	 * for 3 strips: the last-strip should be sequence3 */
 	if (seq3 != NULL && seq2 != NULL) {
 		Sequence *tmp = seq2;
 		seq2 = seq3;
@@ -559,7 +559,7 @@ static Sequence *del_seq_find_replace_recurs(Scene *scene, Sequence *seq)
 	Sequence *seq1, *seq2, *seq3;
 
 	/* try to find a replacement input sequence, and flag for later deletion if
-	   no replacement can be found */
+	 * no replacement can be found */
 
 	if(!seq)
 		return NULL;
@@ -886,7 +886,7 @@ static void UNUSED_FUNCTION(touch_seq_files)(Scene *scene)
 	WM_cursor_wait(0);
 }
 
-/*
+#if 0
 static void set_filter_seq(Scene *scene)
 {
 	Sequence *seq;
@@ -909,7 +909,7 @@ static void set_filter_seq(Scene *scene)
 	}
 	SEQ_END
 }
-*/
+#endif
 
 static void UNUSED_FUNCTION(seq_remap_paths)(Scene *scene)
 {
@@ -980,7 +980,7 @@ static void UNUSED_FUNCTION(no_gaps)(Scene *scene)
 static int seq_get_snaplimit(View2D *v2d)
 {
 	/* fake mouse coords to get the snap value
-	a bit lazy but its only done once pre transform */
+	 * a bit lazy but its only done once pre transform */
 	float xmouse, ymouse, x;
 	int mval[2] = {24, 0}; /* 24 screen px snap */
 	
@@ -1733,7 +1733,7 @@ static int sequencer_separate_images_exec(bContext *C, wmOperator *op)
 	while (seq) {
 		if((seq->flag & SELECT) && (seq->type == SEQ_IMAGE) && (seq->len > 1)) {
 			/* remove seq so overlap tests dont conflict,
-			see seq_free_sequence below for the real free'ing */
+			 * see seq_free_sequence below for the real free'ing */
 			BLI_remlink(ed->seqbasep, seq);
 			/* if(seq->ipo) seq->ipo->id.us--; */
 			/* XXX, remove fcurve and assign to split image strips */
@@ -2306,8 +2306,8 @@ static int find_next_prev_edit(Scene *scene, int cfra, int side)
 	}
 
 	/* if no sequence to the right is found and the
-	   frame is on the start of the last sequence,
-	   move to the end of the last sequence */
+	 * frame is on the start of the last sequence,
+	 * move to the end of the last sequence */
 	if (frame_seq) cfra = frame_seq->enddisp;
 
 	return best_seq ? best_seq->startdisp : cfra;
diff --git a/source/blender/editors/space_sequencer/sequencer_ops.c b/source/blender/editors/space_sequencer/sequencer_ops.c
index ec9f8bb36d9..bf2d9ce833e 100644
--- a/source/blender/editors/space_sequencer/sequencer_ops.c
+++ b/source/blender/editors/space_sequencer/sequencer_ops.c
@@ -188,7 +188,7 @@ void sequencer_keymap(wmKeyConfig *keyconf)
 	WM_keymap_add_item(keymap, "SEQUENCER_OT_swap_inputs", SKEY, KM_PRESS, KM_ALT, 0);
 
 	/* multicam editing keyboard layout, switch to camera 1-10 using
-	   regular number keys */
+	 * regular number keys */
 	{
 		int keys[] = { ONEKEY, TWOKEY, THREEKEY, FOURKEY, FIVEKEY,
 		               SIXKEY, SEVENKEY, EIGHTKEY, NINEKEY, ZEROKEY };
@@ -213,7 +213,7 @@ void sequencer_keymap(wmKeyConfig *keyconf)
 
 
 	/* 2.4x method, now use Alt for handles and select the side based on which handle was selected */
-	/*
+#if 0
 	kmi = WM_keymap_add_item(keymap, "SEQUENCER_OT_select", SELECTMOUSE, KM_PRESS, KM_CTRL, 0);
 	RNA_boolean_set(kmi->ptr, "linked_left", TRUE);
 	kmi = WM_keymap_add_item(keymap, "SEQUENCER_OT_select", SELECTMOUSE, KM_PRESS, KM_ALT, 0);
@@ -235,7 +235,7 @@ void sequencer_keymap(wmKeyConfig *keyconf)
 	kmi= WM_keymap_add_item(keymap, "SEQUENCER_OT_select", SELECTMOUSE, KM_PRESS, KM_SHIFT|KM_ALT, 0);
 	RNA_boolean_set(kmi->ptr, "extend", TRUE);
 	RNA_boolean_set(kmi->ptr, "linked_right", TRUE);
-	 */
+#endif
 
 	/* 2.5 method, Alt and use selected handle */
 	kmi = WM_keymap_add_item(keymap, "SEQUENCER_OT_select", SELECTMOUSE, KM_PRESS, KM_ALT, 0);
diff --git a/source/blender/editors/space_sequencer/space_sequencer.c b/source/blender/editors/space_sequencer/space_sequencer.c
index 303f6912ff1..e19382b0d64 100644
--- a/source/blender/editors/space_sequencer/space_sequencer.c
+++ b/source/blender/editors/space_sequencer/space_sequencer.c
@@ -572,8 +572,8 @@ void ED_spacetype_sequencer(void)
 	BLI_addhead(&st->regiontypes, art);
 	
 	/* Keep as python only for now
-	sequencer_buttons_register(art);
-	*/
+	 * sequencer_buttons_register(art);
+	 */
 
 	/* regions: header */
 	art= MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
diff --git a/source/blender/editors/space_text/space_text.c b/source/blender/editors/space_text/space_text.c
index 314afeac0e6..a416e9cf973 100644
--- a/source/blender/editors/space_text/space_text.c
+++ b/source/blender/editors/space_text/space_text.c
@@ -127,8 +127,8 @@ static void text_listener(ScrArea *sa, wmNotifier *wmn)
 	switch(wmn->category) {
 		case NC_TEXT:
 			/* check if active text was changed, no need to redraw if text isn't active
-			   reference==NULL means text was unlinked, should update anyway for this
-			   case -- no way to know was text active before unlinking or not */
+			 * reference==NULL means text was unlinked, should update anyway for this
+			 * case -- no way to know was text active before unlinking or not */
 			if(wmn->reference && wmn->reference != st->text)
 				break;
 
diff --git a/source/blender/editors/space_text/text_draw.c b/source/blender/editors/space_text/text_draw.c
index 8a78f236fea..dec1abfd009 100644
--- a/source/blender/editors/space_text/text_draw.c
+++ b/source/blender/editors/space_text/text_draw.c
@@ -180,11 +180,11 @@ void flatten_string_free(FlattenString *fs)
 }
 
 /* Checks the specified source string for a Python built-in function name. This
- name must start at the beginning of the source string and must be followed by
- a non-identifier (see text_check_identifier(char)) or null character.
- 
- If a built-in function is found, the length of the matching name is returned.
- Otherwise, -1 is returned. */
+ * name must start at the beginning of the source string and must be followed by
+ * a non-identifier (see text_check_identifier(char)) or null character.
+ * 
+ * If a built-in function is found, the length of the matching name is returned.
+ * Otherwise, -1 is returned. */
 
 static int find_builtinfunc(char *string)
 {
@@ -219,11 +219,11 @@ static int find_builtinfunc(char *string)
 }
 
 /* Checks the specified source string for a Python special name. This name must
- start at the beginning of the source string and must be followed by a non-
- identifier (see text_check_identifier(char)) or null character.
- 
- If a special name is found, the length of the matching name is returned.
- Otherwise, -1 is returned. */
+ * start at the beginning of the source string and must be followed by a non-
+ * identifier (see text_check_identifier(char)) or null character.
+ * 
+ * If a special name is found, the length of the matching name is returned.
+ * Otherwise, -1 is returned. */
 
 static int find_specialvar(char *string) 
 {
@@ -271,7 +271,7 @@ static int find_bool(char *string)
 }
 
 /* Ensures the format string for the given line is long enough, reallocating
- as needed. Allocation is done here, alone, to ensure consistency. */
+ * as needed. Allocation is done here, alone, to ensure consistency. */
 static int text_check_format_len(TextLine *line, unsigned int len)
 {
 	if(line->format) {
@@ -290,18 +290,18 @@ static int text_check_format_len(TextLine *line, unsigned int len)
 }
 
 /* Formats the specified line. If do_next is set, the process will move on to
- the succeeding line if it is affected (eg. multiline strings). Format strings
- may contain any of the following characters:
-	 '_'		Whitespace
-	 '#'		Comment text
-	 '!'		Punctuation and other symbols
-	 'n'		Numerals
-	 'l'		String letters
-	 'v'		Special variables (class, def)
-	 'b'		Built-in names (print, for, etc.)
-	 'q'		Other text (identifiers, etc.)
- It is terminated with a null-terminator '\0' followed by a continuation
- flag indicating whether the line is part of a multi-line string. */
+ * the succeeding line if it is affected (eg. multiline strings). Format strings
+ * may contain any of the following characters:
+ *  '_'  Whitespace
+ *  '#'  Comment text
+ *  '!'  Punctuation and other symbols
+ *  'n'  Numerals
+ *  'l'  String letters
+ *  'v'  Special variables (class, def)
+ *  'b'  Built-in names (print, for, etc.)
+ *  'q'  Other text (identifiers, etc.)
+ * It is terminated with a null-terminator '\0' followed by a continuation
+ * flag indicating whether the line is part of a multi-line string. */
 
 static void txt_format_line(SpaceText *st, TextLine *line, int do_next)
 {
@@ -488,31 +488,29 @@ static void format_draw_color(char formatchar)
 
 /************************** draw text *****************************/
 
-/***********************/ /*
-
-Notes on word-wrap
---
-All word-wrap functions follow the algorithm below to maintain consistency.
-	line		The line to wrap (tabs converted to spaces)
-	view_width	The maximum number of characters displayable in the region
-				This equals region_width/font_width for the region
-	wrap_chars	Characters that allow wrapping. This equals [' ', '\t', '-']
-
-def wrap(line, view_width, wrap_chars):
-	draw_start = 0
-	draw_end = view_width
-	pos = 0
-	for c in line:
-		if pos-draw_start >= view_width:
-			print line[draw_start:draw_end]
-			draw_start = draw_end
-			draw_end += view_width
-		elif c in wrap_chars:
-			draw_end = pos+1
-		pos += 1
-	print line[draw_start:]
-
-*/ /***********************/
+/* Notes on word-wrap
+ * --
+ * All word-wrap functions follow the algorithm below to maintain consistency.
+ *     line        The line to wrap (tabs converted to spaces)
+ *     view_width    The maximum number of characters displayable in the region
+ *                 This equals region_width/font_width for the region
+ *     wrap_chars    Characters that allow wrapping. This equals [' ', '\t', '-']
+ * 
+ * def wrap(line, view_width, wrap_chars):
+ *     draw_start = 0
+ *     draw_end = view_width
+ *     pos = 0
+ *     for c in line:
+ *         if pos-draw_start >= view_width:
+ *             print line[draw_start:draw_end]
+ *             draw_start = draw_end
+ *             draw_end += view_width
+ *         elif c in wrap_chars:
+ *             draw_end = pos+1
+ *         pos += 1
+ *     print line[draw_start:]
+ * 
+ */
 
 int wrap_width(SpaceText *st, ARegion *ar)
 {
@@ -961,8 +959,8 @@ void text_drawcache_tag_update(SpaceText *st, int full)
 			}
 
 			/* quick cache recalculation is also used in delete operator,
-			   which could merge lines which are adjusent to current selection lines
-			   expand recalculate area to this lines */
+			 * which could merge lines which are adjusent to current selection lines
+			 * expand recalculate area to this lines */
 			if(drawcache->valid_head>0) drawcache->valid_head--;
 			if(drawcache->valid_tail>0) drawcache->valid_tail--;
 		} else {
@@ -1856,7 +1854,7 @@ void text_update_character_width(SpaceText *st)
 }
 
 /* Moves the view to the cursor location,
-  also used to make sure the view isnt outside the file */
+ * also used to make sure the view isnt outside the file */
 void text_scroll_to_cursor(SpaceText *st, ScrArea *sa)
 {
 	Text *text;
diff --git a/source/blender/editors/space_text/text_ops.c b/source/blender/editors/space_text/text_ops.c
index a44d5909a4f..1975e4ca633 100644
--- a/source/blender/editors/space_text/text_ops.c
+++ b/source/blender/editors/space_text/text_ops.c
@@ -1775,10 +1775,10 @@ static void txt_wrap_move_down(SpaceText *st, ARegion *ar, short sel)
 }
 
 /* Moves the cursor vertically by the specified number of lines.
- If the destination line is shorter than the current cursor position, the
- cursor will be positioned at the end of this line.
-
- This is to replace screen_skip for PageUp/Down operations.
+ * If the destination line is shorter than the current cursor position, the
+ * cursor will be positioned at the end of this line.
+ *
+ * This is to replace screen_skip for PageUp/Down operations.
  */
 static void cursor_skip(SpaceText* st, ARegion *ar, Text *text, int lines, int sel)
 {
@@ -2243,9 +2243,9 @@ void TEXT_OT_scroll(wmOperatorType *ot)
 {
 	/* identifiers */
 	ot->name= "Scroll";
-	/*don't really see the difference between this and
-	  scroll_bar. Both do basically the same thing (aside 
-	  from keymaps).*/
+	/* don't really see the difference between this and
+	 * scroll_bar. Both do basically the same thing (aside 
+	 * from keymaps).*/
 	ot->idname= "TEXT_OT_scroll";
 	ot->description= "Scroll text screen";
 	
@@ -2337,9 +2337,9 @@ void TEXT_OT_scroll_bar(wmOperatorType *ot)
 {
 	/* identifiers */
 	ot->name= "Scrollbar";
-	/*don't really see the difference between this and
-	  scroll. Both do basically the same thing (aside 
-	  from keymaps).*/
+	/* don't really see the difference between this and
+	 * scroll. Both do basically the same thing (aside 
+	 * from keymaps).*/
 	ot->idname= "TEXT_OT_scroll_bar";
 	ot->description= "Scroll text screen";
 	
@@ -3103,9 +3103,9 @@ static EnumPropertyItem resolution_items[]= {
 	{0, NULL, 0, NULL, NULL}};
 
 /* returns 0 if file on disk is the same or Text is in memory only
-   returns 1 if file has been modified on disk since last local edit
-   returns 2 if file on disk has been deleted
-   -1 is returned if an error occurs */
+ * returns 1 if file has been modified on disk since last local edit
+ * returns 2 if file on disk has been deleted
+ * -1 is returned if an error occurs */
 
 int text_file_modified(Text *text)
 {
diff --git a/source/blender/editors/space_view3d/drawarmature.c b/source/blender/editors/space_view3d/drawarmature.c
index e611ae1b64c..dd3d0c05beb 100644
--- a/source/blender/editors/space_view3d/drawarmature.c
+++ b/source/blender/editors/space_view3d/drawarmature.c
@@ -1280,8 +1280,8 @@ static void draw_wire_bone(int dt, int armflag, int boneflag, short constflag, u
 static void draw_bone(int dt, int armflag, int boneflag, short constflag, unsigned int id, float length)
 {
 	
-	/*	Draw a 3d octahedral bone, we use normalized space based on length,
-		for glDisplayLists */
+	/* Draw a 3d octahedral bone, we use normalized space based on length,
+	 * for glDisplayLists */
 	
 	glScalef(length, length, length);
 
diff --git a/source/blender/editors/space_view3d/drawmesh.c b/source/blender/editors/space_view3d/drawmesh.c
index e368d8c10b7..f41846f3378 100644
--- a/source/blender/editors/space_view3d/drawmesh.c
+++ b/source/blender/editors/space_view3d/drawmesh.c
@@ -835,9 +835,9 @@ typedef struct TexMatCallback {
 static void tex_mat_set_material_cb(void *UNUSED(userData), int mat_nr, void *attribs)
 {
 	/* all we have to do here is simply enable the GLSL material, but note
-	   that the GLSL code will give different result depending on the drawtype,
-	   in texture draw mode it will output the active texture node, in material
-	   draw mode it will show the full material. */
+	 * that the GLSL code will give different result depending on the drawtype,
+	 * in texture draw mode it will output the active texture node, in material
+	 * draw mode it will show the full material. */
 	GPU_enable_material(mat_nr, attribs);
 }
 
diff --git a/source/blender/editors/space_view3d/drawobject.c b/source/blender/editors/space_view3d/drawobject.c
index ecccb673c57..2ab8ec8aa99 100644
--- a/source/blender/editors/space_view3d/drawobject.c
+++ b/source/blender/editors/space_view3d/drawobject.c
@@ -1057,7 +1057,7 @@ static void spotvolume(float lvec[3], float vvec[3], const float inp)
 		plane[1]= 1.0f;
 
 	/* now we've got two equations: one of a cone and one of a plane, but we have
-	three unknowns. We remove one unkown by rotating the plane to z=0 (the plane normal) */
+	 * three unknowns. We remove one unkown by rotating the plane to z=0 (the plane normal) */
 
 	/* rotate around cross product vector of (0,0,1) and plane normal, dot product degrees */
 	/* according definition, we derive cross product is (plane[1],-plane[0],0), en cos = plane[2]);*/
@@ -1339,8 +1339,8 @@ static void drawlamp(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base,
 		if (la->type==LA_SPOT) {
 			float spotblcirc = fabs(z)*(1 - pow(la->spotblend, 2));
 			/* hide line if it is zero size or overlaps with outer border,
-			   previously it adjusted to always to show it but that seems
-			   confusing because it doesn't show the actual blend size */
+			 * previously it adjusted to always to show it but that seems
+			 * confusing because it doesn't show the actual blend size */
 			if (spotblcirc != 0 && spotblcirc != fabsf(z))
 				circ(0.0, 0.0, spotblcirc);
 		}
@@ -1543,8 +1543,8 @@ static void draw_viewport_object_reconstruction(Scene *scene, Base *base, View3D
 
 	if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
 		/* current ogl matrix is translated in camera space, bundles should
-		   be rendered in world space, so camera matrix should be "removed"
-		   from current ogl matrix */
+		 * be rendered in world space, so camera matrix should be "removed"
+		 * from current ogl matrix */
 		invert_m4_m4(imat, base->object->obmat);
 
 		glMultMatrixf(imat);
@@ -2819,7 +2819,7 @@ static void draw_em_measure_stats(View3D *v3d, Object *ob, BMEditMesh *em, UnitS
 
 	if (me->drawflag & ME_DRAWEXTRA_FACEAREA) {
 		/* would be nice to use BM_face_area_calc, but that is for 2d faces
-		so instead add up tessalation triangle areas */
+		 * so instead add up tessalation triangle areas */
 		BMFace *f;
 		int n;
 
@@ -2996,10 +2996,13 @@ static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d,
 	if (em->bm->selected.last) {
 		BMEditSelection *ese= em->bm->selected.last;
 		/* face is handeled above */
-		/*if (ese->type == BM_FACE ) {
+#if 0
+		if (ese->type == BM_FACE ) {
 			efa_act = (BMFace *)ese->data;
 		}
-		else */ if ( ese->htype == BM_EDGE ) {
+		else 
+#endif
+		if ( ese->htype == BM_EDGE ) {
 			eed_act = (BMEdge *)ese->ele;
 		}
 		else if ( ese->htype == BM_VERT ) {
@@ -3170,7 +3173,7 @@ static void draw_mesh_object_outline(View3D *v3d, Object *ob, DerivedMesh *dm)
 		glDepthMask(0);
 		
 		/* if transparent, we cannot draw the edges for solid select... edges have no material info.
-		   drawFacesSolid() doesn't draw the transparent faces */
+		 * drawFacesSolid() doesn't draw the transparent faces */
 		if (ob->dtx & OB_DRAWTRANSP) {
 			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
 			dm->drawFacesSolid(dm, NULL, 0, GPU_enable_material);
@@ -4597,13 +4600,15 @@ static void draw_new_particle_system(Scene *scene, View3D *v3d, RegionView3D *rv
 			glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
 			glEnable(GL_COLOR_MATERIAL);
 		}
-		/*else {
+#if 0
+		else {
 			glDisableClientState(GL_NORMAL_ARRAY);
 
 			glDisable(GL_COLOR_MATERIAL);
 			glDisable(GL_LIGHTING);
 			UI_ThemeColor(TH_WIRE);
-		}*/
+		}
+#endif
 
 		if (totchild && (part->draw&PART_DRAW_PARENT)==0)
 			totpart=0;
@@ -5479,8 +5484,8 @@ static void drawnurb(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base,
 	
 	if (v3d->zbuf) glEnable(GL_DEPTH_TEST);
 
-	/*	direction vectors for 3d curve paths
-		when at its lowest, dont render normals */
+	/* direction vectors for 3d curve paths
+	 * when at its lowest, dont render normals */
 	if (cu->flag & CU_3D && ts->normalsize > 0.0015f && (cu->drawflag & CU_HIDE_NORMALS)==0) {
 
 		UI_ThemeColor(TH_WIRE);
@@ -6766,7 +6771,8 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag)
 		// draw collision objects
 		if ((smd->type & MOD_SMOKE_TYPE_COLL) && smd->coll)
 		{
-			/*SmokeCollSettings *scs = smd->coll;
+#if 0
+			SmokeCollSettings *scs = smd->coll;
 			if (scs->points)
 			{
 				size_t i;
@@ -6795,7 +6801,7 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag)
 				if (col) cpack(col);
 				
 			}
-			*/
+#endif
 		}
 
 		// only draw domains
@@ -7014,8 +7020,8 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag)
 				
 				if (ELEM(cti->type, CONSTRAINT_TYPE_FOLLOWTRACK, CONSTRAINT_TYPE_OBJECTSOLVER)) {
 					/* special case for object solver and follow track constraints because they don't fill
-					   constraint targets properly (design limitation -- scene is needed for their target
-					   but it can't be accessed from get_targets callvack) */
+					 * constraint targets properly (design limitation -- scene is needed for their target
+					 * but it can't be accessed from get_targets callvack) */
 
 					Object *camob= NULL;
 
diff --git a/source/blender/editors/space_view3d/drawvolume.c b/source/blender/editors/space_view3d/drawvolume.c
index 9618e5aeef0..b36ce6656b2 100644
--- a/source/blender/editors/space_view3d/drawvolume.c
+++ b/source/blender/editors/space_view3d/drawvolume.c
@@ -305,12 +305,12 @@ void draw_volume(ARegion *ar, GPUTexture *tex, float *min, float *max, int res[3
 	glEnable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-	/*
+#if 0
 	printf("Viewinv:\n");
 	printf("%f, %f, %f\n", rv3d->viewinv[0][0], rv3d->viewinv[0][1], rv3d->viewinv[0][2]);
 	printf("%f, %f, %f\n", rv3d->viewinv[1][0], rv3d->viewinv[1][1], rv3d->viewinv[1][2]);
 	printf("%f, %f, %f\n", rv3d->viewinv[2][0], rv3d->viewinv[2][1], rv3d->viewinv[2][2]);
-	*/
+#endif
 
 	// get view vector
 	copy_v3_v3(viewnormal, rv3d->viewinv[2]);
diff --git a/source/blender/editors/space_view3d/space_view3d.c b/source/blender/editors/space_view3d/space_view3d.c
index 996d782be4d..43d74a7d2cd 100644
--- a/source/blender/editors/space_view3d/space_view3d.c
+++ b/source/blender/editors/space_view3d/space_view3d.c
@@ -234,8 +234,8 @@ void ED_view3d_init_mats_rv3d_gl(struct Object *ob, struct RegionView3D *rv3d)
 	ED_view3d_init_mats_rv3d(ob, rv3d);
 
 	/* we have to multiply instead of loading viewmatob to make
-	   it work with duplis using displists, otherwise it will
-	   override the dupli-matrix */
+	 * it work with duplis using displists, otherwise it will
+	 * override the dupli-matrix */
 	glMultMatrixf(ob->obmat);
 }
 
diff --git a/source/blender/editors/space_view3d/view3d_buttons.c b/source/blender/editors/space_view3d/view3d_buttons.c
index 3e2979a7e88..9a588f698b9 100644
--- a/source/blender/editors/space_view3d/view3d_buttons.c
+++ b/source/blender/editors/space_view3d/view3d_buttons.c
@@ -1310,7 +1310,7 @@ static void view3d_panel_object(const bContext *C, Panel *pa)
 	if (ob==NULL) return;
 
 	/* make sure we got storage */
-	/*
+#if 0
 	if (v3d->properties_storage==NULL)
 		v3d->properties_storage= MEM_callocN(sizeof(TransformProperties), "TransformProperties");
 	tfp= v3d->properties_storage;
@@ -1324,7 +1324,7 @@ static void view3d_panel_object(const bContext *C, Panel *pa)
 			uiBlockEndAlign(block);
 		}
 	}
-	*/
+#endif
 
 	lim= 10000.0f * MAX2(1.0f, v3d->grid);
 
diff --git a/source/blender/editors/space_view3d/view3d_draw.c b/source/blender/editors/space_view3d/view3d_draw.c
index fc5ef42b462..f1efdd1e165 100644
--- a/source/blender/editors/space_view3d/view3d_draw.c
+++ b/source/blender/editors/space_view3d/view3d_draw.c
@@ -841,8 +841,8 @@ static void draw_viewport_name(ARegion *ar, View3D *v3d)
 }
 
 /* draw info beside axes in bottom left-corner: 
-* 	framenum, object name, bone name (if available), marker name (if available)
-*/
+ * framenum, object name, bone name (if available), marker name (if available)
+ */
 static void draw_selected_name(Scene *scene, Object *ob)
 {
 	char info[256], *markern;
@@ -1225,7 +1225,7 @@ static void drawviewborder(Scene *scene, ARegion *ar, View3D *v3d)
 		}
 		if (ca && (ca->flag & CAM_SHOWSENSOR)) {
 			/* determine sensor fit, and get sensor x/y, for auto fit we
-			   assume and square sensor and only use sensor_x */
+			 * assume and square sensor and only use sensor_x */
 			float sizex= scene->r.xsch*scene->r.xasp;
 			float sizey= scene->r.ysch*scene->r.yasp;
 			int sensor_fit = camera_sensor_fit(ca->sensor_fit, sizex, sizey);
@@ -1562,8 +1562,8 @@ static void draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d)
 				ibuf= BKE_movieclip_get_ibuf(clip, &bgpic->cuser);
 
 				/* working with ibuf from image and clip has got different workflow now.
-				   ibuf acquired from clip is referenced by cache system and should
-				   be dereferenced after usage. */
+				 * ibuf acquired from clip is referenced by cache system and should
+				 * be dereferenced after usage. */
 				freeibuf= ibuf;
 			}
 
@@ -1764,9 +1764,9 @@ static void view3d_draw_xraytransp(Scene *scene, ARegion *ar, View3D *v3d, int c
 /* *********************** */
 
 /*
-	In most cases call draw_dupli_objects,
-	draw_dupli_objects_color was added because when drawing set dupli's
-	we need to force the color
+ * In most cases call draw_dupli_objects,
+ * draw_dupli_objects_color was added because when drawing set dupli's
+ * we need to force the color
  */
 
 #if 0
@@ -1895,7 +1895,7 @@ static void draw_dupli_objects_color(Scene *scene, ARegion *ar, View3D *v3d, Bas
 static void draw_dupli_objects(Scene *scene, ARegion *ar, View3D *v3d, Base *base)
 {
 	/* define the color here so draw_dupli_objects_color can be called
-	* from the set loop */
+	 * from the set loop */
 	
 	int color= (base->flag & SELECT)?TH_SELECT:TH_WIRE;
 	/* debug */
@@ -2753,9 +2753,11 @@ static void view3d_main_area_draw_objects(const bContext *C, ARegion *ar, const
 		v3d->zbuf= FALSE;
 
 	/* enables anti-aliasing for 3D view drawing */
-	/*if (!(U.gameflags & USER_DISABLE_AA))
-		glEnable(GL_MULTISAMPLE_ARB);*/
-	
+#if 0
+	if (!(U.gameflags & USER_DISABLE_AA))
+		glEnable(GL_MULTISAMPLE_ARB);
+#endif
+
 	// needs to be done always, gridview is adjusted in drawgrid() now
 	rv3d->gridview= v3d->grid;
 
@@ -2868,10 +2870,12 @@ static void view3d_main_area_draw_objects(const bContext *C, ARegion *ar, const
 		ED_view3d_clipping_disable();
 	
 	BIF_draw_manipulator(C);
-	
+
+#if 0
 	/* Disable back anti-aliasing */
-	/*if (!(U.gameflags & USER_DISABLE_AA))
-		glDisable(GL_MULTISAMPLE_ARB);*/
+	if (!(U.gameflags & USER_DISABLE_AA))
+		glDisable(GL_MULTISAMPLE_ARB);
+#endif
 
 	if (v3d->zbuf) {
 		v3d->zbuf= FALSE;
diff --git a/source/blender/editors/space_view3d/view3d_edit.c b/source/blender/editors/space_view3d/view3d_edit.c
index c8d577a315e..f3945d1680c 100644
--- a/source/blender/editors/space_view3d/view3d_edit.c
+++ b/source/blender/editors/space_view3d/view3d_edit.c
@@ -610,11 +610,12 @@ void viewrotate_modal_keymap(wmKeyConfig *keyconf)
 	WM_modalkeymap_add_item(keymap, LEFTALTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_AXIS_SNAP_ENABLE);
 	WM_modalkeymap_add_item(keymap, LEFTALTKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_AXIS_SNAP_DISABLE);
 
-	/* disabled mode switching for now, can re-implement better, later on
+	/* disabled mode switching for now, can re-implement better, later on */
+#if 0
 	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
 	WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
 	WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
-	*/
+#endif
 	
 	/* assign map to operators */
 	WM_modalkeymap_assign(keymap, "VIEW3D_OT_rotate");
@@ -640,8 +641,7 @@ static void viewrotate_apply(ViewOpsData *vod, int x, int y)
 		cross_v3_v3v3(q1+1, vod->trackvec, newvec);
 		normalize_v3(q1+1);
 
-		/* Allow for rotation beyond the interval
-			* [-pi, pi] */
+		/* Allow for rotation beyond the interval [-pi, pi] */
 		while (si > 1.0f)
 			si -= 2.0f;
 
@@ -1254,11 +1254,12 @@ void viewmove_modal_keymap(wmKeyConfig *keyconf)
 	WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 	WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 
-	/* disabled mode switching for now, can re-implement better, later on
+	/* disabled mode switching for now, can re-implement better, later on */
+#if 0
 	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
 	WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
 	WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
-	*/
+#endif
 	
 	/* assign map to operators */
 	WM_modalkeymap_assign(keymap, "VIEW3D_OT_move");
@@ -1414,11 +1415,12 @@ void viewzoom_modal_keymap(wmKeyConfig *keyconf)
 	WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 	WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 
-	/* disabled mode switching for now, can re-implement better, later on
+	/* disabled mode switching for now, can re-implement better, later on */
+#if 0
 	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
 	WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
 	WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
-	 */
+#endif
 	
 	/* assign map to operators */
 	WM_modalkeymap_assign(keymap, "VIEW3D_OT_zoom");
@@ -1666,11 +1668,12 @@ void viewdolly_modal_keymap(wmKeyConfig *keyconf)
 	WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 	WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 
-	/* disabled mode switching for now, can re-implement better, later on
+	/* disabled mode switching for now, can re-implement better, later on */
+#if 0
 	WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
 	WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
 	WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
-	 */
+#endif
 	
 	/* assign map to operators */
 	WM_modalkeymap_assign(keymap, "VIEW3D_OT_dolly");
diff --git a/source/blender/editors/space_view3d/view3d_fly.c b/source/blender/editors/space_view3d/view3d_fly.c
index c8c62d63e36..0ae2ae0a9d1 100644
--- a/source/blender/editors/space_view3d/view3d_fly.c
+++ b/source/blender/editors/space_view3d/view3d_fly.c
@@ -183,10 +183,10 @@ typedef struct FlyInfo {
 	short pan_view; /* when true, pan the view instead of rotating */
 
 	/* relative view axis locking - xlock, zlock
-	0; disabled
-	1; enabled but not checking because mouse hasnt moved outside the margin since locking was checked an not needed
-	   when the mouse moves, locking is set to 2 so checks are done.
-	2; mouse moved and checking needed, if no view altering is donem its changed back to 1 */
+	 * 0) disabled
+	 * 1) enabled but not checking because mouse hasnt moved outside the margin since locking was checked an not needed
+	 *    when the mouse moves, locking is set to 2 so checks are done.
+	 * 2) mouse moved and checking needed, if no view altering is donem its changed back to 1 */
 	short xlock, zlock;
 	float xlock_momentum, zlock_momentum; /* nicer dynamics */
 	float grid; /* world scale 1.0 default */
@@ -202,8 +202,8 @@ typedef struct FlyInfo {
 	short persp_backup; /* remember if were ortho or not, only used for restoring the view if it was a ortho view */
 
 	short is_ortho_cam; /* are we flying an ortho camera in perspective view,
-						 * which was originall in ortho view?
-						 * could probably figure it out but better be explicit */
+	                     * which was originall in ortho view?
+	                     * could probably figure it out but better be explicit */
 
 	void *obtfm; /* backup the objects transform */
 
@@ -223,7 +223,7 @@ static void drawFlyPixel(const struct bContext *UNUSED(C), struct ARegion *UNUSE
 	FlyInfo *fly = arg;
 
 	/* draws 4 edge brackets that frame the safe area where the
-	mouse can move during fly mode without spinning the view */
+	 * mouse can move during fly mode without spinning the view */
 	float x1, x2, y1, y2;
 	
 	x1= 0.45f * (float)fly->ar->winx;
@@ -377,11 +377,11 @@ static int initFlyInfo (bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *even
 		copy_v3_v3(fly->ofs_backup, fly->rv3d->ofs);
 
 		/* the dist defines a vector that is infront of the offset
-		to rotate the view about.
-		this is no good for fly mode because we
-		want to rotate about the viewers center.
-		but to correct the dist removal we must
-		alter offset so the view doesn't jump. */
+		 * to rotate the view about.
+		 * this is no good for fly mode because we
+		 * want to rotate about the viewers center.
+		 * but to correct the dist removal we must
+		 * alter offset so the view doesn't jump. */
 
 		fly->rv3d->dist= 0.0f;
 
@@ -720,10 +720,9 @@ static int flyApply(bContext *C, FlyInfo *fly)
 #define FLY_ZUP_CORRECT_FAC 0.1f /* amount to correct per step */
 #define FLY_ZUP_CORRECT_ACCEL 0.05f /* increase upright momentum each step */
 
-	/*
-	fly mode - Shift+F
-	a fly loop where the user can move move the view as if they are flying
-	*/
+	/* fly mode - Shift+F
+	 * a fly loop where the user can move move the view as if they are flying
+	 */
 	RegionView3D *rv3d= fly->rv3d;
 	ARegion *ar = fly->ar;
 
@@ -807,7 +806,7 @@ static int flyApply(bContext *C, FlyInfo *fly)
 			/*fprintf(stderr, "%f\n", time_redraw);*/ /* 0.002 is a small redraw 0.02 is larger */
 
 			/* Scale the time to use shift to scale the speed down- just like
-			shift slows many other areas of blender down */
+			 * shift slows many other areas of blender down */
 			if (fly->use_precision)
 				fly->speed= fly->speed * (1.0f-time_redraw_clamped);
 
@@ -829,7 +828,7 @@ static int flyApply(bContext *C, FlyInfo *fly)
 			}
 			else {
 				float roll; /* similar to the angle between the camera's up and the Z-up,
-				             * but its very rough so just roll*/
+				             * but its very rough so just roll */
 
 				/* rotate about the X axis- look up/down */
 				if (moffset[1]) {
@@ -988,8 +987,10 @@ static int flyApply_ndof(bContext *C, FlyInfo *fly)
 	RegionView3D* rv3d = fly->rv3d;
 	const int flag = U.ndof_flag;
 
-/*	int shouldRotate = (flag & NDOF_SHOULD_ROTATE) && (fly->pan_view == FALSE),
-	    shouldTranslate = (flag & (NDOF_SHOULD_PAN | NDOF_SHOULD_ZOOM)); */
+#if 0
+	int shouldRotate = (flag & NDOF_SHOULD_ROTATE) && (fly->pan_view == FALSE),
+	    shouldTranslate = (flag & (NDOF_SHOULD_PAN | NDOF_SHOULD_ZOOM));
+#endif
 
 	int shouldRotate = (fly->pan_view == FALSE),
 	    shouldTranslate = TRUE;
diff --git a/source/blender/editors/space_view3d/view3d_header.c b/source/blender/editors/space_view3d/view3d_header.c
index f80bd6c3807..b3ec1676bfb 100644
--- a/source/blender/editors/space_view3d/view3d_header.c
+++ b/source/blender/editors/space_view3d/view3d_header.c
@@ -131,7 +131,7 @@ static void handle_view3d_lock(bContext *C)
 			scene->camera= v3d->camera;
 
 			/* not through notifiery, listener don't have context
-			   and non-open screens or spaces need to be updated too */
+			 * and non-open screens or spaces need to be updated too */
 			BKE_screen_view3d_main_sync(&bmain->screen, scene);
 			
 			/* notifiers for scene update */
@@ -140,10 +140,11 @@ static void handle_view3d_lock(bContext *C)
 	}
 }
 
-/* layer code is on three levels actually:
-- here for operator
-- uiTemplateLayers in interface/ code for buttons
-- ED_view3d_scene_layer_set for RNA
+/**
+ * layer code is on three levels actually:
+ * - here for operator
+ * - uiTemplateLayers in interface/ code for buttons
+ * - ED_view3d_scene_layer_set for RNA
  */
 static void view3d_layers_editmode_ensure(Scene *scene, View3D *v3d)
 {
diff --git a/source/blender/editors/space_view3d/view3d_select.c b/source/blender/editors/space_view3d/view3d_select.c
index a5c7e21e3b4..15b1dde500b 100644
--- a/source/blender/editors/space_view3d/view3d_select.c
+++ b/source/blender/editors/space_view3d/view3d_select.c
@@ -394,8 +394,8 @@ int lasso_inside_edge(int mcords[][2], short moves, int x0, int y0, int x1, int
 
 
 /* warning; lasso select with backbuffer-check draws in backbuf with persp(PERSP_WIN) 
-   and returns with persp(PERSP_VIEW). After lasso select backbuf is not OK
-*/
+ * and returns with persp(PERSP_VIEW). After lasso select backbuf is not OK
+ */
 static void do_lasso_select_pose(ViewContext *vc, Object *ob, int mcords[][2], short moves, short select)
 {
 	bPoseChannel *pchan;
@@ -962,7 +962,7 @@ static void view3d_lasso_select(bContext *C, ViewContext *vc, int mcords[][2], s
 
 
 /* lasso operator gives properties, but since old code works
-   with short array we convert */
+ * with short array we convert */
 static int view3d_lasso_select_exec(bContext *C, wmOperator *op)
 {
 	ViewContext vc;
@@ -1377,7 +1377,7 @@ static Base *mouse_select_eval_buffer(ViewContext *vc, unsigned int *buffer, int
 		base= startbase;
 		while (base) {
 			/* skip objects with select restriction, to prevent prematurely ending this loop
-			* with an un-selectable choice */
+			 * with an un-selectable choice */
 			if (base->object->restrictflag & OB_RESTRICT_SELECT) {
 				base=base->next;
 				if (base==NULL) base= FIRSTBASE;
@@ -1534,13 +1534,13 @@ static int mouse_select(bContext *C, const int mval[2], short extend, short obce
 							hitresult= buffer[3+(i*4)];
 
 							/* if there's bundles in buffer select bundles first,
-							   so non-camera elements should be ignored in buffer */
+							 * so non-camera elements should be ignored in buffer */
 							if (basact->selcol != (hitresult & 0xFFFF)) {
 								continue;
 							}
 
 							/* index of bundle is 1<<16-based. if there's no "bone" index
-							   in hight word, this buffer value belongs to camera,. not to bundle */
+							 * in hight word, this buffer value belongs to camera,. not to bundle */
 							if (buffer[4*i+3] & 0xFFFF0000) {
 								MovieClip *clip= object_get_movieclip(scene, basact->object, 0);
 								MovieTracking *tracking= &clip->tracking;
@@ -1578,7 +1578,7 @@ static int mouse_select(bContext *C, const int mval[2], short extend, short obce
 
 						if (!changed) {
 							/* fallback to regular object selection if no new bundles were selected,
-							   allows to select object parented to reconstruction object */
+							 * allows to select object parented to reconstruction object */
 							basact= mouse_select_eval_buffer(&vc, buffer, hits, mval, startbase, 0);
 						}
 					}
@@ -1586,7 +1586,7 @@ static int mouse_select(bContext *C, const int mval[2], short extend, short obce
 				else if (ED_do_pose_selectbuffer(scene, basact, buffer, hits, extend) ) {	/* then bone is found */
 				
 					/* we make the armature selected: 
-					   not-selected active object in posemode won't work well for tools */
+					 * not-selected active object in posemode won't work well for tools */
 					basact->flag|= SELECT;
 					basact->object->flag= basact->flag;
 					
@@ -1984,16 +1984,16 @@ static int do_object_pose_box_select(bContext *C, ViewContext *vc, rcti *rect, i
 	vbuffer = MEM_mallocN(4 * (totobj+MAXPICKBUF) * sizeof(unsigned int), "selection buffer");
 	hits= view3d_opengl_select(vc, vbuffer, 4*(totobj+MAXPICKBUF), rect);
 	/*
-	LOGIC NOTES (theeth):
-	The buffer and ListBase have the same relative order, which makes the selection
-	very simple. Loop through both data sets at the same time, if the color
-	is the same as the object, we have a hit and can move to the next color
-	and object pair, if not, just move to the next object,
-	keeping the same color until we have a hit.
-
-	The buffer order is defined by OGL standard, hopefully no stupid GFX card
-	does it incorrectly.
-	*/
+	 * LOGIC NOTES (theeth):
+	 * The buffer and ListBase have the same relative order, which makes the selection
+	 * very simple. Loop through both data sets at the same time, if the color
+	 * is the same as the object, we have a hit and can move to the next color
+	 * and object pair, if not, just move to the next object,
+	 * keeping the same color until we have a hit.
+	 * 
+	 * The buffer order is defined by OGL standard, hopefully no stupid GFX card
+	 * does it incorrectly.
+	 */
 
 	if (hits>0) { /* no need to loop if there's no hit */
 		Base *base;
@@ -2167,7 +2167,7 @@ static int vertsel_vert_pick(struct bContext *C, Mesh *me, const int mval[2], un
 
 	if (size > 0) {
 		/* sample rect to increase changes of selecting, so that when clicking
-		   on an face in the backbuf, we can still select a vert */
+		 * on an face in the backbuf, we can still select a vert */
 
 		int dist;
 		*index = view3d_sample_backbuf_rect(&vc, mval, size, 1, me->totvert+1, &dist,0,NULL, NULL);
diff --git a/source/blender/editors/space_view3d/view3d_view.c b/source/blender/editors/space_view3d/view3d_view.c
index 847bd2e0b24..359bb8967eb 100644
--- a/source/blender/editors/space_view3d/view3d_view.c
+++ b/source/blender/editors/space_view3d/view3d_view.c
@@ -74,8 +74,8 @@
 #include "view3d_intern.h"	// own include
 
 /* use this call when executing an operator,
-   event system doesn't set for each event the
-   opengl drawing context */
+ * event system doesn't set for each event the
+ * opengl drawing context */
 void view3d_operator_needs_opengl(const bContext *C)
 {
 	wmWindow *win = CTX_wm_window(C);
@@ -179,7 +179,7 @@ void smooth_view(bContext *C, View3D *v3d, ARegion *ar, Object *oldcamera, Objec
 			changed = 1;
 		
 		/* The new view is different from the old one
-			* so animate the view */
+		 * so animate the view */
 		if (changed) {
 
 			/* original values */
@@ -203,9 +203,9 @@ void smooth_view(bContext *C, View3D *v3d, ARegion *ar, Object *oldcamera, Objec
 			sms.time_allowed= (double)U.smooth_viewtx / 1000.0;
 			
 			/* if this is view rotation only
-				* we can decrease the time allowed by
-				* the angle between quats 
-				* this means small rotations wont lag */
+			 * we can decrease the time allowed by
+			 * the angle between quats 
+			 * this means small rotations wont lag */
 			if (quat && !ofs && !dist) {
 				float vec1[3]={0,0,1}, vec2[3]= {0,0,1};
 				float q1[4], q2[4];
@@ -531,7 +531,7 @@ void ED_view3d_calc_clipping(BoundBox *bb, float planes[4][4], bglMats *mats, co
 	int val, flip_sign, a;
 
 	/* near zero floating point values can give issues with gluUnProject
-		in side view on some implementations */
+	 * in side view on some implementations */
 	if (fabs(mats->modelview[0]) < 1e-6) mats->modelview[0]= 0.0;
 	if (fabs(mats->modelview[5]) < 1e-6) mats->modelview[5]= 0.0;
 
@@ -553,8 +553,8 @@ void ED_view3d_calc_clipping(BoundBox *bb, float planes[4][4], bglMats *mats, co
 	}
 
 	/* verify if we have negative scale. doing the transform before cross
-	   product flips the sign of the vector compared to doing cross product
-	   before transform then, so we correct for that. */
+	 * product flips the sign of the vector compared to doing cross product
+	 * before transform then, so we correct for that. */
 	for (a=0; a<16; a++)
 		((float*)modelview)[a] = mats->modelview[a];
 	flip_sign = is_negative_m4(modelview);
@@ -649,15 +649,15 @@ int initgrabz(RegionView3D *rv3d, float x, float y, float z)
 	if (rv3d->zfac < 0.0f)
 		flip= TRUE;
 	/* if x,y,z is exactly the viewport offset, zfac is 0 and we don't want that 
-		* (accounting for near zero values)
-		* */
+	 * (accounting for near zero values)
+	 */
 	if (rv3d->zfac < 1.e-6f && rv3d->zfac > -1.e-6f) rv3d->zfac = 1.0f;
 	
 	/* Negative zfac means x, y, z was behind the camera (in perspective).
-		* This gives flipped directions, so revert back to ok default case.
-	*/
-	// NOTE: I've changed this to flip zfac to be positive again for now so that GPencil draws ok
-	// 	-- Aligorith, 2009Aug31
+	 * This gives flipped directions, so revert back to ok default case.
+	 */
+	/* NOTE: I've changed this to flip zfac to be positive again for now so that GPencil draws ok
+	 * Aligorith, 2009Aug31 */
 	//if (rv3d->zfac < 0.0f) rv3d->zfac = 1.0f;
 	if (rv3d->zfac < 0.0f) rv3d->zfac= -rv3d->zfac;
 	
@@ -757,7 +757,7 @@ void ED_view3d_ob_project_mat_get(RegionView3D *rv3d, Object *ob, float pmat[4][
 }
 
 /* Uses window coordinates (x,y) and depth component z to find a point in
-   modelspace */
+ * modelspace */
 void view3d_unproject(bglMats *mats, float out[3], const short x, const short y, const float z)
 {
 	double ux, uy, uz;
@@ -1192,11 +1192,11 @@ void setviewmatrixview3d(Scene *scene, View3D *v3d, RegionView3D *rv3d)
 	}
 }
 
-/* IGLuint-> GLuint*/
+/* IGLuint-> GLuint */
 /* Warning: be sure to account for a negative return value
-*   This is an error, "Too many objects in select buffer"
-*   and no action should be taken (can crash blender) if this happens
-*/
+ *   This is an error, "Too many objects in select buffer"
+ *   and no action should be taken (can crash blender) if this happens
+ */
 short view3d_opengl_select(ViewContext *vc, unsigned int *buffer, unsigned int bufsize, rcti *input)
 {
 	Scene *scene= vc->scene;
@@ -1683,9 +1683,9 @@ static void game_set_commmandline_options(GameData *gm)
 static int game_engine_poll(bContext *C)
 {
 	/* we need a context and area to launch BGE
-	it's a temporary solution to avoid crash at load time
-	if we try to auto run the BGE. Ideally we want the
-	context to be set as soon as we load the file. */
+	 * it's a temporary solution to avoid crash at load time
+	 * if we try to auto run the BGE. Ideally we want the
+	 * context to be set as soon as we load the file. */
 
 	if (CTX_wm_window(C)==NULL) return 0;
 	if (CTX_wm_screen(C)==NULL) return 0;
@@ -1743,7 +1743,7 @@ static int game_engine_exec(bContext *C, wmOperator *op)
 		return OPERATOR_CANCELLED;
 	
 	/* redraw to hide any menus/popups, we don't go back to
-	   the window manager until after this operator exits */
+	 * the window manager until after this operator exits */
 	WM_redraw_windows(C);
 
 	rv3d= CTX_wm_region_view3d(C);
@@ -1789,7 +1789,7 @@ static int game_engine_exec(bContext *C, wmOperator *op)
 
 	if (prevwin) {
 		/* restore context, in case it changed in the meantime, for
-		   example by working in another window or closing it */
+		 * example by working in another window or closing it */
 		CTX_wm_region_set(C, prevar);
 		CTX_wm_window_set(C, prevwin);
 		CTX_wm_area_set(C, prevsa);
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index f41d826f930..ad6a73e51e1 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -2076,8 +2076,8 @@ static void constraintob_from_transdata(bConstraintOb *cob, TransData *td)
 		if (td->ext->rotOrder == ROT_MODE_QUAT) {
 			/* quats */
 			/* objects and bones do normalization first too, otherwise
-			   we don't necessarily end up with a rotation matrix, and
-			   then conversion back to quat gives a different result */
+			 * we don't necessarily end up with a rotation matrix, and
+			 * then conversion back to quat gives a different result */
 			float quat[4];
 			normalize_qt_qt(quat, td->ext->quat);
 			quat_to_mat4(cob->matrix, quat);
@@ -3740,7 +3740,7 @@ int CurveShrinkFatten(TransInfo *t, const int UNUSED(mval[2]))
 			continue;
 
 		if(td->val) {
-			//*td->val= ratio;
+			// *td->val= ratio;
 			*td->val= td->ival*ratio;
 			if (*td->val <= 0.0f) *td->val = 0.001f;
 		}
@@ -4396,8 +4396,8 @@ static int createSlideVerts(TransInfo *t)
 			numsel = 0;
 			BM_ITER(e, &iter2, em->bm, BM_EDGES_OF_VERT, v) {
 				if (BM_elem_flag_test(e, BM_ELEM_SELECT)) {
-					/*BMESH_TODO: this is probably very evil,
-					  set v->e to a selected edge*/
+					/* BMESH_TODO: this is probably very evil,
+					 * set v->e to a selected edge*/
 					v->e = e;
 
 					numsel++;
@@ -4560,8 +4560,8 @@ static int createSlideVerts(TransInfo *t)
 			BMEdge *e2;
 			float vec1[3], dis2, mval[2] = {t->mval[0], t->mval[1]}, d;
 						
-			/*search cross edges for visible edge to the mouse cursor,
-              then use the shared vertex to calculate screen vector*/
+			/* search cross edges for visible edge to the mouse cursor,
+             * then use the shared vertex to calculate screen vector*/
 			dis2 = -1.0f;
 			for (i=0; i<2; i++) {
 				v = i?e->v1:e->v2;
@@ -4692,8 +4692,8 @@ void projectSVData(TransInfo *t, int final)
 			BLI_smallhash_insert(&visit, (uintptr_t)f, NULL);
 			
 			/*the face attributes of the copied face will get
-			  copied over, so its necessary to save the selection
-			  and hidden state*/
+			 * copied over, so its necessary to save the selection
+			 * and hidden state*/
 			sel = BM_elem_flag_test(f, BM_ELEM_SELECT);
 			hide = BM_elem_flag_test(f, BM_ELEM_HIDDEN);
 			
diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index 07c90f95840..9010ce0c18e 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -103,20 +103,20 @@ typedef struct TransCon {
 	float imtx[3][3];    /* Inverse Matrix of the Constraint space                                    */
 	float pmtx[3][3];    /* Projection Constraint Matrix (same as imtx with some axis == 0)           */
 	float center[3];     /* transformation center to define where to draw the view widget
-							ALWAYS in global space. Unlike the transformation center                  */
+	                      * ALWAYS in global space. Unlike the transformation center                  */
 	int   imval[2];	     /* initial mouse value for visual calculation                                */
-						 /* the one in TransInfo is not garanty to stay the same (Rotates change it)  */
+	                     /* the one in TransInfo is not garanty to stay the same (Rotates change it)  */
 	int   mode;          /* Mode flags of the Constraint                                              */
 	void  (*drawExtra)(struct TransInfo *);
-						 /* For constraints that needs to draw differently from the other
-							uses this instead of the generic draw function							  */
+	                     /* For constraints that needs to draw differently from the other
+	                      * uses this instead of the generic draw function                            */
 	void  (*applyVec)(struct TransInfo *, struct TransData *, float *, float *, float *);
-						 /* Apply function pointer for linear vectorial transformation                */
-						 /* The last three parameters are pointers to the in/out/printable vectors    */
+	                     /* Apply function pointer for linear vectorial transformation                */
+	                     /* The last three parameters are pointers to the in/out/printable vectors    */
 	void  (*applySize)(struct TransInfo *, struct TransData *, float [3][3]);
-						 /* Apply function pointer for size transformation */
+	                     /* Apply function pointer for size transformation */
 	void  (*applyRot)(struct TransInfo *, struct TransData *, float [3], float *);
-						 /* Apply function pointer for rotation transformation */
+	                     /* Apply function pointer for rotation transformation */
 } TransCon;
 
 typedef struct TransDataExtension {
@@ -129,10 +129,10 @@ typedef struct TransDataExtension {
 	float  irot[3];      /* Initial rotation                                                               */
 	float *quat;         /* Rotation quaternion of the data to transform (Faculative)                      */
 	float  iquat[4];	 /* Initial rotation quaternion                                                    */
-	float *rotAngle;	 /* Rotation angle of the data to transform (Faculative) 						 */
-	float  irotAngle;	 /* Initial rotation angle 												 */
-	float *rotAxis;		 /* Rotation axis of the data to transform (Faculative) 						 */
-	float  irotAxis[4];	 /* Initial rotation axis 													 */
+	float *rotAngle;	 /* Rotation angle of the data to transform (Faculative)                           */
+	float  irotAngle;	 /* Initial rotation angle                                                         */
+	float *rotAxis;		 /* Rotation axis of the data to transform (Faculative)                            */
+	float  irotAxis[4];	 /* Initial rotation axis                                                          */
 	float *size;         /* Size of the data to transform (Faculative)                                     */
 	float  isize[3];	 /* Initial size                                                                   */
 	float  obmat[4][4];	 /* Object matrix */
diff --git a/source/blender/editors/transform/transform_constraints.c b/source/blender/editors/transform/transform_constraints.c
index bd34477c13f..db5ec297cc1 100644
--- a/source/blender/editors/transform/transform_constraints.c
+++ b/source/blender/editors/transform/transform_constraints.c
@@ -231,8 +231,8 @@ static void axisProjection(TransInfo *t, float axis[3], float in[3], float out[3
 	angle = RAD2DEGF(angle);
 
 	/* For when view is parallel to constraint... will cause NaNs otherwise
-	   So we take vertical motion in 3D space and apply it to the
-	   constraint axis. Nice for camera grab + MMB */
+	 * So we take vertical motion in 3D space and apply it to the
+	 * constraint axis. Nice for camera grab + MMB */
 	if(angle < 5.0f) {
 		project_v3_v3v3(vec, in, t->viewinv[1]);
 		factor = dot_v3v3(t->viewinv[1], vec) * 2.0f;
@@ -597,11 +597,11 @@ void setLocalConstraint(TransInfo *t, int mode, const char text[])
 }
 
 /*
-	Set the constraint according to the user defined orientation
-
-	ftext is a format string passed to BLI_snprintf. It will add the name of
-	the orientation where %s is (logically).
-*/
+ * Set the constraint according to the user defined orientation
+ *
+ * ftext is a format string passed to BLI_snprintf. It will add the name of
+ * the orientation where %s is (logically).
+ */
 void setUserConstraint(TransInfo *t, short orientation, int mode, const char ftext[])
 {
 	char text[40];
@@ -757,10 +757,10 @@ static void drawObjectConstraint(TransInfo *t)
 	TransData * td = t->data;
 
 	/* Draw the first one lighter because that's the one who controls the others.
-	   Meaning the transformation is projected on that one and just copied on the others
-	   constraint space.
-	   In a nutshell, the object with light axis is controlled by the user and the others follow.
-	   Without drawing the first light, users have little clue what they are doing.
+	 * Meaning the transformation is projected on that one and just copied on the others
+	 * constraint space.
+	 * In a nutshell, the object with light axis is controlled by the user and the others follow.
+	 * Without drawing the first light, users have little clue what they are doing.
 	 */
 	if (t->con.mode & CON_AXIS0) {
 		drawLine(t, td->ob->obmat[3], td->axismtx[0], 'X', DRAWLIGHT);
@@ -896,12 +896,12 @@ static void setNearestAxis3d(TransInfo *t)
 	mvec[2] = 0.0f;
 
 	/* we need to correct axis length for the current zoomlevel of view,
-	   this to prevent projected values to be clipped behind the camera
-	   and to overflow the short integers.
-	   The formula used is a bit stupid, just a simplification of the substraction
-	   of two 2D points 30 pixels apart (that's the last factor in the formula) after
-	   projecting them with window_to_3d_delta and then get the length of that vector.
-	*/
+	 * this to prevent projected values to be clipped behind the camera
+	 * and to overflow the short integers.
+	 * The formula used is a bit stupid, just a simplification of the substraction
+	 * of two 2D points 30 pixels apart (that's the last factor in the formula) after
+	 * projecting them with window_to_3d_delta and then get the length of that vector.
+	 */
 	zfac= t->persmat[0][3]*t->center[0]+ t->persmat[1][3]*t->center[1]+ t->persmat[2][3]*t->center[2]+ t->persmat[3][3];
 	zfac = len_v3(t->persinv[0]) * 2.0f/t->ar->winx * zfac * 30.0f;
 
@@ -1041,10 +1041,10 @@ int getConstraintSpaceDimension(TransInfo *t)
 
 	return n;
 /*
-  Someone willing to do it criptically could do the following instead:
-
-  return t->con & (CON_AXIS0|CON_AXIS1|CON_AXIS2);
-
-  Based on the assumptions that the axis flags are one after the other and start at 1
-*/
+ * Someone willing to do it criptically could do the following instead:
+ *
+ * return t->con & (CON_AXIS0|CON_AXIS1|CON_AXIS2);
+ *
+ * Based on the assumptions that the axis flags are one after the other and start at 1
+ */
 }
diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c
index d6097615ff6..9ed2b1953e5 100644
--- a/source/blender/editors/transform/transform_conversions.c
+++ b/source/blender/editors/transform/transform_conversions.c
@@ -213,7 +213,7 @@ static void sort_trans_data(TransInfo *t)
 }
 
 /* distance calculated from not-selected vertex to nearest selected vertex
-   warning; this is loops inside loop, has minor N^2 issues, but by sorting list it is OK */
+ * warning; this is loops inside loop, has minor N^2 issues, but by sorting list it is OK */
 static void set_prop_dist(TransInfo *t, short with_dist)
 {
 	TransData *tob;
@@ -393,8 +393,8 @@ static short apply_targetless_ik(Object *ob)
 	int segcount, apply= 0;
 
 	/* now we got a difficult situation... we have to find the
-	   target-less IK pchans, and apply transformation to the all
-	   pchans that were in the chain */
+	 * target-less IK pchans, and apply transformation to the all
+	 * pchans that were in the chain */
 
 	for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) {
 		data= has_targetless_ik(pchan);
@@ -1867,10 +1867,10 @@ void flushTransParticles(TransInfo *t)
 /* proportional distance based on connectivity  */
 #define THRESHOLDFACTOR (1.0f-0.0001f)
 
-/*I did this wrong, it should be a breadth-first search
-  but instead it's a depth-first search, fudged
-  to report shortest distances.  I have no idea how fast
-  or slow this is.*/
+/* I did this wrong, it should be a breadth-first search
+ * but instead it's a depth-first search, fudged
+ * to report shortest distances.  I have no idea how fast
+ * or slow this is. */
 static void editmesh_set_connectivity_distance(BMEditMesh *em, float mtx[][3], float *dists)
 {
 	BMVert **queue = NULL;
@@ -2140,12 +2140,12 @@ static void createTransEditVerts(bContext *C, TransInfo *t)
 	if(modifiers_getCageIndex(t->scene, t->obedit, NULL, 1)>=0) {
 		if(modifiers_isCorrectableDeformed(t->obedit)) {
 			/* check if we can use deform matrices for modifier from the
-			   start up to stack, they are more accurate than quats */
+			 * start up to stack, they are more accurate than quats */
 			totleft= editbmesh_get_first_deform_matrices(t->scene, t->obedit, em, &defmats, &defcos);
 
 			/* if we still have more modifiers, also do crazyspace
-			   correction with quats, relative to the coordinates after
-			   the modifiers that support deform matrices (defcos) */
+			 * correction with quats, relative to the coordinates after
+			 * the modifiers that support deform matrices (defcos) */
 			if(totleft > 0) {
 				mappedcos= crazyspace_get_mapped_editverts(t->scene, t->obedit);
 				quats= MEM_mallocN( (t->total)*sizeof(float)*4, "crazy quats");
@@ -2404,9 +2404,9 @@ static void UVsToTransData(SpaceImage *sima, TransData *td, TransData2D *td2d, f
 	ED_space_image_uv_aspect(sima, &aspx, &aspy);
 
 	/* uv coords are scaled by aspects. this is needed for rotations and
-	   proportional editing to be consistent with the stretchted uv coords
-	   that are displayed. this also means that for display and numinput,
-	   and when the the uv coords are flushed, these are converted each time */
+	 * proportional editing to be consistent with the stretchted uv coords
+	 * that are displayed. this also means that for display and numinput,
+	 * and when the the uv coords are flushed, these are converted each time */
 	td2d->loc[0] = uv[0]*aspx;
 	td2d->loc[1] = uv[1]*aspy;
 	td2d->loc[2] = 0.0f;
@@ -2476,7 +2476,7 @@ static void createTransUVs(bContext *C, TransInfo *t)
 	t->total= (propmode)? count: countsel;
 	t->data= MEM_callocN(t->total*sizeof(TransData), "TransObData(UV Editing)");
 	/* for each 2d uv coord a 3d vector is allocated, so that they can be
-	   treated just as if they were 3d verts */
+	 * treated just as if they were 3d verts */
 	t->data2d= MEM_callocN(t->total*sizeof(TransData2D), "TransObData2D(UV Editing)");
 
 	if(sima->flag & SI_CLIP_UV)
@@ -3423,7 +3423,7 @@ static void createTransGraphEditData(bContext *C, TransInfo *t)
 
 				if (ELEM3(t->mode, TFM_TRANSLATION, TFM_TIME_TRANSLATE, TFM_TIME_SLIDE)) {
 					/* for 'normal' pivots - just include anything that is selected.
-					   this works a bit differently in translation modes */
+					 * this works a bit differently in translation modes */
 					if (sel2) count++;
 					else {
 						if (sel1) count++;
@@ -3683,7 +3683,7 @@ static void beztmap_to_data (TransInfo *t, FCurve *fcu, BeztMap *bezms, int totv
 	/* dynamically allocate an array of chars to mark whether an TransData's
 	 * pointers have been fixed already, so that we don't override ones that are
 	 * already done
-	  */
+	 */
 	adjusted= MEM_callocN(t->total, "beztmap_adjusted_map");
 	
 	/* for each beztmap item, find if it is used anywhere */
@@ -4459,8 +4459,8 @@ static void set_trans_object_base_flags(TransInfo *t)
 	View3D *v3d = t->view;
 
 	/*
-	 if Base selected and has parent selected:
-	 base->flag= BA_WAS_SEL
+	 * if Base selected and has parent selected:
+	 * base->flag= BA_WAS_SEL
 	 */
 	Base *base;
 
@@ -4938,7 +4938,7 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
 
 		if(t->scene->nodetree) {
 			/* tracks can be used for stabilization nodes,
-			   flush update for such nodes */
+			 * flush update for such nodes */
 			nodeUpdateID(t->scene->nodetree, &clip->id);
 			WM_event_add_notifier(C, NC_SCENE|ND_NODES, NULL);
 		}
diff --git a/source/blender/editors/transform/transform_generics.c b/source/blender/editors/transform/transform_generics.c
index 557a6936f2f..47989f756e1 100644
--- a/source/blender/editors/transform/transform_generics.c
+++ b/source/blender/editors/transform/transform_generics.c
@@ -1467,9 +1467,9 @@ void calculateCenterMedian(TransInfo *t)
 		}
 		else {
 			/*
-			   All the selected elements are at the head of the array
-			   which means we can stop when it finds unselected data
-			*/
+			 * All the selected elements are at the head of the array
+			 * which means we can stop when it finds unselected data
+			 */
 			break;
 		}
 	}
@@ -1493,9 +1493,9 @@ void calculateCenterBound(TransInfo *t)
 			}
 			else {
 				/*
-				   All the selected elements are at the head of the array
-				   which means we can stop when it finds unselected data
-				*/
+				 * All the selected elements are at the head of the array
+				 * which means we can stop when it finds unselected data
+				 */
 				break;
 			}
 		}
@@ -1657,9 +1657,9 @@ void calculatePropRatio(TransInfo *t)
 					(connected == 0 &&
 						td->rdist > t->prop_size)) {
 				/*
-				   The elements are sorted according to their dist member in the array,
-				   that means we can stop when it finds one element outside of the propsize.
-				*/
+				 * The elements are sorted according to their dist member in the array,
+				 * that means we can stop when it finds one element outside of the propsize.
+				 */
 				td->flag |= TD_NOACTION;
 				td->factor = 0.0f;
 				restoreElement(td);
diff --git a/source/blender/editors/transform/transform_manipulator.c b/source/blender/editors/transform/transform_manipulator.c
index 296fea75317..7825a655170 100644
--- a/source/blender/editors/transform/transform_manipulator.c
+++ b/source/blender/editors/transform/transform_manipulator.c
@@ -316,8 +316,8 @@ int calc_manipulator_stats(const bContext *C)
 				BMIter iter;
 
 				/* do vertices/edges/faces for center depending on selection
-				   mode. note we can't use just vertex selection flag because
-				   it is not flush down on changes */
+				 * mode. note we can't use just vertex selection flag because
+				 * it is not flush down on changes */
 				if(ts->selectmode & SCE_SELECT_VERTEX) {
 					BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL) {
 						if(!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
@@ -654,12 +654,12 @@ static float screen_aligned(RegionView3D *rv3d, float mat[][4])
 
 
 /* radring = radius of donut rings
-   radhole = radius hole
-   start = starting segment (based on nrings)
-   end   = end segment
-   nsides = amount of points in ring
-   nrigns = amount of rings
-*/
+ * radhole = radius hole
+ * start = starting segment (based on nrings)
+ * end   = end segment
+ * nsides = amount of points in ring
+ * nrigns = amount of rings
+ */
 static void partial_donut(float radring, float radhole, int start, int end, int nsides, int nrings)
 {
 	float theta, phi, theta1;
@@ -749,10 +749,10 @@ static char axisBlendAngle(float angle)
 }
 
 /* three colors can be set;
-   grey for ghosting
-   moving: in transform theme color
-   else the red/green/blue
-*/
+ * grey for ghosting
+ * moving: in transform theme color
+ * else the red/green/blue
+ */
 static void manipulator_setcolor(View3D *v3d, char axis, int colcode, unsigned char alpha)
 {
 	unsigned char col[4]= {0};
diff --git a/source/blender/editors/transform/transform_ops.c b/source/blender/editors/transform/transform_ops.c
index 34ded8cdbf8..69d29633972 100644
--- a/source/blender/editors/transform/transform_ops.c
+++ b/source/blender/editors/transform/transform_ops.c
@@ -598,9 +598,9 @@ void TRANSFORM_OT_tilt(struct wmOperatorType *ot)
 {
 	/* identifiers */
 	ot->name   = "Tilt";
-	/*optionals - 
-		"Tilt selected vertices"
-		"Specify an extra axis rotation for selected vertices of 3d curve" */
+	/* optionals - 
+	 * "Tilt selected vertices"
+	 * "Specify an extra axis rotation for selected vertices of 3d curve" */
 	ot->description= "Tilt selected control vertices of 3d curve"; 
 	ot->idname = OP_TILT;
 	ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO|OPTYPE_BLOCKING;
diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index c17667cd639..265af47db80 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -200,9 +200,8 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
 		}
 		else if (t->spacetype==SPACE_IMAGE)
 		{
-			/*This will not draw, and Im nor sure why - campbell */
-			
-			/*			
+			/* This will not draw, and Im nor sure why - campbell */
+#if 0
 			float xuser_asp, yuser_asp;
 			int wi, hi;
 			float w, h;
@@ -230,7 +229,7 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
 			
 			glTranslatef(-t->tsnap.snapPoint[0], -t->tsnap.snapPoint[1], 0.0f);
 			setlinestyle(0);
-			*/
+#endif
 			
 		}
 	}
diff --git a/source/blender/editors/util/crazyspace.c b/source/blender/editors/util/crazyspace.c
index 5ead0959d5c..ee32c04a33c 100644
--- a/source/blender/editors/util/crazyspace.c
+++ b/source/blender/editors/util/crazyspace.c
@@ -80,7 +80,7 @@ static void make_vertexcos__mapFunc(void *userData, int index, float *co, float
 	vec+= 3*index;
 	if(!mappedData->flags[index]) {
 		/* we need coord from prototype vertex, not it clones or images,
-		   suppose they stored in the beginning of vertex array stored in DM */
+		 * suppose they stored in the beginning of vertex array stored in DM */
 		copy_v3_v3(vec, co);
 		mappedData->flags[index]= 1;
 	}
@@ -334,8 +334,8 @@ int editbmesh_get_first_deform_matrices(Scene *scene, Object *ob, BMEditMesh *em
 	md = modifiers_getVirtualModifierList(ob);
 
 	/* compute the deformation matrices and coordinates for the first
-	   modifiers with on cage editing that are enabled and support computing
-	   deform matrices */
+	 * modifiers with on cage editing that are enabled and support computing
+	 * deform matrices */
 	for(i = 0; md && i <= cageIndex; i++, md = md->next) {
 		ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 
@@ -436,7 +436,7 @@ void crazyspace_build_sculpt(Scene *scene, Object *ob, float (**deformmats)[3][3
 
 	if(totleft) {
 		/* there are deformation modifier which doesn't support deformation matrices
-		   calculation. Need additional crazyspace correction */
+		 * calculation. Need additional crazyspace correction */
 
 		float (*deformedVerts)[3]= *deformcos;
 		float (*origVerts)[3]= MEM_dupallocN(deformedVerts);
@@ -452,7 +452,7 @@ void crazyspace_build_sculpt(Scene *scene, Object *ob, float (**deformmats)[3][3
 
 			if(mti->type==eModifierTypeType_OnlyDeform) {
 				/* skip leading modifiers which have been already
-				   handled in sculpt_get_first_deform_matrices */
+				 * handled in sculpt_get_first_deform_matrices */
 				if(mti->deformMatrices && !deformed)
 					continue;
 
diff --git a/source/blender/editors/util/ed_util.c b/source/blender/editors/util/ed_util.c
index 61b1dece957..15dced2f448 100644
--- a/source/blender/editors/util/ed_util.c
+++ b/source/blender/editors/util/ed_util.c
@@ -73,8 +73,8 @@ void ED_editors_init(bContext *C)
 	ID *data;
 
 	/* toggle on modes for objects that were saved with these enabled. for
-	   e.g. linked objects we have to ensure that they are actually the
-	   active object in this scene. */
+	 * e.g. linked objects we have to ensure that they are actually the
+	 * active object in this scene. */
 	for(ob=bmain->object.first; ob; ob=ob->id.next) {
 		int mode= ob->mode;
 
diff --git a/source/blender/editors/util/editmode_undo.c b/source/blender/editors/util/editmode_undo.c
index 4776cf0af53..a06dcb10200 100644
--- a/source/blender/editors/util/editmode_undo.c
+++ b/source/blender/editors/util/editmode_undo.c
@@ -59,25 +59,23 @@
 
 /* ***************** generic editmode undo system ********************* */
 /*
+ * Add this in your local code:
+ *
+ * void undo_editmode_push(bContext *C, const char *name, 
+ * 		void * (*getdata)(bContext *C),     // use context to retrieve current editdata
+ * 		void (*freedata)(void *), 			// pointer to function freeing data
+ * 		void (*to_editmode)(void *, void *),        // data to editmode conversion
+ * 		void * (*from_editmode)(void *))      // editmode to data conversion
+ * 		int  (*validate_undo)(void *, void *))      // check if undo data is still valid
+ *
+ *
+ * Further exported for UI is:
+ *
+ * void undo_editmode_step(bContext *C, int step);	 // undo and redo
+ * void undo_editmode_clear(void)				// free & clear all data
+ * void undo_editmode_menu(void)				// history menu
+ */
 
-Add this in your local code:
-
-void undo_editmode_push(bContext *C, const char *name, 
-		void * (*getdata)(bContext *C),     // use context to retrieve current editdata
-		void (*freedata)(void *), 			// pointer to function freeing data
-		void (*to_editmode)(void *, void *),        // data to editmode conversion
-		void * (*from_editmode)(void *))      // editmode to data conversion
-		int  (*validate_undo)(void *, void *))      // check if undo data is still valid
-
-
-Further exported for UI is:
-
-void undo_editmode_step(bContext *C, int step);	 // undo and redo
-void undo_editmode_clear(void)				// free & clear all data
-void undo_editmode_menu(void)				// history menu
-
-
-*/
 /* ********************************************************************* */
 
 /* ****** XXX ***** */
@@ -129,7 +127,7 @@ void undo_editmode_push(bContext *C, const char *name,
 	uintptr_t memused, totmem, maxmem;
 
 	/* at first here was code to prevent an "original" key to be insterted twice
-	   this was giving conflicts for example when mesh changed due to keys or apply */
+	 * this was giving conflicts for example when mesh changed due to keys or apply */
 	
 	/* remove all undos after (also when curundo==NULL) */
 	while(undobase.last != curundo) {
diff --git a/source/blender/editors/uvedit/uvedit_draw.c b/source/blender/editors/uvedit/uvedit_draw.c
index db71f74b8e1..66ba28e70a6 100644
--- a/source/blender/editors/uvedit/uvedit_draw.c
+++ b/source/blender/editors/uvedit/uvedit_draw.c
@@ -661,12 +661,14 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
 					}
 					glEnd();
 
-					/*glBegin(GL_LINE_STRIP);
+#if 0
+					glBegin(GL_LINE_STRIP);
 						luv = CustomData_bmesh_get(&em->bm->ldata, efa->lbase->head.data, CD_MLOOPUV);
 						glVertex2fv(luv->uv);
 						luv = CustomData_bmesh_get(&em->bm->ldata, efa->lbase->next->head.data, CD_MLOOPUV);
 						glVertex2fv(luv->uv);
-					glEnd();*/
+					glEnd();
+#endif
 
 					setlinestyle(0);
 				}
@@ -900,8 +902,10 @@ static void draw_uvs(SpaceImage *sima, Scene *scene, Object *obedit)
 			index += stitch_preview->uvs_per_polygon[i];
 		}
 		glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
-		/*UI_ThemeColor4(TH_STITCH_PREVIEW_VERT);
-		glDrawArrays(GL_TRIANGLES, 0, stitch_preview->num_tris*3);*/
+#if 0
+		UI_ThemeColor4(TH_STITCH_PREVIEW_VERT);
+		glDrawArrays(GL_TRIANGLES, 0, stitch_preview->num_tris*3);
+#endif
 		glDisable(GL_BLEND);
 
 		/* draw vert preview */
diff --git a/source/blender/editors/uvedit/uvedit_ops.c b/source/blender/editors/uvedit/uvedit_ops.c
index 42e6ec39e46..15d8a644035 100644
--- a/source/blender/editors/uvedit/uvedit_ops.c
+++ b/source/blender/editors/uvedit/uvedit_ops.c
@@ -2348,9 +2348,11 @@ static void uv_faces_do_sticky(bContext *C, SpaceImage *sima, Scene *scene, Obje
 		vmap= EDBM_make_uv_vert_map(em, 0, 0, limit);
 		
 		/* verts are numbered above in make_uv_vert_map_EM, make sure this stays true! */
-		/*for(a=0, eve= em->verts.first; eve; a++, eve= eve->next)
-			eve->tmp.l = a; */
-		
+		/* BMESH_TODO - why keep this commented? - campbell */
+#if 0
+		for(a=0, eve= em->verts.first; eve; a++, eve= eve->next)
+			eve->tmp.l = a;
+#endif
 		if(vmap == NULL) {
 			return;
 		}
diff --git a/source/blender/editors/uvedit/uvedit_parametrizer.c b/source/blender/editors/uvedit/uvedit_parametrizer.c
index 49bfb786f20..d6035b08fd6 100644
--- a/source/blender/editors/uvedit/uvedit_parametrizer.c
+++ b/source/blender/editors/uvedit/uvedit_parametrizer.c
@@ -219,10 +219,10 @@ typedef struct PHandle {
 
 
 /* PHash
-   - special purpose hash that keeps all its elements in a single linked list.
-   - after construction, this hash is thrown away, and the list remains.
-   - removing elements is not possible efficiently.
-*/
+ * - special purpose hash that keeps all its elements in a single linked list.
+ * - after construction, this hash is thrown away, and the list remains.
+ * - removing elements is not possible efficiently.
+ */
 
 static int PHashSizes[] = {
 	1, 3, 5, 11, 17, 37, 67, 131, 257, 521, 1031, 2053, 4099, 8209, 
@@ -497,7 +497,7 @@ static PBool p_intersect_line_2d(float *v1, float *v2, float *v3, float *v4, flo
 
 	if (!p_intersect_line_2d_dir(v1, dir1, v2, dir2, isect)) {
 		/* parallel - should never happen in theory for polygon kernel, but
-		   let's give a point nearby in case things go wrong */
+		 * let's give a point nearby in case things go wrong */
 		isect[0] = (v1[0] + v2[0])*0.5f;
 		isect[1] = (v1[1] + v2[1])*0.5f;
 		return P_FALSE;
@@ -1121,9 +1121,9 @@ static PBool p_quad_split_direction(PHandle *handle, float **co, PHashKey *vkeys
 	PBool dir = (fac <= 0.0f);
 
 	/* the face exists check is there because of a special case: when
-	   two quads share three vertices, they can each be split into two
-	   triangles, resulting in two identical triangles. for example in
-	   suzanne's nose. */
+	 * two quads share three vertices, they can each be split into two
+	 * triangles, resulting in two identical triangles. for example in
+	 * suzanne's nose. */
 	if (dir) {
 		if (p_face_exists(handle,vkeys,0,1,2) || p_face_exists(handle,vkeys,0,2,3))
 			return !dir;
@@ -1536,8 +1536,8 @@ static void p_vert_harmonic_insert(PVert *v)
 
 	if (!p_vert_map_harmonic_weights(v)) {
 		/* do polygon kernel center insertion: this is quite slow, but should
-		   only be needed for 0.01 % of verts or so, when insert with harmonic
-		   weights fails */
+		 * only be needed for 0.01 % of verts or so, when insert with harmonic
+		 * weights fails */
 
 		int npoints = 0, i;
 		float (*points)[2];
@@ -1759,7 +1759,7 @@ static PBool p_collapse_allowed_topologic(PEdge *edge, PEdge *pair)
 			return P_FALSE;
 	}
 	/* avoid merging two boundaries (oldv and keepv are on the 'other side' of
-	   the chart) */
+	 * the chart) */
 	else if (!p_vert_interior(oldv) && !p_vert_interior(keepv))
 		return P_FALSE;
 	
@@ -1870,7 +1870,7 @@ static PBool p_collapse_allowed(PEdge *edge, PEdge *pair)
 static float p_collapse_cost(PEdge *edge, PEdge *pair)
 {
 	/* based on volume and boundary optimization from:
-	  "Fast and Memory Efficient Polygonal Simplification" P. Lindstrom, G. Turk */
+	 * "Fast and Memory Efficient Polygonal Simplification" P. Lindstrom, G. Turk */
 
 	PVert *oldv, *keepv;
 	PEdge *e;
@@ -2036,7 +2036,7 @@ static void p_chart_post_collapse_flush(PChart *chart, PEdge *collapsed)
 	}
 
 	/* these are added last so they can be popped of in the right order
-	   for splitting */
+	 * for splitting */
 	for (e=collapsed; e; e=e->nextlink) {
 		e->nextlink = e->u.nextcollapse;
 		laste = e;
@@ -2098,9 +2098,9 @@ static void p_chart_post_split_flush(PChart *chart)
 static void p_chart_simplify_compute(PChart *chart)
 {
 	/* Computes a list of edge collapses / vertex splits. The collapsed
-	   simplices go in the chart->collapsed_* lists, The original and
-	   collapsed may then be view as stacks, where the next collapse/split
-	   is at the top of the respective lists. */
+	 * simplices go in the chart->collapsed_* lists, The original and
+	 * collapsed may then be view as stacks, where the next collapse/split
+	 * is at the top of the respective lists. */
 
 	Heap *heap = BLI_heap_new();
 	PVert *v, **wheelverts;
@@ -2320,7 +2320,7 @@ static float p_abf_compute_sin_product(PAbfSystem *sys, PVert *v, int aid)
 
 		if (aid == e1->u.id) {
 			/* we are computing a derivative for this angle,
-			   so we use cos and drop the other part */
+			 * so we use cos and drop the other part */
 			sin1 *= sys->cosine[e1->u.id];
 			sin2 = 0.0;
 		}
@@ -2810,7 +2810,7 @@ static PBool p_chart_symmetry_pins(PChart *chart, PEdge *outer, PVert **pin1, PV
 	float len1, len2;
  
 	 /* find longest series of verts split in the chart itself, these are
-	   marked during construction */
+	  * marked during construction */
 	be = outer;
 	lastbe = p_boundary_edge_prev(be);
 	do {
@@ -3406,7 +3406,7 @@ static PBool p_chart_convex_hull(PChart *chart, PVert ***verts, int *nverts, int
 static float p_rectangle_area(float *p1, float *dir, float *p2, float *p3, float *p4)
 {
 	/* given 4 points on the rectangle edges and the direction of on edge,
-	   compute the area of the rectangle */
+	 * compute the area of the rectangle */
 
 	float orthodir[2], corner1[2], corner2[2], corner3[2];
 
diff --git a/source/blender/editors/uvedit/uvedit_parametrizer.h b/source/blender/editors/uvedit/uvedit_parametrizer.h
index 5adb3074314..00cbbd16073 100644
--- a/source/blender/editors/uvedit/uvedit_parametrizer.h
+++ b/source/blender/editors/uvedit/uvedit_parametrizer.h
@@ -19,15 +19,15 @@ typedef enum ParamBool {
 } ParamBool;
 
 /* Chart construction:
-   -------------------
-   - faces and seams may only be added between construct_{begin|end}
-   - the pointers to co and uv are stored, rather than being copied
-   - vertices are implicitly created
-   - in construct_end the mesh will be split up according to the seams
-   - the resulting charts must be:
-	  - manifold, connected, open (at least one boundary loop)
-   - output will be written to the uv pointers
-*/
+ * -------------------
+ * - faces and seams may only be added between construct_{begin|end}
+ * - the pointers to co and uv are stored, rather than being copied
+ * - vertices are implicitly created
+ * - in construct_end the mesh will be split up according to the seams
+ * - the resulting charts must be:
+ * - manifold, connected, open (at least one boundary loop)
+ * - output will be written to the uv pointers
+ */
 
 ParamHandle *param_construct_begin(void);
 
@@ -51,15 +51,15 @@ void param_construct_end(ParamHandle *handle, ParamBool fill, ParamBool impl);
 void param_delete(ParamHandle *chart);
 
 /* Least Squares Conformal Maps:
-   -----------------------------
-   - charts with less than two pinned vertices are assigned 2 pins
-   - lscm is divided in three steps:
-	  - begin: compute matrix and it's factorization (expensive)
-	  - solve using pinned coordinates (cheap)
-	  - end: clean up 
-	- uv coordinates are allowed to change within begin/end, for
-	  quick re-solving
-*/
+ * -----------------------------
+ * - charts with less than two pinned vertices are assigned 2 pins
+ * - lscm is divided in three steps:
+ * - begin: compute matrix and it's factorization (expensive)
+ * - solve using pinned coordinates (cheap)
+ * - end: clean up 
+ * - uv coordinates are allowed to change within begin/end, for
+ *   quick re-solving
+ */
 
 void param_lscm_begin(ParamHandle *handle, ParamBool live, ParamBool abf);
 void param_lscm_solve(ParamHandle *handle);
diff --git a/source/blender/editors/uvedit/uvedit_smart_stitch.c b/source/blender/editors/uvedit/uvedit_smart_stitch.c
index c7750fd516b..f7dd90e6084 100644
--- a/source/blender/editors/uvedit/uvedit_smart_stitch.c
+++ b/source/blender/editors/uvedit/uvedit_smart_stitch.c
@@ -383,7 +383,7 @@ static void stitch_island_calculate_edge_rotation(UvEdge *edge, StitchState *sta
 	index2 = uvfinal_map[element2 - state->element_map->buf];
 
 	/* the idea here is to take the directions of the edges and find the rotation between final and initial
-	* direction. This, using inner and outer vector products, gives the angle. Directions are differences so... */
+	 * direction. This, using inner and outer vector products, gives the angle. Directions are differences so... */
 	uv1[0] = luv2->uv[0] - luv1->uv[0];
 	uv1[1] = luv2->uv[1] - luv1->uv[1];
 
diff --git a/source/blender/editors/uvedit/uvedit_unwrap_ops.c b/source/blender/editors/uvedit/uvedit_unwrap_ops.c
index 56d088577b6..85bf3064d7f 100644
--- a/source/blender/editors/uvedit/uvedit_unwrap_ops.c
+++ b/source/blender/editors/uvedit/uvedit_unwrap_ops.c
@@ -154,7 +154,7 @@ static int uvedit_have_selection(Scene *scene, BMEditMesh *em, short implicit)
 	MLoopUV *luv;
 	
 	/* verify if we have any selected uv's before unwrapping,
-	   so we can cancel the operator early */
+	 * so we can cancel the operator early */
 	BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
 		if(scene->toolsettings->uv_flag & UV_SYNC_SELECTION) {
 			if(BM_elem_flag_test(efa, BM_ELEM_HIDDEN))
-- 
cgit v1.2.3