Style Cleanup
authorCampbell Barton <ideasman42@gmail.com>
Fri, 10 Feb 2012 18:09:19 +0000 (18:09 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 10 Feb 2012 18:09:19 +0000 (18:09 +0000)
source/blender/blenkernel/intern/modifiers_bmesh.c
source/blender/bmesh/intern/bmesh_construct.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/bmeshutils.c
source/blender/editors/mesh/editbmesh_add.c
source/blender/editors/mesh/knifetool.c

index 8fe400dcbe4b2fa31b4811ccb96e2a642e52f43d..48680d19892b38419d572858e8b7207eedb3be77 100644 (file)
 #include "RE_shader_ext.h"
 #include "LOD_decimation.h"
 
 #include "RE_shader_ext.h"
 #include "LOD_decimation.h"
 
-/*converts a cddm to a BMEditMesh.  if existing is non-NULL, the
-  new geometry will be put in there.*/
+/* converts a cddm to a BMEditMesh.  if existing is non-NULL, the
* new geometry will be put in there.*/
 BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int do_tesselate)
 {
        int allocsize[4] = {512, 512, 2048, 512};
 BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int do_tesselate)
 {
        int allocsize[4] = {512, 512, 2048, 512};
@@ -112,8 +112,8 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
        MEdge *me, *medge;
        MPoly *mpoly, *mp;
        MLoop *mloop, *ml;
        MEdge *me, *medge;
        MPoly *mpoly, *mp;
        MLoop *mloop, *ml;
-       BMVert *v, **vtable, **verts=NULL;
-       BMEdge *e, **etable, **edges=NULL;
+       BMVert *v, **vtable, **verts = NULL;
+       BMEdge *e, **etable, **edges = NULL;
        BMFace *f;
        BMIter liter;
        BLI_array_declare(verts);
        BMFace *f;
        BMIter liter;
        BLI_array_declare(verts);
@@ -140,7 +140,7 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 
        /*do verts*/
        mv = mvert = dm->dupVertArray(dm);
 
        /*do verts*/
        mv = mvert = dm->dupVertArray(dm);
-       for (i=0; i<totvert; i++, mv++) {
+       for (i = 0; i < totvert; i++, mv++) {
                v = BM_Make_Vert(bm, mv->co, NULL);
                normal_short_to_float_v3(v->no, mv->no);
                v->head.hflag = BM_Vert_Flag_From_MEFlag(mv->flag);
                v = BM_Make_Vert(bm, mv->co, NULL);
                normal_short_to_float_v3(v->no, mv->no);
                v->head.hflag = BM_Vert_Flag_From_MEFlag(mv->flag);
@@ -152,7 +152,7 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 
        /*do edges*/
        me = medge = dm->dupEdgeArray(dm);
 
        /*do edges*/
        me = medge = dm->dupEdgeArray(dm);
-       for (i=0; i<totedge; i++, me++) {
+       for (i = 0; i < totedge; i++, me++) {
                e = BM_Make_Edge(bm, vtable[me->v1], vtable[me->v2], NULL, FALSE);
 
                e->head.hflag = BM_Edge_Flag_From_MEFlag(me->flag);
                e = BM_Make_Edge(bm, vtable[me->v1], vtable[me->v2], NULL, FALSE);
 
                e->head.hflag = BM_Edge_Flag_From_MEFlag(me->flag);
@@ -165,7 +165,7 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
        /*do faces*/
        mpoly = mp = dm->getPolyArray(dm);
        mloop = dm->getLoopArray(dm);
        /*do faces*/
        mpoly = mp = dm->getPolyArray(dm);
        mloop = dm->getLoopArray(dm);
-       for (i=0; i<dm->numPolyData; i++, mp++) {
+       for (i = 0; i < dm->numPolyData; i++, mp++) {
                BMLoop *l;
 
                BLI_array_empty(verts);
                BMLoop *l;
 
                BLI_array_empty(verts);
@@ -192,12 +192,11 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
                l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
                k = mp->loopstart;
 
                l = BMIter_New(&liter, bm, BM_LOOPS_OF_FACE, f);
                k = mp->loopstart;
 
-               for (j=0; l; l=BMIter_Step(&liter), k++) {
+               for (j = 0; l; l = BMIter_Step(&liter), k++) {
                        CustomData_to_bmesh_block(&dm->loopData, &bm->ldata, k, &l->head.data);
                }
 
                        CustomData_to_bmesh_block(&dm->loopData, &bm->ldata, k, &l->head.data);
                }
 
-               CustomData_to_bmesh_block(&dm->polyData, &bm->pdata,
-                       i, &f->head.data);
+               CustomData_to_bmesh_block(&dm->polyData, &bm->pdata, i, &f->head.data);
        }
 
        MEM_freeN(vtable);
        }
 
        MEM_freeN(vtable);
@@ -217,4 +216,3 @@ BMEditMesh *CDDM_To_BMesh(Object *ob, DerivedMesh *dm, BMEditMesh *existing, int
 
        return em;
 }
 
        return em;
 }
-
index ca3c5fc067a3e8a2d745bb09844b609a41f1fc8a..9b522fc222e055f9542bec38b2e156aa0f468658 100644 (file)
@@ -296,7 +296,7 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
 
        /* ok, edges are in correct order, now ensure they are going
         * in the correct direction */
 
        /* ok, edges are in correct order, now ensure they are going
         * in the correct direction */
-       v1found = reverse = 0;
+       v1found = reverse = FALSE;
        for (i = 0; i < len; i++) {
                if (BM_Vert_In_Edge(edges2[i], v1)) {
                        /* see if v1 and v2 are in the same edge */
        for (i = 0; i < len; i++) {
                if (BM_Vert_In_Edge(edges2[i], v1)) {
                        /* see if v1 and v2 are in the same edge */
@@ -304,16 +304,16 @@ BMFace *BM_Make_Ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, int len,
                                /* if v1 is shared by the *next* edge, then the winding
                                 * is incorrect */
                                if (BM_Vert_In_Edge(edges2[(i + 1) % len], v1)) {
                                /* if v1 is shared by the *next* edge, then the winding
                                 * is incorrect */
                                if (BM_Vert_In_Edge(edges2[(i + 1) % len], v1)) {
-                                       reverse = 1;
+                                       reverse = TRUE;
                                        break;
                                }
                        }
 
                                        break;
                                }
                        }
 
-                       v1found = 1;
+                       v1found = TRUE;
                }
 
                }
 
-               if (!v1found && BM_Vert_In_Edge(edges2[i], v2)) {
-                       reverse = 1;
+               if ((v1found == FALSE) && BM_Vert_In_Edge(edges2[i], v2)) {
+                       reverse = TRUE;
                        break;
                }
        }
                        break;
                }
        }
index 1cfb066ab2c835df8d5e4c8d317cd32f85b6b6c3..c2f0d8c89edca2a5f9db42a8f034c48677503618 100644 (file)
@@ -119,7 +119,7 @@ void EDBM_select_mirrored(Object *UNUSED(obedit), BMEditMesh *em, int extend)
                if (!BM_TestHFlag(v1, BM_TMP_TAG) || BM_TestHFlag(v1, BM_HIDDEN))
                        continue;
 
                if (!BM_TestHFlag(v1, BM_TMP_TAG) || BM_TestHFlag(v1, BM_HIDDEN))
                        continue;
 
-               v2= EDBM_GetMirrorVert(em, v1);
+               v2 = EDBM_GetMirrorVert(em, v1);
                if (v2 && !BM_TestHFlag(v2, BM_HIDDEN)) {
                        BM_Select(em->bm, v2, TRUE);
                }
                if (v2 && !BM_TestHFlag(v2, BM_HIDDEN)) {
                        BM_Select(em->bm, v2, TRUE);
                }
@@ -133,9 +133,9 @@ void EDBM_automerge(Scene *scene, Object *obedit, int update)
        BMEditMesh *em;
        
        if ((scene->toolsettings->automerge) &&
        BMEditMesh *em;
        
        if ((scene->toolsettings->automerge) &&
-           (obedit && obedit->type==OB_MESH))
+           (obedit && obedit->type == OB_MESH))
        {
        {
-               em = ((Mesh*)obedit->data)->edit_btmesh;
+               em = ((Mesh *)obedit->data)->edit_btmesh;
                if (!em)
                        return;
 
                if (!em)
                        return;
 
@@ -148,49 +148,49 @@ void EDBM_automerge(Scene *scene, Object *obedit, int update)
 
 /* ****************************** SELECTION ROUTINES **************** */
 
 
 /* ****************************** SELECTION ROUTINES **************** */
 
-unsigned int bm_solidoffs=0, bm_wireoffs=0, bm_vertoffs=0;     /* set in drawobject.c ... for colorindices */
+unsigned int bm_solidoffs = 0, bm_wireoffs = 0, bm_vertoffs = 0;       /* set in drawobject.c ... for colorindices */
 
 /* facilities for border select and circle select */
 
 /* facilities for border select and circle select */
-static char *selbuf= NULL;
+static char *selbuf = NULL;
 
 /* opengl doesn't support concave... */
 static void draw_triangulated(int mcords[][2], short tot)
 {
 
 /* opengl doesn't support concave... */
 static void draw_triangulated(int mcords[][2], short tot)
 {
-       ListBase lb={NULL, NULL};
+       ListBase lb = {NULL, NULL};
        DispList *dl;
        float *fp;
        int a;
        
        /* make displist */
        DispList *dl;
        float *fp;
        int a;
        
        /* make displist */
-       dl= MEM_callocN(sizeof(DispList), "poly disp");
-       dl->type= DL_POLY;
-       dl->parts= 1;
-       dl->nr= tot;
-       dl->verts= fp=  MEM_callocN(tot*3*sizeof(float), "poly verts");
+       dl = MEM_callocN(sizeof(DispList), "poly disp");
+       dl->type = DL_POLY;
+       dl->parts = 1;
+       dl->nr = tot;
+       dl->verts = fp = MEM_callocN(tot * 3 * sizeof(float), "poly verts");
        BLI_addtail(&lb, dl);
        
        BLI_addtail(&lb, dl);
        
-       for(a=0; a<tot; a++, fp+=3) {
-               fp[0]= (float)mcords[a][0];
-               fp[1]= (float)mcords[a][1];
+       for (a = 0; a < tot; a++, fp += 3) {
+               fp[0] = (float)mcords[a][0];
+               fp[1] = (float)mcords[a][1];
        }
        
        /* do the fill */
        filldisplist(&lb, &lb, 0);
 
        /* do the draw */
        }
        
        /* do the fill */
        filldisplist(&lb, &lb, 0);
 
        /* do the draw */
-       dl= lb.first;   /* filldisplist adds in head of list */
-       if (dl->type==DL_INDEX3) {
+       dl = lb.first;  /* filldisplist adds in head of list */
+       if (dl->type == DL_INDEX3) {
                int *index;
                
                int *index;
                
-               a= dl->parts;
-               fp= dl->verts;
-               index= dl->index;
+               a = dl->parts;
+               fp = dl->verts;
+               index = dl->index;
                glBegin(GL_TRIANGLES);
                glBegin(GL_TRIANGLES);
-               while(a--) {
-                       glVertex3fv(fp+3*index[0]);
-                       glVertex3fv(fp+3*index[1]);
-                       glVertex3fv(fp+3*index[2]);
-                       index+= 3;
+               while (a--) {
+                       glVertex3fv(fp + 3 * index[0]);
+                       glVertex3fv(fp + 3 * index[1]);
+                       glVertex3fv(fp + 3 * index[2]);
+                       index += 3;
                }
                glEnd();
        }
                }
                glEnd();
        }
@@ -207,21 +207,23 @@ int EDBM_init_backbuf_border(ViewContext *vc, short xmin, short ymin, short xmax
        unsigned int *dr;
        int a;
        
        unsigned int *dr;
        int a;
        
-       if (vc->obedit==NULL || vc->v3d->drawtype<OB_SOLID || (vc->v3d->flag & V3D_ZBUF_SELECT)==0) return 0;
+       if (vc->obedit == NULL || vc->v3d->drawtype < OB_SOLID || (vc->v3d->flag & V3D_ZBUF_SELECT) == 0) {
+               return 0;
+       }
        
        
-       buf= view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
-       if (buf==NULL) return 0;
-       if (bm_vertoffs==0) return 0;
+       buf = view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
+       if (buf == NULL) return 0;
+       if (bm_vertoffs == 0) return 0;
 
        dr = buf->rect;
        
        /* build selection lookup */
 
        dr = buf->rect;
        
        /* build selection lookup */
-       selbuf= MEM_callocN(bm_vertoffs+1, "selbuf");
+       selbuf = MEM_callocN(bm_vertoffs + 1, "selbuf");
        
        
-       a= (xmax-xmin+1)*(ymax-ymin+1);
-       while(a--) {
-               if (*dr>0 && *dr<=bm_vertoffs)
-                       selbuf[*dr]= 1;
+       a = (xmax - xmin + 1) * (ymax-ymin + 1);
+       while (a--) {
+               if (*dr > 0 && *dr <= bm_vertoffs)
+                       selbuf[*dr] = 1;
                dr++;
        }
        IMB_freeImBuf(buf);
                dr++;
        }
        IMB_freeImBuf(buf);
@@ -230,8 +232,8 @@ int EDBM_init_backbuf_border(ViewContext *vc, short xmin, short ymin, short xmax
 
 int EDBM_check_backbuf(unsigned int index)
 {
 
 int EDBM_check_backbuf(unsigned int index)
 {
-       if (selbuf==NULL) return 1;
-       if (index>0 && index<=bm_vertoffs)
+       if (selbuf == NULL) return 1;
+       if (index > 0 && index <= bm_vertoffs)
                return selbuf[index];
        return 0;
 }
                return selbuf[index];
        return 0;
 }
@@ -239,7 +241,7 @@ int EDBM_check_backbuf(unsigned int index)
 void EDBM_free_backbuf(void)
 {
        if (selbuf) MEM_freeN(selbuf);
 void EDBM_free_backbuf(void)
 {
        if (selbuf) MEM_freeN(selbuf);
-       selbuf= NULL;
+       selbuf = NULL;
 }
 
 /* mcords is a polygon mask
 }
 
 /* mcords is a polygon mask
@@ -255,16 +257,18 @@ int EDBM_mask_init_backbuf_border(ViewContext *vc, int mcords[][2], short tot, s
        int a;
        
        /* method in use for face selecting too */
        int a;
        
        /* method in use for face selecting too */
-       if (vc->obedit==NULL) {
+       if (vc->obedit == NULL) {
                if (paint_facesel_test(vc->obact));
                else if (paint_vertsel_test(vc->obact));
                else return 0;
        }
                if (paint_facesel_test(vc->obact));
                else if (paint_vertsel_test(vc->obact));
                else return 0;
        }
-       else if (vc->v3d->drawtype<OB_SOLID || (vc->v3d->flag & V3D_ZBUF_SELECT)==0) return 0;
+       else if (vc->v3d->drawtype < OB_SOLID || (vc->v3d->flag & V3D_ZBUF_SELECT) == 0) {
+               return 0;
+       }
 
 
-       buf= view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
-       if (buf==NULL) return 0;
-       if (bm_vertoffs==0) return 0;
+       buf = view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
+       if (buf == NULL) return 0;
+       if (bm_vertoffs == 0) return 0;
 
        dr = buf->rect;
 
 
        dr = buf->rect;
 
@@ -275,31 +279,35 @@ int EDBM_mask_init_backbuf_border(ViewContext *vc, int mcords[][2], short tot, s
        
        /* yah, opengl doesn't do concave... tsk! */
        ED_region_pixelspace(vc->ar);
        
        /* yah, opengl doesn't do concave... tsk! */
        ED_region_pixelspace(vc->ar);
-       draw_triangulated(mcords, tot); 
+       draw_triangulated(mcords, tot);
        
        
-       glBegin(GL_LINE_LOOP);  /* for zero sized masks, lines */
-       for(a=0; a<tot; a++) glVertex2iv(mcords[a]);
+       glBegin(GL_LINE_LOOP);  /* for zero sized masks, lines */
+       for (a = 0; a < tot; a++) {
+               glVertex2iv(mcords[a]);
+       }
        glEnd();
        
        glFinish();     /* to be sure readpixels sees mask */
        
        /* grab mask */
        glEnd();
        
        glFinish();     /* to be sure readpixels sees mask */
        
        /* grab mask */
-       bufmask= view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
+       bufmask = view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
        drm = bufmask->rect;
        drm = bufmask->rect;
-       if (bufmask==NULL) return 0; /* only when mem alloc fails, go crash somewhere else! */
+       if (bufmask == NULL) {
+               return 0; /* only when mem alloc fails, go crash somewhere else! */
+       }
        
        /* build selection lookup */
        
        /* build selection lookup */
-       selbuf= MEM_callocN(bm_vertoffs+1, "selbuf");
+       selbuf = MEM_callocN(bm_vertoffs + 1, "selbuf");
        
        
-       a= (xmax-xmin+1)*(ymax-ymin+1);
-       while(a--) {
-               if (*dr>0 && *dr<=bm_vertoffs && *drm==0) selbuf[*dr]= 1;
+       a = (xmax - xmin + 1) * (ymax - ymin + 1);
+       while (a--) {
+               if (*dr > 0 && *dr <= bm_vertoffs && *drm == 0) selbuf[*dr] = 1;
                dr++; drm++;
        }
        IMB_freeImBuf(buf);
        IMB_freeImBuf(bufmask);
                dr++; drm++;
        }
        IMB_freeImBuf(buf);
        IMB_freeImBuf(bufmask);
+
        return 1;
        return 1;
-       
 }
 
 /* circle shaped sample area */
 }
 
 /* circle shaped sample area */
@@ -311,28 +319,28 @@ int EDBM_init_backbuf_circle(ViewContext *vc, short xs, short ys, short rads)
        int radsq;
        
        /* method in use for face selecting too */
        int radsq;
        
        /* method in use for face selecting too */
-       if (vc->obedit==NULL) {
+       if (vc->obedit == NULL) {
                if (paint_facesel_test(vc->obact));
                else if (paint_vertsel_test(vc->obact));
                else return 0;
        }
                if (paint_facesel_test(vc->obact));
                else if (paint_vertsel_test(vc->obact));
                else return 0;
        }
-       else if (vc->v3d->drawtype<OB_SOLID || (vc->v3d->flag & V3D_ZBUF_SELECT)==0) return 0;
+       else if (vc->v3d->drawtype < OB_SOLID || (vc->v3d->flag & V3D_ZBUF_SELECT) == 0) return 0;
        
        
-       xmin= xs-rads; xmax= xs+rads;
-       ymin= ys-rads; ymax= ys+rads;
-       buf= view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
-       if (bm_vertoffs==0) return 0;
-       if (buf==NULL) return 0;
+       xmin = xs - rads; xmax = xs + rads;
+       ymin = ys - rads; ymax = ys + rads;
+       buf = view3d_read_backbuf(vc, xmin, ymin, xmax, ymax);
+       if (bm_vertoffs == 0) return 0;
+       if (buf == NULL) return 0;
 
        dr = buf->rect;
        
        /* build selection lookup */
 
        dr = buf->rect;
        
        /* build selection lookup */
-       selbuf= MEM_callocN(bm_vertoffs+1, "selbuf");
-       radsq= rads*rads;
-       for(yc= -rads; yc<=rads; yc++) {
-               for(xc= -rads; xc<=rads; xc++, dr++) {
-                       if (xc*xc + yc*yc < radsq) {
-                               if (*dr>0 && *dr<=bm_vertoffs) selbuf[*dr]= 1;
+       selbuf = MEM_callocN(bm_vertoffs + 1, "selbuf");
+       radsq = rads * rads;
+       for (yc = -rads; yc <= rads; yc++) {
+               for (xc = -rads; xc <= rads; xc++, dr++) {
+                       if (xc * xc + yc * yc < radsq) {
+                               if (*dr > 0 && *dr <= bm_vertoffs) selbuf[*dr] = 1;
                        }
                }
        }
                        }
                }
        }
@@ -346,16 +354,16 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y
 {
        struct { short mval[2], pass, select, strict; int dist, lastIndex, closestIndex; BMVert *closest; } *data = userData;
 
 {
        struct { short mval[2], pass, select, strict; int dist, lastIndex, closestIndex; BMVert *closest; } *data = userData;
 
-       if (data->pass==0) {
-               if (index<=data->lastIndex)
+       if (data->pass == 0) {
+               if (index <= data->lastIndex)
                        return;
        }
        else {
                        return;
        }
        else {
-               if (index>data->lastIndex)
+               if (index > data->lastIndex)
                        return;
        }
 
                        return;
        }
 
-       if (data->dist>3) {
+       if (data->dist > 3) {
                int temp = abs(data->mval[0] - x) + abs(data->mval[1]- y);
                if (BM_TestHFlag(eve, BM_SELECT) == data->select) {
                        if (data->strict == 1)
                int temp = abs(data->mval[0] - x) + abs(data->mval[1]- y);
                if (BM_TestHFlag(eve, BM_SELECT) == data->select) {
                        if (data->strict == 1)
@@ -364,7 +372,7 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y
                                temp += 5;
                }
 
                                temp += 5;
                }
 
-               if (temp<data->dist) {
+               if (temp < data->dist) {
                        data->dist = temp;
                        data->closest = eve;
                        data->closestIndex = index;
                        data->dist = temp;
                        data->closest = eve;
                        data->closestIndex = index;
@@ -377,11 +385,11 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y
 
 static unsigned int findnearestvert__backbufIndextest(void *handle, unsigned int index)
 {
 
 static unsigned int findnearestvert__backbufIndextest(void *handle, unsigned int index)
 {
-       BMEditMesh *em= (BMEditMesh *)handle;
-       BMVert *eve = BM_Vert_AtIndex(em->bm, index-1);
+       BMEditMesh *em = (BMEditMesh *)handle;
+       BMVert *eve = BM_Vert_AtIndex(em->bm, index - 1);
 
        if (eve && BM_TestHFlag(eve, BM_SELECT)) return 0;
 
        if (eve && BM_TestHFlag(eve, BM_SELECT)) return 0;
-       return 1; 
+       return 1;
 }
 /**
  * findnearestvert
 }
 /**
  * findnearestvert
@@ -394,15 +402,21 @@ static unsigned int findnearestvert__backbufIndextest(void *handle, unsigned int
  */
 BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict)
 {
  */
 BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict)
 {
-       if (vc->v3d->drawtype>OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
+       if (vc->v3d->drawtype > OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
                int distance;
                unsigned int index;
                BMVert *eve;
                
                int distance;
                unsigned int index;
                BMVert *eve;
                
-               if (strict) index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_wireoffs, 0xFFFFFF, &distance, strict, vc->em, findnearestvert__backbufIndextest);
-               else index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_wireoffs, 0xFFFFFF, &distance, 0, NULL, NULL); 
+               if (strict) {
+                       index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_wireoffs, 0xFFFFFF, &distance,
+                                                          strict, vc->em, findnearestvert__backbufIndextest);
+               }
+               else {
+                       index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_wireoffs, 0xFFFFFF, &distance,
+                                                          0, NULL, NULL);
+               }
                
                
-               eve = BM_Vert_AtIndex(vc->em->bm, index-1);
+               eve = BM_Vert_AtIndex(vc->em->bm, index - 1);
                
                if (eve && distance < *dist) {
                        *dist = distance;
                
                if (eve && distance < *dist) {
                        *dist = distance;
@@ -415,8 +429,8 @@ BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict
        }
        else {
                struct { short mval[2], pass, select, strict; int dist, lastIndex, closestIndex; BMVert *closest; } data;
        }
        else {
                struct { short mval[2], pass, select, strict; int dist, lastIndex, closestIndex; BMVert *closest; } data;
-               static int lastSelectedIndex=0;
-               static BMVert *lastSelected=NULL;
+               static int lastSelectedIndex = 0;
+               static BMVert *lastSelected = NULL;
                
                if (lastSelected && BM_Vert_AtIndex(vc->em->bm, lastSelectedIndex) != lastSelected) {
                        lastSelectedIndex = 0;
                
                if (lastSelected && BM_Vert_AtIndex(vc->em->bm, lastSelectedIndex) != lastSelected) {
                        lastSelectedIndex = 0;
@@ -438,7 +452,7 @@ BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict
 
                mesh_foreachScreenVert(vc, findnearestvert__doClosest, &data, V3D_CLIP_TEST_RV3D_CLIPPING);
 
 
                mesh_foreachScreenVert(vc, findnearestvert__doClosest, &data, V3D_CLIP_TEST_RV3D_CLIPPING);
 
-               if (data.dist>3) {
+               if (data.dist > 3) {
                        data.pass = 1;
                        mesh_foreachScreenVert(vc, findnearestvert__doClosest, &data, V3D_CLIP_TEST_RV3D_CLIPPING);
                }
                        data.pass = 1;
                        mesh_foreachScreenVert(vc, findnearestvert__doClosest, &data, V3D_CLIP_TEST_RV3D_CLIPPING);
                }
@@ -451,18 +465,18 @@ BMVert *EDBM_findnearestvert(ViewContext *vc, int *dist, short sel, short strict
        }
 }
 
        }
 }
 
-/* returns labda for closest distance v1 to line-piece v2-v3 */
+/* returns labda for closest distance v1 to line-piece v2 - v3 */
 float labda_PdistVL2Dfl(const float v1[3], const float v2[3], const float v3[3])
 {
        float rc[2], len;
        
 float labda_PdistVL2Dfl(const float v1[3], const float v2[3], const float v3[3])
 {
        float rc[2], len;
        
-       rc[0]= v3[0]-v2[0];
-       rc[1]= v3[1]-v2[1];
-       len= rc[0]*rc[0]+ rc[1]*rc[1];
-       if (len==0.0f)
+       rc[0] = v3[0] - v2[0];
+       rc[1] = v3[1] - v2[1];
+       len = rc[0] * rc[0] + rc[1] * rc[1];
+       if (len == 0.0f)
                return 0.0f;
        
                return 0.0f;
        
-       return ( rc[0]*(v1[0]-v2[0]) + rc[1]*(v1[1]-v2[1]) )/len;
+       return (rc[0] * (v1[0] - v2[0]) + rc[1] * (v1[1] - v2[1]) ) / len;
 }
 
 /* note; uses v3d, so needs active 3d window */
 }
 
 /* note; uses v3d, so needs active 3d window */
@@ -477,20 +491,23 @@ static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int
        v2[0] = x1;
        v2[1] = y1;
                
        v2[0] = x1;
        v2[1] = y1;
                
-       distance= dist_to_line_segment_v2(data->mval, v1, v2);
+       distance = dist_to_line_segment_v2(data->mval, v1, v2);
                
                
-       if (BM_TestHFlag(eed, BM_SELECT)) distance+=5;
+       if (BM_TestHFlag(eed, BM_SELECT)) {
+               distance += 5;
+       }
+
        if (distance < data->dist) {
                if (data->vc.rv3d->rflag & RV3D_CLIPPING) {
        if (distance < data->dist) {
                if (data->vc.rv3d->rflag & RV3D_CLIPPING) {
-                       float labda= labda_PdistVL2Dfl(data->mval, v1, v2);
+                       float labda = labda_PdistVL2Dfl(data->mval, v1, v2);
                        float vec[3];
 
                        float vec[3];
 
-                       vec[0]= eed->v1->co[0] + labda*(eed->v2->co[0] - eed->v1->co[0]);
-                       vec[1]= eed->v1->co[1] + labda*(eed->v2->co[1] - eed->v1->co[1]);
-                       vec[2]= eed->v1->co[2] + labda*(eed->v2->co[2] - eed->v1->co[2]);
+                       vec[0] = eed->v1->co[0] + labda * (eed->v2->co[0] - eed->v1->co[0]);
+                       vec[1] = eed->v1->co[1] + labda * (eed->v2->co[1] - eed->v1->co[1]);
+                       vec[2] = eed->v1->co[2] + labda * (eed->v2->co[2] - eed->v1->co[2]);
                        mul_m4_v3(data->vc.obedit->obmat, vec);
 
                        mul_m4_v3(data->vc.obedit->obmat, vec);
 
-                       if (ED_view3d_test_clipping(data->vc.rv3d, vec, 1)==0) {
+                       if (ED_view3d_test_clipping(data->vc.rv3d, vec, 1) == 0) {
                                data->dist = distance;
                                data->closest = eed;
                        }
                                data->dist = distance;
                                data->closest = eed;
                        }
@@ -504,7 +521,7 @@ static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int
 BMEdge *EDBM_findnearestedge(ViewContext *vc, int *dist)
 {
 
 BMEdge *EDBM_findnearestedge(ViewContext *vc, int *dist)
 {
 
-       if (vc->v3d->drawtype>OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
+       if (vc->v3d->drawtype > OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
                int distance;
                unsigned int index;
                BMEdge *eed;
                int distance;
                unsigned int index;
                BMEdge *eed;
@@ -512,9 +529,9 @@ BMEdge *EDBM_findnearestedge(ViewContext *vc, int *dist)
                view3d_validate_backbuf(vc);
                
                index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_solidoffs, bm_wireoffs, &distance,0, NULL, NULL);
                view3d_validate_backbuf(vc);
                
                index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_solidoffs, bm_wireoffs, &distance,0, NULL, NULL);
-               eed = BM_Edge_AtIndex(vc->em->bm, index-1);
+               eed = BM_Edge_AtIndex(vc->em->bm, index - 1);
                
                
-               if (eed && distance<*dist) {
+               if (eed && distance < *dist) {
                        *dist = distance;
                        return eed;
                }
                        *dist = distance;
                        return eed;
                }
@@ -525,7 +542,7 @@ BMEdge *EDBM_findnearestedge(ViewContext *vc, int *dist)
        else {
                struct { ViewContext vc; float mval[2]; int dist; BMEdge *closest; } data;
 
        else {
                struct { ViewContext vc; float mval[2]; int dist; BMEdge *closest; } data;
 
-               data.vc= *vc;
+               data.vc = *vc;
                data.mval[0] = vc->mval[0];
                data.mval[1] = vc->mval[1];
                data.dist = *dist;
                data.mval[0] = vc->mval[0];
                data.mval[1] = vc->mval[1];
                data.dist = *dist;
@@ -543,10 +560,10 @@ static void findnearestface__getDistance(void *userData, BMFace *efa, int x, int
 {
        struct { short mval[2]; int dist; BMFace *toFace; } *data = userData;
 
 {
        struct { short mval[2]; int dist; BMFace *toFace; } *data = userData;
 
-       if (efa==data->toFace) {
-               int temp = abs(data->mval[0]-x) + abs(data->mval[1]-y);
+       if (efa == data->toFace) {
+               int temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
 
 
-               if (temp<data->dist)
+               if (temp < data->dist)
                        data->dist = temp;
        }
 }
                        data->dist = temp;
        }
 }
@@ -554,19 +571,19 @@ static void findnearestface__doClosest(void *userData, BMFace *efa, int x, int y
 {
        struct { short mval[2], pass; int dist, lastIndex, closestIndex; BMFace *closest; } *data = userData;
 
 {
        struct { short mval[2], pass; int dist, lastIndex, closestIndex; BMFace *closest; } *data = userData;
 
-       if (data->pass==0) {
-               if (index<=data->lastIndex)
+       if (data->pass == 0) {
+               if (index <= data->lastIndex)
                        return;
        }
        else {
                        return;
        }
        else {
-               if (index>data->lastIndex)
+               if (index > data->lastIndex)
                        return;
        }
 
                        return;
        }
 
-       if (data->dist>3) {
-               int temp = abs(data->mval[0]-x) + abs(data->mval[1]-y);
+       if (data->dist > 3) {
+               int temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
 
 
-               if (temp<data->dist) {
+               if (temp < data->dist) {
                        data->dist = temp;
                        data->closest = efa;
                        data->closestIndex = index;
                        data->dist = temp;
                        data->closest = efa;
                        data->closestIndex = index;
@@ -577,14 +594,14 @@ static void findnearestface__doClosest(void *userData, BMFace *efa, int x, int y
 BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
 {
 
 BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
 {
 
-       if (vc->v3d->drawtype>OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
+       if (vc->v3d->drawtype > OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
                unsigned int index;
                BMFace *efa;
 
                view3d_validate_backbuf(vc);
 
                index = view3d_sample_backbuf(vc, vc->mval[0], vc->mval[1]);
                unsigned int index;
                BMFace *efa;
 
                view3d_validate_backbuf(vc);
 
                index = view3d_sample_backbuf(vc, vc->mval[0], vc->mval[1]);
-               efa = BM_Face_AtIndex(vc->em->bm, index-1);
+               efa = BM_Face_AtIndex(vc->em->bm, index - 1);
                
                if (efa) {
                        struct { short mval[2]; int dist; BMFace *toFace; } data;
                
                if (efa) {
                        struct { short mval[2]; int dist; BMFace *toFace; } data;
@@ -596,8 +613,8 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
 
                        mesh_foreachScreenFace(vc, findnearestface__getDistance, &data);
 
 
                        mesh_foreachScreenFace(vc, findnearestface__getDistance, &data);
 
-                       if (vc->em->selectmode == SCE_SELECT_FACE || data.dist<*dist) { /* only faces, no dist check */
-                               *dist= data.dist;
+                       if (vc->em->selectmode == SCE_SELECT_FACE || data.dist < *dist) {       /* only faces, no dist check */
+                               *dist = data.dist;
                                return efa;
                        }
                }
                                return efa;
                        }
                }
@@ -606,8 +623,8 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
        }
        else {
                struct { short mval[2], pass; int dist, lastIndex, closestIndex; BMFace *closest; } data;
        }
        else {
                struct { short mval[2], pass; int dist, lastIndex, closestIndex; BMFace *closest; } data;
-               static int lastSelectedIndex=0;
-               static BMFace *lastSelected=NULL;
+               static int lastSelectedIndex = 0;
+               static BMFace *lastSelected = NULL;
 
                if (lastSelected && BM_Face_AtIndex(vc->em->bm, lastSelectedIndex) != lastSelected) {
                        lastSelectedIndex = 0;
 
                if (lastSelected && BM_Face_AtIndex(vc->em->bm, lastSelectedIndex) != lastSelected) {
                        lastSelectedIndex = 0;
@@ -625,7 +642,7 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
                data.pass = 0;
                mesh_foreachScreenFace(vc, findnearestface__doClosest, &data);
 
                data.pass = 0;
                mesh_foreachScreenFace(vc, findnearestface__doClosest, &data);
 
-               if (data.dist>3) {
+               if (data.dist > 3) {
                        data.pass = 1;
                        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
                        mesh_foreachScreenFace(vc, findnearestface__doClosest, &data);
                        data.pass = 1;
                        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
                        mesh_foreachScreenFace(vc, findnearestface__doClosest, &data);
@@ -646,31 +663,31 @@ BMFace *EDBM_findnearestface(ViewContext *vc, int *dist)
 */
 static int unified_findnearest(ViewContext *vc, BMVert **eve, BMEdge **eed, BMFace **efa) 
 {
 */
 static int unified_findnearest(ViewContext *vc, BMVert **eve, BMEdge **eed, BMFace **efa) 
 {
-       BMEditMesh *em= vc->em;
-       int dist= 75;
+       BMEditMesh *em = vc->em;
+       int dist = 75;
        
        
-       *eve= NULL;
-       *eed= NULL;
-       *efa= NULL;
+       *eve = NULL;
+       *eed = NULL;
+       *efa = NULL;
        
        /* no afterqueue (yet), so we check it now, otherwise the em_xxxofs indices are bad */
        view3d_validate_backbuf(vc);
        
        if (em->selectmode & SCE_SELECT_VERTEX)
        
        /* no afterqueue (yet), so we check it now, otherwise the em_xxxofs indices are bad */
        view3d_validate_backbuf(vc);
        
        if (em->selectmode & SCE_SELECT_VERTEX)
-               *eve= EDBM_findnearestvert(vc, &dist, BM_SELECT, 0);
+               *eve = EDBM_findnearestvert(vc, &dist, BM_SELECT, 0);
        if (em->selectmode & SCE_SELECT_FACE)
        if (em->selectmode & SCE_SELECT_FACE)
-               *efa= EDBM_findnearestface(vc, &dist);
+               *efa = EDBM_findnearestface(vc, &dist);
 
        dist-= 20;      /* since edges select lines, we give dots advantage of 20 pix */
        if (em->selectmode & SCE_SELECT_EDGE)
 
        dist-= 20;      /* since edges select lines, we give dots advantage of 20 pix */
        if (em->selectmode & SCE_SELECT_EDGE)
-               *eed= EDBM_findnearestedge(vc, &dist);
+               *eed = EDBM_findnearestedge(vc, &dist);
 
        /* return only one of 3 pointers, for frontbuffer redraws */
        if (*eed) {
 
        /* return only one of 3 pointers, for frontbuffer redraws */
        if (*eed) {
-               *efa= NULL; *eve= NULL;
+               *efa = NULL; *eve = NULL;
        }
        else if (*efa) {
        }
        else if (*efa) {
-               *eve= NULL;
+               *eve = NULL;
        }
        
        return (*eve || *eed || *efa);
        }
        
        return (*eve || *eed || *efa);
@@ -706,7 +723,7 @@ static EnumPropertyItem prop_similar_types[] = {
 static int similar_face_select_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int similar_face_select_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        /* get the type from RNA */
        BMOperator bmop;
 
        /* get the type from RNA */
@@ -747,7 +764,7 @@ static int similar_face_select_exec(bContext *C, wmOperator *op)
 static int similar_edge_select_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int similar_edge_select_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        /* get the type from RNA */
        BMOperator bmop;
 
        /* get the type from RNA */
@@ -794,7 +811,7 @@ VERT GROUP
 static int similar_vert_select_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int similar_vert_select_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
        /* get the type from RNA */
        int type = RNA_enum_get(op->ptr, "type");
        BMOperator bmop;
        /* get the type from RNA */
        int type = RNA_enum_get(op->ptr, "type");
@@ -829,7 +846,7 @@ static int similar_vert_select_exec(bContext *C, wmOperator *op)
 
 static int select_similar_exec(bContext *C, wmOperator *op)
 {
 
 static int select_similar_exec(bContext *C, wmOperator *op)
 {
-       int type= RNA_enum_get(op->ptr, "type");
+       int type = RNA_enum_get(op->ptr, "type");
 
        if (type < 100)
                return similar_vert_select_exec(C, op);
 
        if (type < 100)
                return similar_vert_select_exec(C, op);
@@ -839,33 +856,34 @@ static int select_similar_exec(bContext *C, wmOperator *op)
                return similar_face_select_exec(C, op);
 }
 
                return similar_face_select_exec(C, op);
 }
 
-static EnumPropertyItem *select_similar_type_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free)
+static EnumPropertyItem *select_similar_type_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop),
+                                                   int *free)
 {
        Object *obedit = CTX_data_edit_object(C);
 
        if (obedit && obedit->type == OB_MESH) {
 {
        Object *obedit = CTX_data_edit_object(C);
 
        if (obedit && obedit->type == OB_MESH) {
-               EnumPropertyItem *item= NULL;
-               int a, totitem= 0;
-               BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh; 
+               EnumPropertyItem *item = NULL;
+               int a, totitem = 0;
+               BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
 
                if (em->selectmode & SCE_SELECT_VERTEX) {
 
                if (em->selectmode & SCE_SELECT_VERTEX) {
-                       for (a=SIMVERT_NORMAL; a<SIMEDGE_LENGTH; a++) {
+                       for (a = SIMVERT_NORMAL; a < SIMEDGE_LENGTH; a++) {
                                RNA_enum_items_add_value(&item, &totitem, prop_similar_types, a);
                        }
                }
                else if (em->selectmode & SCE_SELECT_EDGE) {
                                RNA_enum_items_add_value(&item, &totitem, prop_similar_types, a);
                        }
                }
                else if (em->selectmode & SCE_SELECT_EDGE) {
-                       for (a=SIMEDGE_LENGTH; a<SIMFACE_MATERIAL; a++) {
+                       for (a = SIMEDGE_LENGTH; a < SIMFACE_MATERIAL; a++) {
                                RNA_enum_items_add_value(&item, &totitem, prop_similar_types, a);
                        }
                }
                else if (em->selectmode & SCE_SELECT_FACE) {
                                RNA_enum_items_add_value(&item, &totitem, prop_similar_types, a);
                        }
                }
                else if (em->selectmode & SCE_SELECT_FACE) {
-                       for (a=SIMFACE_MATERIAL; a<=SIMFACE_COPLANAR; a++) {
+                       for (a = SIMFACE_MATERIAL; a <= SIMFACE_COPLANAR; a++) {
                                RNA_enum_items_add_value(&item, &totitem, prop_similar_types, a);
                        }
                }
                RNA_enum_item_end(&item, &totitem);
 
                                RNA_enum_items_add_value(&item, &totitem, prop_similar_types, a);
                        }
                }
                RNA_enum_item_end(&item, &totitem);
 
-               *free= 1;
+               *free = 1;
 
                return item;
        }
 
                return item;
        }
@@ -878,20 +896,20 @@ void MESH_OT_select_similar(wmOperatorType *ot)
        PropertyRNA *prop;
 
        /* identifiers */
        PropertyRNA *prop;
 
        /* identifiers */
-       ot->name= "Select Similar";
-       ot->idname= "MESH_OT_select_similar";
+       ot->name = "Select Similar";
+       ot->idname = "MESH_OT_select_similar";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= WM_menu_invoke;
-       ot->exec= select_similar_exec;
-       ot->poll= ED_operator_editmesh;
-       ot->description= "Select similar vertices, edges or faces by property types";
+       ot->invoke = WM_menu_invoke;
+       ot->exec = select_similar_exec;
+       ot->poll = ED_operator_editmesh;
+       ot->description = "Select similar vertices, edges or faces by property types";
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* properties */
        
        /* properties */
-       prop= ot->prop= RNA_def_enum(ot->srna, "type", prop_similar_types, SIMVERT_NORMAL, "Type", "");
+       prop = ot->prop = RNA_def_enum(ot->srna, "type", prop_similar_types, SIMVERT_NORMAL, "Type", "");
        RNA_def_enum_funcs(prop, select_similar_type_itemf);
 }
 
        RNA_def_enum_funcs(prop, select_similar_type_itemf);
 }
 
@@ -920,17 +938,17 @@ static void walker_select(BMEditMesh *em, int walkercode, void *start, int selec
 
 static int loop_multiselect(bContext *C, wmOperator *op)
 {
 
 static int loop_multiselect(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMEdge *eed;
        BMEdge **edarray;
        int edindex;
        BMEdge *eed;
        BMEdge **edarray;
        int edindex;
-       int looptype= RNA_boolean_get(op->ptr, "ring");
+       int looptype = RNA_boolean_get(op->ptr, "ring");
        
        BMIter iter;
        int totedgesel = 0;
 
        
        BMIter iter;
        int totedgesel = 0;
 
-       for(eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
+       for (eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
            eed; eed = BMIter_Step(&iter)) {
 
                if (BM_TestHFlag(eed, BM_SELECT)) {
            eed; eed = BMIter_Step(&iter)) {
 
                if (BM_TestHFlag(eed, BM_SELECT)) {
@@ -939,11 +957,13 @@ static int loop_multiselect(bContext *C, wmOperator *op)
        }
 
        
        }
 
        
-       edarray = MEM_mallocN(sizeof(BMEdge*)*totedgesel,"edge array");
+       edarray = MEM_mallocN(sizeof(BMEdge *)*totedgesel,"edge array");
        edindex = 0;
        
        edindex = 0;
        
-       for(eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
-           eed; eed = BMIter_Step(&iter)) {
+       for (eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
+            eed;
+            eed = BMIter_Step(&iter))
+       {
 
                if (BM_TestHFlag(eed, BM_SELECT)) {
                        edarray[edindex] = eed;
 
                if (BM_TestHFlag(eed, BM_SELECT)) {
                        edarray[edindex] = eed;
@@ -952,14 +972,14 @@ static int loop_multiselect(bContext *C, wmOperator *op)
        }
        
        if (looptype) {
        }
        
        if (looptype) {
-               for(edindex = 0; edindex < totedgesel; edindex +=1) {
+               for (edindex = 0; edindex < totedgesel; edindex += 1) {
                        eed = edarray[edindex];
                        walker_select(em, BMW_EDGERING, eed, 1);
                }
                EDBM_selectmode_flush(em);
        }
        else{
                        eed = edarray[edindex];
                        walker_select(em, BMW_EDGERING, eed, 1);
                }
                EDBM_selectmode_flush(em);
        }
        else{
-               for(edindex = 0; edindex < totedgesel; edindex +=1) {
+               for (edindex = 0; edindex < totedgesel; edindex += 1) {
                        eed = edarray[edindex];
                        walker_select(em, BMW_LOOP, eed, 1);
                }
                        eed = edarray[edindex];
                        walker_select(em, BMW_LOOP, eed, 1);
                }
@@ -970,22 +990,22 @@ static int loop_multiselect(bContext *C, wmOperator *op)
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
 
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
 
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_loop_multi_select(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_loop_multi_select(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Multi Select Loops";
-       ot->idname= "MESH_OT_loop_multi_select";
+       ot->name = "Multi Select Loops";
+       ot->idname = "MESH_OT_loop_multi_select";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= loop_multiselect;
-       ot->poll= ED_operator_editmesh;
-       ot->description= "Select a loop of connected edges by connection type";
+       ot->exec = loop_multiselect;
+       ot->poll = ED_operator_editmesh;
+       ot->description = "Select a loop of connected edges by connection type";
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* properties */
        RNA_def_boolean(ot->srna, "ring", 0, "Ring", "");
        
        /* properties */
        RNA_def_boolean(ot->srna, "ring", 0, "Ring", "");
@@ -1002,26 +1022,28 @@ static void mouse_mesh_loop(bContext *C, int mval[2], short extend, short ring)
        ViewContext vc;
        BMEditMesh *em;
        BMEdge *eed;
        ViewContext vc;
        BMEditMesh *em;
        BMEdge *eed;
-       int select= 1;
+       int select = TRUE;
        int dist = 50;
        
        em_setup_viewcontext(C, &vc);
        int dist = 50;
        
        em_setup_viewcontext(C, &vc);
-       vc.mval[0]= mval[0];
-       vc.mval[1]= mval[1];
-       em= vc.em;
+       vc.mval[0] = mval[0];
+       vc.mval[1] = mval[1];
+       em = vc.em;
        
        /* no afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad */
        view3d_validate_backbuf(&vc);
 
        eed = EDBM_findnearestedge(&vc, &dist);
        if (eed) {
        
        /* no afterqueue (yet), so we check it now, otherwise the bm_xxxofs indices are bad */
        view3d_validate_backbuf(&vc);
 
        eed = EDBM_findnearestedge(&vc, &dist);
        if (eed) {
-               if (extend==0) EDBM_clear_flag_all(em, BM_SELECT);
+               if (extend == 0) {
+                       EDBM_clear_flag_all(em, BM_SELECT);
+               }
        
        
-               if (BM_TestHFlag(eed, BM_SELECT)==0) {
-                       select=1;
+               if (BM_TestHFlag(eed, BM_SELECT) == 0) {
+                       select = TRUE;
                }
                else if (extend) {
                }
                else if (extend) {
-                       select=0;
+                       select = FALSE;
                }
 
                if (em->selectmode & SCE_SELECT_FACE) {
                }
 
                if (em->selectmode & SCE_SELECT_FACE) {
@@ -1048,16 +1070,16 @@ static void mouse_mesh_loop(bContext *C, int mval[2], short extend, short ring)
                if (select) {
                        if (em->selectmode & SCE_SELECT_VERTEX) {
                                /* TODO: would be nice if the edge vertex chosen here
                if (select) {
                        if (em->selectmode & SCE_SELECT_VERTEX) {
                                /* TODO: would be nice if the edge vertex chosen here
-                                  was the one closer to the selection pointer, instead
-                                  of arbitrarily selecting the first one */
+                                * was the one closer to the selection pointer, instead
+                                * of arbitrarily selecting the first one */
                                EDBM_store_selection(em, eed->v1);
                        }
                        else if (em->selectmode & SCE_SELECT_EDGE) {
                                EDBM_store_selection(em, eed);
                        }
                        /* TODO: would be nice if the nearest face that
                                EDBM_store_selection(em, eed->v1);
                        }
                        else if (em->selectmode & SCE_SELECT_EDGE) {
                                EDBM_store_selection(em, eed);
                        }
                        /* TODO: would be nice if the nearest face that
-                          belongs to the selected edge could be set to
-                          active here in face select mode */
+                        * belongs to the selected edge could be set to
+                        * active here in face select mode */
                }
 
                WM_event_add_notifier(C, NC_GEOM|ND_SELECT, vc.obedit);
                }
 
                WM_event_add_notifier(C, NC_GEOM|ND_SELECT, vc.obedit);
@@ -1079,17 +1101,17 @@ static int mesh_select_loop_invoke(bContext *C, wmOperator *op, wmEvent *event)
 void MESH_OT_loop_select(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_loop_select(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Loop Select";
-       ot->idname= "MESH_OT_loop_select";
-       ot->description= "Select a loop";
+       ot->name = "Loop Select";
+       ot->idname = "MESH_OT_loop_select";
+       ot->description = "Select a loop";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= mesh_select_loop_invoke;
-       ot->poll= ED_operator_editmesh_region_view3d;
-       ot->description= "Select a loop of connected edges";
+       ot->invoke = mesh_select_loop_invoke;
+       ot->poll = ED_operator_editmesh_region_view3d;
+       ot->description = "Select a loop of connected edges";
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* properties */
        RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "Extend the selection");
        
        /* properties */
        RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "Extend the selection");
@@ -1099,16 +1121,16 @@ void MESH_OT_loop_select(wmOperatorType *ot)
 void MESH_OT_edgering_select (wmOperatorType *ot)
 {
        /* description */
 void MESH_OT_edgering_select (wmOperatorType *ot)
 {
        /* description */
-       ot->name= "Edge Ring Select";
-       ot->idname= "MESH_OT_edgering_select";
-       ot->description= "Select an edge ring";
+       ot->name = "Edge Ring Select";
+       ot->idname = "MESH_OT_edgering_select";
+       ot->description = "Select an edge ring";
        
        /* callbacks */
        
        /* callbacks */
-       ot->invoke= mesh_select_loop_invoke;
-       ot->poll= ED_operator_editmesh_region_view3d;
+       ot->invoke = mesh_select_loop_invoke;
+       ot->poll = ED_operator_editmesh_region_view3d;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the selection");
        RNA_def_boolean(ot->srna, "ring", 1, "Select Ring", "Select ring");
 
        RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the selection");
        RNA_def_boolean(ot->srna, "ring", 1, "Select Ring", "Select ring");
@@ -1116,22 +1138,22 @@ void MESH_OT_edgering_select (wmOperatorType *ot)
 
 /* ******************* edgetag_shortest_path and helpers ****************** */
 
 
 /* ******************* edgetag_shortest_path and helpers ****************** */
 
-static float edgetag_cut_cost(BMEditMesh *UNUSED(em), BMEdge *e1, BMEdge *e2, BMVertv)
+static float edgetag_cut_cost(BMEditMesh *UNUSED(em), BMEdge *e1, BMEdge *e2, BMVert *v)
 {
        BMVert *v1 = (e1->v1 == v) ? e1->v2 : e1->v1;
        BMVert *v2 = (e2->v1 == v) ? e2->v2 : e2->v1;
        float cost, d1[3], d2[3];
 
 {
        BMVert *v1 = (e1->v1 == v) ? e1->v2 : e1->v1;
        BMVert *v2 = (e2->v1 == v) ? e2->v2 : e2->v1;
        float cost, d1[3], d2[3];
 
-       /*The cost is based on the simple sum of the length of the two edgees...*/
+       /* The cost is based on the simple sum of the length of the two edgees... */
        sub_v3_v3v3(d1, v->co, v1->co);
        sub_v3_v3v3(d2, v2->co, v->co);
        cost = len_v3(d1);
        cost += len_v3(d2);
 
        sub_v3_v3v3(d1, v->co, v1->co);
        sub_v3_v3v3(d2, v2->co, v->co);
        cost = len_v3(d1);
        cost += len_v3(d2);
 
-       /*...but is biased to give higher values to sharp turns, so that it will take
-         paths with fewer "turns" when selecting between equal-weighted paths between
-         the two edges*/
-       cost = cost + 0.5f*cost*(2.0f - sqrt(fabs(dot_v3v3(d1, d2))));
+       /*.but is biased to give higher values to sharp turns, so that it will take
+        * paths with fewer "turns" when selecting between equal-weighted paths between
+        * the two edges */
+       cost = cost + 0.5f * cost * (2.0f - sqrt(fabs(dot_v3v3(d1, d2))));
 
        return cost;
 }
 
        return cost;
 }
@@ -1141,7 +1163,7 @@ static void edgetag_add_adjacent(BMEditMesh *em, SmallHash *visithash, Heap *hea
 {
        BMEdge *e1 = EDBM_get_edge_for_index(em, mednum);
        BMVert *v = EDBM_get_vert_for_index(em, vertnum);
 {
        BMEdge *e1 = EDBM_get_edge_for_index(em, mednum);
        BMVert *v = EDBM_get_vert_for_index(em, vertnum);
-       int startadj, endadj = nedges[vertnum+1];
+       int startadj, endadj = nedges[vertnum + 1];
 
        for (startadj = nedges[vertnum]; startadj < endadj; startadj++) {
                int adjnum = edges[startadj];
 
        for (startadj = nedges[vertnum]; startadj < endadj; startadj++) {
                int adjnum = edges[startadj];
@@ -1177,7 +1199,7 @@ static void edgetag_context_set(BMEditMesh *em, Scene *scene, BMEdge *e, int val
        case EDGE_MODE_TAG_SHARP:
                if (val)                {BM_SetHFlag(e, BM_SEAM);}
                else                    {BM_ClearHFlag(e, BM_SEAM);}
        case EDGE_MODE_TAG_SHARP:
                if (val)                {BM_SetHFlag(e, BM_SEAM);}
                else                    {BM_ClearHFlag(e, BM_SEAM);}
-               break;                          
+               break;
        case EDGE_MODE_TAG_CREASE:
         {
                float *crease = CustomData_bmesh_get(&em->bm->edata, e->head.data, CD_CREASE);
        case EDGE_MODE_TAG_CREASE:
         {
                float *crease = CustomData_bmesh_get(&em->bm->edata, e->head.data, CD_CREASE);
@@ -1221,13 +1243,13 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
        Heap *heap;
        SmallHash visithash;
        float *cost;
        Heap *heap;
        SmallHash visithash;
        float *cost;
-       int i, totvert=0, totedge=0, *nedges, *edges, *prevedge, mednum = -1, nedgeswap = 0;
+       int i, totvert = 0, totedge = 0, *nedges, *edges, *prevedge, mednum = -1, nedgeswap = 0;
        int targetnum;
 
        BLI_smallhash_init(&visithash);
 
        /* note, would pass BM_EDGE except we are looping over all edges anyway */
        int targetnum;
 
        BLI_smallhash_init(&visithash);
 
        /* note, would pass BM_EDGE except we are looping over all edges anyway */
-       BM_ElemIndex_Ensure(em->bm, BM_VERT /* | BM_EDGE */ );
+       BM_ElemIndex_Ensure(em->bm, BM_VERT /* | BM_EDGE */);
 
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                e->head.flags[0].f = 0;
 
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                e->head.flags[0].f = 0;
@@ -1242,28 +1264,28 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
 
        /* alloc */
        totvert = em->bm->totvert;
 
        /* alloc */
        totvert = em->bm->totvert;
-       nedges = MEM_callocN(sizeof(*nedges)*totvert+1, "SeamPathNEdges");
-       edges = MEM_mallocN(sizeof(*edges)*totedge*2, "SeamPathEdges");
-       prevedge = MEM_mallocN(sizeof(*prevedge)*totedge, "SeamPathPrevious");
-       cost = MEM_mallocN(sizeof(*cost)*totedge, "SeamPathCost");
+       nedges = MEM_callocN(sizeof(*nedges) * totvert + 1, "SeamPathNEdges");
+       edges = MEM_mallocN(sizeof(*edges) * totedge * 2, "SeamPathEdges");
+       prevedge = MEM_mallocN(sizeof(*prevedge) * totedge, "SeamPathPrevious");
+       cost = MEM_mallocN(sizeof(*cost) * totedge, "SeamPathCost");
 
        /* count edges, compute adjacent edges offsets and fill adjacent */
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
 
        /* count edges, compute adjacent edges offsets and fill adjacent */
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
-               nedges[BM_GetIndex(e->v1)+1]++;
-               nedges[BM_GetIndex(e->v2)+1]++;
+               nedges[BM_GetIndex(e->v1) + 1]++;
+               nedges[BM_GetIndex(e->v2) + 1]++;
        }
 
        for (i = 1; i < totvert; i++) {
        }
 
        for (i = 1; i < totvert; i++) {
-               int newswap = nedges[i+1];
-               nedges[i+1] = nedgeswap + nedges[i];
+               int newswap = nedges[i + 1];
+               nedges[i + 1] = nedgeswap + nedges[i];
                nedgeswap = newswap;
        }
        nedges[0] = nedges[1] = 0;
 
        i = 0;
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                nedgeswap = newswap;
        }
        nedges[0] = nedges[1] = 0;
 
        i = 0;
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
-               edges[nedges[BM_GetIndex(e->v1)+1]++] = i;
-               edges[nedges[BM_GetIndex(e->v2)+1]++] = i;
+               edges[nedges[BM_GetIndex(e->v1) + 1]++] = i;
+               edges[nedges[BM_GetIndex(e->v2) + 1]++] = i;
 
                cost[i] = 1e20f;
                prevedge[i] = -1;
 
                cost[i] = 1e20f;
                prevedge[i] = -1;
@@ -1273,8 +1295,8 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
        /*
         * Arrays are now filled as follows:
         *
        /*
         * Arrays are now filled as follows:
         *
-        *      nedges[n] = sum of the # of edges incident to all vertices numbered 0 thru n-1
-        *      edges[edges[n]..edges[n-1]] = the indices of of the edges incident to vertex n
+        *      nedges[n] = sum of the # of edges incident to all vertices numbered 0 thru n - 1
+        *      edges[edges[n]..edges[n - 1]] = the indices of of the edges incident to vertex n
         *
         * As the search continues, prevedge[n] will be the previous edge on the shortest
         * path found so far to edge n. The visitedhash will of course contain entries
         *
         * As the search continues, prevedge[n] will be the previous edge on the shortest
         * path found so far to edge n. The visitedhash will of course contain entries
@@ -1286,9 +1308,9 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
 
 #if 0 /* UNUSED */ /* this block does nothing, not sure why its here? - campbell */
        for (i = 0; i < totvert; i++) {
 
 #if 0 /* UNUSED */ /* this block does nothing, not sure why its here? - campbell */
        for (i = 0; i < totvert; i++) {
-               int start = nedges[i], end = nedges[i+1], cur;
+               int start = nedges[i], end = nedges[i + 1], cur;
                for (cur = start; cur < end; cur++) {
                for (cur = start; cur < end; cur++) {
-                       BMEdgee = EDBM_get_edge_for_index(em, edges[cur]);
+                       BMEdge *e = EDBM_get_edge_for_index(em, edges[cur]);
                }
        }
 #endif
                }
        }
 #endif
@@ -1319,8 +1341,8 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
        if (mednum == targetnum) {
                short allseams = 1;
 
        if (mednum == targetnum) {
                short allseams = 1;
 
-               /*Check whether the path is already completely tagged.
-                 if it is, the tags will be cleared instead of set.*/
+               /* Check whether the path is already completely tagged.
+                * if it is, the tags will be cleared instead of set. */
                mednum = targetnum;
                do {
                        e = EDBM_get_edge_for_index(em, mednum);
                mednum = targetnum;
                do {
                        e = EDBM_get_edge_for_index(em, mednum);
@@ -1331,7 +1353,7 @@ static int edgetag_shortest_path(Scene *scene, BMEditMesh *em, BMEdge *source, B
                        mednum = prevedge[mednum];
                } while (mednum != BM_GetIndex(source));
 
                        mednum = prevedge[mednum];
                } while (mednum != BM_GetIndex(source));
 
-               /*Follow path back and source and add or remove tags*/
+               /* Follow path back and source and add or remove tags */
                mednum = targetnum;
                do {
                        e = EDBM_get_edge_for_index(em, mednum);
                mednum = targetnum;
                do {
                        e = EDBM_get_edge_for_index(em, mednum);
@@ -1363,20 +1385,20 @@ static void mouse_mesh_shortest_path(bContext *C, int mval[2])
        ViewContext vc;
        BMEditMesh *em;
        BMEdge *e;
        ViewContext vc;
        BMEditMesh *em;
        BMEdge *e;
-       int dist= 50;
+       int dist = 50;
        
        em_setup_viewcontext(C, &vc);
        
        em_setup_viewcontext(C, &vc);
-       vc.mval[0]= mval[0];
-       vc.mval[1]= mval[1];
-       em= vc.em;
+       vc.mval[0] = mval[0];
+       vc.mval[1] = mval[1];
+       em = vc.em;
        
        
-       e= EDBM_findnearestedge(&vc, &dist);
+       e = EDBM_findnearestedge(&vc, &dist);
        if (e) {
        if (e) {
-               Mesh *me= vc.obedit->data;
+               Mesh *me = vc.obedit->data;
                int path = 0;
                
                if (em->bm->selected.last) {
                int path = 0;
                
                if (em->bm->selected.last) {
-                       BMEditSelection *ese= em->bm->selected.last;
+                       BMEditSelection *ese = em->bm->selected.last;
                        
                        if (ese && ese->htype == BM_EDGE) {
                                BMEdge *e_act;
                        
                        if (ese && ese->htype == BM_EDGE) {
                                BMEdge *e_act;
@@ -1389,15 +1411,15 @@ static void mouse_mesh_shortest_path(bContext *C, int mval[2])
                                }
                        }
                }
                                }
                        }
                }
-               if (path==0) {
-                       int act = (edgetag_context_check(vc.scene, em, e)==0);
+               if (path == 0) {
+                       int act = (edgetag_context_check(vc.scene, em, e) == 0);
                        edgetag_context_set(em, vc.scene, e, act); /* switch the edge option */
                }
                
                EDBM_selectmode_flush(em);
 
                /* even if this is selected it may not be in the selection list */
                        edgetag_context_set(em, vc.scene, e, act); /* switch the edge option */
                }
                
                EDBM_selectmode_flush(em);
 
                /* even if this is selected it may not be in the selection list */
-               if (edgetag_context_check(vc.scene, em, e)==0)
+               if (edgetag_context_check(vc.scene, em, e) == 0)
                        EDBM_remove_selection(em, e);
                else
                        EDBM_store_selection(em, e);
                        EDBM_remove_selection(em, e);
                else
                        EDBM_store_selection(em, e);
@@ -1438,16 +1460,16 @@ static int mesh_shortest_path_select_invoke(bContext *C, wmOperator *UNUSED(op),
 void MESH_OT_select_shortest_path(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_select_shortest_path(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Shortest Path Select";
-       ot->idname= "MESH_OT_select_shortest_path";
+       ot->name = "Shortest Path Select";
+       ot->idname = "MESH_OT_select_shortest_path";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= mesh_shortest_path_select_invoke;
-       ot->poll= ED_operator_editmesh;
-       ot->description= "Select shortest path between two selections";
+       ot->invoke = mesh_shortest_path_select_invoke;
+       ot->poll = ED_operator_editmesh;
+       ot->description = "Select shortest path between two selections";
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* properties */
        RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
        
        /* properties */
        RNA_def_boolean(ot->srna, "extend", 0, "Extend Select", "");
@@ -1465,12 +1487,12 @@ int mouse_mesh(bContext *C, const int mval[2], short extend)
        
        /* setup view context for argument to callbacks */
        em_setup_viewcontext(C, &vc);
        
        /* setup view context for argument to callbacks */
        em_setup_viewcontext(C, &vc);
-       vc.mval[0]= mval[0];
-       vc.mval[1]= mval[1];
+       vc.mval[0] = mval[0];
+       vc.mval[1] = mval[1];
        
        if (unified_findnearest(&vc, &eve, &eed, &efa)) {
                
        
        if (unified_findnearest(&vc, &eve, &eed, &efa)) {
                
-               if (extend==0) EDBM_clear_flag_all(vc.em, BM_SELECT);
+               if (extend == 0) EDBM_clear_flag_all(vc.em, BM_SELECT);
                
                if (efa) {
                        /* set the last selected face */
                
                if (efa) {
                        /* set the last selected face */
@@ -1510,9 +1532,9 @@ int mouse_mesh(bContext *C, const int mval[2], short extend)
                  
 //             if (EM_texFaceCheck()) {
 
                  
 //             if (EM_texFaceCheck()) {
 
-               if (efa && efa->mat_nr != vc.obedit->actcol-1) {
-                       vc.obedit->actcol= efa->mat_nr+1;
-                       vc.em->mat_nr= efa->mat_nr;
+               if (efa && efa->mat_nr != vc.obedit->actcol - 1) {
+                       vc.obedit->actcol = efa->mat_nr + 1;
+                       vc.em->mat_nr = efa->mat_nr;
 //                     BIF_preview_changed(ID_MA);
                }
 
 //                     BIF_preview_changed(ID_MA);
                }
 
@@ -1529,23 +1551,23 @@ static void EDBM_strip_selections(BMEditMesh *em)
 
        if (!(em->selectmode & SCE_SELECT_VERTEX)) {
                ese = em->bm->selected.first;
 
        if (!(em->selectmode & SCE_SELECT_VERTEX)) {
                ese = em->bm->selected.first;
-               while(ese) {
-                       nextese = ese->next; 
-                       if (ese->htype == BM_VERT) BLI_freelinkN(&(em->bm->selected),ese);
+               while (ese) {
+                       nextese = ese->next;
+                       if (ese->htype == BM_VERT) BLI_freelinkN(&(em->bm->selected), ese);
                        ese = nextese;
                }
        }
        if (!(em->selectmode & SCE_SELECT_EDGE)) {
                        ese = nextese;
                }
        }
        if (!(em->selectmode & SCE_SELECT_EDGE)) {
-               ese=em->bm->selected.first;
-               while(ese) {
+               ese = em->bm->selected.first;
+               while (ese) {
                        nextese = ese->next;
                        if (ese->htype == BM_EDGE) BLI_freelinkN(&(em->bm->selected), ese);
                        ese = nextese;
                }
        }
        if (!(em->selectmode & SCE_SELECT_FACE)) {
                        nextese = ese->next;
                        if (ese->htype == BM_EDGE) BLI_freelinkN(&(em->bm->selected), ese);
                        ese = nextese;
                }
        }
        if (!(em->selectmode & SCE_SELECT_FACE)) {
-               ese=em->bm->selected.first;
-               while(ese) {
+               ese = em->bm->selected.first;
+               while (ese) {
                        nextese = ese->next;
                        if (ese->htype == BM_FACE) BLI_freelinkN(&(em->bm->selected), ese);
                        ese = nextese;
                        nextese = ese->next;
                        if (ese->htype == BM_FACE) BLI_freelinkN(&(em->bm->selected), ese);
                        ese = nextese;
@@ -1564,7 +1586,7 @@ void EDBM_selectmode_set(BMEditMesh *em)
        
        em->bm->selectmode = em->selectmode;
 
        
        em->bm->selectmode = em->selectmode;
 
-       EDBM_strip_selections(em); /*strip BMEditSelections from em->selected that are not relevant to new mode*/
+       EDBM_strip_selections(em); /* strip BMEditSelections from em->selected that are not relevant to new mode */
        
        if (em->selectmode & SCE_SELECT_VERTEX) {
                EDBM_select_flush(em);
        
        if (em->selectmode & SCE_SELECT_VERTEX) {
                EDBM_select_flush(em);
@@ -1572,10 +1594,10 @@ void EDBM_selectmode_set(BMEditMesh *em)
        else if (em->selectmode & SCE_SELECT_EDGE) {
                /* deselect vertices, and select again based on edge select */
                eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
        else if (em->selectmode & SCE_SELECT_EDGE) {
                /* deselect vertices, and select again based on edge select */
                eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-               for ( ; eve; eve=BMIter_Step(&iter)) BM_Select(em->bm, eve, FALSE);
+               for ( ; eve; eve = BMIter_Step(&iter)) BM_Select(em->bm, eve, FALSE);
                
                eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
                
                eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
-               for ( ; eed; eed=BMIter_Step(&iter)) {
+               for ( ; eed; eed = BMIter_Step(&iter)) {
                        if (BM_TestHFlag(eed, BM_SELECT)) {
                                BM_Select(em->bm, eed, TRUE);
                        }
                        if (BM_TestHFlag(eed, BM_SELECT)) {
                                BM_Select(em->bm, eed, TRUE);
                        }
@@ -1587,10 +1609,10 @@ void EDBM_selectmode_set(BMEditMesh *em)
        else if (em->selectmode & SCE_SELECT_FACE) {
                /* deselect eges, and select again based on face select */
                eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
        else if (em->selectmode & SCE_SELECT_FACE) {
                /* deselect eges, and select again based on face select */
                eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
-               for ( ; eed; eed=BMIter_Step(&iter)) BM_Select(em->bm, eed, FALSE);
+               for ( ; eed; eed = BMIter_Step(&iter)) BM_Select(em->bm, eed, FALSE);
                
                efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
                
                efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
-               for ( ; efa; efa=BMIter_Step(&iter)) {
+               for ( ; efa; efa = BMIter_Step(&iter)) {
                        if (BM_TestHFlag(efa, BM_SELECT)) {
                                BM_Select(em->bm, efa, TRUE);
                        }
                        if (BM_TestHFlag(efa, BM_SELECT)) {
                                BM_Select(em->bm, efa, TRUE);
                        }
@@ -1604,12 +1626,12 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode)
        BMFace *efa;
        BMIter iter;
 
        BMFace *efa;
        BMIter iter;
 
-       /*have to find out what the selectionmode was previously*/
+       /* have to find out what the selectionmode was previously */
        if (oldmode == SCE_SELECT_VERTEX) {
                if (selectmode == SCE_SELECT_EDGE) {
        if (oldmode == SCE_SELECT_VERTEX) {
                if (selectmode == SCE_SELECT_EDGE) {
-                       /*select all edges associated with every selected vertex*/
+                       /* select all edges associated with every selected vertex */
                        eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
                        eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
-                       for ( ; eed; eed=BMIter_Step(&iter)) {
+                       for ( ; eed; eed = BMIter_Step(&iter)) {
                                if ( (BM_TestHFlag(eed->v1, BM_SELECT) ||
                                      BM_TestHFlag(eed->v2, BM_SELECT)))
                                {
                                if ( (BM_TestHFlag(eed->v1, BM_SELECT) ||
                                      BM_TestHFlag(eed->v2, BM_SELECT)))
                                {
@@ -1621,11 +1643,11 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode)
                        BMIter liter;
                        BMLoop *l;
 
                        BMIter liter;
                        BMLoop *l;
 
-                       /*select all faces associated with every selected vertex*/
+                       /* select all faces associated with every selected vertex */
                        efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
                        efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
-                       for ( ; efa; efa=BMIter_Step(&iter)) {
+                       for ( ; efa; efa = BMIter_Step(&iter)) {
                                l = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa);
                                l = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa);
-                               for (; l; l=BMIter_Step(&liter)) {
+                               for (; l; l = BMIter_Step(&liter)) {
                                        if (BM_TestHFlag(l->v, BM_SELECT)) {
                                                BM_Select(em->bm, efa, TRUE);
                                                break;
                                        if (BM_TestHFlag(l->v, BM_SELECT)) {
                                                BM_Select(em->bm, efa, TRUE);
                                                break;
@@ -1640,11 +1662,11 @@ void EDBM_convertsel(BMEditMesh *em, short oldmode, short selectmode)
                        BMIter liter;
                        BMLoop *l;
 
                        BMIter liter;
                        BMLoop *l;
 
-                       /*select all faces associated with every selected vertex*/
+                       /* select all faces associated with every selected vertex */
                        efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
                        efa = BMIter_New(&iter, em->bm, BM_FACES_OF_MESH, NULL);
-                       for ( ; efa; efa=BMIter_Step(&iter)) {
+                       for ( ; efa; efa = BMIter_Step(&iter)) {
                                l = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa);
                                l = BMIter_New(&liter, em->bm, BM_LOOPS_OF_FACE, efa);
-                               for (; l; l=BMIter_Step(&liter)) {
+                               for (; l; l = BMIter_Step(&liter)) {
                                        if (BM_TestHFlag(l->v, BM_SELECT)) {
                                                BM_Select(em->bm, efa, TRUE);
                                                break;
                                        if (BM_TestHFlag(l->v, BM_SELECT)) {
                                                BM_Select(em->bm, efa, TRUE);
                                                break;
@@ -1705,10 +1727,10 @@ void EDBM_select_swap(BMEditMesh *em) /* exported for UV */
 
 static void linked_limit_default(bContext *C, wmOperator *op)
 {
 
 static void linked_limit_default(bContext *C, wmOperator *op)
 {
-       if(!RNA_struct_property_is_set(op->ptr, "limit")) {
-               Object *obedit= CTX_data_edit_object(C);
-               BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
-               if(em->selectmode == SCE_SELECT_FACE)
+       if (!RNA_struct_property_is_set(op->ptr, "limit")) {
+               Object *obedit = CTX_data_edit_object(C);
+               BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
+               if (em->selectmode == SCE_SELECT_FACE)
                        RNA_boolean_set(op->ptr, "limit", TRUE);
                else
                        RNA_boolean_set(op->ptr, "limit", FALSE);
                        RNA_boolean_set(op->ptr, "limit", TRUE);
                else
                        RNA_boolean_set(op->ptr, "limit", FALSE);
@@ -1717,7 +1739,7 @@ static void linked_limit_default(bContext *C, wmOperator *op)
 
 static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
 
 static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       Object *obedit= CTX_data_edit_object(C);
+       Object *obedit = CTX_data_edit_object(C);
        ViewContext vc;
        BMesh *bm;
        BMWalker walker;
        ViewContext vc;
        BMesh *bm;
        BMWalker walker;
@@ -1725,7 +1747,7 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event
        BMVert *eve;
        BMEdge *e, *eed;
        BMFace *efa;
        BMVert *eve;
        BMEdge *e, *eed;
        BMFace *efa;
-       int sel= !RNA_boolean_get(op->ptr, "deselect");
+       int sel = !RNA_boolean_get(op->ptr, "deselect");
 
        int limit;
 
 
        int limit;
 
@@ -1740,17 +1762,17 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event
        em_setup_viewcontext(C, &vc);
        em = vc.em;
 
        em_setup_viewcontext(C, &vc);
        em = vc.em;
 
-       if (em->bm->totedge==0)
+       if (em->bm->totedge == 0)
                return OPERATOR_CANCELLED;
        
                return OPERATOR_CANCELLED;
        
-       bm= em->bm;
+       bm = em->bm;
 
 
-       vc.mval[0]= event->mval[0];
-       vc.mval[1]= event->mval[1];
+       vc.mval[0] = event->mval[0];
+       vc.mval[1] = event->mval[1];
        
        /* return warning! */
        
        
        /* return warning! */
        
-       if ( unified_findnearest(&vc, &eve, &eed, &efa)==0 ) {
+       if (unified_findnearest(&vc, &eve, &eed, &efa) == 0) {
                WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
                return OPERATOR_CANCELLED;
                WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
                return OPERATOR_CANCELLED;
@@ -1775,7 +1797,7 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event
                         BMW_NIL_LAY);
 
                e = BMW_Begin(&walker, efa);
                         BMW_NIL_LAY);
 
                e = BMW_Begin(&walker, efa);
-               for (; efa; efa=BMW_Step(&walker)) {
+               for (; efa; efa = BMW_Step(&walker)) {
                        BM_Select(bm, efa, sel);
                }
                BMW_End(&walker);
                        BM_Select(bm, efa, sel);
                }
                BMW_End(&walker);
@@ -1796,29 +1818,29 @@ static int select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event
                         BMW_NIL_LAY);
 
                e = BMW_Begin(&walker, eed->v1);
                         BMW_NIL_LAY);
 
                e = BMW_Begin(&walker, eed->v1);
-               for (; e; e=BMW_Step(&walker)) {
+               for ( ; e; e = BMW_Step(&walker)) {
                        BM_Select(bm, e, sel);
                }
                BMW_End(&walker);
        }
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
                        BM_Select(bm, e, sel);
                }
                BMW_End(&walker);
        }
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_select_linked_pick(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_select_linked_pick(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Linked";
-       ot->idname= "MESH_OT_select_linked_pick";
+       ot->name = "Select Linked";
+       ot->idname = "MESH_OT_select_linked_pick";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= select_linked_pick_invoke;
-       ot->poll= ED_operator_editmesh;
-       ot->description= "select/deselect all vertices linked to the edge under the mouse cursor";
+       ot->invoke = select_linked_pick_invoke;
+       ot->poll = ED_operator_editmesh;
+       ot->description = "select/deselect all vertices linked to the edge under the mouse cursor";
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "deselect", 0, "Deselect", "");
        RNA_def_boolean(ot->srna, "limit", 0, "Limit by Seams", "");
        
        RNA_def_boolean(ot->srna, "deselect", 0, "Deselect", "");
        RNA_def_boolean(ot->srna, "limit", 0, "Limit by Seams", "");
@@ -1827,9 +1849,9 @@ void MESH_OT_select_linked_pick(wmOperatorType *ot)
 
 static int select_linked_exec(bContext *C, wmOperator *op)
 {
 
 static int select_linked_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
-       BMesh *bm= em->bm;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
+       BMesh *bm = em->bm;
        BMIter iter;
        BMVert *v;
        BMEdge *e;
        BMIter iter;
        BMVert *v;
        BMEdge *e;
@@ -1867,7 +1889,7 @@ static int select_linked_exec(bContext *C, wmOperator *op)
                BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
                        if (BM_TestHFlag(efa, BM_TMP_TAG)) {
                                e = BMW_Begin(&walker, efa);
                BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
                        if (BM_TestHFlag(efa, BM_TMP_TAG)) {
                                e = BMW_Begin(&walker, efa);
-                               for (; efa; efa=BMW_Step(&walker)) {
+                               for (; efa; efa = BMW_Step(&walker)) {
                                        BM_Select(bm, efa, TRUE);
                                }
                        }
                                        BM_Select(bm, efa, TRUE);
                                }
                        }
@@ -1890,7 +1912,7 @@ static int select_linked_exec(bContext *C, wmOperator *op)
                BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
                        if (BM_TestHFlag(v, BM_TMP_TAG)) {
                                e = BMW_Begin(&walker, v);
                BM_ITER(v, &iter, em->bm, BM_VERTS_OF_MESH, NULL) {
                        if (BM_TestHFlag(v, BM_TMP_TAG)) {
                                e = BMW_Begin(&walker, v);
-                               for (; e; e=BMW_Step(&walker)) {
+                               for (; e; e = BMW_Step(&walker)) {
                                        BM_Select(em->bm, e->v1, TRUE);
                                        BM_Select(em->bm, e->v2, TRUE);
                                }
                                        BM_Select(em->bm, e->v1, TRUE);
                                        BM_Select(em->bm, e->v2, TRUE);
                                }
@@ -1902,22 +1924,22 @@ static int select_linked_exec(bContext *C, wmOperator *op)
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
 
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
 
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_select_linked(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_select_linked(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Linked All";
-       ot->idname= "MESH_OT_select_linked";
+       ot->name = "Select Linked All";
+       ot->idname = "MESH_OT_select_linked";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= select_linked_exec;
-       ot->poll= ED_operator_editmesh;
-       ot->description= "Select all vertices linked to the active mesh";
+       ot->exec = select_linked_exec;
+       ot->poll = ED_operator_editmesh;
+       ot->description = "Select all vertices linked to the active mesh";
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "limit", 0, "Limit by Seams", "");
 }
        
        RNA_def_boolean(ot->srna, "limit", 0, "Limit by Seams", "");
 }
@@ -1926,8 +1948,8 @@ void MESH_OT_select_linked(wmOperatorType *ot)
 
 static int select_more(bContext *C, wmOperator *UNUSED(op))
 {
 
 static int select_more(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = (((Mesh *)obedit->data))->edit_btmesh;
 
        EDBM_select_more(em);
 
 
        EDBM_select_more(em);
 
@@ -1938,22 +1960,22 @@ static int select_more(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_select_more(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_select_more(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select More";
-       ot->idname= "MESH_OT_select_more";
-       ot->description= "Select more vertices, edges or faces connected to initial selection";
+       ot->name = "Select More";
+       ot->idname = "MESH_OT_select_more";
+       ot->description = "Select more vertices, edges or faces connected to initial selection";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= select_more;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_more;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 static int select_less(bContext *C, wmOperator *UNUSED(op))
 {
 }
 
 static int select_less(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = (((Mesh *)obedit->data))->edit_btmesh;
 
        EDBM_select_less(em);
 
 
        EDBM_select_less(em);
 
@@ -1964,16 +1986,16 @@ static int select_less(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_select_less(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_select_less(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Less";
-       ot->idname= "MESH_OT_select_less";
-       ot->description= "Deselect vertices, edges or faces at the boundary of each selection region";
+       ot->name = "Select Less";
+       ot->idname = "MESH_OT_select_less";
+       ot->description = "Deselect vertices, edges or faces at the boundary of each selection region";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= select_less;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_less;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 /* Walk all reachable elements of the same type as h_act in breadth-first
 }
 
 /* Walk all reachable elements of the same type as h_act in breadth-first
@@ -1986,15 +2008,15 @@ static void walker_deselect_nth(BMEditMesh *em, int nth, int offset, BMHeader *h
        BMWalker walker;
        BMIter iter;
        int walktype = 0, itertype = 0, flushtype = 0;
        BMWalker walker;
        BMIter iter;
        int walktype = 0, itertype = 0, flushtype = 0;
-       short mask_vert=0, mask_edge=0, mask_loop=0, mask_face=0;
+       short mask_vert = 0, mask_edge = 0, mask_loop = 0, mask_face = 0;
 
        /* No active element from which to start - nothing to do */
 
        /* No active element from which to start - nothing to do */
-       if (h_act==NULL) {
+       if (h_act == NULL) {
                return;
        }
 
        /* Determine which type of iter, walker, and select flush to use
                return;
        }
 
        /* Determine which type of iter, walker, and select flush to use
-          based on type of the elements being deselected */
+        * based on type of the elements being deselected */
        switch (h_act->htype) {
        case BM_VERT:
                itertype = BM_VERTS_OF_MESH;
        switch (h_act->htype) {
        case BM_VERT:
                itertype = BM_VERTS_OF_MESH;
@@ -2053,23 +2075,23 @@ static void deselect_nth_active(BMEditMesh *em, BMVert **v_p, BMEdge **e_p, BMFa
        BMIter iter;
        BMEditSelection *ese;
 
        BMIter iter;
        BMEditSelection *ese;
 
-       *v_p= NULL;
-       *e_p= NULL;
-       *f_p= NULL;
+       *v_p = NULL;
+       *e_p = NULL;
+       *f_p = NULL;
 
        EDBM_selectmode_flush(em);
 
        EDBM_selectmode_flush(em);
-       ese= (BMEditSelection*)em->bm->selected.last;
+       ese = (BMEditSelection *)em->bm->selected.last;
 
        if (ese) {
                switch(ese->htype) {
                case BM_VERT:
 
        if (ese) {
                switch(ese->htype) {
                case BM_VERT:
-                       *v_p= (BMVert *)ese->data;
+                       *v_p = (BMVert *)ese->data;
                        return;
                case BM_EDGE:
                        return;
                case BM_EDGE:
-                       *e_p= (BMEdge *)ese->data;
+                       *e_p = (BMEdge *)ese->data;
                        return;
                case BM_FACE:
                        return;
                case BM_FACE:
-                       *f_p= (BMFace *)ese->data;
+                       *f_p = (BMFace *)ese->data;
                        return;
                }
        }
                        return;
                }
        }
@@ -2091,9 +2113,9 @@ static void deselect_nth_active(BMEditMesh *em, BMVert **v_p, BMEdge **e_p, BMFa
                }
        }
        else if (em->selectmode & SCE_SELECT_FACE) {
                }
        }
        else if (em->selectmode & SCE_SELECT_FACE) {
-               f= BM_get_actFace(em->bm, TRUE);
+               f = BM_get_actFace(em->bm, TRUE);
                if (f) {
                if (f) {
-                       *f_p= f;
+                       *f_p = f;
                        return;
                }
        }
                        return;
                }
        }
@@ -2125,10 +2147,10 @@ static int EM_deselect_nth(BMEditMesh *em, int nth, int offset)
 
 static int mesh_select_nth_exec(bContext *C, wmOperator *op)
 {
 
 static int mesh_select_nth_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
-       int nth= RNA_int_get(op->ptr, "nth");
-       int offset= RNA_int_get(op->ptr, "offset");
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
+       int nth = RNA_int_get(op->ptr, "nth");
+       int offset = RNA_int_get(op->ptr, "offset");
 
        offset = MIN2(nth, offset);
 
 
        offset = MIN2(nth, offset);
 
@@ -2147,16 +2169,16 @@ static int mesh_select_nth_exec(bContext *C, wmOperator *op)
 void MESH_OT_select_nth(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_select_nth(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Nth";
-       ot->description= "";
-       ot->idname= "MESH_OT_select_nth";
+       ot->name = "Select Nth";
+       ot->description = "";
+       ot->idname = "MESH_OT_select_nth";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_select_nth_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_select_nth_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_int(ot->srna, "nth", 2, 2, 100, "Nth Selection", "", 1, INT_MAX);
        RNA_def_int(ot->srna, "offset", 0, 0, 100, "Offset", "", 0, INT_MAX);
 
        RNA_def_int(ot->srna, "nth", 2, 2, 100, "Nth Selection", "", 1, INT_MAX);
        RNA_def_int(ot->srna, "offset", 0, 0, 100, "Offset", "", 0, INT_MAX);
@@ -2167,8 +2189,8 @@ void em_setup_viewcontext(bContext *C, ViewContext *vc)
        view3d_set_viewcontext(C, vc);
        
        if (vc->obedit) {
        view3d_set_viewcontext(C, vc);
        
        if (vc->obedit) {
-               Mesh *me= vc->obedit->data;
-               vc->em= me->edit_btmesh;
+               Mesh *me = vc->obedit->data;
+               vc->em = me->edit_btmesh;
        }
 }
 
        }
 }
 
@@ -2187,8 +2209,8 @@ static int select_sharp_edges_exec(bContext *C, wmOperator *op)
        * 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= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMIter iter;
        BMEdge *e;
        BMLoop *l1, *l2;
        BMIter iter;
        BMEdge *e;
        BMLoop *l1, *l2;
@@ -2223,16 +2245,16 @@ static int select_sharp_edges_exec(bContext *C, wmOperator *op)
 void MESH_OT_edges_select_sharp(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_edges_select_sharp(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Sharp Edges";
-       ot->description= "Marked selected edges as sharp";
-       ot->idname= "MESH_OT_edges_select_sharp";
+       ot->name = "Select Sharp Edges";
+       ot->description = "Marked selected edges as sharp";
+       ot->idname = "MESH_OT_edges_select_sharp";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= select_sharp_edges_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_sharp_edges_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* props */
        RNA_def_float(ot->srna, "sharpness", 1.0f, 0.01f, FLT_MAX, "sharpness", "", 1.0f, 180.0f);
        
        /* props */
        RNA_def_float(ot->srna, "sharpness", 1.0f, 0.01f, FLT_MAX, "sharpness", "", 1.0f, 180.0f);
@@ -2240,8 +2262,8 @@ void MESH_OT_edges_select_sharp(wmOperatorType *ot)
 
 static int select_linked_flat_faces_exec(bContext *C, wmOperator *op)
 {
 
 static int select_linked_flat_faces_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMIter iter, liter, liter2;
        BMFace *f, **stack = NULL;
        BLI_array_declare(stack);
        BMIter iter, liter, liter2;
        BMFace *f, **stack = NULL;
        BLI_array_declare(stack);
@@ -2263,10 +2285,10 @@ static int select_linked_flat_faces_exec(bContext *C, wmOperator *op)
                i = 1;
 
                BLI_array_growone(stack);
                i = 1;
 
                BLI_array_growone(stack);
-               stack[i-1] = f;
+               stack[i - 1] = f;
 
                while (i) {
 
                while (i) {
-                       f = stack[i-1];
+                       f = stack[i - 1];
                        i--;
 
                        BM_Select(em->bm, f, TRUE);
                        i--;
 
                        BM_Select(em->bm, f, TRUE);
@@ -2281,10 +2303,10 @@ static int select_linked_flat_faces_exec(bContext *C, wmOperator *op)
                                                continue;
 
                                        /* edge has exactly two neighboring faces, check angle */
                                                continue;
 
                                        /* edge has exactly two neighboring faces, check angle */
-                                       angle = saacos(f->no[0]*l2->f->no[0]+f->no[1]*l2->f->no[1]+f->no[2]*l2->f->no[2]);
+                                       angle = angle_normalized_v3v3(f->no, l2->f->no);
 
                                        /* invalidate: edge too sharp */
 
                                        /* invalidate: edge too sharp */
-                                       if (fabs(angle) < sharp) {
+                                       if (angle < sharp) {
                                                BLI_array_growone(stack);
                                                stack[i] = l2->f;
                                                i++;
                                                BLI_array_growone(stack);
                                                stack[i] = l2->f;
                                                i++;
@@ -2304,16 +2326,16 @@ static int select_linked_flat_faces_exec(bContext *C, wmOperator *op)
 void MESH_OT_faces_select_linked_flat(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_faces_select_linked_flat(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Linked Flat Faces";
-       ot->description= "Select linked faces by angle";
-       ot->idname= "MESH_OT_faces_select_linked_flat";
+       ot->name = "Select Linked Flat Faces";
+       ot->description = "Select linked faces by angle";
+       ot->idname = "MESH_OT_faces_select_linked_flat";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= select_linked_flat_faces_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_linked_flat_faces_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* props */
        RNA_def_float(ot->srna, "sharpness", 1.0f, 0.01f, FLT_MAX, "sharpness", "", 1.0f, 180.0f);
        
        /* props */
        RNA_def_float(ot->srna, "sharpness", 1.0f, 0.01f, FLT_MAX, "sharpness", "", 1.0f, 180.0f);
@@ -2321,8 +2343,8 @@ void MESH_OT_faces_select_linked_flat(wmOperatorType *ot)
 
 static int select_non_manifold_exec(bContext *C, wmOperator *op)
 {
 
 static int select_non_manifold_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMVert *v;
        BMEdge *e;
        BMIter iter;
        BMVert *v;
        BMEdge *e;
        BMIter iter;
@@ -2331,7 +2353,7 @@ static int select_non_manifold_exec(bContext *C, wmOperator *op)
         * faces
         */
        
         * faces
         */
        
-       if (em->selectmode==SCE_SELECT_FACE) {
+       if (em->selectmode == SCE_SELECT_FACE) {
                BKE_report(op->reports, RPT_ERROR, "Doesn't work in face selection mode");
                return OPERATOR_CANCELLED;
        }
                BKE_report(op->reports, RPT_ERROR, "Doesn't work in face selection mode");
                return OPERATOR_CANCELLED;
        }
@@ -2350,35 +2372,35 @@ static int select_non_manifold_exec(bContext *C, wmOperator *op)
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit->data);
 
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit->data);
 
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_select_non_manifold(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_select_non_manifold(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Non Manifold";
-       ot->description= "Select all non-manifold vertices or edges";
-       ot->idname= "MESH_OT_select_non_manifold";
+       ot->name = "Select Non Manifold";
+       ot->description = "Select all non-manifold vertices or edges";
+       ot->idname = "MESH_OT_select_non_manifold";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= select_non_manifold_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_non_manifold_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 static int mesh_select_random_exec(bContext *C, wmOperator *op)
 {
 }
 
 static int mesh_select_random_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMVert *eve;
        BMEdge *eed;
        BMFace *efa;
        BMIter iter;
        float randfac =  RNA_float_get(op->ptr, "percent")/100.0f;
 
        BMVert *eve;
        BMEdge *eed;
        BMFace *efa;
        BMIter iter;
        float randfac =  RNA_float_get(op->ptr, "percent")/100.0f;
 
-       BLI_srand( BLI_rand() ); /* random seed */
+       BLI_srand(BLI_rand()); /* random seed */
        
        if (!RNA_boolean_get(op->ptr, "extend"))
                EDBM_clear_flag_all(em, BM_SELECT);
        
        if (!RNA_boolean_get(op->ptr, "extend"))
                EDBM_clear_flag_all(em, BM_SELECT);
@@ -2410,32 +2432,34 @@ static int mesh_select_random_exec(bContext *C, wmOperator *op)
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit->data);
        
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit->data);
        
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_select_random(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_select_random(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Random";
-       ot->description= "Randomly select vertices";
-       ot->idname= "MESH_OT_select_random";
+       ot->name = "Select Random";
+       ot->description = "Randomly select vertices";
+       ot->idname = "MESH_OT_select_random";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_select_random_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_select_random_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* props */
        
        /* props */
-       RNA_def_float_percentage(ot->srna, "percent", 50.f, 0.0f, 100.0f, "Percent", "Percentage of elements to select randomly", 0.f, 100.0f);
-       RNA_def_boolean(ot->srna, "extend", 0, "Extend Selection", "Extend selection instead of deselecting everything first");
+       RNA_def_float_percentage(ot->srna, "percent", 50.f, 0.0f, 100.0f,
+                                "Percent", "Percentage of elements to select randomly", 0.f, 100.0f);
+       RNA_def_boolean(ot->srna, "extend", 0,
+                       "Extend Selection", "Extend selection instead of deselecting everything first");
 }
 
 static int select_next_loop(bContext *C, wmOperator *UNUSED(op))
 {
 }
 
 static int select_next_loop(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = (((Mesh *)obedit->data))->edit_btmesh;
        BMFace *f;
        BMVert *v;
        BMIter iter;
        BMFace *f;
        BMVert *v;
        BMIter iter;
@@ -2469,23 +2493,23 @@ static int select_next_loop(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_select_next_loop(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_select_next_loop(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Next Loop";
-       ot->idname= "MESH_OT_select_next_loop";
-       ot->description= "";
+       ot->name = "Select Next Loop";
+       ot->idname = "MESH_OT_select_next_loop";
+       ot->description = "";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= select_next_loop;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_next_loop;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 
 static int region_to_loop(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit = CTX_data_edit_object(C);
 }
 
 
 static int region_to_loop(bContext *C, wmOperator *UNUSED(op))
 {
        Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)obedit->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMFace *f;
        BMEdge *e;
        BMIter iter;
        BMFace *f;
        BMEdge *e;
        BMIter iter;
@@ -2502,7 +2526,7 @@ static int region_to_loop(bContext *C, wmOperator *UNUSED(op))
                BMIter liter1, liter2;
                
                BM_ITER(l1, &liter1, em->bm, BM_LOOPS_OF_FACE, f) {
                BMIter liter1, liter2;
                
                BM_ITER(l1, &liter1, em->bm, BM_LOOPS_OF_FACE, f) {
-                       int tot=0, totsel=0;
+                       int tot = 0, totsel = 0;
                        
                        BM_ITER(l2, &liter2, em->bm, BM_LOOPS_OF_EDGE, l1->e) {
                                tot++;
                        
                        BM_ITER(l2, &liter2, em->bm, BM_LOOPS_OF_EDGE, l1->e) {
                                tot++;
@@ -2537,15 +2561,15 @@ static int region_to_loop(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_region_to_loop(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_region_to_loop(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Boundary Loop";
-       ot->idname= "MESH_OT_region_to_loop";
+       ot->name = "Select Boundary Loop";
+       ot->idname = "MESH_OT_region_to_loop";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= region_to_loop;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = region_to_loop;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 static int loop_find_region(BMEditMesh *em, BMLoop *l, int flag, 
 }
 
 static int loop_find_region(BMEditMesh *em, BMLoop *l, int flag, 
@@ -2588,16 +2612,16 @@ static int loop_find_region(BMEditMesh *em, BMLoop *l, int flag,
 
 static int verg_radial(const void *va, const void *vb)
 {
 
 static int verg_radial(const void *va, const void *vb)
 {
-       BMEdge *e1 = *((void**)va);
-       BMEdge *e2 = *((void**)vb);
+       BMEdge *e1 = *((void **)va);
+       BMEdge *e2 = *((void **)vb);
        int a, b;
        
        a = BM_Edge_FaceCount(e1);
        b = BM_Edge_FaceCount(e2);
        
        int a, b;
        
        a = BM_Edge_FaceCount(e1);
        b = BM_Edge_FaceCount(e2);
        
-       if (a > b) return -1;
-       if (a == b) return 0;
-       if (a < b) return 1;
+       if (a > b)  return -1;
+       if (a == b) return  0;
+       if (a < b)  return  1;
        
        return -1;
 }
        
        return -1;
 }
@@ -2606,7 +2630,7 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
 {
        SmallHash visithash;
        BMIter iter;
 {
        SmallHash visithash;
        BMIter iter;
-       BMEdge *e, **edges=NULL;
+       BMEdge *e, **edges = NULL;
        BLI_array_declare(edges);
        BMFace *f;
        int count = 0, i;
        BLI_array_declare(edges);
        BMFace *f;
        int count = 0, i;
@@ -2627,14 +2651,14 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
                }
        }
        
                }
        }
        
-       /*sort edges by radial cycle length*/
-       qsort(edges,  BLI_array_count(edges), sizeof(void*), verg_radial);
+       /* sort edges by radial cycle length */
+       qsort(edges,  BLI_array_count(edges), sizeof(void *), verg_radial);
        
        
-       for (i=0; i<BLI_array_count(edges); i++) {
+       for (i = 0; i < BLI_array_count(edges); i++) {
                BMIter liter;
                BMLoop *l;
                BMIter liter;
                BMLoop *l;
-               BMFace **region=NULL, **r;
-               int c, tot=0;
+               BMFace **region = NULL, **r;
+               int c, tot = 0;
                
                e = edges[i];
                
                
                e = edges[i];
                
@@ -2666,7 +2690,7 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
                if (region) {
                        int j;
                        
                if (region) {
                        int j;
                        
-                       for (j=0; j<tot; j++) {
+                       for (j = 0; j < tot; j++) {
                                BM_SetHFlag(region[j], BM_TMP_TAG);
                                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, region[j]) {
                                        BM_ClearHFlag(l->e, BM_TMP_TAG);
                                BM_SetHFlag(region[j], BM_TMP_TAG);
                                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, region[j]) {
                                        BM_ClearHFlag(l->e, BM_TMP_TAG);
@@ -2688,13 +2712,13 @@ static int loop_find_regions(BMEditMesh *em, int selbigger)
 static int loop_to_region(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
 static int loop_to_region(bContext *C, wmOperator *op)
 {
        Object *obedit = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)obedit->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMIter iter;
        BMFace *f;
        int selbigger = RNA_boolean_get(op->ptr, "select_bigger");
        int a, b;
 
        BMIter iter;
        BMFace *f;
        int selbigger = RNA_boolean_get(op->ptr, "select_bigger");
        int a, b;
 
-       /*find the set of regions with smallest number of total faces*/
+       /* find the set of regions with smallest number of total faces */
        a = loop_find_regions(em, selbigger);
        b = loop_find_regions(em, !selbigger);
        
        a = loop_find_regions(em, selbigger);
        b = loop_find_regions(em, !selbigger);
        
@@ -2717,15 +2741,15 @@ static int loop_to_region(bContext *C, wmOperator *op)
 void MESH_OT_loop_to_region(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_loop_to_region(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select Loop Inner-Region";
-       ot->idname= "MESH_OT_loop_to_region";
+       ot->name = "Select Loop Inner-Region";
+       ot->idname = "MESH_OT_loop_to_region";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= loop_to_region;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = loop_to_region;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "select_bigger", 0, "Select Bigger", "Select bigger regions instead of smaller ones");
 }
        
        RNA_def_boolean(ot->srna, "select_bigger", 0, "Select Bigger", "Select bigger regions instead of smaller ones");
 }
index 29707e832a1c60ffd393298149d800a6a7a3ecf0..2145fc1dbe889b64e052d2d55feeded9361f69e1 100644 (file)
 
 #include "BLO_sys_types.h" // for intptr_t support
 
 
 #include "BLO_sys_types.h" // for intptr_t support
 
-/*these wrap equivilent bmesh functions.  I'm in two minds of it we should
-  just use the bm functions directly; on the one hand, there's no real
-  need (at the moment) to wrap them, but on the other hand having these
 wrapped avoids a confusing mess of mixing BM_ and EDBM_ namespaces.*/
+/* these wrap equivilent bmesh functions.  I'm in two minds of it we should
* just use the bm functions directly; on the one hand, there's no real
* need (at the moment) to wrap them, but on the other hand having these
* wrapped avoids a confusing mess of mixing BM_ and EDBM_ namespaces. */
 
 void EDBM_editselection_center(BMEditMesh *em, float *center, BMEditSelection *ese)
 {
 
 void EDBM_editselection_center(BMEditMesh *em, float *center, BMEditSelection *ese)
 {
index 1e268cd58fdc1ef900bcd0cf25200c092edd5a74..52b0a4a03d31289e0b90b76bafc600cb78593109 100644 (file)
@@ -110,12 +110,12 @@ static void add_normal_aligned(float nor[3], const float add[3])
 static int subdivide_exec(bContext *C, wmOperator *op)
 {
        ToolSettings *ts = CTX_data_tool_settings(C);
 static int subdivide_exec(bContext *C, wmOperator *op)
 {
        ToolSettings *ts = CTX_data_tool_settings(C);
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
-       int cuts= RNA_int_get(op->ptr,"number_cuts");
-       float smooth= 0.292f*RNA_float_get(op->ptr, "smoothness");
-       float fractal= RNA_float_get(op->ptr, "fractal")/2.5;
-       int flag= 0;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
+       int cuts = RNA_int_get(op->ptr,"number_cuts");
+       float smooth = 0.292f * RNA_float_get(op->ptr, "smoothness");
+       float fractal = RNA_float_get(op->ptr, "fractal")/2.5;
+       int flag = 0;
 
        if (smooth != 0.0f)
                flag |= B_SMOOTH;
 
        if (smooth != 0.0f)
                flag |= B_SMOOTH;
@@ -125,7 +125,7 @@ static int subdivide_exec(bContext *C, wmOperator *op)
        if (RNA_boolean_get(op->ptr, "quadtri") && 
            RNA_enum_get(op->ptr, "quadcorner") == SUBD_STRAIGHT_CUT)
        {
        if (RNA_boolean_get(op->ptr, "quadtri") && 
            RNA_enum_get(op->ptr, "quadcorner") == SUBD_STRAIGHT_CUT)
        {
-               RNA_enum_set(op->ptr, "quadcorner", SUBD_INNERVERT);    
+               RNA_enum_set(op->ptr, "quadcorner", SUBD_INNERVERT);
        }
        
        BM_esubdivideflag(obedit, em->bm, BM_SELECT, 
        }
        
        BM_esubdivideflag(obedit, em->bm, BM_SELECT, 
@@ -153,16 +153,16 @@ static EnumPropertyItem prop_mesh_cornervert_types[] = {
 void MESH_OT_subdivide(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_subdivide(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Subdivide";
-       ot->description= "Subdivide selected edges";
-       ot->idname= "MESH_OT_subdivide";
+       ot->name = "Subdivide";
+       ot->description = "Subdivide selected edges";
+       ot->idname = "MESH_OT_subdivide";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= subdivide_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = subdivide_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* properties */
        RNA_def_int(ot->srna, "number_cuts", 1, 1, INT_MAX, "Number of Cuts", "", 1, 10);
 
        /* properties */
        RNA_def_int(ot->srna, "number_cuts", 1, 1, INT_MAX, "Number of Cuts", "", 1, 10);
@@ -170,7 +170,8 @@ void MESH_OT_subdivide(wmOperatorType *ot)
        RNA_def_float(ot->srna, "smoothness", 0.0f, 0.0f, FLT_MAX, "Smoothness", "Smoothness factor (BMESH TODO)", 0.0f, 1.0f);
 
        RNA_def_boolean(ot->srna, "quadtri", 0, "Quad/Tri Mode", "Tries to prevent ngons");
        RNA_def_float(ot->srna, "smoothness", 0.0f, 0.0f, FLT_MAX, "Smoothness", "Smoothness factor (BMESH TODO)", 0.0f, 1.0f);
 
        RNA_def_boolean(ot->srna, "quadtri", 0, "Quad/Tri Mode", "Tries to prevent ngons");
-       RNA_def_enum(ot->srna, "quadcorner", prop_mesh_cornervert_types, SUBD_STRAIGHT_CUT, "Quad Corner Type", "How to subdivide quad corners (anything other then Straight Cut will prevent ngons)");
+       RNA_def_enum(ot->srna, "quadcorner", prop_mesh_cornervert_types, SUBD_STRAIGHT_CUT,
+                    "Quad Corner Type", "How to subdivide quad corners (anything other then Straight Cut will prevent ngons)");
 
        RNA_def_float(ot->srna, "fractal", 0.0f, 0.0f, FLT_MAX, "Fractal", "Fractal randomness factor", 0.0f, 1000.0f);
        RNA_def_int(ot->srna, "seed", 0, 0, 10000, "Random Seed", "Seed for the random number generator", 0, 50);
 
        RNA_def_float(ot->srna, "fractal", 0.0f, 0.0f, FLT_MAX, "Fractal", "Fractal randomness factor", 0.0f, 1000.0f);
        RNA_def_int(ot->srna, "seed", 0, 0, 10000, "Random Seed", "Seed for the random number generator", 0, 50);
@@ -208,7 +209,7 @@ static short EDBM_Extrude_face_indiv(BMEditMesh *em, wmOperator *op, const char
 
        EDBM_InitOpf(em, &bmop, op, "extrude_face_indiv faces=%hf", hflag);
 
 
        EDBM_InitOpf(em, &bmop, op, "extrude_face_indiv faces=%hf", hflag);
 
-       /*deselect original verts*/
+       /* deselect original verts */
        EDBM_clear_flag_all(em, BM_SELECT);
 
        BMO_Exec_Op(em->bm, &bmop);
        EDBM_clear_flag_all(em, BM_SELECT);
 
        BMO_Exec_Op(em->bm, &bmop);
@@ -216,7 +217,7 @@ static short EDBM_Extrude_face_indiv(BMEditMesh *em, wmOperator *op, const char
        BMO_ITER(f, &siter, em->bm, &bmop, "faceout", BM_FACE) {
                BM_Select(em->bm, f, TRUE);
 
        BMO_ITER(f, &siter, em->bm, &bmop, "faceout", BM_FACE) {
                BM_Select(em->bm, f, TRUE);
 
-               /*set face vertex normals to face normal*/
+               /* set face vertex normals to face normal */
                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
                        copy_v3_v3(l->v->no, f->no);
                }
                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
                        copy_v3_v3(l->v->no, f->no);
                }
@@ -236,7 +237,7 @@ static short EDBM_Extrude_edges_indiv(BMEditMesh *em, wmOperator *op, const char
 
        EDBM_InitOpf(em, &bmop, op, "extrude_edge_only edges=%he", hflag);
 
 
        EDBM_InitOpf(em, &bmop, op, "extrude_edge_only edges=%he", hflag);
 
-       /*deselect original verts*/
+       /* deselect original verts */
        EDBM_clear_flag_all(em, BM_SELECT);
 
        BMO_Exec_Op(em->bm, &bmop);
        EDBM_clear_flag_all(em, BM_SELECT);
 
        BMO_Exec_Op(em->bm, &bmop);
@@ -256,7 +257,7 @@ static short EDBM_Extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char
 
        EDBM_InitOpf(em, &bmop, op, "extrude_vert_indiv verts=%hv", hflag);
 
 
        EDBM_InitOpf(em, &bmop, op, "extrude_vert_indiv verts=%hv", hflag);
 
-       /*deselect original verts*/
+       /* deselect original verts */
        BMO_UnHeaderFlag_Buffer(em->bm, &bmop, "verts", BM_SELECT, BM_VERT);
 
        BMO_Exec_Op(em->bm, &bmop);
        BMO_UnHeaderFlag_Buffer(em->bm, &bmop, "verts", BM_SELECT, BM_VERT);
 
        BMO_Exec_Op(em->bm, &bmop);
@@ -269,7 +270,7 @@ static short EDBM_Extrude_verts_indiv(BMEditMesh *em, wmOperator *op, const char
        return 'g'; // g is grab
 }
 
        return 'g'; // g is grab
 }
 
-static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, float *nor)
+static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag, float nor[3])
 {
        BMesh *bm = em->bm;
        BMIter iter;
 {
        BMesh *bm = em->bm;
        BMIter iter;
@@ -288,9 +289,9 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
         * of the cases above to handle edges on the line of symmetry.
         */
        md = obedit->modifiers.first;
         * of the cases above to handle edges on the line of symmetry.
         */
        md = obedit->modifiers.first;
-       for (; md; md=md->next) {
-               if ((md->type==eModifierType_Mirror) && (md->mode & eModifierMode_Realtime)) {
-                       MirrorModifierData *mmd = (MirrorModifierData*) md;     
+       for (; md; md = md->next) {
+               if ((md->type == eModifierType_Mirror) && (md->mode & eModifierMode_Realtime)) {
+                       MirrorModifierData *mmd = (MirrorModifierData *) md;
                
                        if (mmd->flag & MOD_MIR_CLIPPING) {
                                float mtx[4][4];
                
                        if (mmd->flag & MOD_MIR_CLIPPING) {
                                float mtx[4][4];
@@ -300,8 +301,9 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
                                        mult_m4_m4m4(mtx, imtx, obedit->obmat);
                                }
 
                                        mult_m4_m4m4(mtx, imtx, obedit->obmat);
                                }
 
-                               for (edge=BMIter_New(&iter,bm,BM_EDGES_OF_MESH,NULL);
-                                    edge; edge=BMIter_Step(&iter))
+                               for (edge = BMIter_New(&iter, bm, BM_EDGES_OF_MESH, NULL);
+                                    edge;
+                                    edge = BMIter_Step(&iter))
                                {
                                        if (BM_TestHFlag(edge, hflag)) {
                                                float co1[3], co2[3];
                                {
                                        if (BM_TestHFlag(edge, hflag)) {
                                                float co1[3], co2[3];
@@ -314,20 +316,27 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
                                                        mul_v3_m4v3(co2, mtx, co2);
                                                }
 
                                                        mul_v3_m4v3(co2, mtx, co2);
                                                }
 
-                                               if (mmd->flag & MOD_MIR_AXIS_X)
+                                               if (mmd->flag & MOD_MIR_AXIS_X) {
                                                        if ( (fabs(co1[0]) < mmd->tolerance) &&
                                                                 (fabs(co2[0]) < mmd->tolerance) )
                                                        if ( (fabs(co1[0]) < mmd->tolerance) &&
                                                                 (fabs(co2[0]) < mmd->tolerance) )
+                                                       {
                                                                BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
                                                                BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
-
-                                               if (mmd->flag & MOD_MIR_AXIS_Y)
+                                                       }
+                                               }
+                                               if (mmd->flag & MOD_MIR_AXIS_Y) {
                                                        if ( (fabs(co1[1]) < mmd->tolerance) &&
                                                                 (fabs(co2[1]) < mmd->tolerance) )
                                                        if ( (fabs(co1[1]) < mmd->tolerance) &&
                                                                 (fabs(co2[1]) < mmd->tolerance) )
+                                                       {
                                                                BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
                                                                BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
-
-                                               if (mmd->flag & MOD_MIR_AXIS_Z)
+                                                       }
+                                               }
+                                               if (mmd->flag & MOD_MIR_AXIS_Z) {
                                                        if ( (fabs(co1[2]) < mmd->tolerance) &&
                                                                 (fabs(co2[2]) < mmd->tolerance) )
                                                        if ( (fabs(co1[2]) < mmd->tolerance) &&
                                                                 (fabs(co2[2]) < mmd->tolerance) )
+                                                       {
                                                                BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
                                                                BMO_Insert_MapPointer(bm, &extop, "exclude", edge, NULL);
+                                                       }
+                                               }
                                        }
                                }
                        }
                                        }
                                }
                        }
@@ -344,7 +353,7 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
                BM_Select(bm, el, TRUE);
 
                if (el->htype == BM_FACE) {
                BM_Select(bm, el, TRUE);
 
                if (el->htype == BM_FACE) {
-                       f = (BMFace*)el;
+                       f = (BMFace *)el;
                        add_normal_aligned(nor, f->no);
                };
        }
                        add_normal_aligned(nor, f->no);
                };
        }
@@ -353,7 +362,7 @@ static short EDBM_Extrude_edge(Object *obedit, BMEditMesh *em, const char hflag,
 
        BMO_Finish_Op(bm, &extop);
 
 
        BMO_Finish_Op(bm, &extop);
 
-       if (nor[0]==0.0 && nor[1]==0.0 && nor[2]==0.0) return 'g'; // grab
+       if (nor[0] == 0.0f && nor[1] == 0.0f && nor[2] == 0.0f) return 'g'; // grab
        return 'n'; // normal constraint 
 
 }
        return 'n'; // normal constraint 
 
 }
@@ -362,9 +371,9 @@ static short EDBM_Extrude_vert(Object *obedit, BMEditMesh *em, const char hflag,
        BMIter iter;
        BMEdge *eed;
                
        BMIter iter;
        BMEdge *eed;
                
-       /*ensure vert flags are consistent for edge selections*/
+       /* ensure vert flags are consistent for edge selections */
        eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
        eed = BMIter_New(&iter, em->bm, BM_EDGES_OF_MESH, NULL);
-       for ( ; eed; eed=BMIter_Step(&iter)) {
+       for ( ; eed; eed = BMIter_Step(&iter)) {
                if (BM_TestHFlag(eed, hflag)) {
                        if (hflag & BM_SELECT) {
                                BM_Select(em->bm, eed->v1, TRUE);
                if (BM_TestHFlag(eed, hflag)) {
                        if (hflag & BM_SELECT) {
                                BM_Select(em->bm, eed->v1, TRUE);
@@ -390,34 +399,29 @@ static short EDBM_Extrude_vert(Object *obedit, BMEditMesh *em, const char hflag,
 
 static int extrude_repeat_mesh(bContext *C, wmOperator *op)
 {
 
 static int extrude_repeat_mesh(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
+       Object *obedit = CTX_data_edit_object(C);
        BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
-       RegionView3D *rv3d = CTX_wm_region_view3d(C);           
+       RegionView3D *rv3d = CTX_wm_region_view3d(C);
                
        int steps = RNA_int_get(op->ptr,"steps");
        
        float offs = RNA_float_get(op->ptr,"offset");
                
        int steps = RNA_int_get(op->ptr,"steps");
        
        float offs = RNA_float_get(op->ptr,"offset");
-       float dvec[3], tmat[3][3], bmat[3][3], nor[3]= {0.0, 0.0, 0.0};
+       float dvec[3], tmat[3][3], bmat[3][3], nor[3] = {0.0, 0.0, 0.0};
        short a;
 
        /* dvec */
        short a;
 
        /* dvec */
-       dvec[0]= rv3d->persinv[2][0];
-       dvec[1]= rv3d->persinv[2][1];
-       dvec[2]= rv3d->persinv[2][2];
-       normalize_v3(dvec);
-       dvec[0]*= offs;
-       dvec[1]*= offs;
-       dvec[2]*= offs;
+       normalize_v3_v3(dvec, rv3d->persinv[2]);
+       mul_v3_fl(dvec, offs);
 
        /* base correction */
        copy_m3_m4(bmat, obedit->obmat);
        invert_m3_m3(tmat, bmat);
        mul_m3_v3(tmat, dvec);
 
 
        /* base correction */
        copy_m3_m4(bmat, obedit->obmat);
        invert_m3_m3(tmat, bmat);
        mul_m3_v3(tmat, dvec);
 
-       for(a=0; a<steps; a++) {
+       for (a = 0; a < steps; a++) {
                EDBM_Extrude_edge(obedit, em, BM_SELECT, nor);
                //BMO_CallOpf(em->bm, "extrudefaceregion edgefacein=%hef", BM_SELECT);
                EDBM_Extrude_edge(obedit, em, BM_SELECT, nor);
                //BMO_CallOpf(em->bm, "extrudefaceregion edgefacein=%hef", BM_SELECT);
-               BMO_CallOpf(em->bm, "translate vec=%v verts=%hv", (float*)dvec, BM_SELECT);
+               BMO_CallOpf(em->bm, "translate vec=%v verts=%hv", (float *)dvec, BM_SELECT);
                //extrudeflag(obedit, em, SELECT, nor);
                //translateflag(em, SELECT, dvec);
        }
                //extrudeflag(obedit, em, SELECT, nor);
                //translateflag(em, SELECT, dvec);
        }
@@ -433,16 +437,16 @@ static int extrude_repeat_mesh(bContext *C, wmOperator *op)
 void MESH_OT_extrude_repeat(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_extrude_repeat(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Extrude Repeat Mesh";
-       ot->description= "Extrude selected vertices, edges or faces repeatedly";
-       ot->idname= "MESH_OT_extrude_repeat";
+       ot->name = "Extrude Repeat Mesh";
+       ot->description = "Extrude selected vertices, edges or faces repeatedly";
+       ot->idname = "MESH_OT_extrude_repeat";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= extrude_repeat_mesh;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = extrude_repeat_mesh;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* props */
        RNA_def_float(ot->srna, "offset", 2.0f, 0.0f, 100.0f, "Offset", "", 0.0f, FLT_MAX);
        
        /* props */
        RNA_def_float(ot->srna, "offset", 2.0f, 0.0f, 100.0f, "Offset", "", 0.0f, FLT_MAX);
@@ -452,52 +456,52 @@ void MESH_OT_extrude_repeat(wmOperatorType *ot)
 /* generic extern called extruder */
 static int EDBM_Extrude_Mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOperator *op, float *norin)
 {
 /* generic extern called extruder */
 static int EDBM_Extrude_Mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOperator *op, float *norin)
 {
-       short nr, transmode= 0;
+       short nr, transmode = 0;
        float stacknor[3] = {0.0f, 0.0f, 0.0f};
        float *nor = norin ? norin : stacknor;
 
        nor[0] = nor[1] = nor[2] = 0.0f;
 
        if (em->selectmode & SCE_SELECT_VERTEX) {
        float stacknor[3] = {0.0f, 0.0f, 0.0f};
        float *nor = norin ? norin : stacknor;
 
        nor[0] = nor[1] = nor[2] = 0.0f;
 
        if (em->selectmode & SCE_SELECT_VERTEX) {
-               if (em->bm->totvertsel==0) nr= 0;
-               else if (em->bm->totvertsel==1) nr= 4;
-               else if (em->bm->totedgesel==0) nr= 4;
-               else if (em->bm->totfacesel==0)
-                       nr= 3; // pupmenu("Extrude %t|Only Edges%x3|Only Vertices%x4");
-               else if (em->bm->totfacesel==1)
-                       nr= 1; // pupmenu("Extrude %t|Region %x1|Only Edges%x3|Only Vertices%x4");
+               if (em->bm->totvertsel == 0) nr = 0;
+               else if (em->bm->totvertsel == 1) nr = 4;
+               else if (em->bm->totedgesel == 0) nr = 4;
+               else if (em->bm->totfacesel == 0)
+                       nr = 3; // pupmenu("Extrude %t|Only Edges%x3|Only Vertices%x4");
+               else if (em->bm->totfacesel == 1)
+                       nr = 1; // pupmenu("Extrude %t|Region %x1|Only Edges%x3|Only Vertices%x4");
                else 
                else 
-                       nr= 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2|Only Edges%x3|Only Vertices%x4");
+                       nr = 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2|Only Edges%x3|Only Vertices%x4");
        }
        else if (em->selectmode & SCE_SELECT_EDGE) {
        }
        else if (em->selectmode & SCE_SELECT_EDGE) {
-               if (em->bm->totedgesel==0) nr = 0;
+               if (em->bm->totedgesel == 0) nr = 0;
                
                nr = 1;
                
                nr = 1;
-               /*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 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
                else
-                       nr= 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2|Only Edges%x3");
+                       nr = 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2|Only Edges%x3");
                */
        }
        else {
                if (em->bm->totfacesel == 0) nr = 0;
                else if (em->bm->totfacesel == 1) nr = 1;
                else
                */
        }
        else {
                if (em->bm->totfacesel == 0) nr = 0;
                else if (em->bm->totfacesel == 1) nr = 1;
                else
-                       nr= 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2");
+                       nr = 1; // pupmenu("Extrude %t|Region %x1||Individual Faces %x2");
        }
 
        }
 
-       if (nr<1) return 'g';
+       if (nr < 1) return 'g';
 
 
-       if (nr==1 && em->selectmode & SCE_SELECT_VERTEX)
-               transmode= EDBM_Extrude_vert(obedit, em, BM_SELECT, nor);
-       else if (nr == 1) transmode= EDBM_Extrude_edge(obedit, em, BM_SELECT, nor);
-       else if (nr==4) transmode= EDBM_Extrude_verts_indiv(em, op, BM_SELECT, nor);
-       else if (nr==3) transmode= EDBM_Extrude_edges_indiv(em, op, BM_SELECT, nor);
-       else transmode= EDBM_Extrude_face_indiv(em, op, BM_SELECT, nor);
+       if (nr == 1 && em->selectmode & SCE_SELECT_VERTEX)
+               transmode = EDBM_Extrude_vert(obedit, em, BM_SELECT, nor);
+       else if (nr == 1) transmode = EDBM_Extrude_edge(obedit, em, BM_SELECT, nor);
+       else if (nr == 4) transmode = EDBM_Extrude_verts_indiv(em, op, BM_SELECT, nor);
+       else if (nr == 3) transmode = EDBM_Extrude_edges_indiv(em, op, BM_SELECT, nor);
+       else transmode = EDBM_Extrude_face_indiv(em, op, BM_SELECT, nor);
        
        
-       if (transmode==0) {
+       if (transmode == 0) {
                BKE_report(op->reports, RPT_ERROR, "Not a valid selection for extrude");
        }
        else {
                BKE_report(op->reports, RPT_ERROR, "Not a valid selection for extrude");
        }
        else {
@@ -508,18 +512,18 @@ static int EDBM_Extrude_Mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOpe
                        * This shouldn't be necessary, derived queries should be
                        * automatically building this data if invalid. Or something.
                        */
                        * 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); 
+//             DAG_object_flush_update(scene, obedit, OB_RECALC_DATA);
                object_handle_update(scene, obedit);
 
                /* individual faces? */
 //             BIF_TransformSetUndo("Extrude");
                object_handle_update(scene, obedit);
 
                /* individual faces? */
 //             BIF_TransformSetUndo("Extrude");
-               if (nr==2) {
+               if (nr == 2) {
 //                     initTransform(TFM_SHRINKFATTEN, CTX_NO_PET|CTX_NO_MIRROR);
 //                     Transform();
                }
                else {
 //                     initTransform(TFM_TRANSLATION, CTX_NO_PET|CTX_NO_MIRROR);
 //                     initTransform(TFM_SHRINKFATTEN, CTX_NO_PET|CTX_NO_MIRROR);
 //                     Transform();
                }
                else {
 //                     initTransform(TFM_TRANSLATION, CTX_NO_PET|CTX_NO_MIRROR);
-                       if (transmode=='n') {
+                       if (transmode == 'n') {
                                mul_m4_v3(obedit->obmat, nor);
                                sub_v3_v3v3(nor, nor, obedit->obmat[3]);
 //                             BIF_setSingleAxisConstraint(nor, "along normal");
                                mul_m4_v3(obedit->obmat, nor);
                                sub_v3_v3v3(nor, nor, obedit->obmat[3]);
 //                             BIF_setSingleAxisConstraint(nor, "along normal");
@@ -535,64 +539,64 @@ static int EDBM_Extrude_Mesh(Scene *scene, Object *obedit, BMEditMesh *em, wmOpe
 static int mesh_extrude_region_exec(bContext *C, wmOperator *op)
 {
        Scene *scene = CTX_data_scene(C);
 static int mesh_extrude_region_exec(bContext *C, wmOperator *op)
 {
        Scene *scene = CTX_data_scene(C);
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        
        EDBM_Extrude_Mesh(scene, obedit, em, op, NULL);
 
        
        EDBM_Extrude_Mesh(scene, obedit, em, op, NULL);
 
-       /*This normally happens when pushing undo but modal operators
-         like this one don't push undo data until after modal mode is
-         done.*/
+       /* This normally happens when pushing undo but modal operators
+        * like this one don't push undo data until after modal mode is
+        * done.*/
        EDBM_RecalcNormals(em);
        BMEdit_RecalcTesselation(em);
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
        EDBM_RecalcNormals(em);
        BMEdit_RecalcTesselation(em);
 
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_extrude_region(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_extrude_region(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Extrude Region";
-       ot->idname= "MESH_OT_extrude_region";
+       ot->name = "Extrude Region";
+       ot->idname = "MESH_OT_extrude_region";
        
        /* api callbacks */
        
        /* api callbacks */
-       //ot->invoke= mesh_extrude_region_invoke;
-       ot->exec= mesh_extrude_region_exec;
-       ot->poll= ED_operator_editmesh;
+       //ot->invoke = mesh_extrude_region_invoke;
+       ot->exec = mesh_extrude_region_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 }
 
 static int mesh_extrude_verts_exec(bContext *C, wmOperator *op)
 {
 
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 }
 
 static int mesh_extrude_verts_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        float nor[3];
 
        EDBM_Extrude_verts_indiv(em, op, BM_SELECT, nor);
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
        float nor[3];
 
        EDBM_Extrude_verts_indiv(em, op, BM_SELECT, nor);
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_extrude_verts_indiv(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_extrude_verts_indiv(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Extrude Only Vertices";
-       ot->idname= "MESH_OT_extrude_verts_indiv";
+       ot->name = "Extrude Only Vertices";
+       ot->idname = "MESH_OT_extrude_verts_indiv";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= mesh_extrude_verts_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_extrude_verts_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* to give to transform */
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 
        /* to give to transform */
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
@@ -600,29 +604,29 @@ void MESH_OT_extrude_verts_indiv(wmOperatorType *ot)
 
 static int mesh_extrude_edges_exec(bContext *C, wmOperator *op)
 {
 
 static int mesh_extrude_edges_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        float nor[3];
 
        EDBM_Extrude_edges_indiv(em, op, BM_SELECT, nor);
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
        float nor[3];
 
        EDBM_Extrude_edges_indiv(em, op, BM_SELECT, nor);
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_extrude_edges_indiv(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_extrude_edges_indiv(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Extrude Only Edges";
-       ot->idname= "MESH_OT_extrude_edges_indiv";
+       ot->name = "Extrude Only Edges";
+       ot->idname = "MESH_OT_extrude_edges_indiv";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= mesh_extrude_edges_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_extrude_edges_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* to give to transform */
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 
        /* to give to transform */
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
@@ -630,29 +634,29 @@ void MESH_OT_extrude_edges_indiv(wmOperatorType *ot)
 
 static int mesh_extrude_faces_exec(bContext *C, wmOperator *op)
 {
 
 static int mesh_extrude_faces_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        float nor[3];
 
        EDBM_Extrude_face_indiv(em, op, BM_SELECT, nor);
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
        float nor[3];
 
        EDBM_Extrude_face_indiv(em, op, BM_SELECT, nor);
        
        WM_event_add_notifier(C, NC_GEOM|ND_SELECT, obedit);
        
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_extrude_faces_indiv(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_extrude_faces_indiv(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Extrude Individual Faces";
-       ot->idname= "MESH_OT_extrude_faces_indiv";
+       ot->name = "Extrude Individual Faces";
+       ot->idname = "MESH_OT_extrude_faces_indiv";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= mesh_extrude_faces_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_extrude_faces_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 }
 
        RNA_def_boolean(ot->srna, "mirror", 0, "Mirror Editing", "");
 }
@@ -669,8 +673,8 @@ void EDBM_toggle_select_all(BMEditMesh *em) /* exported for UV */
 
 static int mesh_select_all_exec(bContext *C, wmOperator *op)
 {
 
 static int mesh_select_all_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        int action = RNA_enum_get(op->ptr, "action");
        
        switch (action) {
        int action = RNA_enum_get(op->ptr, "action");
        
        switch (action) {
@@ -696,16 +700,16 @@ static int mesh_select_all_exec(bContext *C, wmOperator *op)
 void MESH_OT_select_all(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_select_all(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Select/Deselect All";
-       ot->idname= "MESH_OT_select_all";
-       ot->description= "(de)select all vertices, edges or faces";
+       ot->name = "Select/Deselect All";
+       ot->idname = "MESH_OT_select_all";
+       ot->description = "(de)select all vertices, edges or faces";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= mesh_select_all_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_select_all_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        WM_operator_properties_select_all(ot);
 }
 
        WM_operator_properties_select_all(ot);
 }
@@ -718,37 +722,37 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
        BMVert *v1;
        BMIter iter;
        float min[3], max[3];
        BMVert *v1;
        BMIter iter;
        float min[3], max[3];
-       int done= 0;
+       int done = 0;
        short use_proj;
        
        em_setup_viewcontext(C, &vc);
        
        short use_proj;
        
        em_setup_viewcontext(C, &vc);
        
-       use_proj= (vc.scene->toolsettings->snap_flag & SCE_SNAP) &&     (vc.scene->toolsettings->snap_mode==SCE_SNAP_MODE_FACE);
+       use_proj = (vc.scene->toolsettings->snap_flag & SCE_SNAP) &&    (vc.scene->toolsettings->snap_mode == SCE_SNAP_MODE_FACE);
 
        INIT_MINMAX(min, max);
        
        BM_ITER(v1, &iter, vc.em->bm, BM_VERTS_OF_MESH, NULL) {
                if (BM_TestHFlag(v1, BM_SELECT)) {
                        DO_MINMAX(v1->co, min, max);
 
        INIT_MINMAX(min, max);
        
        BM_ITER(v1, &iter, vc.em->bm, BM_VERTS_OF_MESH, NULL) {
                if (BM_TestHFlag(v1, BM_SELECT)) {
                        DO_MINMAX(v1->co, min, max);
-                       done= 1;
+                       done = 1;
                }
        }
 
        /* call extrude? */
        if (done) {
                }
        }
 
        /* call extrude? */
        if (done) {
-               const short rot_src= RNA_boolean_get(op->ptr, "rotate_source");
+               const short rot_src = RNA_boolean_get(op->ptr, "rotate_source");
                BMEdge *eed;
                float vec[3], cent[3], mat[3][3];
                BMEdge *eed;
                float vec[3], cent[3], mat[3][3];
-               float nor[3]= {0.0, 0.0, 0.0};
+               float nor[3] = {0.0, 0.0, 0.0};
 
                /* 2D normal calc */
                float mval_f[2];
 
 
                /* 2D normal calc */
                float mval_f[2];
 
-               mval_f[0]= (float)event->mval[0];
-               mval_f[1]= (float)event->mval[1];
+               mval_f[0] = (float)event->mval[0];
+               mval_f[1] = (float)event->mval[1];
 
                /* check for edges that are half selected, use for rotation */
 
                /* check for edges that are half selected, use for rotation */
-               done= 0;
+               done = 0;
                BM_ITER(eed, &iter, vc.em->bm, BM_EDGES_OF_MESH, NULL) {
                        if (BM_TestHFlag(eed, BM_SELECT)) {
                                float co1[3], co2[3];
                BM_ITER(eed, &iter, vc.em->bm, BM_EDGES_OF_MESH, NULL) {
                        if (BM_TestHFlag(eed, BM_SELECT)) {
                                float co1[3], co2[3];
@@ -771,7 +775,7 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
                                        nor[1] += -(co2[0] - co1[0]);
                                }
                        }
                                        nor[1] += -(co2[0] - co1[0]);
                                }
                        }
-                       done= 1;
+                       done = 1;
                }
 
                if (done) {
                }
 
                if (done) {
@@ -806,24 +810,24 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
 
                        copy_v3_v3(vec, min);
                        normalize_v3(vec);
 
                        copy_v3_v3(vec, min);
                        normalize_v3(vec);
-                       dot= dot_v3v3(vec, nor);
+                       dot = dot_v3v3(vec, nor);
 
 
-                       if ( fabs(dot)<0.999) {
+                       if (fabsf(dot) < 0.999f) {
                                float cross[3], si, q1[4];
 
                                cross_v3_v3v3(cross, nor, vec);
                                normalize_v3(cross);
                                float cross[3], si, q1[4];
 
                                cross_v3_v3v3(cross, nor, vec);
                                normalize_v3(cross);
-                               dot= 0.5f*saacos(dot);
+                               dot = 0.5f * saacos(dot);
 
                                /* halve the rotation if its applied twice */
                                if (rot_src) dot *= 0.5f;
 
 
                                /* halve the rotation if its applied twice */
                                if (rot_src) dot *= 0.5f;
 
-                               si= (float)sin(dot);
-                               q1[0]= (float)cos(dot);
-                               q1[1]= cross[0]*si;
-                               q1[2]= cross[1]*si;
-                               q1[3]= cross[2]*si;
-                               quat_to_mat3( mat,q1);
+                               si = sinf(dot);
+                               q1[0] = cosf(dot);
+                               q1[1] = cross[0] * si;
+                               q1[2] = cross[1] * si;
+                               q1[3] = cross[2] * si;
+                               quat_to_mat3(mat, q1);
                        }
                }
                
                        }
                }
                
@@ -843,14 +847,14 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
                        BM_SELECT, min);
        }
        else {
                        BM_SELECT, min);
        }
        else {
-               float *curs= give_cursor(vc.scene, vc.v3d);
+               float *curs = give_cursor(vc.scene, vc.v3d);
                BMOperator bmop;
                BMOIter oiter;
                
                copy_v3_v3(min, curs);
                view3d_get_view_aligned_coordinate(&vc, min, event->mval, 0);
 
                BMOperator bmop;
                BMOIter oiter;
                
                copy_v3_v3(min, curs);
                view3d_get_view_aligned_coordinate(&vc, min, event->mval, 0);
 
-               invert_m4_m4(vc.obedit->imat, vc.obedit->obmat); 
+               invert_m4_m4(vc.obedit->imat, vc.obedit->obmat);
                mul_m4_v3(vc.obedit->imat, min); // back in object space
                
                EDBM_InitOpf(vc.em, &bmop, op, "makevert co=%v", min);
                mul_m4_v3(vc.obedit->imat, min); // back in object space
                
                EDBM_InitOpf(vc.em, &bmop, op, "makevert co=%v", min);
@@ -868,13 +872,13 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
        if (use_proj)
                EMBM_project_snap_verts(C, vc.ar, vc.obedit, vc.em);
 
        if (use_proj)
                EMBM_project_snap_verts(C, vc.ar, vc.obedit, vc.em);
 
-       /*This normally happens when pushing undo but modal operators
-         like this one don't push undo data until after modal mode is
-         done.*/
+       /* This normally happens when pushing undo but modal operators
+        * like this one don't push undo data until after modal mode is
+        * done. */
        EDBM_RecalcNormals(vc.em);
        BMEdit_RecalcTesselation(vc.em);
 
        EDBM_RecalcNormals(vc.em);
        BMEdit_RecalcTesselation(vc.em);
 
-       WM_event_add_notifier(C, NC_GEOM|ND_DATA, vc.obedit->data); 
+       WM_event_add_notifier(C, NC_GEOM|ND_DATA, vc.obedit->data);
        DAG_id_tag_update(vc.obedit->data, OB_RECALC_DATA);
        
        return OPERATOR_FINISHED;
        DAG_id_tag_update(vc.obedit->data, OB_RECALC_DATA);
        
        return OPERATOR_FINISHED;
@@ -883,38 +887,38 @@ static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
 void MESH_OT_dupli_extrude_cursor(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_dupli_extrude_cursor(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Duplicate or Extrude at 3D Cursor";
-       ot->idname= "MESH_OT_dupli_extrude_cursor";
+       ot->name = "Duplicate or Extrude at 3D Cursor";
+       ot->idname = "MESH_OT_dupli_extrude_cursor";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= dupli_extrude_cursor;
-       ot->description= "Duplicate and extrude selected vertices, edges or faces towards the mouse cursor";
-       ot->poll= ED_operator_editmesh;
+       ot->invoke = dupli_extrude_cursor;
+       ot->description = "Duplicate and extrude selected vertices, edges or faces towards the mouse cursor";
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_boolean(ot->srna, "rotate_source", 1, "Rotate Source", "Rotate initial selection giving better shape");
 }
 
 static int delete_mesh(bContext *C, Object *obedit, wmOperator *op, int event, Scene *UNUSED(scene))
 {
 
        RNA_def_boolean(ot->srna, "rotate_source", 1, "Rotate Source", "Rotate initial selection giving better shape");
 }
 
 static int delete_mesh(bContext *C, Object *obedit, wmOperator *op, int event, Scene *UNUSED(scene))
 {
-       BMEditMesh *bem = ((Mesh*)obedit->data)->edit_btmesh;
+       BMEditMesh *bem = ((Mesh *)obedit->data)->edit_btmesh;
        
        
-       if (event<1) return OPERATOR_CANCELLED;
+       if (event < 1) return OPERATOR_CANCELLED;
 
 
-       if (event==10 ) {
+       if (event == 10) {
                //"Erase Vertices";
 
                if (!EDBM_CallOpf(bem, op, "del geom=%hv context=%i", BM_SELECT, DEL_VERTS))
                        return OPERATOR_CANCELLED;
        } 
                //"Erase Vertices";
 
                if (!EDBM_CallOpf(bem, op, "del geom=%hv context=%i", BM_SELECT, DEL_VERTS))
                        return OPERATOR_CANCELLED;
        } 
-       else if (event==11) {
+       else if (event == 11) {
                //"Edge Loop"
                if (!EDBM_CallOpf(bem, op, "dissolveedgeloop edges=%he", BM_SELECT))
                        return OPERATOR_CANCELLED;
        }
                //"Edge Loop"
                if (!EDBM_CallOpf(bem, op, "dissolveedgeloop edges=%he", BM_SELECT))
                        return OPERATOR_CANCELLED;
        }
-       else if (event==7) {
+       else if (event == 7) {
                int use_verts = RNA_boolean_get(op->ptr, "use_verts");
                //"Dissolve"
                if (bem->selectmode & SCE_SELECT_FACE) {
                int use_verts = RNA_boolean_get(op->ptr, "use_verts");
                //"Dissolve"
                if (bem->selectmode & SCE_SELECT_FACE) {
@@ -926,26 +930,26 @@ static int delete_mesh(bContext *C, Object *obedit, wmOperator *op, int event, S
                                return OPERATOR_CANCELLED;
                }
                else if (bem->selectmode & SCE_SELECT_VERTEX) {
                                return OPERATOR_CANCELLED;
                }
                else if (bem->selectmode & SCE_SELECT_VERTEX) {
-                       if (!EDBM_CallOpf(bem, op, "dissolveverts verts=%hv",BM_SELECT))
+                       if (!EDBM_CallOpf(bem, op, "dissolveverts verts=%hv", BM_SELECT))
                                return OPERATOR_CANCELLED;
                }
        }
                                return OPERATOR_CANCELLED;
                }
        }
-       else if (event==4) {
+       else if (event == 4) {
                //Edges and Faces
                if (!EDBM_CallOpf(bem, op, "del geom=%hef context=%i", BM_SELECT, DEL_EDGESFACES))
                        return OPERATOR_CANCELLED;
        } 
                //Edges and Faces
                if (!EDBM_CallOpf(bem, op, "del geom=%hef context=%i", BM_SELECT, DEL_EDGESFACES))
                        return OPERATOR_CANCELLED;
        } 
-       else if (event==1) {
+       else if (event == 1) {
                //"Erase Edges"
                if (!EDBM_CallOpf(bem, op, "del geom=%he context=%i", BM_SELECT, DEL_EDGES))
                        return OPERATOR_CANCELLED;
        }
                //"Erase Edges"
                if (!EDBM_CallOpf(bem, op, "del geom=%he context=%i", BM_SELECT, DEL_EDGES))
                        return OPERATOR_CANCELLED;
        }
-       else if (event==2) {
+       else if (event == 2) {
                //"Erase Faces";
                if (!EDBM_CallOpf(bem, op, "del geom=%hf context=%i", BM_SELECT, DEL_FACES))
                        return OPERATOR_CANCELLED;
        }
                //"Erase Faces";
                if (!EDBM_CallOpf(bem, op, "del geom=%hf context=%i", BM_SELECT, DEL_FACES))
                        return OPERATOR_CANCELLED;
        }
-       else if (event==5) {
+       else if (event == 5) {
                //"Erase Only Faces";
                if (!EDBM_CallOpf(bem, op, "del geom=%hf context=%d",
                                  BM_SELECT, DEL_ONLYFACES))
                //"Erase Only Faces";
                if (!EDBM_CallOpf(bem, op, "del geom=%hf context=%d",
                                  BM_SELECT, DEL_ONLYFACES))
@@ -973,8 +977,8 @@ static EnumPropertyItem prop_mesh_delete_types[] = {
 
 static int delete_mesh_exec(bContext *C, wmOperator *op)
 {
 
 static int delete_mesh_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        Scene *scene = CTX_data_scene(C);
        int type = RNA_enum_get(op->ptr, "type");
        
        Scene *scene = CTX_data_scene(C);
        int type = RNA_enum_get(op->ptr, "type");
        
@@ -997,20 +1001,20 @@ static int delete_mesh_exec(bContext *C, wmOperator *op)
 void MESH_OT_delete(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_delete(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Delete";
-       ot->description= "Delete selected vertices, edges or faces";
-       ot->idname= "MESH_OT_delete";
+       ot->name = "Delete";
+       ot->description = "Delete selected vertices, edges or faces";
+       ot->idname = "MESH_OT_delete";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= WM_menu_invoke;
-       ot->exec= delete_mesh_exec;
+       ot->invoke = WM_menu_invoke;
+       ot->exec = delete_mesh_exec;
        
        
-       ot->poll= ED_operator_editmesh;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
 
-       /*props */
+       /* props */
        ot->prop = RNA_def_enum(ot->srna, "type", prop_mesh_delete_types, 10, "Type", "Method used for deleting mesh data");
 
        /* TODO, move dissolve into its own operator so this doesnt confuse non-dissolve options */
        ot->prop = RNA_def_enum(ot->srna, "type", prop_mesh_delete_types, 10, "Type", "Method used for deleting mesh data");
 
        /* TODO, move dissolve into its own operator so this doesnt confuse non-dissolve options */
@@ -1022,8 +1026,8 @@ void MESH_OT_delete(wmOperatorType *ot)
 static int addedgeface_mesh_exec(bContext *C, wmOperator *op)
 {
        BMOperator bmop;
 static int addedgeface_mesh_exec(bContext *C, wmOperator *op)
 {
        BMOperator bmop;
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        
        if (!EDBM_InitOpf(em, &bmop, op, "contextual_create geom=%hfev", BM_SELECT))
                return OPERATOR_CANCELLED;
        
        if (!EDBM_InitOpf(em, &bmop, op, "contextual_create geom=%hfev", BM_SELECT))
                return OPERATOR_CANCELLED;
@@ -1044,32 +1048,32 @@ static int addedgeface_mesh_exec(bContext *C, wmOperator *op)
 void MESH_OT_edge_face_add(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_edge_face_add(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Make Edge/Face";
-       ot->description= "Add an edge or face to selected";
-       ot->idname= "MESH_OT_edge_face_add";
+       ot->name = "Make Edge/Face";
+       ot->description = "Add an edge or face to selected";
+       ot->idname = "MESH_OT_edge_face_add";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= addedgeface_mesh_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = addedgeface_mesh_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 /* ************************* SEAMS AND EDGES **************** */
 
 static int editbmesh_mark_seam(bContext *C, wmOperator *op)
 {
 }
 
 /* ************************* SEAMS AND EDGES **************** */
 
 static int editbmesh_mark_seam(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       Mesh *me= ((Mesh *)obedit->data);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       Mesh *me = ((Mesh *)obedit->data);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMesh *bm = em->bm;
        BMEdge *eed;
        BMIter iter;
        int clear = RNA_boolean_get(op->ptr, "clear");
        
        /* auto-enable seams drawing */
        BMesh *bm = em->bm;
        BMEdge *eed;
        BMIter iter;
        int clear = RNA_boolean_get(op->ptr, "clear");
        
        /* auto-enable seams drawing */
-       if (clear==0) {
+       if (clear == 0) {
                me->drawflag |= ME_DRAWSEAMS;
        }
 
                me->drawflag |= ME_DRAWSEAMS;
        }
 
@@ -1098,25 +1102,25 @@ static int editbmesh_mark_seam(bContext *C, wmOperator *op)
 void MESH_OT_mark_seam(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_mark_seam(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Mark Seam";
-       ot->idname= "MESH_OT_mark_seam";
-       ot->description= "(un)mark selected edges as a seam";
+       ot->name = "Mark Seam";
+       ot->idname = "MESH_OT_mark_seam";
+       ot->description = "(un)mark selected edges as a seam";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= editbmesh_mark_seam;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = editbmesh_mark_seam;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "clear", 0, "Clear", "");
 }
 
 static int editbmesh_mark_sharp(bContext *C, wmOperator *op)
 {
        
        RNA_def_boolean(ot->srna, "clear", 0, "Clear", "");
 }
 
 static int editbmesh_mark_sharp(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       Mesh *me= ((Mesh *)obedit->data);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       Mesh *me = ((Mesh *)obedit->data);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMesh *bm = em->bm;
        BMEdge *eed;
        BMIter iter;
        BMesh *bm = em->bm;
        BMEdge *eed;
        BMIter iter;
@@ -1154,16 +1158,16 @@ static int editbmesh_mark_sharp(bContext *C, wmOperator *op)
 void MESH_OT_mark_sharp(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_mark_sharp(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Mark Sharp";
-       ot->idname= "MESH_OT_mark_sharp";
-       ot->description= "(un)mark selected edges as sharp";
+       ot->name = "Mark Sharp";
+       ot->idname = "MESH_OT_mark_sharp";
+       ot->description = "(un)mark selected edges as sharp";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= editbmesh_mark_sharp;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = editbmesh_mark_sharp;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "clear", 0, "Clear", "");
 }
        
        RNA_def_boolean(ot->srna, "clear", 0, "Clear", "");
 }
@@ -1171,8 +1175,8 @@ void MESH_OT_mark_sharp(wmOperatorType *ot)
 
 static int editbmesh_vert_connect(bContext *C, wmOperator *op)
 {
 
 static int editbmesh_vert_connect(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMesh *bm = em->bm;
        BMOperator bmop;
        int len = 0;
        BMesh *bm = em->bm;
        BMOperator bmop;
        int len = 0;
@@ -1195,21 +1199,21 @@ static int editbmesh_vert_connect(bContext *C, wmOperator *op)
 void MESH_OT_vert_connect(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_vert_connect(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Vertex Connect";
-       ot->idname= "MESH_OT_vert_connect";
+       ot->name = "Vertex Connect";
+       ot->idname = "MESH_OT_vert_connect";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= editbmesh_vert_connect;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = editbmesh_vert_connect;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 static int editbmesh_edge_split(bContext *C, wmOperator *op)
 {
 }
 
 static int editbmesh_edge_split(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMesh *bm = em->bm;
        BMOperator bmop;
        int len = 0;
        BMesh *bm = em->bm;
        BMOperator bmop;
        int len = 0;
@@ -1233,15 +1237,15 @@ static int editbmesh_edge_split(bContext *C, wmOperator *op)
 void MESH_OT_edge_split(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_edge_split(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Edge Split";
-       ot->idname= "MESH_OT_edge_split";
+       ot->name = "Edge Split";
+       ot->idname = "MESH_OT_edge_split";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= editbmesh_edge_split;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = editbmesh_edge_split;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_int(ot->srna, "number_cuts", 1, 1, 10, "Number of Cuts", "", 1, INT_MAX);
 }
 
        RNA_def_int(ot->srna, "number_cuts", 1, 1, 10, "Number of Cuts", "", 1, INT_MAX);
 }
@@ -1250,8 +1254,8 @@ void MESH_OT_edge_split(wmOperatorType *ot)
 
 static int mesh_duplicate_exec(bContext *C, wmOperator *op)
 {
 
 static int mesh_duplicate_exec(bContext *C, wmOperator *op)
 {
-       Object *ob= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh*)ob->data)->edit_btmesh;
+       Object *ob = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        EDBM_InitOpf(em, &bmop, op, "dupe geom=%hvef", BM_SELECT);
        BMOperator bmop;
 
        EDBM_InitOpf(em, &bmop, op, "dupe geom=%hvef", BM_SELECT);
@@ -1283,15 +1287,15 @@ static int mesh_duplicate_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(ev
 void MESH_OT_duplicate(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_duplicate(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Duplicate";
-       ot->description= "Duplicate selected vertices, edges or faces";
-       ot->idname= "MESH_OT_duplicate";
+       ot->name = "Duplicate";
+       ot->description = "Duplicate selected vertices, edges or faces";
+       ot->idname = "MESH_OT_duplicate";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->invoke= mesh_duplicate_invoke;
-       ot->exec= mesh_duplicate_exec;
+       ot->invoke = mesh_duplicate_invoke;
+       ot->exec = mesh_duplicate_exec;
        
        
-       ot->poll= ED_operator_editmesh;
+       ot->poll = ED_operator_editmesh;
        
        /* to give to transform */
        RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
        
        /* to give to transform */
        RNA_def_int(ot->srna, "mode", TFM_TRANSLATION, 0, INT_MAX, "Mode", "", 0, INT_MAX);
@@ -1299,8 +1303,8 @@ void MESH_OT_duplicate(wmOperatorType *ot)
 
 static int flip_normals(bContext *C, wmOperator *op)
 {
 
 static int flip_normals(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = (((Mesh *)obedit->data))->edit_btmesh;
        
        if (!EDBM_CallOpf(em, op, "reversefaces faces=%hf", BM_SELECT))
                return OPERATOR_CANCELLED;
        
        if (!EDBM_CallOpf(em, op, "reversefaces faces=%hf", BM_SELECT))
                return OPERATOR_CANCELLED;
@@ -1314,16 +1318,16 @@ static int flip_normals(bContext *C, wmOperator *op)
 void MESH_OT_flip_normals(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_flip_normals(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Flip Normals";
-       ot->description= "Flip the direction of selected face's vertex and face normals";
-       ot->idname= "MESH_OT_flip_normals";
+       ot->name = "Flip Normals";
+       ot->description = "Flip the direction of selected face's vertex and face normals";
+       ot->idname = "MESH_OT_flip_normals";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= flip_normals;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = flip_normals;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 float *bm_get_cd_float(CustomData *cdata, void *data, int type)
 }
 
 float *bm_get_cd_float(CustomData *cdata, void *data, int type)
@@ -1333,7 +1337,7 @@ float *bm_get_cd_float(CustomData *cdata, void *data, int type)
        return f;
 }
 
        return f;
 }
 
-static const EnumPropertyItem direction_items[]= {
+static const EnumPropertyItem direction_items[] = {
        {DIRECTION_CW, "CW", 0, "Clockwise", ""},
        {DIRECTION_CCW, "CCW", 0, "Counter Clockwise", ""},
        {0, NULL, 0, NULL, NULL}};
        {DIRECTION_CW, "CW", 0, "Clockwise", ""},
        {DIRECTION_CCW, "CCW", 0, "Counter Clockwise", ""},
        {0, NULL, 0, NULL, NULL}};
@@ -1341,20 +1345,20 @@ static const EnumPropertyItem direction_items[]= {
 /* only accepts 1 selected edge, or 2 selected faces */
 static int edge_rotate_selected(bContext *C, wmOperator *op)
 {
 /* only accepts 1 selected edge, or 2 selected faces */
 static int edge_rotate_selected(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMOperator bmop;
        BMEdge *eed;
        BMIter iter;
        const int do_ccw = RNA_enum_get(op->ptr, "direction") == 1;
        BMOperator bmop;
        BMEdge *eed;
        BMIter iter;
        const int do_ccw = RNA_enum_get(op->ptr, "direction") == 1;
-       int do_deselect= FALSE; /* do we deselect */
+       int do_deselect = FALSE; /* do we deselect */
        
        if (!(em->bm->totfacesel == 2 || em->bm->totedgesel == 1)) {
                BKE_report(op->reports, RPT_ERROR, "Select one edge or two adjacent faces");
                return OPERATOR_CANCELLED;
        }
 
        
        if (!(em->bm->totfacesel == 2 || em->bm->totedgesel == 1)) {
                BKE_report(op->reports, RPT_ERROR, "Select one edge or two adjacent faces");
                return OPERATOR_CANCELLED;
        }
 
-       /*first see if we have two adjacent faces*/
+       /* first see if we have two adjacent faces */
        BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                if (BM_Edge_FaceCount(eed) == 2) {
                        if ((BM_TestHFlag(eed->l->f, BM_SELECT) && BM_TestHFlag(eed->l->radial_next->f, BM_SELECT))
        BM_ITER(eed, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                if (BM_Edge_FaceCount(eed) == 2) {
                        if ((BM_TestHFlag(eed->l->f, BM_SELECT) && BM_TestHFlag(eed->l->radial_next->f, BM_SELECT))
@@ -1365,8 +1369,8 @@ static int edge_rotate_selected(bContext *C, wmOperator *op)
                }
        }
        
                }
        }
        
-       /*ok, we don't have two adjacent faces, but we do have two selected ones.
-         that's an error condition.*/
+       /* ok, we don't have two adjacent faces, but we do have two selected ones.
+        * that's an error condition.*/
        if (!eed && em->bm->totfacesel == 2) {
                BKE_report(op->reports, RPT_ERROR, "Select one edge or two adjacent faces");
                return OPERATOR_CANCELLED;
        if (!eed && em->bm->totfacesel == 2) {
                BKE_report(op->reports, RPT_ERROR, "Select one edge or two adjacent faces");
                return OPERATOR_CANCELLED;
@@ -1382,7 +1386,7 @@ static int edge_rotate_selected(bContext *C, wmOperator *op)
                }
        }
 
                }
        }
 
-       /*this should never happen*/
+       /* this should never happen */
        if (!eed)
                return OPERATOR_CANCELLED;
        
        if (!eed)
                return OPERATOR_CANCELLED;
        
@@ -1409,16 +1413,16 @@ static int edge_rotate_selected(bContext *C, wmOperator *op)
 void MESH_OT_edge_rotate(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_edge_rotate(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Rotate Selected Edge";
-       ot->description= "Rotate selected edge or adjoining faces";
-       ot->idname= "MESH_OT_edge_rotate";
+       ot->name = "Rotate Selected Edge";
+       ot->description = "Rotate selected edge or adjoining faces";
+       ot->idname = "MESH_OT_edge_rotate";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= edge_rotate_selected;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = edge_rotate_selected;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* props */
        RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "direction", "direction to rotate edge around");
 
        /* props */
        RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "direction", "direction to rotate edge around");
@@ -1431,7 +1435,7 @@ void EDBM_hide_mesh(BMEditMesh *em, int swap)
        BMHeader *h;
        int itermode;
 
        BMHeader *h;
        int itermode;
 
-       if (em==NULL) return;
+       if (em == NULL) return;
        
        if (em->selectmode & SCE_SELECT_VERTEX)
                itermode = BM_VERTS_OF_MESH;
        
        if (em->selectmode & SCE_SELECT_VERTEX)
                itermode = BM_VERTS_OF_MESH;
@@ -1447,8 +1451,8 @@ void EDBM_hide_mesh(BMEditMesh *em, int swap)
 
        EDBM_selectmode_flush(em);
 
 
        EDBM_selectmode_flush(em);
 
-       /*original hide flushing comment (OUTDATED): 
-         hide happens on least dominant select mode, and flushes up, not down! (helps preventing errors in subsurf) */
+       /* 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
        /*  - vertex hidden, always means edge is hidden too
                - edge hidden, always means face is hidden too
                - face hidden, only set face hide
@@ -1459,30 +1463,30 @@ void EDBM_hide_mesh(BMEditMesh *em, int swap)
 
 static int hide_mesh_exec(bContext *C, wmOperator *op)
 {
 
 static int hide_mesh_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = (((Mesh *)obedit->data))->edit_btmesh;
        
        EDBM_hide_mesh(em, RNA_boolean_get(op->ptr, "unselected"));
                
        DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 
        
        EDBM_hide_mesh(em, RNA_boolean_get(op->ptr, "unselected"));
                
        DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_hide(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_hide(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Hide Selection";
-       ot->idname= "MESH_OT_hide";
+       ot->name = "Hide Selection";
+       ot->idname = "MESH_OT_hide";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= hide_mesh_exec;
-       ot->poll= ED_operator_editmesh;
-        ot->description= "Hide (un)selected vertices, edges or faces";
+       ot->exec = hide_mesh_exec;
+       ot->poll = ED_operator_editmesh;
+        ot->description = "Hide (un)selected vertices, edges or faces";
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        /* props */
        RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "Hide unselected rather than selected");
        
        /* props */
        RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "Hide unselected rather than selected");
@@ -1537,39 +1541,39 @@ void EDBM_reveal_mesh(BMEditMesh *em)
 
 static int reveal_mesh_exec(bContext *C, wmOperator *UNUSED(op))
 {
 
 static int reveal_mesh_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= (((Mesh *)obedit->data))->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = (((Mesh *)obedit->data))->edit_btmesh;
        
        EDBM_reveal_mesh(em);
 
        DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 
        
        EDBM_reveal_mesh(em);
 
        DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_reveal(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_reveal(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Reveal Hidden";
-       ot->idname= "MESH_OT_reveal";
-       ot->description= "Reveal all hidden vertices, edges and faces";
+       ot->name = "Reveal Hidden";
+       ot->idname = "MESH_OT_reveal";
+       ot->description = "Reveal all hidden vertices, edges and faces";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= reveal_mesh_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = reveal_mesh_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 static int normals_make_consistent_exec(bContext *C, wmOperator *op)
 {
 }
 
 static int normals_make_consistent_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        
        /* doflip has to do with bmesh_rationalize_normals, it's an internal
        
        /* doflip has to do with bmesh_rationalize_normals, it's an internal
-        * thing*/
+        * thing */
        if (!EDBM_CallOpf(em, op, "righthandfaces faces=%hf doflip=%d", BM_SELECT, 1))
                return OPERATOR_CANCELLED;
 
        if (!EDBM_CallOpf(em, op, "righthandfaces faces=%hf doflip=%d", BM_SELECT, 1))
                return OPERATOR_CANCELLED;
 
@@ -1579,22 +1583,22 @@ static int normals_make_consistent_exec(bContext *C, wmOperator *op)
        DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 
        DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
 
-       return OPERATOR_FINISHED;       
+       return OPERATOR_FINISHED;
 }
 
 void MESH_OT_normals_make_consistent(wmOperatorType *ot)
 {
        /* identifiers */
 }
 
 void MESH_OT_normals_make_consistent(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Make Normals Consistent";
-       ot->description= "Make face and vertex normals point either outside or inside the mesh";
-       ot->idname= "MESH_OT_normals_make_consistent";
+       ot->name = "Make Normals Consistent";
+       ot->description = "Make face and vertex normals point either outside or inside the mesh";
+       ot->idname = "MESH_OT_normals_make_consistent";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= normals_make_consistent_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = normals_make_consistent_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
        
        RNA_def_boolean(ot->srna, "inside", 0, "Inside", "");
 }
        
        RNA_def_boolean(ot->srna, "inside", 0, "Inside", "");
 }
@@ -1603,10 +1607,10 @@ void MESH_OT_normals_make_consistent(wmOperatorType *ot)
 
 static int do_smooth_vertex(bContext *C, wmOperator *op)
 {
 
 static int do_smooth_vertex(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        ModifierData *md;
        ModifierData *md;
-       int mirrx=0, mirry=0, mirrz=0;
+       int mirrx = 0, mirry = 0, mirrz = 0;
        int i, repeat;
        float clipdist = 0.0f;
 
        int i, repeat;
        float clipdist = 0.0f;
 
@@ -1618,9 +1622,9 @@ static int do_smooth_vertex(bContext *C, wmOperator *op)
        /* if there is a mirror modifier with clipping, flag the verts that
         * are within tolerance of the plane(s) of reflection 
         */
        /* if there is a mirror modifier with clipping, flag the verts that
         * are within tolerance of the plane(s) of reflection 
         */
-       for(md=obedit->modifiers.first; md; md=md->next) {
-               if (md->type==eModifierType_Mirror && (md->mode & eModifierMode_Realtime)) {
-                       MirrorModifierData *mmd = (MirrorModifierData*) md;     
+       for (md = obedit->modifiers.first; md; md = md->next) {
+               if (md->type == eModifierType_Mirror && (md->mode & eModifierMode_Realtime)) {
+                       MirrorModifierData *mmd = (MirrorModifierData *)md;
                
                        if (mmd->flag & MOD_MIR_CLIPPING) {
                                if (mmd->flag & MOD_MIR_AXIS_X)
                
                        if (mmd->flag & MOD_MIR_CLIPPING) {
                                if (mmd->flag & MOD_MIR_AXIS_X)
@@ -1639,7 +1643,7 @@ static int do_smooth_vertex(bContext *C, wmOperator *op)
        if (!repeat)
                repeat = 1;
        
        if (!repeat)
                repeat = 1;
        
-       for (i=0; i<repeat; i++) {
+       for (i = 0; i < repeat; i++) {
                if (!EDBM_CallOpf(em, op,
                                  "vertexsmooth verts=%hv mirror_clip_x=%d mirror_clip_y=%d mirror_clip_z=%d clipdist=%f",
                                  BM_SELECT, mirrx, mirry, mirrz, clipdist))
                if (!EDBM_CallOpf(em, op,
                                  "vertexsmooth verts=%hv mirror_clip_x=%d mirror_clip_y=%d mirror_clip_z=%d clipdist=%f",
                                  BM_SELECT, mirrx, mirry, mirrz, clipdist))
@@ -1663,16 +1667,16 @@ static int do_smooth_vertex(bContext *C, wmOperator *op)
 void MESH_OT_vertices_smooth(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_vertices_smooth(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Smooth Vertex";
-       ot->description= "Flatten angles of selected vertices";
-       ot->idname= "MESH_OT_vertices_smooth";
+       ot->name = "Smooth Vertex";
+       ot->description = "Flatten angles of selected vertices";
+       ot->idname = "MESH_OT_vertices_smooth";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= do_smooth_vertex;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = do_smooth_vertex;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_int(ot->srna, "repeat", 1, 1, 100, "Number of times to smooth the mesh", "", 1, INT_MAX);
 }
 
        RNA_def_int(ot->srna, "repeat", 1, 1, 100, "Number of times to smooth the mesh", "", 1, INT_MAX);
 }
@@ -1680,15 +1684,15 @@ void MESH_OT_vertices_smooth(wmOperatorType *ot)
 
 static int bm_test_exec(bContext *C, wmOperator *UNUSED(op))
 {
 
 static int bm_test_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
+       Object *obedit = CTX_data_edit_object(C);
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMBVHTree *tree = BMBVH_NewBVH(em, 0, NULL, NULL);
        BMIter iter;
        BMEdge *e;
 
        BMBVHTree *tree = BMBVH_NewBVH(em, 0, NULL, NULL);
        BMIter iter;
        BMEdge *e;
 
-       /*hide all back edges*/
+       /* hide all back edges */
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                if (!BM_TestHFlag(e, BM_SELECT))
                        continue;
        BM_ITER(e, &iter, em->bm, BM_EDGES_OF_MESH, NULL) {
                if (!BM_TestHFlag(e, BM_SELECT))
                        continue;
@@ -1705,7 +1709,7 @@ static int bm_test_exec(bContext *C, wmOperator *UNUSED(op))
        BMLoop *l, *l2;
        MLoopUV *luv;
        BMWalker walker;
        BMLoop *l, *l2;
        MLoopUV *luv;
        BMWalker walker;
-       int i=0;
+       int i = 0;
 
        BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
 
        BM_ITER(f, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
                BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, f) {
@@ -1720,7 +1724,7 @@ static int bm_test_exec(bContext *C, wmOperator *UNUSED(op))
                        luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
                        if (luv->flag & MLOOPUV_VERTSEL) {
                                l2 = BMW_Begin(&walker, l);
                        luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
                        if (luv->flag & MLOOPUV_VERTSEL) {
                                l2 = BMW_Begin(&walker, l);
-                               for (; l2; l2=BMW_Step(&walker)) {
+                               for (; l2; l2 = BMW_Step(&walker)) {
                                        luv = CustomData_bmesh_get(&em->bm->ldata, l2->head.data, CD_MLOOPUV);
                                        luv->flag |= MLOOPUV_VERTSEL;
                                }                               
                                        luv = CustomData_bmesh_get(&em->bm->ldata, l2->head.data, CD_MLOOPUV);
                                        luv->flag |= MLOOPUV_VERTSEL;
                                }                               
@@ -1739,15 +1743,15 @@ static int bm_test_exec(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_bm_test(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_bm_test(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "BMesh Test Operator";
-       ot->idname= "MESH_OT_bm_test";
+       ot->name = "BMesh Test Operator";
+       ot->idname = "MESH_OT_bm_test";
        
        /* api callbacks */
        
        /* api callbacks */
-       ot->exec= bm_test_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = bm_test_exec;
+       ot->poll = ED_operator_editmesh;
        
        /* flags */
        
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        //RNA_def_int(ot->srna, "repeat", 1, 1, 100, "Number of times to smooth the mesh", "", 1, INT_MAX);
 }
 
        //RNA_def_int(ot->srna, "repeat", 1, 1, 100, "Number of times to smooth the mesh", "", 1, INT_MAX);
 }
@@ -1759,7 +1763,7 @@ static void mesh_set_smooth_faces(BMEditMesh *em, short smooth)
        BMIter iter;
        BMFace *efa;
 
        BMIter iter;
        BMFace *efa;
 
-       if (em==NULL) return;
+       if (em == NULL) return;
        
        BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
                if (BM_TestHFlag(efa, BM_SELECT)) {
        
        BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
                if (BM_TestHFlag(efa, BM_SELECT)) {
@@ -1773,8 +1777,8 @@ static void mesh_set_smooth_faces(BMEditMesh *em, short smooth)
 
 static int mesh_faces_shade_smooth_exec(bContext *C, wmOperator *UNUSED(op))
 {
 
 static int mesh_faces_shade_smooth_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
 
        mesh_set_smooth_faces(em, 1);
 
 
        mesh_set_smooth_faces(em, 1);
 
@@ -1787,22 +1791,22 @@ static int mesh_faces_shade_smooth_exec(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_faces_shade_smooth(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_faces_shade_smooth(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Shade Smooth";
-        ot->description= "Display faces smooth (using vertex normals)";
-       ot->idname= "MESH_OT_faces_shade_smooth";
+       ot->name = "Shade Smooth";
+        ot->description = "Display faces smooth (using vertex normals)";
+       ot->idname = "MESH_OT_faces_shade_smooth";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_faces_shade_smooth_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_faces_shade_smooth_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 static int mesh_faces_shade_flat_exec(bContext *C, wmOperator *UNUSED(op))
 {
 }
 
 static int mesh_faces_shade_flat_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
 
        mesh_set_smooth_faces(em, 0);
 
 
        mesh_set_smooth_faces(em, 0);
 
@@ -1815,23 +1819,23 @@ static int mesh_faces_shade_flat_exec(bContext *C, wmOperator *UNUSED(op))
 void MESH_OT_faces_shade_flat(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_faces_shade_flat(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Shade Flat";
-       ot->description= "Display faces flat";
-       ot->idname= "MESH_OT_faces_shade_flat";
+       ot->name = "Shade Flat";
+       ot->description = "Display faces flat";
+       ot->idname = "MESH_OT_faces_shade_flat";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_faces_shade_flat_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_faces_shade_flat_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 
 /********************** UV/Color Operators *************************/
 
 
 }
 
 
 /********************** UV/Color Operators *************************/
 
 
-static const EnumPropertyItem axis_items[]= {
+static const EnumPropertyItem axis_items[] = {
        {OPUVC_AXIS_X, "X", 0, "X", ""},
        {OPUVC_AXIS_Y, "Y", 0, "Y", ""},
        {0, NULL, 0, NULL, NULL}};
        {OPUVC_AXIS_X, "X", 0, "X", ""},
        {OPUVC_AXIS_Y, "Y", 0, "Y", ""},
        {0, NULL, 0, NULL, NULL}};
@@ -1839,7 +1843,7 @@ static const EnumPropertyItem axis_items[]= {
 static int mesh_rotate_uvs(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int mesh_rotate_uvs(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        /* get the direction from RNA */
        BMOperator bmop;
 
        /* get the direction from RNA */
@@ -1867,7 +1871,7 @@ static int mesh_rotate_uvs(bContext *C, wmOperator *op)
 static int mesh_reverse_uvs(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int mesh_reverse_uvs(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
        BMOperator bmop;
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
@@ -1892,7 +1896,7 @@ static int mesh_reverse_uvs(bContext *C, wmOperator *op)
 static int mesh_rotate_colors(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int mesh_rotate_colors(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        /* get the direction from RNA */
        BMOperator bmop;
 
        /* get the direction from RNA */
@@ -1923,7 +1927,7 @@ static int mesh_rotate_colors(bContext *C, wmOperator *op)
 static int mesh_reverse_colors(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int mesh_reverse_colors(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
        BMOperator bmop;
 
        /* initialize the bmop using EDBM api, which does various ui error reporting and other stuff */
@@ -1947,15 +1951,15 @@ static int mesh_reverse_colors(bContext *C, wmOperator *op)
 void MESH_OT_uvs_rotate(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_uvs_rotate(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Rotate UVs";
-       ot->idname= "MESH_OT_uvs_rotate";
+       ot->name = "Rotate UVs";
+       ot->idname = "MESH_OT_uvs_rotate";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_rotate_uvs;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_rotate_uvs;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* props */
        RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "Direction", "Direction to rotate UVs around");
 
        /* props */
        RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CW, "Direction", "Direction to rotate UVs around");
@@ -1965,15 +1969,15 @@ void MESH_OT_uvs_rotate(wmOperatorType *ot)
 void MESH_OT_uvs_reverse(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_uvs_reverse(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Reverse UVs";
-       ot->idname= "MESH_OT_uvs_reverse";
+       ot->name = "Reverse UVs";
+       ot->idname = "MESH_OT_uvs_reverse";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_reverse_uvs;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_reverse_uvs;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* props */
        //RNA_def_enum(ot->srna, "axis", axis_items, DIRECTION_CW, "Axis", "Axis to mirror UVs around");
 
        /* props */
        //RNA_def_enum(ot->srna, "axis", axis_items, DIRECTION_CW, "Axis", "Axis to mirror UVs around");
@@ -1982,15 +1986,15 @@ void MESH_OT_uvs_reverse(wmOperatorType *ot)
 void MESH_OT_colors_rotate(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_colors_rotate(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Rotate Colors";
-       ot->idname= "MESH_OT_colors_rotate";
+       ot->name = "Rotate Colors";
+       ot->idname = "MESH_OT_colors_rotate";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_rotate_colors;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_rotate_colors;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* props */
        RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CCW, "Direction", "Direction to rotate edge around");
 
        /* props */
        RNA_def_enum(ot->srna, "direction", direction_items, DIRECTION_CCW, "Direction", "Direction to rotate edge around");
@@ -1999,15 +2003,15 @@ void MESH_OT_colors_rotate(wmOperatorType *ot)
 void MESH_OT_colors_reverse(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_colors_reverse(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Reverse Colors";
-       ot->idname= "MESH_OT_colors_reverse";
+       ot->name = "Reverse Colors";
+       ot->idname = "MESH_OT_colors_reverse";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= mesh_reverse_colors;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = mesh_reverse_colors;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* props */
        //RNA_def_enum(ot->srna, "axis", axis_items, DIRECTION_CW, "Axis", "Axis to mirror colors around");
 
        /* props */
        //RNA_def_enum(ot->srna, "axis", axis_items, DIRECTION_CW, "Axis", "Axis to mirror colors around");
@@ -2022,11 +2026,11 @@ static int merge_firstlast(BMEditMesh *em, int first, int uvmerge, wmOperator *w
        /* do sanity check in mergemenu in edit.c ?*/
        if (first == 0) {
                ese = em->bm->selected.last;
        /* do sanity check in mergemenu in edit.c ?*/
        if (first == 0) {
                ese = em->bm->selected.last;
-               mergevert= (BMVert*)ese->data;
+               mergevert = (BMVert *)ese->data;
        }
        else{
                ese = em->bm->selected.first;
        }
        else{
                ese = em->bm->selected.first;
-               mergevert = (BMVert*)ese->data;
+               mergevert = (BMVert *)ese->data;
        }
 
        if (!BM_TestHFlag(mergevert, BM_SELECT))
        }
 
        if (!BM_TestHFlag(mergevert, BM_SELECT))
@@ -2048,7 +2052,7 @@ static int merge_target(BMEditMesh *em, Scene *scene, View3D *v3d, Object *ob,
 {
        BMIter iter;
        BMVert *v;
 {
        BMIter iter;
        BMVert *v;
-       float *vco=NULL, co[3], cent[3] = {0.0f, 0.0f, 0.0f};
+       float *vco = NULL, co[3], cent[3] = {0.0f, 0.0f, 0.0f};
 
        if (target) {
                vco = give_cursor(scene, v3d);
 
        if (target) {
                vco = give_cursor(scene, v3d);
@@ -2090,11 +2094,11 @@ static int merge_target(BMEditMesh *em, Scene *scene, View3D *v3d, Object *ob,
 
 static int merge_exec(bContext *C, wmOperator *op)
 {
 
 static int merge_exec(bContext *C, wmOperator *op)
 {
-       Scene *scene= CTX_data_scene(C);
+       Scene *scene = CTX_data_scene(C);
        View3D *v3d = CTX_wm_view3d(C);
        View3D *v3d = CTX_wm_view3d(C);
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
-       int status= 0, uvs= RNA_boolean_get(op->ptr, "uvs");
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
+       int status = 0, uvs = RNA_boolean_get(op->ptr, "uvs");
 
        switch(RNA_enum_get(op->ptr, "type")) {
                case 3:
 
        switch(RNA_enum_get(op->ptr, "type")) {
                case 3:
@@ -2125,7 +2129,7 @@ static int merge_exec(bContext *C, wmOperator *op)
        return OPERATOR_FINISHED;
 }
 
        return OPERATOR_FINISHED;
 }
 
-static EnumPropertyItem merge_type_items[]= {
+static EnumPropertyItem merge_type_items[] = {
        {6, "FIRST", 0, "At First", ""},
        {1, "LAST", 0, "At Last", ""},
        {3, "CENTER", 0, "At Center", ""},
        {6, "FIRST", 0, "At First", ""},
        {1, "LAST", 0, "At Last", ""},
        {3, "CENTER", 0, "At Center", ""},
@@ -2136,26 +2140,30 @@ static EnumPropertyItem merge_type_items[]= {
 static EnumPropertyItem *merge_type_itemf(bContext *C, PointerRNA *UNUSED(ptr),  PropertyRNA *UNUSED(prop), int *free)
 {      
        Object *obedit;
 static EnumPropertyItem *merge_type_itemf(bContext *C, PointerRNA *UNUSED(ptr),  PropertyRNA *UNUSED(prop), int *free)
 {      
        Object *obedit;
-       EnumPropertyItem *item= NULL;
-       int totitem= 0;
+       EnumPropertyItem *item = NULL;
+       int totitem = 0;
        
        if (!C) /* needed for docs */
                return merge_type_items;
        
        
        if (!C) /* needed for docs */
                return merge_type_items;
        
-       obedit= CTX_data_edit_object(C);
+       obedit = CTX_data_edit_object(C);
        if (obedit && obedit->type == OB_MESH) {
        if (obedit && obedit->type == OB_MESH) {
-               BMEditMesh *em= ((Mesh*)obedit->data)->edit_btmesh;
+               BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
 
                if (em->selectmode & SCE_SELECT_VERTEX) {
 
                if (em->selectmode & SCE_SELECT_VERTEX) {
-                       if (em->bm->selected.first && em->bm->selected.last &&
-                               ((BMEditSelection*)em->bm->selected.first)->htype == BM_VERT && ((BMEditSelection*)em->bm->selected.last)->htype == BM_VERT) {
+                       if ( em->bm->selected.first && em->bm->selected.last &&
+                            ((BMEditSelection *)em->bm->selected.first)->htype == BM_VERT &&
+                            ((BMEditSelection *)em->bm->selected.last)->htype == BM_VERT)
+                       {
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 6);
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 1);
                        }
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 6);
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 1);
                        }
-                       else if (em->bm->selected.first && ((BMEditSelection*)em->bm->selected.first)->htype == BM_VERT)
+                       else if (em->bm->selected.first && ((BMEditSelection *)em->bm->selected.first)->htype == BM_VERT) {
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 1);
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 1);
-                       else if (em->bm->selected.last && ((BMEditSelection*)em->bm->selected.last)->htype == BM_VERT)
+                       }
+                       else if (em->bm->selected.last && ((BMEditSelection *)em->bm->selected.last)->htype == BM_VERT) {
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 6);
                                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 6);
+                       }
                }
 
                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 3);
                }
 
                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 3);
@@ -2163,7 +2171,7 @@ static EnumPropertyItem *merge_type_itemf(bContext *C, PointerRNA *UNUSED(ptr),
                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 5);
                RNA_enum_item_end(&item, &totitem);
 
                RNA_enum_items_add_value(&item, &totitem, merge_type_items, 5);
                RNA_enum_item_end(&item, &totitem);
 
-               *free= 1;
+               *free = 1;
 
                return item;
        }
 
                return item;
        }
@@ -2174,19 +2182,19 @@ static EnumPropertyItem *merge_type_itemf(bContext *C, PointerRNA *UNUSED(ptr),
 void MESH_OT_merge(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_merge(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Merge";
-       ot->idname= "MESH_OT_merge";
+       ot->name = "Merge";
+       ot->idname = "MESH_OT_merge";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= merge_exec;
-       ot->invoke= WM_menu_invoke;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = merge_exec;
+       ot->invoke = WM_menu_invoke;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* properties */
 
        /* properties */
-       ot->prop= RNA_def_enum(ot->srna, "type", merge_type_items, 3, "Type", "Merge method to use");
+       ot->prop = RNA_def_enum(ot->srna, "type", merge_type_items, 3, "Type", "Merge method to use");
        RNA_def_enum_funcs(ot->prop, merge_type_itemf);
        RNA_def_boolean(ot->srna, "uvs", 1, "UVs", "Move UVs according to merge");
 }
        RNA_def_enum_funcs(ot->prop, merge_type_itemf);
        RNA_def_boolean(ot->srna, "uvs", 1, "UVs", "Move UVs according to merge");
 }
@@ -2194,8 +2202,8 @@ void MESH_OT_merge(wmOperatorType *ot)
 
 static int removedoublesflag_exec(bContext *C, wmOperator *op)
 {
 
 static int removedoublesflag_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMOperator bmop;
        /* int count; */ /* UNUSED */
 
        BMOperator bmop;
        /* int count; */ /* UNUSED */
 
@@ -2214,8 +2222,9 @@ static int removedoublesflag_exec(bContext *C, wmOperator *op)
                return OPERATOR_CANCELLED;
        }
 
                return OPERATOR_CANCELLED;
        }
 
-       /*we need a better way of reporting this, since this doesn't work
-         with the last operator panel correctly.
+       /* we need a better way of reporting this, since this doesn't work
+        * with the last operator panel correctly.
+
        if (count)
        {
                sprintf(msg, "Removed %d vertices", count);
        if (count)
        {
                sprintf(msg, "Removed %d vertices", count);
@@ -2232,15 +2241,15 @@ static int removedoublesflag_exec(bContext *C, wmOperator *op)
 void MESH_OT_remove_doubles(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_remove_doubles(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Remove Doubles";
-       ot->idname= "MESH_OT_remove_doubles";
+       ot->name = "Remove Doubles";
+       ot->idname = "MESH_OT_remove_doubles";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= removedoublesflag_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = removedoublesflag_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        RNA_def_float(ot->srna, "mergedist", 0.0001f, 0.000001f, 50.0f, 
                "Merge Distance", 
 
        RNA_def_float(ot->srna, "mergedist", 0.0001f, 0.000001f, 50.0f, 
                "Merge Distance", 
@@ -2266,7 +2275,7 @@ typedef struct PathEdge {
 static int select_vertex_path_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
 static int select_vertex_path_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
-       BMEditMesh *em = ((Mesh*)ob->data)->edit_btmesh;
+       BMEditMesh *em = ((Mesh *)ob->data)->edit_btmesh;
        BMOperator bmop;
        BMEditSelection *sv, *ev;
 
        BMOperator bmop;
        BMEditSelection *sv, *ev;
 
@@ -2274,10 +2283,10 @@ static int select_vertex_path_exec(bContext *C, wmOperator *op)
        int type = RNA_enum_get(op->ptr, "type");
 
        sv = em->bm->selected.last;
        int type = RNA_enum_get(op->ptr, "type");
 
        sv = em->bm->selected.last;
-       if ( sv != NULL )
+       if (sv != NULL)
                ev = sv->prev;
        else return OPERATOR_CANCELLED;
                ev = sv->prev;
        else return OPERATOR_CANCELLED;
-       if ( ev == NULL )
+       if (ev == NULL)
                return OPERATOR_CANCELLED;
 
        if ((sv->htype != BM_VERT) || (ev->htype != BM_VERT))
                return OPERATOR_CANCELLED;
 
        if ((sv->htype != BM_VERT) || (ev->htype != BM_VERT))
@@ -2322,15 +2331,15 @@ void MESH_OT_select_vertex_path(wmOperatorType *ot)
                {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
                {0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
-       ot->name= "Select Vertex Path";
-       ot->idname= "MESH_OT_select_vertex_path";
+       ot->name = "Select Vertex Path";
+       ot->idname = "MESH_OT_select_vertex_path";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= select_vertex_path_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = select_vertex_path_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* properties */
        RNA_def_enum(ot->srna, "type", type_items, VPATH_SELECT_EDGE_LENGTH, "Type", "Method to compute distance");
 
        /* properties */
        RNA_def_enum(ot->srna, "type", type_items, VPATH_SELECT_EDGE_LENGTH, "Type", "Method to compute distance");
@@ -2344,8 +2353,8 @@ static float mesh_rip_edgedist(ARegion *ar, float mat[][4], float *co1, float *c
 
        ED_view3d_project_float(ar, co1, vec1, mat);
        ED_view3d_project_float(ar, co2, vec2, mat);
 
        ED_view3d_project_float(ar, co1, vec1, mat);
        ED_view3d_project_float(ar, co2, vec2, mat);
-       mvalf[0]= (float)mval[0];
-       mvalf[1]= (float)mval[1];
+       mvalf[0] = (float)mval[0];
+       mvalf[1] = (float)mval[1];
 
        return dist_to_line_segment_v2(mvalf, vec1, vec2);
 }
 
        return dist_to_line_segment_v2(mvalf, vec1, vec2);
 }
@@ -2353,11 +2362,11 @@ static float mesh_rip_edgedist(ARegion *ar, float mat[][4], float *co1, float *c
 /* based on mouse cursor position, it defines how is being ripped */
 static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
 /* based on mouse cursor position, it defines how is being ripped */
 static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       ARegion *ar= CTX_wm_region(C);
+       Object *obedit = CTX_data_edit_object(C);
+       ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        View3D *v3d = CTX_wm_view3d(C);
-       RegionView3D *rv3d= CTX_wm_region_view3d(C);
-       BMEditMesh *em= ((Mesh *)obedit->data)->edit_btmesh;
+       RegionView3D *rv3d = CTX_wm_region_view3d(C);
+       BMEditMesh *em = ((Mesh *)obedit->data)->edit_btmesh;
        BMesh *bm = em->bm;
        BMOperator bmop;
        BMBVHTree *bvhtree;
        BMesh *bm = em->bm;
        BMOperator bmop;
        BMBVHTree *bvhtree;
@@ -2381,19 +2390,19 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
                }
        }
 
                }
        }
 
-       /*handle case of one vert selected.  identify
-         closest edge around that vert to mouse cursor,
-         then rip two adjacent edges in the vert fan.*/
+       /* handle case of one vert selected.  identify
+        * closest edge around that vert to mouse cursor,
+        * then rip two adjacent edges in the vert fan. */
        if (bm->totvertsel == 1 && bm->totedgesel == 0 && bm->totfacesel == 0) {
                singlesel = 1;
 
        if (bm->totvertsel == 1 && bm->totedgesel == 0 && bm->totfacesel == 0) {
                singlesel = 1;
 
-               /*find selected vert*/
+               /* find selected vert */
                BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                        if (BM_TestHFlag(v, BM_SELECT))
                                break;
                }
 
                BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                        if (BM_TestHFlag(v, BM_SELECT))
                                break;
                }
 
-               /*this should be impossible, but sanity checks are a good thing*/
+               /* this should be impossible, but sanity checks are a good thing */
                if (!v)
                        return OPERATOR_CANCELLED;
 
                if (!v)
                        return OPERATOR_CANCELLED;
 
@@ -2402,7 +2411,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
                        return OPERATOR_CANCELLED;
                }
 
                        return OPERATOR_CANCELLED;
                }
 
-               /*find closest edge to mouse cursor*/
+               /* find closest edge to mouse cursor */
                e2 = NULL;
                BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
                        d = mesh_rip_edgedist(ar, projectMat, e->v1->co, e->v2->co, event->mval);
                e2 = NULL;
                BM_ITER(e, &iter, bm, BM_EDGES_OF_VERT, v) {
                        d = mesh_rip_edgedist(ar, projectMat, e->v1->co, e->v2->co, event->mval);
@@ -2415,7 +2424,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
                if (!e2)
                        return OPERATOR_CANCELLED;
 
                if (!e2)
                        return OPERATOR_CANCELLED;
 
-               /*rip two adjacent edges*/
+               /* rip two adjacent edges */
                if (BM_Edge_FaceCount(e2) == 1 || BM_Vert_FaceCount(v) == 2) {
                        l = e2->l;
                        ripvert = BM_Rip_Vertex(bm, l->f, v);
                if (BM_Edge_FaceCount(e2) == 1 || BM_Vert_FaceCount(v) == 2) {
                        l = e2->l;
                        ripvert = BM_Rip_Vertex(bm, l->f, v);
@@ -2440,7 +2449,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
                dist = FLT_MAX;
        }
        else {
                dist = FLT_MAX;
        }
        else {
-               /*expand edge selection*/
+               /* expand edge selection */
                BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                        e2 = NULL;
                        i = 0;
                BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                        e2 = NULL;
                        i = 0;
@@ -2469,10 +2478,10 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
        
        BMO_Exec_Op(bm, &bmop);
 
        
        BMO_Exec_Op(bm, &bmop);
 
-       /*build bvh tree for edge visibility tests*/
+       /* build bvh tree for edge visibility tests */
        bvhtree = BMBVH_NewBVH(em, 0, NULL, NULL);
 
        bvhtree = BMBVH_NewBVH(em, 0, NULL, NULL);
 
-       for (i=0; i<2; i++) {
+       for (i = 0; i < 2; i++) {
                BMO_ITER(e, &siter, bm, &bmop, i ? "edgeout2":"edgeout1", BM_EDGE) {
                        float cent[3] = {0, 0, 0}, mid[3], vec[3];
 
                BMO_ITER(e, &siter, bm, &bmop, i ? "edgeout2":"edgeout1", BM_EDGE) {
                        float cent[3] = {0, 0, 0}, mid[3], vec[3];
 
@@ -2522,7 +2531,7 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
                }
        }
 
                }
        }
 
-       /*constrict edge selection again*/
+       /* constrict edge selection again */
        BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                e2 = NULL;
                i = 0;
        BM_ITER(v, &iter, bm, BM_VERTS_OF_MESH, NULL) {
                e2 = NULL;
                i = 0;
@@ -2566,15 +2575,15 @@ static int mesh_rip_invoke(bContext *C, wmOperator *op, wmEvent *event)
 void MESH_OT_rip(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_rip(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Rip";
-       ot->idname= "MESH_OT_rip";
+       ot->name = "Rip";
+       ot->idname = "MESH_OT_rip";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->invoke= mesh_rip_invoke;
-       ot->poll= EM_view3d_poll;
+       ot->invoke = mesh_rip_invoke;
+       ot->poll = EM_view3d_poll;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* to give to transform */
        Transform_Properties(ot, P_PROPORTIONAL);
 
        /* to give to transform */
        Transform_Properties(ot, P_PROPORTIONAL);
@@ -2583,7 +2592,7 @@ void MESH_OT_rip(wmOperatorType *ot)
 
 /************************ Shape Operators *************************/
 
 
 /************************ Shape Operators *************************/
 
-/*BMESH_TODO this should be properly encapsulated in a bmop.  but later.*/
+/* BMESH_TODO this should be properly encapsulated in a bmop.  but later.*/
 static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op)
 {
        BMIter iter;
 static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op)
 {
        BMIter iter;
@@ -2600,7 +2609,7 @@ static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op)
                if (!BM_TestHFlag(eve, BM_SELECT) || BM_TestHFlag(eve, BM_HIDDEN))
                        continue;
 
                if (!BM_TestHFlag(eve, BM_SELECT) || BM_TestHFlag(eve, BM_HIDDEN))
                        continue;
 
-               for (i=0; i<totshape; i++) {
+               for (i = 0; i < totshape; i++) {
                        co = CustomData_bmesh_get_n(&em->bm->vdata, eve->head.data, CD_SHAPEKEY, i);
                        copy_v3_v3(co, eve->co);
                }
                        co = CustomData_bmesh_get_n(&em->bm->vdata, eve->head.data, CD_SHAPEKEY, i);
                        copy_v3_v3(co, eve->co);
                }
@@ -2608,7 +2617,7 @@ static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op)
 
 #if 0
        //TAG Mesh Objects that share this data
 
 #if 0
        //TAG Mesh Objects that share this data
-       for(base = scene->base.first; base; base = base->next) {
+       for (base = scene->base.first; base; base = base->next) {
                if (base->object && base->object->data == me) {
                        base->object->recalc = OB_RECALC_DATA;
                }
                if (base->object && base->object->data == me) {
                        base->object->recalc = OB_RECALC_DATA;
                }
@@ -2621,9 +2630,9 @@ static void shape_propagate(Object *obedit, BMEditMesh *em, wmOperator *op)
 
 static int shape_propagate_to_all_exec(bContext *C, wmOperator *op)
 {
 
 static int shape_propagate_to_all_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       Mesh *me= obedit->data;
-       BMEditMesh *em= me->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       Mesh *me = obedit->data;
+       BMEditMesh *em = me->edit_btmesh;
 
        shape_propagate(obedit, em, op);
 
 
        shape_propagate(obedit, em, op);
 
@@ -2637,33 +2646,33 @@ static int shape_propagate_to_all_exec(bContext *C, wmOperator *op)
 void MESH_OT_shape_propagate_to_all(wmOperatorType *ot)
 {
        /* identifiers */
 void MESH_OT_shape_propagate_to_all(wmOperatorType *ot)
 {
        /* identifiers */
-       ot->name= "Shape Propagate";
-       ot->description= "Apply selected vertex locations to all other shape keys";
-       ot->idname= "MESH_OT_shape_propagate_to_all";
+       ot->name = "Shape Propagate";
+       ot->description = "Apply selected vertex locations to all other shape keys";
+       ot->idname = "MESH_OT_shape_propagate_to_all";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= shape_propagate_to_all_exec;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = shape_propagate_to_all_exec;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
 }
 
-/*BMESH_TODO this should be properly encapsulated in a bmop.  but later.*/
+/* BMESH_TODO this should be properly encapsulated in a bmop.  but later.*/
 static int blend_from_shape_exec(bContext *C, wmOperator *op)
 {
 static int blend_from_shape_exec(bContext *C, wmOperator *op)
 {
-       Object *obedit= CTX_data_edit_object(C);
-       Mesh *me= obedit->data;
-       BMEditMesh *em= me->edit_btmesh;
+       Object *obedit = CTX_data_edit_object(C);
+       Mesh *me = obedit->data;
+       BMEditMesh *em = me->edit_btmesh;
        BMVert *eve;
        BMIter iter;
        float co[3], *sco;
        BMVert *eve;
        BMIter iter;
        float co[3], *sco;
-       float blend= RNA_float_get(op->ptr, "blend");
-       int shape= RNA_enum_get(op->ptr, "shape");
-       int add= RNA_boolean_get(op->ptr, "add");
+       float blend = RNA_float_get(op->ptr, "blend");
+       int shape = RNA_enum_get(op->ptr, "shape");
+       int add = RNA_boolean_get(op->ptr, "add");
        int totshape;
 
        int totshape;
 
-       /*sanity check*/
+       /* sanity check */
        totshape = CustomData_number_of_layers(&em->bm->vdata, CD_SHAPEKEY);
        if (totshape == 0 || shape < 0 || shape >= totshape)
                return OPERATOR_CANCELLED;
        totshape = CustomData_number_of_layers(&em->bm->vdata, CD_SHAPEKEY);
        if (totshape == 0 || shape < 0 || shape >= totshape)
                return OPERATOR_CANCELLED;
@@ -2694,23 +2703,23 @@ static int blend_from_shape_exec(bContext *C, wmOperator *op)
 
 static EnumPropertyItem *shape_itemf(bContext *C, PointerRNA *UNUSED(ptr),  PropertyRNA *UNUSED(prop), int *free)
 {      
 
 static EnumPropertyItem *shape_itemf(bContext *C, PointerRNA *UNUSED(ptr),  PropertyRNA *UNUSED(prop), int *free)
 {      
-       Object *obedit= CTX_data_edit_object(C);
-       Mesh *me= (obedit) ? obedit->data : NULL;
+       Object *obedit = CTX_data_edit_object(C);
+       Mesh *me = (obedit) ? obedit->data : NULL;
        BMEditMesh *em = me->edit_btmesh;
        BMEditMesh *em = me->edit_btmesh;
-       EnumPropertyItem *item= NULL;
-       int totitem= 0;
+       EnumPropertyItem *item = NULL;
+       int totitem = 0;
 
        if (obedit && obedit->type == OB_MESH && CustomData_has_layer(&em->bm->vdata, CD_SHAPEKEY)) {
 
        if (obedit && obedit->type == OB_MESH && CustomData_has_layer(&em->bm->vdata, CD_SHAPEKEY)) {
-               EnumPropertyItem tmp= {0, "", 0, "", ""};
+               EnumPropertyItem tmp = {0, "", 0, "", ""};
                int a;
 
                int a;
 
-               for (a=0; a<em->bm->vdata.totlayer; a++) {
+               for (a = 0; a < em->bm->vdata.totlayer; a++) {
                        if (em->bm->vdata.layers[a].type != CD_SHAPEKEY)
                                continue;
 
                        if (em->bm->vdata.layers[a].type != CD_SHAPEKEY)
                                continue;
 
-                       tmp.value= totitem;
-                       tmp.identifier= em->bm->vdata.layers[a].name;
-                       tmp.name= em->bm->vdata.layers[a].name;
+                       tmp.value = totitem;
+                       tmp.identifier = em->bm->vdata.layers[a].name;
+                       tmp.name = em->bm->vdata.layers[a].name;
                        RNA_enum_item_add(&item, &totitem, &tmp);
 
                        totitem++;
                        RNA_enum_item_add(&item, &totitem, &tmp);
 
                        totitem++;
@@ -2718,7 +2727,7 @@ static EnumPropertyItem *shape_itemf(bContext *C, PointerRNA *UNUSED(ptr),  Prop
        }
 
        RNA_enum_item_end(&item, &totitem);
        }
 
        RNA_enum_item_end(&item, &totitem);
-       *free= 1;
+       *free = 1;
 
        return item;
 }
 
        return item;
 }
@@ -2726,23 +2735,23 @@ static EnumPropertyItem *shape_itemf(bContext *C, PointerRNA *UNUSED(ptr),  Prop
 void MESH_OT_blend_from_shape(wmOperatorType *ot)
 {
        PropertyRNA *prop;
 void MESH_OT_blend_from_shape(wmOperatorType *ot)
 {
        PropertyRNA *prop;
-       static EnumPropertyItem shape_items[]= {{0, NULL, 0, NULL, NULL}};
+       static EnumPropertyItem shape_items[] = {{0, NULL, 0, NULL, NULL}};
 
        /* identifiers */
 
        /* identifiers */
-       ot->name= "Blend From Shape";
-       ot->description= "Blend in shape from a shape key";
-       ot->idname= "MESH_OT_blend_from_shape";
+       ot->name = "Blend From Shape";
+       ot->description = "Blend in shape from a shape key";
+       ot->idname = "MESH_OT_blend_from_shape";
 
        /* api callbacks */
 
        /* api callbacks */
-       ot->exec= blend_from_shape_exec;
-       ot->invoke= WM_operator_props_popup;
-       ot->poll= ED_operator_editmesh;
+       ot->exec = blend_from_shape_exec;
+       ot->invoke = WM_operator_props_popup;
+       ot->poll = ED_operator_editmesh;
 
        /* flags */
 
        /* flags */
-       ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
+       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 
        /* properties */
 
        /* properties */
-       prop= RNA_def_enum(ot->srna, "shape", shape_items, 0, "Shape", "Shape key to use for blending");
+       prop = RNA_def_enum(ot->srna, "shape", shape_items, 0, "Shape", "Shape key to use for blending");
        RNA_def_enum_funcs(prop, shape_itemf);
     &n