Fix/Cleanup: I18N: Bad usage of IFACE_ instead of TIP_.
[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   Base **bases;
83   uint bases_len;
84
85   /* These values switch objects based on the object under the cursor. */
86   uint base_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 base_index = 0; base_index < lcd->bases_len; base_index++) {
115       Object *ob_iter = lcd->bases[base_index]->object;
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->bases);
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 base_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->base_index = base_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->base_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 base_index;
335   } best = {
336       .dist = ED_view3d_select_dist_px(),
337   };
338
339   uint base_index;
340   BMEdge *eed_test = EDBM_edge_find_nearest_ex(
341       &lcd->vc, &best.dist, NULL, false, false, NULL, lcd->bases, lcd->bases_len, &base_index);
342
343   if (eed_test) {
344     best.ob = lcd->bases[base_index]->object;
345     best.eed = eed_test;
346     best.base_index = base_index;
347   }
348
349   if (best.eed) {
350     ED_view3d_viewcontext_init_object(&lcd->vc, best.ob);
351   }
352
353   loopcut_update_edge(lcd, best.base_index, best.eed, previewlines);
354 }
355
356 /* called by both init() and exec() */
357 static int loopcut_init(bContext *C, wmOperator *op, const wmEvent *event)
358 {
359   const bool is_interactive = (event != NULL);
360
361   /* Use for redo - intentionally wrap int to uint. */
362   const struct {
363     uint base_index;
364     uint e_index;
365   } exec_data = {
366       .base_index = (uint)RNA_int_get(op->ptr, "object_index"),
367       .e_index = (uint)RNA_int_get(op->ptr, "edge_index"),
368   };
369
370   ViewLayer *view_layer = CTX_data_view_layer(C);
371
372   uint bases_len;
373   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode(
374       view_layer, CTX_wm_view3d(C), &bases_len);
375
376   if (is_interactive) {
377     for (uint base_index = 0; base_index < bases_len; base_index++) {
378       Object *ob_iter = bases[base_index]->object;
379       if (modifiers_isDeformedByLattice(ob_iter) || modifiers_isDeformedByArmature(ob_iter)) {
380         BKE_report(
381             op->reports, RPT_WARNING, "Loop cut does not work well on deformed edit mesh display");
382         break;
383       }
384     }
385   }
386
387   view3d_operator_needs_opengl(C);
388
389   /* for re-execution, check edge index is in range before we setup ringsel */
390   bool ok = true;
391   if (is_interactive == false) {
392     if (exec_data.base_index >= bases_len) {
393       return OPERATOR_CANCELLED;
394       ok = false;
395     }
396     else {
397       Object *ob_iter = bases[exec_data.base_index]->object;
398       BMEditMesh *em = BKE_editmesh_from_object(ob_iter);
399       if (exec_data.e_index >= em->bm->totedge) {
400         ok = false;
401       }
402     }
403   }
404
405   if (!ok || !ringsel_init(C, op, true)) {
406     MEM_freeN(bases);
407     return OPERATOR_CANCELLED;
408   }
409
410   /* add a modal handler for this operator - handles loop selection */
411   if (is_interactive) {
412     op->flag |= OP_IS_MODAL_CURSOR_REGION;
413     WM_event_add_modal_handler(C, op);
414   }
415
416   RingSelOpData *lcd = op->customdata;
417
418   lcd->bases = bases;
419   lcd->bases_len = bases_len;
420
421   if (is_interactive) {
422     copy_v2_v2_int(lcd->vc.mval, event->mval);
423     loopcut_mouse_move(lcd, is_interactive ? 1 : 0);
424   }
425   else {
426
427     Object *ob_iter = bases[exec_data.base_index]->object;
428     ED_view3d_viewcontext_init_object(&lcd->vc, ob_iter);
429
430     BMEdge *e;
431     BM_mesh_elem_table_ensure(lcd->vc.em->bm, BM_EDGE);
432     e = BM_edge_at_index(lcd->vc.em->bm, exec_data.e_index);
433     loopcut_update_edge(lcd, exec_data.base_index, e, 0);
434   }
435
436 #ifdef USE_LOOPSLIDE_HACK
437   /* for use in macro so we can restore, HACK */
438   {
439     Scene *scene = CTX_data_scene(C);
440     ToolSettings *settings = scene->toolsettings;
441     const bool mesh_select_mode[3] = {
442         (settings->selectmode & SCE_SELECT_VERTEX) != 0,
443         (settings->selectmode & SCE_SELECT_EDGE) != 0,
444         (settings->selectmode & SCE_SELECT_FACE) != 0,
445     };
446
447     RNA_boolean_set_array(op->ptr, "mesh_select_mode_init", mesh_select_mode);
448   }
449 #endif
450
451   if (is_interactive) {
452     ED_workspace_status_text(
453         C,
454         TIP_("Select a ring to be cut, use mouse-wheel or page-up/down for number of cuts, "
455              "hold Alt for smooth"));
456     return OPERATOR_RUNNING_MODAL;
457   }
458   else {
459     ringsel_finish(C, op);
460     ringsel_exit(C, op);
461     return OPERATOR_FINISHED;
462   }
463 }
464
465 static int ringcut_invoke(bContext *C, wmOperator *op, const wmEvent *event)
466 {
467   /* When accessed as a tool, get the active edge from the preselection gizmo. */
468   {
469     ARegion *ar = CTX_wm_region(C);
470     wmGizmoMap *gzmap = ar->gizmo_map;
471     wmGizmoGroup *gzgroup = gzmap ? WM_gizmomap_group_find(gzmap,
472                                                            "VIEW3D_GGT_mesh_preselect_edgering") :
473                                     NULL;
474     if ((gzgroup != NULL) && gzgroup->gizmos.first) {
475       wmGizmo *gz = gzgroup->gizmos.first;
476       const int object_index = RNA_int_get(gz->ptr, "object_index");
477       const int edge_index = RNA_int_get(gz->ptr, "edge_index");
478
479       if (object_index != -1 && edge_index != -1) {
480         RNA_int_set(op->ptr, "object_index", object_index);
481         RNA_int_set(op->ptr, "edge_index", edge_index);
482         return loopcut_init(C, op, NULL);
483       }
484       return OPERATOR_CANCELLED;
485     }
486   }
487
488   return loopcut_init(C, op, event);
489 }
490
491 static int loopcut_exec(bContext *C, wmOperator *op)
492 {
493   return loopcut_init(C, op, NULL);
494 }
495
496 static int loopcut_finish(RingSelOpData *lcd, bContext *C, wmOperator *op)
497 {
498   /* finish */
499   ED_region_tag_redraw(lcd->ar);
500   ED_workspace_status_text(C, NULL);
501
502   if (lcd->eed) {
503     /* set for redo */
504     BM_mesh_elem_index_ensure(lcd->em->bm, BM_EDGE);
505     RNA_int_set(op->ptr, "object_index", lcd->base_index);
506     RNA_int_set(op->ptr, "edge_index", BM_elem_index_get(lcd->eed));
507
508     /* execute */
509     ringsel_finish(C, op);
510     ringsel_exit(C, op);
511   }
512   else {
513     ringcut_cancel(C, op);
514     return OPERATOR_CANCELLED;
515   }
516
517   return OPERATOR_FINISHED;
518 }
519
520 static int loopcut_modal(bContext *C, wmOperator *op, const wmEvent *event)
521 {
522   RingSelOpData *lcd = op->customdata;
523   float cuts = lcd->cuts;
524   float smoothness = lcd->smoothness;
525   bool show_cuts = false;
526   const bool has_numinput = hasNumInput(&lcd->num);
527
528   em_setup_viewcontext(C, &lcd->vc);
529   lcd->ar = lcd->vc.ar;
530
531   view3d_operator_needs_opengl(C);
532
533   /* using the keyboard to input the number of cuts */
534   /* Modal numinput active, try to handle numeric inputs first... */
535   if (event->val == KM_PRESS && has_numinput && handleNumInput(C, &lcd->num, event)) {
536     float values[2] = {cuts, smoothness};
537     applyNumInput(&lcd->num, values);
538     cuts = values[0];
539     smoothness = values[1];
540   }
541   else {
542     bool handled = false;
543     switch (event->type) {
544       case RETKEY:
545       case PADENTER:
546       case LEFTMOUSE: /* confirm */  // XXX hardcoded
547         if (event->val == KM_PRESS) {
548           return loopcut_finish(lcd, C, op);
549         }
550
551         ED_region_tag_redraw(lcd->ar);
552         handled = true;
553         break;
554       case RIGHTMOUSE: /* abort */  // XXX hardcoded
555         ED_region_tag_redraw(lcd->ar);
556         ringsel_exit(C, op);
557         ED_workspace_status_text(C, NULL);
558
559         return OPERATOR_CANCELLED;
560       case ESCKEY:
561         if (event->val == KM_RELEASE) {
562           /* cancel */
563           ED_region_tag_redraw(lcd->ar);
564           ED_workspace_status_text(C, NULL);
565
566           ringcut_cancel(C, op);
567           return OPERATOR_CANCELLED;
568         }
569
570         ED_region_tag_redraw(lcd->ar);
571         handled = true;
572         break;
573       case MOUSEPAN:
574         if (event->alt == 0) {
575           cuts += 0.02f * (event->y - event->prevy);
576           if (cuts < 1 && lcd->cuts >= 1) {
577             cuts = 1;
578           }
579         }
580         else {
581           smoothness += 0.002f * (event->y - event->prevy);
582         }
583         handled = true;
584         break;
585       case PADPLUSKEY:
586       case PAGEUPKEY:
587       case WHEELUPMOUSE: /* change number of cuts */
588         if (event->val == KM_RELEASE) {
589           break;
590         }
591         if (event->alt == 0) {
592           cuts += 1;
593         }
594         else {
595           smoothness += 0.05f;
596         }
597         handled = true;
598         break;
599       case PADMINUS:
600       case PAGEDOWNKEY:
601       case WHEELDOWNMOUSE: /* change number of cuts */
602         if (event->val == KM_RELEASE) {
603           break;
604         }
605         if (event->alt == 0) {
606           cuts = max_ff(cuts - 1, 1);
607         }
608         else {
609           smoothness -= 0.05f;
610         }
611         handled = true;
612         break;
613       case MOUSEMOVE: /* mouse moved somewhere to select another loop */
614
615         /* This is normally disabled for all modal operators.
616          * This is an exception since mouse movement doesn't relate to numeric input.
617          *
618          * If numeric input changes we'll need to add this back see: D2973 */
619 #if 0
620         if (!has_numinput)
621 #endif
622       {
623         lcd->vc.mval[0] = event->mval[0];
624         lcd->vc.mval[1] = event->mval[1];
625         loopcut_mouse_move(lcd, (int)lcd->cuts);
626
627         ED_region_tag_redraw(lcd->ar);
628         handled = true;
629       } break;
630     }
631
632     /* Modal numinput inactive, try to handle numeric inputs last... */
633     if (!handled && event->val == KM_PRESS && handleNumInput(C, &lcd->num, event)) {
634       float values[2] = {cuts, smoothness};
635       applyNumInput(&lcd->num, values);
636       cuts = values[0];
637       smoothness = values[1];
638     }
639   }
640
641   if (cuts != lcd->cuts) {
642     /* allow zero so you can backspace and type in a value
643      * otherwise 1 as minimum would make more sense */
644     lcd->cuts = clamp_i(cuts, 0, SUBD_CUTS_MAX);
645     RNA_int_set(op->ptr, "number_cuts", (int)lcd->cuts);
646     ringsel_find_edge(lcd, (int)lcd->cuts);
647     show_cuts = true;
648     ED_region_tag_redraw(lcd->ar);
649   }
650
651   if (smoothness != lcd->smoothness) {
652     lcd->smoothness = clamp_f(smoothness, -SUBD_SMOOTH_MAX, SUBD_SMOOTH_MAX);
653     RNA_float_set(op->ptr, "smoothness", lcd->smoothness);
654     show_cuts = true;
655     ED_region_tag_redraw(lcd->ar);
656   }
657
658   if (show_cuts) {
659     Scene *sce = CTX_data_scene(C);
660     char buf[UI_MAX_DRAW_STR];
661     char str_rep[NUM_STR_REP_LEN * 2];
662     if (hasNumInput(&lcd->num)) {
663       outputNumInput(&lcd->num, str_rep, &sce->unit);
664     }
665     else {
666       BLI_snprintf(str_rep, NUM_STR_REP_LEN, "%d", (int)lcd->cuts);
667       BLI_snprintf(str_rep + NUM_STR_REP_LEN, NUM_STR_REP_LEN, "%.2f", smoothness);
668     }
669     BLI_snprintf(buf,
670                  sizeof(buf),
671                  TIP_("Number of Cuts: %s, Smooth: %s (Alt)"),
672                  str_rep,
673                  str_rep + NUM_STR_REP_LEN);
674     ED_workspace_status_text(C, buf);
675   }
676
677   /* keep going until the user confirms */
678   return OPERATOR_RUNNING_MODAL;
679 }
680
681 /* for bmesh this tool is in bmesh_select.c */
682 #if 0
683
684 void MESH_OT_edgering_select(wmOperatorType *ot)
685 {
686   /* description */
687   ot->name = "Edge Ring Select";
688   ot->idname = "MESH_OT_edgering_select";
689   ot->description = "Select an edge ring";
690
691   /* callbacks */
692   ot->invoke = ringsel_invoke;
693   ot->poll = ED_operator_editmesh_region_view3d;
694
695   /* flags */
696   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
697
698   RNA_def_boolean(ot->srna, "extend", 0, "Extend", "Extend the selection");
699 }
700
701 #endif
702
703 void MESH_OT_loopcut(wmOperatorType *ot)
704 {
705   PropertyRNA *prop;
706
707   /* description */
708   ot->name = "Loop Cut";
709   ot->idname = "MESH_OT_loopcut";
710   ot->description = "Add a new loop between existing loops";
711
712   /* callbacks */
713   ot->invoke = ringcut_invoke;
714   ot->exec = loopcut_exec;
715   ot->modal = loopcut_modal;
716   ot->cancel = ringcut_cancel;
717   ot->poll = ED_operator_editmesh_region_view3d;
718
719   /* flags */
720   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
721
722   /* properties */
723   prop = RNA_def_int(ot->srna, "number_cuts", 1, 1, 1000000, "Number of Cuts", "", 1, 100);
724   /* avoid re-using last var because it can cause
725    * _very_ high poly meshes and annoy users (or worse crash) */
726   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
727
728   prop = RNA_def_float(ot->srna,
729                        "smoothness",
730                        0.0f,
731                        -1e3f,
732                        1e3f,
733                        "Smoothness",
734                        "Smoothness factor",
735                        -SUBD_SMOOTH_MAX,
736                        SUBD_SMOOTH_MAX);
737   RNA_def_property_flag(prop, PROP_SKIP_SAVE);
738
739   WM_operatortype_props_advanced_begin(ot);
740
741   prop = RNA_def_property(ot->srna, "falloff", PROP_ENUM, PROP_NONE);
742   RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_curve_only_items);
743   RNA_def_property_enum_default(prop, PROP_INVSQUARE);
744   RNA_def_property_ui_text(prop, "Falloff", "Falloff type the feather");
745   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
746
747   /* For redo only. */
748   prop = RNA_def_int(ot->srna, "object_index", -1, -1, INT_MAX, "Object Index", "", 0, INT_MAX);
749   RNA_def_property_flag(prop, PROP_HIDDEN);
750   prop = RNA_def_int(ot->srna, "edge_index", -1, -1, INT_MAX, "Edge Index", "", 0, INT_MAX);
751   RNA_def_property_flag(prop, PROP_HIDDEN);
752
753 #ifdef USE_LOOPSLIDE_HACK
754   prop = RNA_def_boolean_array(ot->srna, "mesh_select_mode_init", 3, NULL, "", "");
755   RNA_def_property_flag(prop, PROP_HIDDEN);
756 #endif
757 }