style cleanup - use aligned * prefixed blocks for descriptive comments (was already...
authorCampbell Barton <ideasman42@gmail.com>
Sat, 3 Mar 2012 16:31:46 +0000 (16:31 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 3 Mar 2012 16:31:46 +0000 (16:31 +0000)
134 files changed:
source/blender/editors/animation/anim_channels_defines.c
source/blender/editors/animation/anim_deps.c
source/blender/editors/animation/anim_markers.c
source/blender/editors/animation/keyframes_edit.c
source/blender/editors/armature/armature_ops.c
source/blender/editors/armature/editarmature.c
source/blender/editors/armature/meshlaplacian.c
source/blender/editors/armature/reeb.c
source/blender/editors/curve/editcurve.c
source/blender/editors/gpencil/drawgpencil.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/BIF_glutil.h
source/blender/editors/include/ED_armature.h
source/blender/editors/include/ED_datafiles.h
source/blender/editors/include/ED_mesh.h
source/blender/editors/include/ED_render.h
source/blender/editors/include/ED_space_api.h
source/blender/editors/include/UI_interface.h
source/blender/editors/include/UI_interface_icons.h
source/blender/editors/interface/interface.c
source/blender/editors/interface/interface_draw.c
source/blender/editors/interface/interface_handlers.c
source/blender/editors/interface/interface_icons.c
source/blender/editors/interface/interface_intern.h
source/blender/editors/interface/interface_layout.c
source/blender/editors/interface/interface_panel.c
source/blender/editors/interface/interface_regions.c
source/blender/editors/interface/interface_style.c
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/interface_utils.c
source/blender/editors/interface/interface_widgets.c
source/blender/editors/interface/view2d_ops.c
source/blender/editors/mesh/bmesh_select.c
source/blender/editors/mesh/bmesh_selecthistory.c
source/blender/editors/mesh/bmesh_tools.c
source/blender/editors/mesh/editface.c
source/blender/editors/mesh/editmesh_bvh.c
source/blender/editors/mesh/loopcut.c
source/blender/editors/mesh/mesh_data.c
source/blender/editors/mesh/mesh_intern.h
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_add.c
source/blender/editors/object/object_bake.c
source/blender/editors/object/object_group.c
source/blender/editors/object/object_hook.c
source/blender/editors/object/object_modifier.c
source/blender/editors/object/object_relations.c
source/blender/editors/object/object_select.c
source/blender/editors/object/object_transform.c
source/blender/editors/object/object_vgroup.c
source/blender/editors/physics/dynamicpaint_ops.c
source/blender/editors/physics/particle_edit.c
source/blender/editors/render/render_internal.c
source/blender/editors/render/render_preview.c
source/blender/editors/render/render_update.c
source/blender/editors/render/render_view.c
source/blender/editors/screen/area.c
source/blender/editors/screen/glutil.c
source/blender/editors/screen/screen_edit.c
source/blender/editors/screen/screen_ops.c
source/blender/editors/sculpt_paint/paint_cursor.c
source/blender/editors/sculpt_paint/paint_image.c
source/blender/editors/sculpt_paint/paint_intern.h
source/blender/editors/sculpt_paint/paint_stroke.c
source/blender/editors/sculpt_paint/paint_utils.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/sculpt_paint/sculpt_undo.c
source/blender/editors/sound/sound_ops.c
source/blender/editors/space_api/spacetypes.c
source/blender/editors/space_buttons/buttons_texture.c
source/blender/editors/space_clip/clip_draw.c
source/blender/editors/space_clip/space_clip.c
source/blender/editors/space_clip/tracking_ops.c
source/blender/editors/space_console/console_ops.c
source/blender/editors/space_console/space_console.c
source/blender/editors/space_file/file_ops.c
source/blender/editors/space_file/filesel.c
source/blender/editors/space_file/fsmenu.c
source/blender/editors/space_file/space_file.c
source/blender/editors/space_image/image_buttons.c
source/blender/editors/space_image/image_draw.c
source/blender/editors/space_image/space_image.c
source/blender/editors/space_info/info_report.c
source/blender/editors/space_logic/logic_ops.c
source/blender/editors/space_logic/logic_window.c
source/blender/editors/space_nla/space_nla.c
source/blender/editors/space_node/node_draw.c
source/blender/editors/space_node/node_edit.c
source/blender/editors/space_outliner/outliner_draw.c
source/blender/editors/space_outliner/outliner_intern.h
source/blender/editors/space_outliner/outliner_select.c
source/blender/editors/space_outliner/outliner_tools.c
source/blender/editors/space_outliner/outliner_tree.c
source/blender/editors/space_sequencer/sequencer_draw.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/editors/space_sequencer/sequencer_ops.c
source/blender/editors/space_sequencer/space_sequencer.c
source/blender/editors/space_text/space_text.c
source/blender/editors/space_text/text_draw.c
source/blender/editors/space_text/text_ops.c
source/blender/editors/space_view3d/drawarmature.c
source/blender/editors/space_view3d/drawmesh.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/drawvolume.c
source/blender/editors/space_view3d/space_view3d.c
source/blender/editors/space_view3d/view3d_buttons.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_fly.c
source/blender/editors/space_view3d/view3d_header.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/space_view3d/view3d_view.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform.h
source/blender/editors/transform/transform_constraints.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_generics.c
source/blender/editors/transform/transform_manipulator.c
source/blender/editors/transform/transform_ops.c
source/blender/editors/transform/transform_snap.c
source/blender/editors/util/crazyspace.c
source/blender/editors/util/ed_util.c
source/blender/editors/util/editmode_undo.c
source/blender/editors/uvedit/uvedit_draw.c
source/blender/editors/uvedit/uvedit_ops.c
source/blender/editors/uvedit/uvedit_parametrizer.c
source/blender/editors/uvedit/uvedit_parametrizer.h
source/blender/editors/uvedit/uvedit_smart_stitch.c
source/blender/editors/uvedit/uvedit_unwrap_ops.c
source/gameengine/Converter/BL_ArmatureObject.cpp
source/gameengine/Converter/BL_BlenderDataConversion.cpp
source/gameengine/Converter/BL_ModifierDeformer.cpp
source/gameengine/Converter/KX_BlenderSceneConverter.cpp

index f8bb690e31d73ae0ac8f7171ab657b7f21b042ae..ae1f308369da25e597dbcbc94b0fb8e25db16a30 100644 (file)
@@ -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 */
index 8e91e575db1f870074beb42264b1d052930d50c8..be66edb8dc9016750e447cc238f76d78555b843e 100644 (file)
@@ -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?
        }
 }
