2.5
[blender.git] / source / blender / editors / space_view3d / view3d_select.c
index 3dcf531ad38b5a7159ebc863cb69f4bf891c2b2e..33ac9a649682fcf3a020118f1c9f367b76a9915d 100644 (file)
 
 #include "view3d_intern.h"     // own include
 
+
+static void view3d_set_viewcontext(bContext *C, ViewContext *vc)
+{
+       memset(vc, 0, sizeof(ViewContext));
+       vc->ar= CTX_wm_region(C);
+       vc->scene= CTX_data_scene(C);
+       vc->v3d= (View3D *)CTX_wm_space_data(C);
+       vc->obact= CTX_data_active_object(C);
+       vc->obedit= CTX_data_edit_object(C); 
+}
+
 /* ********************** view3d_select: selection manipulations ********************* */
 
 /* XXX to solve *************** */
@@ -390,6 +401,9 @@ static void do_lasso_select_mesh(ViewContext *vc, short mcords[][2], short moves
        
        lasso_select_boundbox(&rect, mcords, moves);
        
+       /* set editmesh */
+       vc->em= ((Mesh *)vc->obedit->data)->edit_mesh;
+
        data.vc= *vc;
        data.rect = ▭
        data.mcords = mcords;
@@ -398,7 +412,7 @@ static void do_lasso_select_mesh(ViewContext *vc, short mcords[][2], short moves
        data.done = 0;
        data.pass = 0;
 
-       bbsel= EM_mask_init_backbuf_border(vc->v3d, mcords, moves, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
+       bbsel= EM_mask_init_backbuf_border(vc, mcords, moves, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
        
        if(vc->scene->selectmode & SCE_SELECT_VERTEX) {
                if (bbsel) {
@@ -516,6 +530,7 @@ static void do_lasso_select_curve(ViewContext *vc, short mcords[][2], short move
 {
        struct { short (*mcords)[2]; short moves; short select; } data;
 
+       /* set vc->editnurb */
        data.mcords = mcords;
        data.moves = moves;
        data.select = select;
@@ -535,6 +550,7 @@ static void do_lasso_select_lattice(ViewContext *vc, short mcords[][2], short mo
 {
        struct { short (*mcords)[2]; short moves; short select; } data;
 
+       /* set editdata in vc */
        data.mcords = mcords;
        data.moves = moves;
        data.select = select;
@@ -548,6 +564,8 @@ static void do_lasso_select_armature(ViewContext *vc, short mcords[][2], short m
        float vec[3];
        short sco1[2], sco2[2], didpoint;
        
+       /* set editdata in vc */
+       
        for (ebone=G.edbo.first; ebone; ebone=ebone->next) {
 
                VECCOPY(vec, ebone->head);
@@ -589,7 +607,7 @@ static void do_lasso_select_facemode(ViewContext *vc, short mcords[][2], short m
        em_vertoffs= me->totface+1;     /* max index array */
        
        lasso_select_boundbox(&rect, mcords, moves);
-       EM_mask_init_backbuf_border(vc->v3d, mcords, moves, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
+       EM_mask_init_backbuf_border(vc, mcords, moves, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
        
        EM_backbuf_checkAndSelectTFaces(me, select);
        
@@ -654,6 +672,65 @@ void view3d_lasso_select(ViewContext *vc, short mcords[][2], short moves, short
        
 }
 
+static EnumPropertyItem lasso_select_types[] = {
+       {0, "SELECT", "Select", ""},
+       {1, "DESELECT", "Deselect", ""},
+       {0, NULL, NULL, NULL}
+};
+
+
+/* lasso operator gives properties, but since old code works
+   with short array we convert */
+static int view3d_lasso_select_exec(bContext *C, wmOperator *op)
+{
+       ViewContext vc;
+       int select, i= 0;
+       short mcords[1024][2];
+
+       RNA_BEGIN(op->ptr, itemptr, "path") {
+               float loc[2];
+               
+               RNA_float_get_array(&itemptr, "loc", loc);
+               mcords[i][0]= (short)loc[0];
+               mcords[i][1]= (short)loc[1];
+               i++;
+               if(i>=1024) break;
+       }
+       RNA_END;
+       
+       /* setup view context for argument to callbacks */
+       view3d_set_viewcontext(C, &vc);
+       
+       select= RNA_enum_is_equal(op->ptr, "type", "SELECT");
+       view3d_lasso_select(&vc, mcords, i, select);
+       
+       return OPERATOR_FINISHED;
+}
+
+void VIEW3D_OT_lasso_select(wmOperatorType *ot)
+{
+       PropertyRNA *prop;
+       
+       ot->name= "Lasso Select";
+       ot->idname= "VIEW3D_OT_lasso_select";
+       
+       ot->invoke= WM_gesture_lasso_invoke;
+       ot->modal= WM_gesture_lasso_modal;
+       ot->exec= view3d_lasso_select_exec;
+       
+       ot->poll= WM_operator_winactive;
+       
+       prop= RNA_def_property(ot->srna, "path", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_runtime(prop, &RNA_OperatorMousePath);
+       
+       prop = RNA_def_property(ot->srna, "type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_items(prop, lasso_select_types);
+
+}
+
+
+/* ************************************************* */
+
 #if 0
 /* smart function to sample a rect spiralling outside, nice for backbuf selection */
 static unsigned int samplerect(unsigned int *buf, int size, unsigned int dontdo)
@@ -835,8 +912,9 @@ static short mixed_bones_object_selectbuffer(ViewContext *vc, unsigned int *buff
        return 0;
 }
 
+
 /* mval is region coords */
-static void mouse_select(bContext *C, short *mval, short modifier)
+static void mouse_select(bContext *C, short *mval, short extend, short obcenter)
 {
        ViewContext vc;
        ARegion *ar= CTX_wm_region(C);
@@ -848,21 +926,19 @@ static void mouse_select(bContext *C, short *mval, short modifier)
        short hits;
        
        /* setup view context for argument to callbacks */
-       memset(&vc, 0, sizeof(ViewContext));
-       vc.ar= ar;
-       vc.scene= scene;
-       vc.v3d= v3d;
-       vc.obact= OBACT;
+       view3d_set_viewcontext(C, &vc);
        
        /* always start list from basact in wire mode */
        startbase=  FIRSTBASE;
        if(BASACT && BASACT->next) startbase= BASACT->next;
        
        /* This block uses the control key to make the object selected by its center point rather then its contents */
-       if(G.obedit==0 && modifier == KM_CTRL) {
+       /* XXX later on, in editmode do not activate */
+       if(G.obedit==NULL && obcenter) {
                
                /* note; shift+alt goes to group-flush-selecting */
-               if(modifier == KM_ALT && modifier == KM_CTRL) 
+               /* XXX solve */
+               if(0) 
                        basact= mouse_select_menu(&vc, NULL, 0, mval);
                else {
                        base= startbase;
@@ -896,7 +972,7 @@ static void mouse_select(bContext *C, short *mval, short modifier)
                        for(a=0; a<hits; a++) if(buffer[4*a+3] & 0xFFFF0000) has_bones= 1;
 
                        /* note; shift+alt goes to group-flush-selecting */
-                       if(has_bones==0 && (modifier == KM_ALT)
+                       if(has_bones==0 && 0
                                basact= mouse_select_menu(&vc, buffer, hits, mval);
                        else {
                                static short lastmval[2]={-100, -100};
@@ -1023,11 +1099,11 @@ static void mouse_select(bContext *C, short *mval, short modifier)
                        oldbasact= BASACT;
                        BASACT= basact;
                        
-                       if(modifier != KM_SHIFT) {
+                       if(!extend) {
                                deselectall_except(scene, basact);
                                ED_base_object_select(basact, BA_SELECT);
                        }
-                       else if(modifier == KM_CTRL && modifier == KM_ALT) {
+                       else if(0) {
                                // XXX select_all_from_groups(basact);
                        }
                        else {
@@ -1171,7 +1247,7 @@ static void do_mesh_box_select(ViewContext *vc, rcti *rect, int select)
        data.pass = 0;
        data.done = 0;
 
-       bbsel= EM_init_backbuf_border(vc->v3d, rect->xmin, rect->ymin, rect->xmax, rect->ymax);
+       bbsel= EM_init_backbuf_border(vc, rect->xmin, rect->ymin, rect->xmax, rect->ymax);
 
        if(vc->scene->selectmode & SCE_SELECT_VERTEX) {
                if (bbsel) {
@@ -1210,7 +1286,6 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
        ViewContext vc;
        Scene *scene= CTX_data_scene(C);
        ScrArea *sa= CTX_wm_area(C);
-       ARegion *ar= CTX_wm_region(C);
        View3D *v3d= sa->spacedata.first;
        rcti rect;
        Base *base;
@@ -1219,13 +1294,10 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
        int a, index;
        short hits, val;
 
-       /* setup view context for argument to callbacks */
-       memset(&vc, 0, sizeof(ViewContext));
-       vc.ar= ar;
-       vc.scene= scene;
-       vc.v3d= v3d;
-       vc.obact= OBACT;
+       view3d_operator_needs_opengl(C);
        
+       /* setup view context for argument to callbacks */
+       view3d_set_viewcontext(C, &vc);
        
        val= RNA_int_get(op->ptr, "event_type");
        rect.xmin= RNA_int_get(op->ptr, "xmin");
@@ -1244,10 +1316,11 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
        
        if(G.obedit) {
                if(G.obedit->type==OB_MESH) {
+                       Mesh *me= G.obedit->data;
+                       vc.em= me->edit_mesh;
                        do_mesh_box_select(&vc, &rect, (val==LEFTMOUSE));
-//                     allqueue(REDRAWVIEW3D, 0);
 //                     if (EM_texFaceCheck())
-//                             allqueue(REDRAWIMAGE, 0);
+                       WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_SELECT, G.obedit);
                        
                }
                else if(ELEM(G.obedit->type, OB_CURVE, OB_SURF)) {
@@ -1408,18 +1481,22 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
                }
                MEM_freeN(vbuffer);
        }
-
-       BIF_undo_push("Border select");
        
        return OPERATOR_FINISHED;
 } 
 
 
 /* *****************Selection Operators******************* */
+static EnumPropertyItem prop_select_types[] = {
+       {0, "EXCLUSIVE", "Exclusive", ""},
+       {1, "EXTEND", "Extend", ""},
+       {0, NULL, NULL, NULL}
+};
 
 /* ****** Border Select ****** */
 void VIEW3D_OT_borderselect(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
        
        /* identifiers */
        ot->name= "Border Select";
@@ -1438,14 +1515,19 @@ void VIEW3D_OT_borderselect(wmOperatorType *ot)
        RNA_def_property(ot->srna, "xmax", PROP_INT, PROP_NONE);
        RNA_def_property(ot->srna, "ymin", PROP_INT, PROP_NONE);
        RNA_def_property(ot->srna, "ymax", PROP_INT, PROP_NONE);
+
+       prop = RNA_def_property(ot->srna, "type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_items(prop, prop_select_types);
 }
 
 /* ****** Mouse Select ****** */
 
+
 static int view3d_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
        ARegion *ar= CTX_wm_region(C);
        Object *obedit= CTX_data_edit_object(C);
+       short extend= RNA_enum_is_equal(op->ptr, "type", "EXTEND");
        short mval[2];  
        
        mval[0]= event->x - ar->winrct.xmin;
@@ -1455,16 +1537,18 @@ static int view3d_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
        
        if(obedit) {
                if(obedit->type==OB_MESH)
-                       mouse_mesh(C, mval);
+                       mouse_mesh(C, mval, extend);
        }
        else 
-               mouse_select(C, mval, 0);
+               mouse_select(C, mval, extend, 0);
        
-       return OPERATOR_FINISHED;
+       /* allowing tweaks */
+       return OPERATOR_PASS_THROUGH;
 }
 
 void VIEW3D_OT_select(wmOperatorType *ot)
 {
+       PropertyRNA *prop;
 
        /* identifiers */
        ot->name= "Activate/Select";
@@ -1474,61 +1558,14 @@ void VIEW3D_OT_select(wmOperatorType *ot)
        ot->invoke= view3d_select_invoke;
        ot->poll= ED_operator_view3d_active;
 
+       prop = RNA_def_property(ot->srna, "type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_items(prop, prop_select_types);
 }
-static EnumPropertyItem prop_select_extend_types[] = {
-       {KM_SHIFT, "SHIFT", "Shift", ""},
-       {KM_CTRL, "CTRL", "Ctrl", ""},
-       {KM_ALT, "ALT", "Alt", ""},
-       {0, NULL, NULL, NULL}
-};
-
-static int view3d_select_extend_invoke(bContext *C, wmOperator *op, wmEvent *event)
-{
-       ARegion *ar= CTX_wm_region(C);
-       short mval[2], modifier;        
-       
-       mval[0]= event->x - ar->winrct.xmin;
-       mval[1]= event->y - ar->winrct.ymin;
-
-       modifier = RNA_enum_get(op->ptr, "modifier");
-       
-       view3d_operator_needs_opengl(C);        
-       
-       mouse_select(C, mval, modifier);
-       
-       return OPERATOR_FINISHED;
-}
-
-void VIEW3D_OT_select_extend(wmOperatorType *ot)
-{
-       PropertyRNA *prop;
-       
-       /* identifiers */
-       ot->name= "Activate/Select Extend";
-       ot->idname= "VIEW3D_OT_select_extend";
-       
-       /* api callbacks */
-       ot->invoke= view3d_select_extend_invoke;
-       ot->poll= ED_operator_view3d_active;    
-       
-       prop = RNA_def_property(ot->srna, "modifier", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_items(prop, prop_select_extend_types);
-
-}
-
-
-/* ------------------------------------------------------------------------- */
 
-/** The following functions are quick & dirty callback functions called
-  * on the Circle select function (press B twice in Editmode)
-  * They were torn out of the circle_select to make the latter more reusable
-  * The callback version of circle_select (called circle_selectCB) was moved
-  * to edit.c because of it's (wanted) generality.
 
-       XXX These callback functions are still dirty, because they call globals... 
-  */
+/* -------------------- circle select --------------------------------------------- */
 
-static void mesh_selectionCB__doSelectVert(void *userData, EditVert *eve, int x, int y, int index)
+static void mesh_circle_doSelectVert(void *userData, EditVert *eve, int x, int y, int index)
 {
        struct { short select, mval[2]; float radius; } *data = userData;
        int mx = x - data->mval[0], my = y - data->mval[1];
@@ -1538,7 +1575,7 @@ static void mesh_selectionCB__doSelectVert(void *userData, EditVert *eve, int x,
                eve->f = data->select?(eve->f|1):(eve->f&~1);
        }
 }
-static void mesh_selectionCB__doSelectEdge(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index)
+static void mesh_circle_doSelectEdge(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index)
 {
        struct { short select, mval[2]; float radius; } *data = userData;
 
@@ -1546,7 +1583,7 @@ static void mesh_selectionCB__doSelectEdge(void *userData, EditEdge *eed, int x0
                EM_select_edge(eed, data->select);
        }
 }
-static void mesh_selectionCB__doSelectFace(void *userData, EditFace *efa, int x, int y, int index)
+static void mesh_circle_doSelectFace(void *userData, EditFace *efa, int x, int y, int index)
 {
        struct { short select, mval[2]; float radius; } *data = userData;
        int mx = x - data->mval[0], my = y - data->mval[1];
@@ -1558,65 +1595,66 @@ static void mesh_selectionCB__doSelectFace(void *userData, EditFace *efa, int x,
        }
 }
 
-static void mesh_selectionCB(ViewContext *vc, int selecting, Object *editobj, short *mval, float rad)
+static void mesh_circle_select(ViewContext *vc, int selecting, short *mval, float rad)
 {
-       struct { short select, mval[2]; float radius; } data;
        int bbsel;
-
-       if(!G.obedit && (FACESEL_PAINT_TEST)) {
+       
+       if(vc->obedit==NULL && (FACESEL_PAINT_TEST)) {
                Object *ob= vc->obact;
                Mesh *me = ob?ob->data:NULL;
 
                if (me) {
                        em_vertoffs= me->totface+1;     /* max index array */
 
-                       bbsel= EM_init_backbuf_circle(vc->v3d, mval[0], mval[1], (short)(rad+1.0));
+                       bbsel= EM_init_backbuf_circle(vc, mval[0], mval[1], (short)(rad+1.0));
                        EM_backbuf_checkAndSelectTFaces(me, selecting==LEFTMOUSE);
                        EM_free_backbuf();
 
 // XXX                 object_tface_flags_changed(OBACT, 0);
                }
-
-               return;
        }
+       else {
+               struct { short select, mval[2]; float radius; } data;
+               
+               bbsel= EM_init_backbuf_circle(vc, mval[0], mval[1], (short)(rad+1.0));
+               vc->em= ((Mesh *)vc->obedit->data)->edit_mesh;
 
-       bbsel= EM_init_backbuf_circle(vc->v3d, mval[0], mval[1], (short)(rad+1.0));
-       
-       data.select = (selecting==LEFTMOUSE);
-       data.mval[0] = mval[0];
-       data.mval[1] = mval[1];
-       data.radius = rad;
+               data.select = selecting;
+               data.mval[0] = mval[0];
+               data.mval[1] = mval[1];
+               data.radius = rad;
 
-       if(vc->scene->selectmode & SCE_SELECT_VERTEX) {
-               if(bbsel) {
-                       EM_backbuf_checkAndSelectVerts(vc->em, selecting==LEFTMOUSE);
-               } else {
-                       mesh_foreachScreenVert(vc, mesh_selectionCB__doSelectVert, &data, 1);
+               if(vc->scene->selectmode & SCE_SELECT_VERTEX) {
+                       if(bbsel) {
+                               EM_backbuf_checkAndSelectVerts(vc->em, selecting==LEFTMOUSE);
+                       } else {
+                               mesh_foreachScreenVert(vc, mesh_circle_doSelectVert, &data, 1);
+                       }
                }
-       }
 
-       if(vc->scene->selectmode & SCE_SELECT_EDGE) {
-               if (bbsel) {
-                       EM_backbuf_checkAndSelectEdges(vc->em, selecting==LEFTMOUSE);
-               } else {
-                       mesh_foreachScreenEdge(vc, mesh_selectionCB__doSelectEdge, &data, 0);
+               if(vc->scene->selectmode & SCE_SELECT_EDGE) {
+                       if (bbsel) {
+                               EM_backbuf_checkAndSelectEdges(vc->em, selecting==LEFTMOUSE);
+                       } else {
+                               mesh_foreachScreenEdge(vc, mesh_circle_doSelectEdge, &data, 0);
+                       }
                }
-       }
-       
-       if(vc->scene->selectmode & SCE_SELECT_FACE) {
-               if(bbsel) {
-                       EM_backbuf_checkAndSelectFaces(vc->em, selecting==LEFTMOUSE);
-               } else {
-                       mesh_foreachScreenFace(vc, mesh_selectionCB__doSelectFace, &data);
+               
+               if(vc->scene->selectmode & SCE_SELECT_FACE) {
+                       if(bbsel) {
+                               EM_backbuf_checkAndSelectFaces(vc->em, selecting==LEFTMOUSE);
+                       } else {
+                               mesh_foreachScreenFace(vc, mesh_circle_doSelectFace, &data);
+                       }
                }
-       }
 
-       EM_free_backbuf();
-       EM_selectmode_flush(vc->em);
+               EM_free_backbuf();
+               EM_selectmode_flush(vc->em);
+       }
 }
 
 
-static void nurbscurve_selectionCB__doSelect(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y)
+static void nurbscurve_circle_doSelect(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y)
 {
        struct { short select, mval[2]; float radius; } *data = userData;
        int mx = x - data->mval[0], my = y - data->mval[1];
@@ -1636,20 +1674,22 @@ static void nurbscurve_selectionCB__doSelect(void *userData, Nurb *nu, BPoint *b
                }
        }
 }
-static void nurbscurve_selectionCB(ViewContext *vc, int selecting, Object *editobj, short *mval, float rad)
+static void nurbscurve_circle_select(ViewContext *vc, int selecting, short *mval, float rad)
 {
        struct { short select, mval[2]; float radius; } data;
 
-       data.select = (selecting==LEFTMOUSE);
+       /* set vc-> edit data */
+       
+       data.select = selecting;
        data.mval[0] = mval[0];
        data.mval[1] = mval[1];
        data.radius = rad;
 
-       nurbs_foreachScreenVert(vc, nurbscurve_selectionCB__doSelect, &data);
+       nurbs_foreachScreenVert(vc, nurbscurve_circle_doSelect, &data);
 }
 
 
-static void latticecurve_selectionCB__doSelect(void *userData, BPoint *bp, int x, int y)
+static void latticecurve_circle_doSelect(void *userData, BPoint *bp, int x, int y)
 {
        struct { short select, mval[2]; float radius; } *data = userData;
        int mx = x - data->mval[0], my = y - data->mval[1];
@@ -1659,67 +1699,80 @@ static void latticecurve_selectionCB__doSelect(void *userData, BPoint *bp, int x
                bp->f1 = data->select?(bp->f1|SELECT):(bp->f1&~SELECT);
        }
 }
-static void lattice_selectionCB(ViewContext *vc, int selecting, Object *editobj, short *mval, float rad)
+static void lattice_circle_select(ViewContext *vc, int selecting, short *mval, float rad)
 {
        struct { short select, mval[2]; float radius; } data;
 
-       data.select = (selecting==LEFTMOUSE);
+       /* set vc-> edit data */
+       
+       data.select = selecting;
        data.mval[0] = mval[0];
        data.mval[1] = mval[1];
        data.radius = rad;
 
-       lattice_foreachScreenVert(vc, latticecurve_selectionCB__doSelect, &data);
+       lattice_foreachScreenVert(vc, latticecurve_circle_doSelect, &data);
 }
 
-/** Callbacks for selection in Editmode */
+/** Callbacks for circle selection in Editmode */
 
-void obedit_selectionCB(ViewContext *vc, short selecting, Object *editobj, short *mval, float rad) 
+static void obedit_circle_select(ViewContext *vc, short selecting, short *mval, float rad) 
 {
-       switch(editobj->type) {         
+       switch(vc->obedit->type) {              
        case OB_MESH:
-               mesh_selectionCB(vc, selecting, editobj, mval, rad);
+               mesh_circle_select(vc, selecting, mval, rad);
                break;
        case OB_CURVE:
        case OB_SURF:
-               nurbscurve_selectionCB(vc, selecting, editobj, mval, rad);
+               nurbscurve_circle_select(vc, selecting, mval, rad);
                break;
        case OB_LATTICE:
-               lattice_selectionCB(vc, selecting, editobj, mval, rad);
+               lattice_circle_select(vc, selecting, mval, rad);
                break;
        default:
                return;
        }
-
-//     draw_sel_circle(0, 0, 0, 0, 0); /* signal */
-//     force_draw(0);
 }
 
 /* not a real operator, only for circle test */
-static int view3d_circle_select(bContext *C, wmOperator *op)
+static int view3d_circle_select_exec(bContext *C, wmOperator *op)
 {
        ScrArea *sa= CTX_wm_area(C);
        ARegion *ar= CTX_wm_region(C);
        Scene *scene= CTX_data_scene(C);
        View3D *v3d= sa->spacedata.first;
-       Base *base;
-
        int x= RNA_int_get(op->ptr, "x");
        int y= RNA_int_get(op->ptr, "y");
        int radius= RNA_int_get(op->ptr, "radius");
        
-       for(base= FIRSTBASE; base; base= base->next) {
-               if(base->lay & v3d->lay) {
-                       project_short(ar, v3d, base->object->obmat[3], &base->sx);
-                       if(base->sx!=IS_CLIPPED) {
-                               int dx= base->sx-x;
-                               int dy= base->sy-y;
-                               if( dx*dx + dy*dy < radius*radius)
-                                       ED_base_object_select(base, BA_SELECT);
+       if(CTX_data_edit_object(C)) {
+               ViewContext vc;
+               short mval[2], selecting;
+               
+               view3d_set_viewcontext(C, &vc);
+               mval[0]= x;
+               mval[1]= y;
+               selecting= LEFTMOUSE==RNA_int_get(op->ptr, "event_type"); // XXX solve
+               obedit_circle_select(&vc, selecting, mval, (float)radius);
+       }
+       else {
+               Base *base;
+               
+               for(base= FIRSTBASE; base; base= base->next) {
+                       if(base->lay & v3d->lay) {
+                               project_short(ar, v3d, base->object->obmat[3], &base->sx);
+                               if(base->sx!=IS_CLIPPED) {
+                                       int dx= base->sx-x;
+                                       int dy= base->sy-y;
+                                       if( dx*dx + dy*dy < radius*radius)
+                                               ED_base_object_select(base, BA_SELECT);
+                               }
                        }
                }
+               
+               WM_event_add_notifier(C, NC_SCENE|ND_OB_SELECT, CTX_data_scene(C));
        }
-       WM_event_add_notifier(C, NC_SCENE|ND_OB_SELECT, CTX_data_scene(C));
-       return 0;
+       
+       return OPERATOR_FINISHED;
 }
 
 void VIEW3D_OT_circle_select(wmOperatorType *ot)
@@ -1729,11 +1782,12 @@ void VIEW3D_OT_circle_select(wmOperatorType *ot)
        
        ot->invoke= WM_gesture_circle_invoke;
        ot->modal= WM_gesture_circle_modal;
-       ot->exec= view3d_circle_select;
+       ot->exec= view3d_circle_select_exec;
        ot->poll= ED_operator_view3d_active;
        
        RNA_def_property(ot->srna, "x", PROP_INT, PROP_NONE);
        RNA_def_property(ot->srna, "y", PROP_INT, PROP_NONE);
        RNA_def_property(ot->srna, "radius", PROP_INT, PROP_NONE);
+       RNA_def_property(ot->srna, "event_type", PROP_INT, PROP_NONE);
        
 }