Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / mesh / editmesh_loopcut.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2007 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edmesh
22  */
23
24 #include "DNA_object_types.h"
25
26 #include "MEM_guardedalloc.h"
27
28 #include "BLI_string.h"
29 #include "BLI_math.h"
30
31 #include "BLT_translation.h"
32
33 #include "DNA_mesh_types.h"
34
35 #include "BKE_context.h"
36 #include "BKE_modifier.h"
37 #include "BKE_report.h"
38 #include "BKE_editmesh.h"
39 #include "BKE_unit.h"
40 #include "BKE_layer.h"
41
42 #include "GPU_immediate.h"
43 #include "GPU_matrix.h"
44 #include "GPU_state.h"
45
46 #include "UI_interface.h"
47
48 #include "ED_screen.h"
49 #include "ED_space_api.h"
50 #include "ED_view3d.h"
51 #include "ED_mesh.h"
52 #include "ED_numinput.h"
53
54 #include "RNA_access.h"
55 #include "RNA_define.h"
56 #include "RNA_enum_types.h"
57
58 #include "WM_api.h"
59 #include "WM_types.h"
60
61 #include "DEG_depsgraph.h"
62 #include "DEG_depsgraph_query.h"
63
64 #include "mesh_intern.h" /* own include */
65
66 #define SUBD_SMOOTH_MAX 4.0f
67 #define SUBD_CUTS_MAX 500
68
69 /* ringsel operator */
70
71 /* struct for properties used while drawing */
72 typedef struct RingSelOpData {
73   ARegion *ar;       /* region that ringsel was activated in */
74   void *draw_handle; /* for drawing preview loop */
75
76   struct EditMesh_PreSelEdgeRing *presel_edgering;
77
78   ViewContext vc;
79
80   Depsgraph *depsgraph;
81
82   Object **objects;
83   uint objects_len;
84
85   /* These values switch objects based on the object under the cursor. */
86   uint ob_index;
87   Object *ob;
88   BMEditMesh *em;
89   BMEdge *eed;
90
91   NumInput num;
92
93   bool extend;
94   bool do_cut;
95
96   float cuts; /* cuts as float so smooth mouse pan works in small increments */
97   float smoothness;
98 } RingSelOpData;
99
100 /* modal loop selection drawing callback */
101 static void ringsel_draw(const bContext *UNUSED(C), ARegion *UNUSED(ar), void *arg)
102 {
103   RingSelOpData *lcd = arg;
104   EDBM_preselect_edgering_draw(lcd->presel_edgering, lcd->ob->obmat);
105 }
106
107 static void edgering_select(RingSelOpData *lcd)
108 {
109   if (!lcd->eed) {
110     return;
111   }
112
113   if (!lcd->extend) {
114     for (uint ob_index = 0; ob_index < lcd->objects_len; ob_index++) {
115       Object *ob_iter = lcd->objects[ob_index];
116       BMEditMesh *em = BKE_editmesh_from_object(ob_iter);
117       EDBM_flag_disable_all(em, BM_ELEM_SELECT);
118       DEG_id_tag_update(ob_iter->data, ID_RECALC_SELECT);
119       WM_main_add_notifier(NC_GEOM | ND_SELECT, ob_iter->data);
120     }
121   }
122
123   BMEditMesh *em = lcd->em;
124   BMEdge *eed_start = lcd->eed;
125   BMWalker walker;
126   BMEdge *eed;
127   BMW_init(&walker,
128            em->bm,
129            BMW_EDGERING,
130            BMW_MASK_NOP,
131            BMW_MASK_NOP,
132            BMW_MASK_NOP,
133            BMW_FLAG_TEST_HIDDEN,
134            BMW_NIL_LAY);
135
136   for (eed = BMW_begin(&walker, eed_start); eed; eed = BMW_step(&walker)) {
137     BM_edge_select_set(em->bm, eed, true);
138   }
139   BMW_end(&walker);
140 }
141
142 static void ringsel_find_edge(RingSelOpData *lcd, const int previewlines)
143 {
144   if (lcd->eed) {
145     const float(*coords)[3] = NULL;
146     {
147       Mesh *me_eval = (Mesh *)DEG_get_evaluated_id(lcd->depsgraph, lcd->ob->data);
148       if (me_eval->runtime.edit_data) {
149         coords = me_eval->runtime.edit_data->vertexCos;
150       }
151     }
152     EDBM_preselect_edgering_update_from_edge(
153         lcd->presel_edgering, lcd->em->bm, lcd->eed, previewlines, coords);
154   }
155   else {
156     EDBM_preselect_edgering_clear(lcd->presel_edgering);
157   }
158 }
159
160 static void ringsel_finish(bContext *C, wmOperator *op)
161 {
162   RingSelOpData *lcd = op->customdata;
163   const int cuts = RNA_int_get(op->ptr, "number_cuts");
164   const float smoothness = RNA_float_get(op->ptr, "smoothness");
165   const int smooth_falloff = RNA_enum_get(op->ptr, "falloff");
166 #ifdef BMW_EDGERING_NGON
167   const bool use_only_quads = false;
168 #else
169   const bool use_only_quads = false;
170 #endif
171
172   if (lcd->eed) {
173     BMEditMesh *em = lcd->em;
174     BMVert *v_eed_orig[2] = {lcd->eed->v1, lcd->eed->v2};
175
176     edgering_select(lcd);
177
178     if (lcd->do_cut) {
179       const bool is_macro = (op->opm != NULL);
180       /* a single edge (rare, but better support) */
181       const bool is_single = (BM_edge_is_wire(lcd->eed));
182       const int seltype = is_single ? SUBDIV_SELECT_INNER : SUBDIV_SELECT_LOOPCUT;
183
184       /* Enable gridfill, so that intersecting loopcut works as one would expect.
185        * Note though that it will break edgeslide in this specific case.
186        * See [#31939]. */
187       BM_mesh_esubdivide(em->bm,
188                          BM_ELEM_SELECT,
189                          smoothness,
190                          smooth_falloff,
191                          true,
192                          0.0f,
193                          0.0f,
194                          cuts,
195                          seltype,
196                          SUBD_CORNER_PATH,
197                          0,
198                          true,
199                          use_only_quads,
200                          0);
201
202       /* when used in a macro the tessfaces will be recalculated anyway,
203        * this is needed here because modifiers depend on updated tessellation, see T45920 */
204       EDBM_update_generic(em, true, true);
205
206       if (is_single) {
207         /* de-select endpoints */
208         BM_vert_select_set(em->bm, v_eed_orig[0], false);
209         BM_vert_select_set(em->bm, v_eed_orig[1], false);
210
211         EDBM_selectmode_flush_ex(lcd->em, SCE_SELECT_VERTEX);
212       }
213       /* we cant slide multiple edges in vertex select mode */
214       else if (is_macro && (cuts > 1) && (em->selectmode & SCE_SELECT_VERTEX)) {
215         EDBM_selectmode_disable(lcd->vc.scene, em, SCE_SELECT_VERTEX, SCE_SELECT_EDGE);
216       }
217       /* force edge slide to edge select mode in in face select mode */
218       else if (EDBM_selectmode_disable(lcd->vc.scene, em, SCE_SELECT_FACE, SCE_SELECT_EDGE)) {
219         /* pass, the change will flush selection */
220       }
221       else {
222         /* else flush explicitly */
223         EDBM_selectmode_flush(lcd->em);
224       }
225     }
226     else {
227       /* XXX Is this piece of code ever used now? Simple loop select is now
228        *     in editmesh_select.c (around line 1000)... */
229       /* sets as active, useful for other tools */
230       if (em->selectmode & SCE_SELECT_VERTEX) {
231         /* low priority TODO, get vertrex close to mouse */
232         BM_select_history_store(em->bm, lcd->eed->v1);
233       }
234       if (em->selectmode & SCE_SELECT_EDGE) {
235         BM_select_history_store(em->bm, lcd->eed);
236       }
237
238       EDBM_selectmode_flush(lcd->em);
239       DEG_id_tag_update(lcd->ob->data, ID_RECALC_SELECT);
240       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, lcd->ob->data);
241     }
242   }
243 }
244
245 /* called when modal loop selection is done... */
246 static void ringsel_exit(bContext *UNUSED(C), wmOperator *op)
247 {
248   RingSelOpData *lcd = op->customdata;
249
250   /* deactivate the extra drawing stuff in 3D-View */
251   ED_region_draw_cb_exit(lcd->ar->type, lcd->draw_handle);
252
253   EDBM_preselect_edgering_destroy(lcd->presel_edgering);
254
255   MEM_freeN(lcd->objects);
256
257   ED_region_tag_redraw(lcd->ar);
258
259   /* free the custom data */
260   MEM_freeN(lcd);
261   op->customdata = NULL;
262 }
263
264 /* called when modal loop selection gets set up... */
265 static int ringsel_init(bContext *C, wmOperator *op, bool do_cut)
266 {
267   RingSelOpData *lcd;
268   Scene *scene = CTX_data_scene(C);
269
270   /* alloc new customdata */
271   lcd = op->customdata = MEM_callocN(sizeof(RingSelOpData), "ringsel Modal Op Data");
272
273   em_setup_viewcontext(C, &lcd->vc);
274
275   lcd->depsgraph = CTX_data_depsgraph(C);
276
277   /* assign the drawing handle for drawing preview line... */
278   lcd->ar = CTX_wm_region(C);
279   lcd->draw_handle = ED_region_draw_cb_activate(
280       lcd->ar->type, ringsel_draw, lcd, REGION_DRAW_POST_VIEW);
281   lcd->presel_edgering = EDBM_preselect_edgering_create();
282   /* Initialize once the cursor is over a mesh. */
283   lcd->ob = NULL;
284   lcd->em = NULL;
285   lcd->extend = do_cut ? false : RNA_boolean_get(op->ptr, "extend");
286   lcd->do_cut = do_cut;
287   lcd->cuts = RNA_int_get(op->ptr, "number_cuts");
288   lcd->smoothness = RNA_float_get(op->ptr, "smoothness");
289
290   initNumInput(&lcd->num);
291   lcd->num.idx_max = 1;
292   lcd->num.val_flag[0] |= NUM_NO_NEGATIVE | NUM_NO_FRACTION;
293   /* No specific flags for smoothness. */
294   lcd->num.unit_sys = scene->unit.system;
295   lcd->num.unit_type[0] = B_UNIT_NONE;
296   lcd->num.unit_type[1] = B_UNIT_NONE;
297
298   ED_region_tag_redraw(lcd->ar);
299
300   return 1;
301 }
302
303 static void ringcut_cancel(bContext *C, wmOperator *op)
304 {
305   /* this is just a wrapper around exit() */
306   ringsel_exit(C, op);
307 }
308
309 static void loopcut_update_edge(RingSelOpData *lcd,
310                                 uint ob_index,
311                                 BMEdge *e,
312                                 const int previewlines)
313 {
314   if (e != lcd->eed) {
315     lcd->eed = e;
316     lcd->ob = lcd->vc.obedit;
317     lcd->ob_index = ob_index;
318     lcd->em = lcd->vc.em;
319     ringsel_find_edge(lcd, previewlines);
320   }
321   else if (e == NULL) {
322     lcd->ob = NULL;
323     lcd->em = NULL;
324     lcd->ob_index = UINT_MAX;
325   }
326 }
327
328 static void loopcut_mouse_move(RingSelOpData *lcd, const int previewlines)
329 {
330   struct {
331     Object *ob;
332     BMEdge *eed;
333     float dist;
334     int ob_index;
335   } best = {
336       .dist = ED_view3d_select_dist_px(),
337   };
338
339   for (uint ob_index = 0; ob_index < lcd->objects_len; ob_index++) {
340     Object *ob_iter = lcd->objects[ob_index];
341     ED_view3d_viewcontext_init_object(&lcd->vc, ob_iter);
342     BMEdge *eed_test = EDBM_edge_find_nearest_ex(&lcd->vc, &best.dist, NULL, false, false, NULL);
343     if (eed_test) {
344       best.ob = ob_iter;
345       best.eed = eed_test;
346       best.ob_index = ob_index;
347     }
348   }
349
350   if (best.eed) {
351     ED_view3d_viewcontext_init_object(&lcd->vc, best.ob);
352   }
353
354   loopcut_update_edge(lcd, best.ob_index, best.eed, previewlines);
355 }
356
357 /* called by both init() and exec() */
358 static int loopcut_init(bContext *C, wmOperator *op, const wmEvent *event)
359 {
360   const bool is_interactive = (event != NULL);
361
362   /* Use for redo - intentionally wrap int to uint. */
363   const struct {
364     uint ob_index;
365     uint e_index;
366   } exec_data = {
367       .ob_index = (uint)RNA_int_get(op->ptr, "object_index"),
368       .e_index = (uint)RNA_int_get(op->ptr, "edge_index"),
369   };
370
371   ViewLayer *view_layer = CTX_data_view_layer(C);
372
373   uint objects_len;
374   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode(
375       view_layer, CTX_wm_view3d(C), &objects_len);
376
377   if (is_interactive) {
378     for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
379       Object *ob_iter = objects[ob_index];
380       if (modifiers_isDeformedByLattice(ob_iter) || modifiers_isDeformedByArmature(ob_iter)) {
381         BKE_report(
382             op->reports, RPT_WARNING, "Loop cut does not work well on deformed edit mesh display");
383         break;
384       }
385     }
386   }
387
388   view3d_operator_needs_opengl(C);
389
390   /* for re-execution, check edge index is in range before we setup ringsel */
391   bool ok = true;
392   if (is_interactive == false) {
393     if (exec_data.ob_index >= objects_len) {
394       return OPERATOR_CANCELLED;
395       ok = false;
396     }
397     else {
398       Object *ob_iter = objects[exec_data.ob_index];
399       BMEditMesh *em = BKE_editmesh_from_object(ob_iter);
400       if (exec_data.e_index >= em->bm->totedge) {
401         ok = false;
402       }
403     }
404   }
405
406   if (!ok || !ringsel_init(C, op, true)) {
407     MEM_freeN(objects);
408     return OPERATOR_CANCELLED;
409   }
410
411   /* add a modal handler for this operator - handles loop selection */
412   if (is_interactive) {
413     op->flag |= OP_IS_MODAL_CURSOR_REGION;
414     WM_event_add_modal_handler(C, op);
415   }
416
417   RingSelOpData *lcd = op->customdata;
418
419   lcd->objects = objects;
420   lcd->objects_len = objects_len;
421
422   if (is_interactive) {
423     copy_v2_v2_int(lcd->vc.mval, event->mval);
424     loopcut_mouse_move(lcd, is_interactive ? 1 : 0);
425   }
426   else {
427
428     Object *ob_iter = objects[exec_data.ob_index];
429     ED_view3d_viewcontext_init_object(&lcd->vc, ob_iter);
430
431     BMEdge *e;
432     BM_mesh_elem_table_ensure(lcd->vc.em->bm, BM_EDGE);
433     e = BM_edge_at_index(lcd->vc.em->bm, exec_data.e_index);
434     loopcut_update_edge(lcd, exec_data.ob_index, e, 0);
435   }
436
437 #ifdef USE_LOOPSLIDE_HACK
438   /* for use in macro so we can restore, HACK */
439   {
440     Scene *scene = CTX_data_scene(C);
441     ToolSettings *settings = scene->toolsettings;
442     const bool mesh_select_mode[3] = {
443         (settings->selectmode & SCE_SELECT_VERTEX) != 0,
444         (settings->selectmode & SCE_SELECT_EDGE) != 0,
445         (settings->selectmode & SCE_SELECT_FACE) != 0,
446     };
447
448     RNA_boolean_set_array(op->ptr, "mesh_select_mode_init", mesh_select_mode);
449   }
450 #endif
451
452   if (is_interactive) {
453     ED_workspace_status_text(
454         C,
455         IFACE_("Select a ring to be cut, use mouse-wheel or page-up/down for number of cuts, "
456                "hold Alt for smooth"));
457     return OPERATOR_RUNNING_MODAL;
458   }
459   else {
460     ringsel_finish(C, op);
461     ringsel_exit(C, op);
462     return OPERATOR_FINISHED;
463   }
464 }
465
466 static int ringcut_invoke(bContext *C, wmOperator *op, const wmEvent *event)
467 {
468   /* When accessed as a tool, get the active edge from the preselection gizmo. */
469   {
470     ARegion *ar = CTX_wm_region(C);
471     wmGizmoMap *gzmap = ar->gizmo_map;
472     wmGizmoGroup *gzgroup = gzmap ? WM_gizmomap_group_find(gzmap,
473                                                            "VIEW3D_GGT_mesh_preselect_edgering") :
474                                     NULL;
475     if ((gzgroup != NULL) && gzgroup->gizmos.first) {
476       wmGizmo *gz = gzgroup->gizmos.first;
477       const int object_index = RNA_int_get(gz->ptr, "object_index");
478       const int edge_index = RNA_int_get(gz->ptr, "edge_index");
479
480       if (object_index != -1 && edge_index != -1) {
481         RNA_int_set(op->ptr, "object_index", object_index);
482         RNA_int_set(op->ptr, "edge_index", edge_index);
483         return loopcut_init(C, op, NULL);
484       }
485       return OPERATOR_CANCELLED;
486     }
487   }
488
489   return loopcut_init(C, op, event);
490 }
491
492 static int loopcut_exec(bContext *C, wmOperator *op)
493 {
494   return loopcut_init(C, op, NULL);
495 }
496
497 static int loopcut_finish(RingSelOpData *lcd, bContext *C, wmOperator *op)
498 {
499   /* finish */
500   ED_region_tag_redraw(lcd->ar);
501   ED_workspace_status_text(C, NULL);
502
503   if (lcd->eed) {
504     /* set for redo */
505     BM_mesh_elem_index_ensure(lcd->em->bm, BM_EDGE);
506     RNA_int_set(op->ptr, "object_index", lcd->ob_index);
507     RNA_int_set(op->ptr, "edge_index", BM_elem_index_get(lcd->eed));
508
509     /* execute */
510     ringsel_finish(C, op);
511     ringsel_exit(C, op);
512   }
513   else {
514     ringcut_cancel(C, op);
515     return OPERATOR_CANCELLED;
516   }
517
518   return OPERATOR_FINISHED;
519 }
520
521 static int loopcut_modal(bContext *C, wmOperator *op, const wmEvent *event)
522 {
523   RingSelOpData *lcd = op->customdata;
524   float cuts = lcd->cuts;
525   float smoothness = lcd->smoothness;
526   bool show_cuts = false;
527   const bool has_numinput = hasNumInput(&lcd->num);
528
529   em_setup_viewcontext(C, &lcd->vc);
530   lcd->ar = lcd->vc.ar;
531
532   view3d_operator_needs_opengl(C);
533
534   /* using the keyboard to input the number of cuts */
535   /* Modal numinput active, try to handle numeric inputs first... */
536   if (event->val == KM_PRESS && has_numinput && handleNumInput(C, &lcd->num, event)) {
537     float values[2] = {cuts, smoothness};
538     applyNumInput(&lcd->num, values);
539     cuts = values[0];
540     smoothness = values[1];
541   }
542   else {
543     bool handled = false;
544     switch (event->type) {
545       case RETKEY:
546       case PADENTER:
547       case LEFTMOUSE: /* confirm */  // XXX hardcoded
548         if (event->val == KM_PRESS) {
549           return loopcut_finish(lcd, C, op);
550         }
551
552         ED_region_tag_redraw(lcd->ar);
553         handled = true;
554         break;
555       case RIGHTMOUSE: /* abort */  // XXX hardcoded
556         ED_region_tag_redraw(lcd->ar);
557         ringsel_exit(C, op);
558         ED_workspace_status_text(C, NULL);
559
560         return OPERATOR_CANCELLED;
561       case ESCKEY:
562         if (event->val == KM_RELEASE) {
563           /* cancel */
564           ED_region_tag_redraw(lcd->ar);
565           ED_workspace_status_text(C, NULL);
566
567           ringcut_cancel(C, op);
568           return OPERATOR_CANCELLED;
569         }
570
571         ED_region_tag_redraw(lcd->ar);
572         handled = true;
573         break;
574       case MOUSEPAN:
575         if (event->alt == 0) {
576           cuts += 0.02f * (event->y - event->prevy);
577           if (cuts < 1 && lcd->cuts >= 1) {
578             cuts = 1;
579           }
580         }
581         else {
582           smoothness += 0.002f * (event->y - event->prevy);
583         }
584         handled = true;
585         break;
586       case PADPLUSKEY:
587       case PAGEUPKEY:
588       case WHEELUPMOUSE: /* change number of cuts */
589         if (event->val == KM_RELEASE) {
590           break;
591         }
592         if (event->alt == 0) {
593           cuts += 1;
594         }
595         else {
596           smoothness += 0.05f;
597         }
598         handled = true;
599         break;
600       case PADMINUS:
601       case PAGEDOWNKEY:
602       case WHEELDOWNMOUSE: /* change number of cuts */
603         if (event->val == KM_RELEASE) {
604           break;
605         }
606         if (event->alt == 0) {
607           cuts = max_ff(cuts - 1, 1);
608         }
609         else {
610           smoothness -= 0.05f;
611         }
612         handled = true;
613         break;
614       case MOUSEMOVE: /* mouse moved somewhere to select another loop */
615
616         /* This is normally disabled for all modal operators.
617          * This is an exception since mouse movement doesn't relate to numeric input.
618          *
619          * If numeric input changes we'll need to add this back see: D2973 */
620 #if 0
621         if (!has_numinput)
622 #endif
623       {
624         lcd->vc.mval[0] = event->mval[0];
625         lcd->vc.mval[1] = event->mval[1];
626         loopcut_mouse_move(lcd, (int)lcd->cuts);
627
628         ED_region_tag_redraw(lcd->ar);
629         handled = true;
630       } break;
631     }
632
633     /* Modal numinput inactive, try to handle numeric inputs last... */
634     if (!handled && event->val == KM_PRESS && handleNumInput(C, &lcd->num, event)) {
635       float values[2] = {cuts, smoothness};
636       applyNumInput(&lcd->num, values);
637       cuts = values[0];
638       smoothness = values[1];
639     }
640   }
641
642   if (cuts != lcd->cuts) {
643     /* allow zero so you can backspace and type in a value
644      * otherwise 1 as minimum would make more sense */
645     lcd->cuts = clamp_i(cuts, 0, SUBD_CUTS_MAX);
646     RNA_int_set(op->ptr, "number_cuts", (int)lcd->cuts);
647     ringsel_find_edge(lcd, (int)lcd->cuts);
648     show_cuts = true;
649     ED_region_tag_redraw(lcd->ar);
650   }
651
652   if (smoothness != lcd->smoothness) {
653     lcd->smoothness = clamp_f(smoothness, -SUBD_SMOOTH_MAX, SUBD_SMOOTH_MAX);
654     RNA_float_set(op->ptr, "smoothness", lcd->smoothness);
655     show_cuts = true;
656     ED_region_tag_redraw(lcd->ar);
657   }
658
659   if (show_cuts) {
660     Scene *sce = CTX_data_scene(C);
661     char buf[UI_MAX_DRAW_STR];
662     char str_rep[NUM_STR_REP_LEN * 2];
663     if (hasNumInput(&lcd->num)) {
664       outputNumInput(&lcd->num, str_rep, &sce->unit);
665     }
666     else {
667       BLI_snprintf(str_rep, NUM_STR_REP_LEN, "%d", (int)lcd->cuts);
668       BLI_snprintf(str_rep + NUM_STR_REP_LEN, NUM_STR_REP_LEN, "%.2f", smoothness);
669     }
670     BLI_snprintf(buf,
671                  sizeof(buf),
672                  IFACE_("Number of Cuts: %s, Smooth: %s (Alt)"),
673                  str_rep,
674                  str_rep + NUM_STR_REP_LEN);
675     ED_workspace_status_text(C, buf);
676   }
677
678   /* keep going until the user confirms */
679   return OPERATOR_RUNNING_MODAL;
680 }
681
682 /* for bmesh this tool is in bmesh_select.c */
683 #if 0
684
685 void MESH_OT_edgering_select(wmOperatorType *ot)
686 {
687   /* description */
688   ot->name = "Edge Ring Select";
689   ot->idname = "MESH_OT_edgering_select";
690   ot->description = "Select an edge ring";
691
692   /* callbacks */
693   ot->invoke = ringsel_invoke;
694   ot->poll = ED_operator_editmesh_region_view3d;
695
696   /* flags */
697   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
698
699   RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the selection");
700 }
701
702 #endif
703
704 void MESH_OT_loopcut(wmOperatorType *ot)
705 {
706   PropertyRNA *prop;
707
708   /* description */
709   ot->name = "Loop Cut";
710   ot->idname = "MESH_OT_loopcut";
711   ot->description = "Add a new loop between existing loops";
712
713   /* callbacks */
714   ot->invoke = ringcut_invoke;
715   ot->exec = loopcut_exec;
716   ot->modal = loopcut_modal;
717   ot->cancel = ringcut_cancel;
718   ot->poll = ED_operator_editmesh_region_view3d;
719
720   /* flags */
721   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
722
723   /* properties */
724   prop = RNA_def_int(ot->srna, "number_cuts", 1, 1, 1000000, "Number of Cuts", "", 1, 100);
725   /* avoid re-using last var because it can cause
726    * _very_ high poly meshes and annoy users (or worse crash) */
727   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
728
729   prop = RNA_def_float(ot->srna,
730                        "smoothness",
731                        0.0f,
732                        -1e3f,
733                        1e3f,
734                        "Smoothness",
735                        "Smoothness factor",
736                        -SUBD_SMOOTH_MAX,
737                        SUBD_SMOOTH_MAX);
738   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
739
740   WM_operatortype_props_advanced_begin(ot);
741
742   prop = RNA_def_property(ot->srna, "falloff", PROP_ENUM, PROP_NONE);
743   RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_curve_only_items);
744   RNA_def_property_enum_default(prop, PROP_INVSQUARE);
745   RNA_def_property_ui_text(prop, "Falloff", "Falloff type the feather");
746   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
747
748   /* For redo only. */
749   prop = RNA_def_int(ot->srna, "object_index", -1, -1, INT_MAX, "Object Index", "", 0, INT_MAX);
750   RNA_def_property_flag(prop, PROP_HIDDEN);
751   prop = RNA_def_int(ot->srna, "edge_index", -1, -1, INT_MAX, "Edge Index", "", 0, INT_MAX);
752   RNA_def_property_flag(prop, PROP_HIDDEN);
753
754 #ifdef USE_LOOPSLIDE_HACK
755   prop = RNA_def_boolean_array(ot->srna, "mesh_select_mode_init", 3, NULL, "", "");
756   RNA_def_property_flag(prop, PROP_HIDDEN);
757 #endif
758 }