index 7e92c9eb6909740a672e1ef3e14ecdf4a7a41ba8..7f7b1b28319c2dd5fb2e8215e0ba1ece196663f1 100644 (file)
@@ -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)
 {
index af78fe739cc8bd1134d4b00edbe5e4c6840028d3..a99276db12288671f785f9dd4e30f5c7bbbe8848 100644 (file)
@@ -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;
                        }
                }
index 7379a278d011cff91df93600eff0e8cf5d16b7a0..ad52f4e61cb267ee84717392bf6853d52ff421fb 100644 (file)
@@ -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);
        
index ba542d5d80120386529da26973d39260a01d3860..357a53eacb309bd6544bc36696c4e49657d756a1 100644 (file)
@@ -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;
index a592e7279887b2b8b6c54b2cbfa3dc4ddbc68191..74c44ea1f0d705aafb9f3bc646af40d41374bd23 100644 (file)
@@ -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
 
index 3c84ee65ac76863811125521b2c86e8a19d4228d..08f95ecb08ae3806dd33cfe5a9d1e51ad982157e 100644 (file)
@@ -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);
        
index c09f4d16936209daf6d4e4babe0fdb47eb92a15b..28e29bf0a8c97d05ca77b487c19e4af20f36a880 100644 (file)
@@ -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);
index 19dc25dd282d8c69c8740c979e27b766eab79096..5e9acc5b84f68df2728bb56eb119a5b4bb8bcc2a 100644 (file)
@@ -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)    
index 673d7c637ffcc50e4d62d2f4e6ac83359aae4269..c9d1f70aa6520dc61bcda7a61fa79c333424364b 100644 (file)
@@ -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);
index 77c50f9ca6d76ff721cc4962dd5122aace46746e..d0d50aa86fa8f24c1c00383a3394231dcab6ecb3 100644 (file)
@@ -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 
index a073cdddae7bb315687f25105a27d9e75b334b20..851bd09dd2910429aacf8ce6fcb671495501c265 100644 (file)
@@ -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;
index 9fe2fe685a0b9ca7de6ced15181ecbc1e1343bca..c725808ec34d6f24957272926374ce6b36ceb354 100644 (file)
@@ -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[];
 
index 986c2abad695a97bf5a080f20ee0144cf0605f94..c40048625a778ed233442c3e2b34f21594af430a 100644 (file)
@@ -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);
index c9e00b0296a7d1f4ee96c1ee8a69c3d35314db12..73bbd5ffef8da7e28f766dca5b4e001e421a3388 100644 (file)
@@ -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
index 0d6e640c7bf9f4840d37a1eac970855186620a59..8023eef83700896cfbda328992aed4e52ba0f1e3 100644 (file)
@@ -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);
index fafd35bf911076d2bf454100ffb8f1115a4f5c71..18e2af939fddc8ff469b92c6572398b27a3aa406 100644 (file)
@@ -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
index a1b42ac39c24ca2c527954d7042e6f5e894c84e7..c2bc2cf6af18462e3ed3d42706b256daf0a71da1 100644 (file)
@@ -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);
index 1944f81ec2dc685cab80d62bd80e2cd1266e8f70..6e3e7a2a4e0f64cf30e92cfd1318c08134fd0dc7 100644 (file)
@@ -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)
 {
index 93cb0f8ae9768a117a0a66c8aceed5bc3fb6d3b5..97248e8710caa0316ef2025d9683d453e30c4c4f 100644 (file)
@@ -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);
index 41385292707cd7d3860d567fd7a7700eca24a4a0..f1d4d6b7277fef6bf989864f7d651a1fe7383f9f 100644 (file)
@@ -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);
        }
index 3e6d4f314797afde374fb001f5a4b3b2906c5711..bde2c3344447dc1b79574a4e74429d200b5217ad 100644 (file)
@@ -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)
index d324018e4bae186fef81d37bbf46f065d332e4db..dd4bbc7524990eb13930102e2bf890d64bc7686c 100644 (file)
@@ -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;
index b3b187f92a214dda91b869396f012cc198a110e2..a258d22a8dc979680d7a33c28b73f39e8f505bb8 100644 (file)
@@ -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;
index d802c8640b8c8f1ee8db18010d11a5d148e5d88d..769087b73ef3bd221b5cce87245f45e51e39f831 100644 (file)
@@ -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
 }
 
index 32f284826a707880d72ecf0298f0faafcd159342..40bd332a056702117f5ce3ac01f4aadf0cb45a8c 100644 (file)
@@ -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)));
index 16b543737d09e29490acadfbd3dcfb44f39e14e4..b9c29888a6429b8dfc20441bce3c925aa3c50a59 100644 (file)
 /* 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.
+ */
 
 
 /* ********************************************** */
index 1fc9b18a0f660d0d6620bd2a51cfbc555fd4fab4..70336eb9e0f33b91a305c11ae9d2d8a38a5706dd 100644 (file)
@@ -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);
        }
index 8335668a6246100bedd77afc67f945730281552b..610e9f8762d9124b163a237c8c23fc83e9fdae78 100644 (file)
@@ -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;
index 419f13254e60131a868c82794523498eb6e4de42..0e51932df9022aff9aad4310b50785d83f588e15 100644 (file)
 
 /* ************** 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},
index d8f187d181ae16dfe63f4bba143aa041b48485e5..029ca50db5b4fed29582b050ecbf210806087a28 100644 (file)
@@ -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) {
index 2e21f6d1f282bcc5282912af627da484de815349..fd6242fb209ad865d78b579256d864a3063d6b19 100644 (file)
@@ -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);
index f0c00d0ff0779108da60aba4e3170e3aa4f48fa0..c912813ac639b7118f954751b94fa5b62d6dfc2c 100644 (file)
@@ -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);
index 4ea74777d890f828f4d8f160c6ee1cde647cbf08..79164d87e98649da8bfe6cda1bdb78b5417f1c10 100644 (file)
@@ -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;
index 58b5154cdffb2b1c48b09c6ebce2b73a52f4c5e4..a6ceba061f626665172846979164244e11ef68b5 100644 (file)
@@ -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);
index fc7818183bb1c0f9f25486dcdf99a070dc552a14..d9ba7a1b36a9ee85954c7be78d94885c107f558b 100644 (file)
@@ -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);
index a82310be9260d6fca84c82ce30bbb587387a9021..5f8c842f4f3ba0b67b84fdfc673802e6ab386674 100644 (file)
@@ -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])
 {
index 4259f7fc5584ed66027265f9ccae6c24f50547d4..b4b9461b3c0f3e58877da014e688e16425cbd762 100644 (file)
@@ -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)
 {
index b1c95da17314d7b1b3bf2b66fd861177157fe960..1afc1796ef6a32eea7e4b0b700672afca039fb65 100644 (file)
@@ -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*/
index 7bf41bdce00f87c6b99233d68767f7652bc5149b..f44af97d403f1aa6436a2cb8f7b0bba0c391ac89 100644 (file)
@@ -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)
 {
index 2952682573679f202c3397b4e9cabd6a81faf7e2..0c12d7016169a39fea180597fd0c12b165df5bcf 100644 (file)
@@ -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) {
index 340a6df8bf6c8b4c85597381b2248d3273340664..f1fbf27312ab815f80d28ddc76e07a330fae175f 100644 (file)
  *  \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)
index 1b8c0fd08401ee24218ad2c6dbe96f9ae12a98dd..d5dfbda869698af65510044744f0ee1a6a2c6ba3 100644 (file)
@@ -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)) {
index 8b5a9ae6c9bec9923e6a644ac93403e75f15ef13..eb128ad3025263f5ab8296e20054ce51bba93586 100644 (file)
@@ -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 */
index c5d8196909826dc29dbe86dd05ea88491830a11c..bda373dd4417e7a128332b34082a3450a861e605 100644 (file)
@@ -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 */
        
index 2281d7a26d8496ec8ce5df061536a1bbfaf42693..2945075b9debbc0266d1cfdd45aac17092786736 100644 (file)
@@ -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) {
index 69372ac1a90ca20aa6367b6cb268c4f2ef9848cb..4377aad0c4253970bbdc3c6d70d84072fc323977 100644 (file)
@@ -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))
index 45db21749a5fee58ea4ca6ca78467c863bcba016..be41f08df8e28afdbd86f6f72daea7941a66d011 100644 (file)
@@ -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 {
index f610d75824397d61fc7116dda89a9d022f65917c..b545598f240d2b3370e13120fcf70ffdc5ead8df 100644 (file)
@@ -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;
index 7f5688338668d15ee4f2b56bdd92c6a4c5c840ef..4e9145a6ff327487bc2d2be1a136d6181c49053d 100644 (file)
@@ -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];
index 2a7f9b2a6266e0897a7d5334f3a5b756c7de827d..8201b27a4edeaa1090a81ad247bd730195e2abb0 100644 (file)
@@ -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;
index d018a8d03d3b5ec5bb5bb056b0c13958579090ad..4fbc5085b2d2932ffb5a7c9fa7495579ec758a63 100644 (file)
@@ -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 */
index 3eda30e15544f885e73771c05637ae01d8300e76..f0ef7c633cbbd59487a847610c5d923dc4084f8e 100644 (file)
@@ -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))
 {
index d921308aad5e8b247b54490ffc35ff84bf5c70a4..4483d7d8ba18ebaabac16e240f15f8c88c6383b8 100644 (file)
@@ -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;
 
index d8719c7d7cdbae895f470468f6daa53d39596770..8850bef286d8c58ed10d6d8aeff8d8558aa4992e 100644 (file)
@@ -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
index e4088fe10c4f1f0a1b0e8f2731249f645e1d98d5..6f846b82c5fb5fd1ae6d10aa791d5822707fdee1 100644 (file)
@@ -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
index 918df2f90e0049dbcba6ab24c308ca041dfceb97..2608e9e3482a4b855fdd0e57a76af7ee91bb9810 100644 (file)
@@ -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;
index f3a6904f8d0cc3224dedb45356a07c936084486c..7ab73c6b9764919c2ccd81fcb404f35ce24a7f39 100644 (file)
@@ -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;
 
index 8818bd66b2304d1e02b2dfce5815908654b754e0..94d1f3c6a811902dfcec0dd810ffa0dc02314608 100644 (file)
@@ -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)
index 0148f11b930ce9f9db3f427f02e20ad56e0d5602..ea1e3eb47af3d5e912ab3ad8da01ea82246a12b6 100644 (file)
 
 #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,
index 63e976693e3a5d5689aa5738f03edeec241ec4d5..2b111613c4b5fd311099c14daf63c9deb3eb57fe 100644 (file)
@@ -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;
index b4315c2847dc03213615a8624ec4e1b903754500..bae433bdb557d77dffe4a12a0ff1bf7c47e1492e 100644 (file)
@@ -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,
index cd8262f06bdc9302e0794e58a59d736f85b877f1..d306abef9d06b44e32294cbc6c48df9c7d96572f 100644 (file)
@@ -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;
index 0d9c0f2e38e80385b6d9997006960fdc81e3bfd6..610c49ef27f703c2a668c498ab02568c3f3baa7a 100644 (file)
@@ -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) {
index e84a7c623b4174c9c9da3b08e6b471bb65070601..1d84a0aca8eacc385fbb9ca3fed319a345088f32 100644 (file)
@@ -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;
index dc25f2964e0c77983d2a12a93680da37bf83b4b4..7c3d8f0e9cdd1ed3e5f2f5d64fb6a86514c67595 100644 (file)
@@ -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;
 
index 46a75d3b722b689b97c4e829744c5629ece3a2d3..84b8b5a8bce3c0239916be06b7bb843236e34579 100644 (file)
@@ -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);
 
index 4f145a617f709a6e2a98ef9b77c3c2cff87ceb82..205b2064f519fba354b188868c5acdffce23f4a6 100644 (file)
@@ -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";
index 7c5361c8af0d69cff5ce054811343352aa9de5a8..b876003c0597f53d9141491b50209a10e7cb377e 100644 (file)
@@ -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;
index 6927a78332fcb48d7c8e9ac21e07c1fb8af033d7..fb46dd55a121c2b564534f059a8bd9314a3bd517 100644 (file)
@@ -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);
index 42c127df016db8703ab3924d768095a31bb7e97b..af2db9697b2cce68adf361e2935e5404f08898b9 100644 (file)
@@ -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);
 
index 9edf4fab280c55ec18f20e30f47e00045525c053..0b5cfbbc7d3808cb19ad68670b73e46fcd383228 100644 (file)
@@ -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);
 
index 18a5d8689c8fdbe7cc827f884341460929d6175b..a88296a97298ec028b3dc2db53a92b50e5d1ae55 100644 (file)
@@ -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;
                                }
                        }
index 9640701965c3b2d49e6cc769e860ce907959b5e5..427776eca7d09d9224dd230be37beb4705055246 100644 (file)
@@ -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);
 }
index 3df8e98be3a3ca84d674ed79335a8623683a8703..701a0bb1cb884c0291aefd7bbe353ca5780ddd93 100644 (file)
@@ -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);
index 548a51d9ee24963cad4bddd97033390593d39526..05de70b99ab98a61a46c982511b93e80d3825dcb 100644 (file)
@@ -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 */
index 44eadc9dee85c59aefb7ab248d5cfb309586e169..fa2874f48422da0ea9c501d78e732f99b604a72f 100644 (file)
@@ -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];
index ea894750605bac00ab023afd1d7ed5277397656e..4f4ad52e4a453ea9cb66baa5ecefbc33dda407f2 100644 (file)
@@ -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);
index 02c9728348e294ea11295a1e6e5e6321986b666f..7821547aaf355c6ea47be4fb54f773eee96cd047 100644 (file)
@@ -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);
index 150872813b2ba5b6d7fe1087104be4c19fa0c60d..d54468f64ea3af190b8c5bba7635140f6e2f92c8 100644 (file)
@@ -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);
 }
 
index 9ec9c5ef0e02c387c93af773508070c3af597092..e91a44e03582ba12b8426367c7044590bba55996 100644 (file)
 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) {
index 7abc0c6ea71529345f8f58ae6e1db145973cf963..1af37a660225cb2cc826e5a15390b5d8f084a165 100644 (file)
@@ -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)
index 206639f064af5975febecb98526a157fe2957704..a1ea044912800f43b8781ce90204d0b250939cc0 100644 (file)
@@ -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) {
index 0dfcafcf5492485dead1246f9de7818b30d864fa..86ac2d0c3696745c6e1cc65af7650a5ed10a9b5f 100644 (file)
@@ -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;
index 15aab2aa9b096e3e142995b442731a12bc2b34c9..ea593b57ee06307e8260abd4dd84d432fcbd996e 100644 (file)
@@ -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++) {
index 48859acff6a90815bbe1589a38ad7a80fcb96256..2f0d39c5f9138de205c4213b2004faded4db7638 100644 (file)
@@ -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:
index 5b35352417c2ae8e7a1bb8bcad534bdfaa172aaa..f7ed7d58f389dbf3e8e3d955a25a2b25bd9e3d93 100644 (file)
@@ -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));
        
index a6d18b58cca8c82e88f8805eaca8c9c65caade9e..bb99464e3c7af601f516fb9b70a25cf61b53d1b1 100644 (file)
@@ -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;
index bb694ae5705e12657128acd94a78cf49543feb32..1a08df79664ee5cae19415858a03f2f2ff7f03e8 100644 (file)
@@ -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;
 
index 8c53e9ad111757013fd6459d47b4cbd953139472..b1990d3054ec587039251cdf2d3c690b23a8fb4f 100644 (file)
@@ -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)
 
index 345e7a835f4e49714fbd37ceb2042187d7214d95..a71ea9a6d4ab0aa5e8ab48ec2b67eeaaa15f5354 100644 (file)
@@ -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:
index 09a125692d27dc586ddc13ec8ae8a1ea9c5e0a05..c8da45270b7c6e36905be19f1eb7a90dbf31ef06 100644 (file)
@@ -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);