GPencil: Fix keymap error for Fill Boundary strokes
[blender.git] / source / blender / editors / sculpt_paint / paint_ops.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
17 /** \file
18  * \ingroup edsculpt
19  */
20
21 #include "MEM_guardedalloc.h"
22
23 #include "BLI_listbase.h"
24 #include "BLI_math_vector.h"
25 #include "BLI_string.h"
26 #include "BLI_utildefines.h"
27 #include <stdlib.h>
28
29 #include "IMB_imbuf.h"
30 #include "IMB_imbuf_types.h"
31
32 #include "DNA_brush_types.h"
33 #include "DNA_customdata_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_scene_types.h"
36
37 #include "BKE_brush.h"
38 #include "BKE_context.h"
39 #include "BKE_image.h"
40 #include "BKE_lib_id.h"
41 #include "BKE_main.h"
42 #include "BKE_paint.h"
43 #include "BKE_report.h"
44
45 #include "ED_image.h"
46 #include "ED_paint.h"
47 #include "ED_screen.h"
48
49 #include "WM_api.h"
50 #include "WM_toolsystem.h"
51 #include "WM_types.h"
52
53 #include "RNA_access.h"
54 #include "RNA_define.h"
55
56 #include "paint_intern.h"
57 #include "sculpt_intern.h"
58
59 #include <string.h>
60 //#include <stdio.h>
61 #include <stddef.h>
62
63 /* Brush operators */
64 static int brush_add_exec(bContext *C, wmOperator *UNUSED(op))
65 {
66   /*int type = RNA_enum_get(op->ptr, "type");*/
67   Paint *paint = BKE_paint_get_active_from_context(C);
68   Brush *br = BKE_paint_brush(paint);
69   Main *bmain = CTX_data_main(C);
70   ePaintMode mode = BKE_paintmode_get_active_from_context(C);
71
72   if (br) {
73     br = BKE_brush_copy(bmain, br);
74   }
75   else {
76     br = BKE_brush_add(bmain, "Brush", BKE_paint_object_mode_from_paintmode(mode));
77   }
78   id_us_min(&br->id); /* fake user only */
79
80   BKE_paint_brush_set(paint, br);
81
82   return OPERATOR_FINISHED;
83 }
84
85 static void BRUSH_OT_add(wmOperatorType *ot)
86 {
87   /* identifiers */
88   ot->name = "Add Brush";
89   ot->description = "Add brush by mode type";
90   ot->idname = "BRUSH_OT_add";
91
92   /* api callbacks */
93   ot->exec = brush_add_exec;
94
95   /* flags */
96   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
97 }
98
99 static int brush_add_gpencil_exec(bContext *C, wmOperator *UNUSED(op))
100 {
101   /*int type = RNA_enum_get(op->ptr, "type");*/
102   ToolSettings *ts = CTX_data_tool_settings(C);
103   Paint *paint = &ts->gp_paint->paint;
104   Brush *br = BKE_paint_brush(paint);
105   Main *bmain = CTX_data_main(C);
106
107   if (br) {
108     br = BKE_brush_copy(bmain, br);
109   }
110   else {
111     br = BKE_brush_add(bmain, "Brush", OB_MODE_PAINT_GPENCIL);
112
113     /* Init grease pencil specific data. */
114     BKE_brush_init_gpencil_settings(br);
115   }
116
117   id_us_min(&br->id); /* fake user only */
118
119   BKE_paint_brush_set(paint, br);
120
121   return OPERATOR_FINISHED;
122 }
123
124 static void BRUSH_OT_add_gpencil(wmOperatorType *ot)
125 {
126   /* identifiers */
127   ot->name = "Add Drawing Brush";
128   ot->description = "Add brush for Grease Pencil";
129   ot->idname = "BRUSH_OT_add_gpencil";
130
131   /* api callbacks */
132   ot->exec = brush_add_gpencil_exec;
133
134   /* flags */
135   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
136 }
137
138 static int brush_scale_size_exec(bContext *C, wmOperator *op)
139 {
140   Scene *scene = CTX_data_scene(C);
141   Paint *paint = BKE_paint_get_active_from_context(C);
142   Brush *brush = BKE_paint_brush(paint);
143   // Object *ob = CTX_data_active_object(C);
144   float scalar = RNA_float_get(op->ptr, "scalar");
145
146   if (brush) {
147     // pixel radius
148     {
149       const int old_size = BKE_brush_size_get(scene, brush);
150       int size = (int)(scalar * old_size);
151
152       if (abs(old_size - size) < U.pixelsize) {
153         if (scalar > 1) {
154           size += U.pixelsize;
155         }
156         else if (scalar < 1) {
157           size -= U.pixelsize;
158         }
159       }
160
161       BKE_brush_size_set(scene, brush, size);
162     }
163
164     // unprojected radius
165     {
166       float unprojected_radius = scalar * BKE_brush_unprojected_radius_get(scene, brush);
167
168       if (unprojected_radius < 0.001f) {  // XXX magic number
169         unprojected_radius = 0.001f;
170       }
171
172       BKE_brush_unprojected_radius_set(scene, brush, unprojected_radius);
173     }
174
175     WM_main_add_notifier(NC_BRUSH | NA_EDITED, brush);
176   }
177
178   return OPERATOR_FINISHED;
179 }
180
181 static void BRUSH_OT_scale_size(wmOperatorType *ot)
182 {
183   /* identifiers */
184   ot->name = "Scale Sculpt/Paint Brush Size";
185   ot->description = "Change brush size by a scalar";
186   ot->idname = "BRUSH_OT_scale_size";
187
188   /* api callbacks */
189   ot->exec = brush_scale_size_exec;
190
191   /* flags */
192   ot->flag = 0;
193
194   RNA_def_float(ot->srna, "scalar", 1, 0, 2, "Scalar", "Factor to scale brush size by", 0, 2);
195 }
196
197 /* Palette operators */
198
199 static int palette_new_exec(bContext *C, wmOperator *UNUSED(op))
200 {
201   Paint *paint = BKE_paint_get_active_from_context(C);
202   Main *bmain = CTX_data_main(C);
203   Palette *palette;
204
205   palette = BKE_palette_add(bmain, "Palette");
206
207   BKE_paint_palette_set(paint, palette);
208
209   return OPERATOR_FINISHED;
210 }
211
212 static void PALETTE_OT_new(wmOperatorType *ot)
213 {
214   /* identifiers */
215   ot->name = "Add New Palette";
216   ot->description = "Add new palette";
217   ot->idname = "PALETTE_OT_new";
218
219   /* api callbacks */
220   ot->exec = palette_new_exec;
221
222   /* flags */
223   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
224 }
225
226 static bool palette_poll(bContext *C)
227 {
228   Paint *paint = BKE_paint_get_active_from_context(C);
229
230   if (paint && paint->palette != NULL) {
231     return true;
232   }
233
234   return false;
235 }
236
237 static int palette_color_add_exec(bContext *C, wmOperator *UNUSED(op))
238 {
239   Scene *scene = CTX_data_scene(C);
240   Paint *paint = BKE_paint_get_active_from_context(C);
241   Brush *brush = paint->brush;
242   ePaintMode mode = BKE_paintmode_get_active_from_context(C);
243   Palette *palette = paint->palette;
244   PaletteColor *color;
245
246   color = BKE_palette_color_add(palette);
247   palette->active_color = BLI_listbase_count(&palette->colors) - 1;
248
249   if (ELEM(mode,
250            PAINT_MODE_TEXTURE_3D,
251            PAINT_MODE_TEXTURE_2D,
252            PAINT_MODE_VERTEX,
253            PAINT_MODE_SCULPT)) {
254     copy_v3_v3(color->rgb, BKE_brush_color_get(scene, brush));
255     color->value = 0.0;
256   }
257   else if (mode == PAINT_MODE_WEIGHT) {
258     zero_v3(color->rgb);
259     color->value = brush->weight;
260   }
261
262   return OPERATOR_FINISHED;
263 }
264
265 static void PALETTE_OT_color_add(wmOperatorType *ot)
266 {
267   /* identifiers */
268   ot->name = "New Palette Color";
269   ot->description = "Add new color to active palette";
270   ot->idname = "PALETTE_OT_color_add";
271
272   /* api callbacks */
273   ot->exec = palette_color_add_exec;
274   ot->poll = palette_poll;
275   /* flags */
276   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
277 }
278
279 static int palette_color_delete_exec(bContext *C, wmOperator *UNUSED(op))
280 {
281   Paint *paint = BKE_paint_get_active_from_context(C);
282   Palette *palette = paint->palette;
283   PaletteColor *color = BLI_findlink(&palette->colors, palette->active_color);
284
285   if (color) {
286     BKE_palette_color_remove(palette, color);
287   }
288
289   return OPERATOR_FINISHED;
290 }
291
292 static void PALETTE_OT_color_delete(wmOperatorType *ot)
293 {
294   /* identifiers */
295   ot->name = "Delete Palette Color";
296   ot->description = "Remove active color from palette";
297   ot->idname = "PALETTE_OT_color_delete";
298
299   /* api callbacks */
300   ot->exec = palette_color_delete_exec;
301   ot->poll = palette_poll;
302   /* flags */
303   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
304 }
305
306 /* --- Extract Palette from Image. */
307 static bool palette_extract_img_poll(bContext *C)
308 {
309   SpaceLink *sl = CTX_wm_space_data(C);
310   if ((sl != NULL) && (sl->spacetype == SPACE_IMAGE)) {
311     SpaceImage *sima = CTX_wm_space_image(C);
312     Image *image = sima->image;
313     ImageUser iuser = sima->iuser;
314     return BKE_image_has_ibuf(image, &iuser);
315   }
316
317   return false;
318 }
319
320 static int palette_extract_img_exec(bContext *C, wmOperator *op)
321 {
322   const int threshold = RNA_int_get(op->ptr, "threshold");
323
324   Main *bmain = CTX_data_main(C);
325   bool done = false;
326
327   SpaceImage *sima = CTX_wm_space_image(C);
328   Image *image = sima->image;
329   ImageUser iuser = sima->iuser;
330   void *lock;
331   ImBuf *ibuf;
332   GHash *color_table = BLI_ghash_int_new(__func__);
333
334   ibuf = BKE_image_acquire_ibuf(image, &iuser, &lock);
335
336   if (ibuf && ibuf->rect) {
337     /* Extract all colors. */
338     const int range = (int)pow(10.0f, threshold);
339     for (int row = 0; row < ibuf->y; row++) {
340       for (int col = 0; col < ibuf->x; col++) {
341         float color[4];
342         IMB_sampleImageAtLocation(ibuf, (float)col, (float)row, false, color);
343         for (int i = 0; i < 3; i++) {
344           color[i] = truncf(color[i] * range) / range;
345         }
346
347         uint key = rgb_to_cpack(color[0], color[1], color[2]);
348         if (!BLI_ghash_haskey(color_table, POINTER_FROM_INT(key))) {
349           BLI_ghash_insert(color_table, POINTER_FROM_INT(key), POINTER_FROM_INT(key));
350         }
351       }
352     }
353
354     done = BKE_palette_from_hash(bmain, color_table, image->id.name + 2, false);
355   }
356
357   /* Free memory. */
358   BLI_ghash_free(color_table, NULL, NULL);
359   BKE_image_release_ibuf(image, ibuf, lock);
360
361   if (done) {
362     BKE_reportf(op->reports, RPT_INFO, "Palette created");
363   }
364
365   return OPERATOR_FINISHED;
366 }
367
368 static void PALETTE_OT_extract_from_image(wmOperatorType *ot)
369 {
370   PropertyRNA *prop;
371
372   /* identifiers */
373   ot->name = "Extract Palette from Image";
374   ot->idname = "PALETTE_OT_extract_from_image";
375   ot->description = "Extract all colors used in Image and create a Palette";
376
377   /* api callbacks */
378   ot->exec = palette_extract_img_exec;
379   ot->poll = palette_extract_img_poll;
380
381   /* flags */
382   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
383
384   /* properties */
385   prop = RNA_def_int(ot->srna, "threshold", 1, 1, 1, "Threshold", "", 1, 1);
386   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
387 }
388
389 /* Sort Palette color by Hue and Saturation. */
390 static int palette_sort_exec(bContext *C, wmOperator *op)
391 {
392   const int type = RNA_enum_get(op->ptr, "type");
393
394   Paint *paint = BKE_paint_get_active_from_context(C);
395   Palette *palette = paint->palette;
396
397   if (palette == NULL) {
398     return OPERATOR_CANCELLED;
399   }
400
401   tPaletteColorHSV *color_array = NULL;
402   tPaletteColorHSV *col_elm = NULL;
403
404   const int totcol = BLI_listbase_count(&palette->colors);
405
406   if (totcol > 0) {
407     color_array = MEM_calloc_arrayN(totcol, sizeof(tPaletteColorHSV), __func__);
408     /* Put all colors in an array. */
409     int t = 0;
410     LISTBASE_FOREACH (PaletteColor *, color, &palette->colors) {
411       float h, s, v;
412       rgb_to_hsv(color->rgb[0], color->rgb[1], color->rgb[2], &h, &s, &v);
413       col_elm = &color_array[t];
414       copy_v3_v3(col_elm->rgb, color->rgb);
415       col_elm->value = color->value;
416       col_elm->h = h;
417       col_elm->s = s;
418       col_elm->v = v;
419       t++;
420     }
421     /* Sort */
422     if (type == 1) {
423       BKE_palette_sort_hsv(color_array, totcol);
424     }
425     else if (type == 2) {
426       BKE_palette_sort_svh(color_array, totcol);
427     }
428     else if (type == 3) {
429       BKE_palette_sort_vhs(color_array, totcol);
430     }
431     else {
432       BKE_palette_sort_luminance(color_array, totcol);
433     }
434
435     /* Clear old color swatches. */
436     PaletteColor *color_next = NULL;
437     for (PaletteColor *color = palette->colors.first; color; color = color_next) {
438       color_next = color->next;
439       BKE_palette_color_remove(palette, color);
440     }
441
442     /* Recreate swatches sorted. */
443     for (int i = 0; i < totcol; i++) {
444       col_elm = &color_array[i];
445       PaletteColor *palcol = BKE_palette_color_add(palette);
446       if (palcol) {
447         copy_v3_v3(palcol->rgb, col_elm->rgb);
448       }
449     }
450   }
451
452   /* Free memory. */
453   if (totcol > 0) {
454     MEM_SAFE_FREE(color_array);
455   }
456
457   WM_event_add_notifier(C, NC_BRUSH | NA_EDITED, NULL);
458
459   return OPERATOR_FINISHED;
460 }
461
462 static void PALETTE_OT_sort(wmOperatorType *ot)
463 {
464   static const EnumPropertyItem sort_type[] = {
465       {1, "HSV", 0, "Hue, Saturation, Value", ""},
466       {2, "SVH", 0, "Saturation, Value, Hue", ""},
467       {3, "VHS", 0, "Value, Hue, Saturation", ""},
468       {4, "LUMINANCE", 0, "Luminance", ""},
469       {0, NULL, 0, NULL, NULL},
470   };
471
472   /* identifiers */
473   ot->name = "Sort Palette";
474   ot->idname = "PALETTE_OT_sort";
475   ot->description = "Sort Palette Colors";
476
477   /* api callbacks */
478   ot->exec = palette_sort_exec;
479   ot->poll = palette_poll;
480
481   /* flags */
482   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
483
484   ot->prop = RNA_def_enum(ot->srna, "type", sort_type, 1, "Type", "");
485 }
486
487 /* Move colors in palette. */
488 static int palette_color_move_exec(bContext *C, wmOperator *op)
489 {
490   Paint *paint = BKE_paint_get_active_from_context(C);
491   Palette *palette = paint->palette;
492   PaletteColor *palcolor = BLI_findlink(&palette->colors, palette->active_color);
493
494   if (palcolor == NULL) {
495     return OPERATOR_CANCELLED;
496   }
497
498   const int direction = RNA_enum_get(op->ptr, "type");
499
500   BLI_assert(ELEM(direction, -1, 0, 1)); /* we use value below */
501   if (BLI_listbase_link_move(&palette->colors, palcolor, direction)) {
502     palette->active_color += direction;
503     WM_event_add_notifier(C, NC_BRUSH | NA_EDITED, NULL);
504   }
505
506   return OPERATOR_FINISHED;
507 }
508
509 static void PALETTE_OT_color_move(wmOperatorType *ot)
510 {
511   static const EnumPropertyItem slot_move[] = {
512       {-1, "UP", 0, "Up", ""},
513       {1, "DOWN", 0, "Down", ""},
514       {0, NULL, 0, NULL, NULL},
515   };
516
517   /* identifiers */
518   ot->name = "Move Palette Color";
519   ot->idname = "PALETTE_OT_color_move";
520   ot->description = "Move the active Color up/down in the list";
521
522   /* api callbacks */
523   ot->exec = palette_color_move_exec;
524   ot->poll = palette_poll;
525
526   /* flags */
527   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
528
529   ot->prop = RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
530 }
531
532 /* Join Palette swatches. */
533 static int palette_join_exec(bContext *C, wmOperator *op)
534 {
535   Main *bmain = CTX_data_main(C);
536   Paint *paint = BKE_paint_get_active_from_context(C);
537   Palette *palette = paint->palette;
538   Palette *palette_join = NULL;
539   bool done = false;
540
541   char name[MAX_ID_NAME - 2];
542   RNA_string_get(op->ptr, "palette", name);
543
544   if ((palette == NULL) || (name[0] == '\0')) {
545     return OPERATOR_CANCELLED;
546   }
547
548   palette_join = (Palette *)BKE_libblock_find_name(bmain, ID_PAL, name);
549   if (palette_join == NULL) {
550     return OPERATOR_CANCELLED;
551   }
552
553   const int totcol = BLI_listbase_count(&palette_join->colors);
554
555   if (totcol > 0) {
556     LISTBASE_FOREACH (PaletteColor *, color, &palette_join->colors) {
557       PaletteColor *palcol = BKE_palette_color_add(palette);
558       if (palcol) {
559         copy_v3_v3(palcol->rgb, color->rgb);
560         palcol->value = color->value;
561         done = true;
562       }
563     }
564   }
565
566   if (done) {
567     /* Clear old color swatches. */
568     PaletteColor *color_next = NULL;
569     for (PaletteColor *color = palette_join->colors.first; color; color = color_next) {
570       color_next = color->next;
571       BKE_palette_color_remove(palette_join, color);
572     }
573
574     /* Notifier. */
575     WM_event_add_notifier(C, NC_BRUSH | NA_EDITED, NULL);
576   }
577
578   return OPERATOR_FINISHED;
579 }
580
581 static void PALETTE_OT_join(wmOperatorType *ot)
582 {
583   /* identifiers */
584   ot->name = "Join Palette Swatches";
585   ot->idname = "PALETTE_OT_join";
586   ot->description = "Join Palette Swatches";
587
588   /* api callbacks */
589   ot->exec = palette_join_exec;
590   ot->poll = palette_poll;
591
592   /* flags */
593   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
594
595   /* properties */
596   RNA_def_string(ot->srna, "palette", NULL, MAX_ID_NAME - 2, "Palette", "Name of the Palette");
597 }
598
599 static int brush_reset_exec(bContext *C, wmOperator *UNUSED(op))
600 {
601   Paint *paint = BKE_paint_get_active_from_context(C);
602   Brush *brush = BKE_paint_brush(paint);
603   Object *ob = CTX_data_active_object(C);
604
605   if (!ob || !brush) {
606     return OPERATOR_CANCELLED;
607   }
608
609   /* TODO: other modes */
610   if (ob->mode & OB_MODE_SCULPT) {
611     BKE_brush_sculpt_reset(brush);
612   }
613   else {
614     return OPERATOR_CANCELLED;
615   }
616   WM_event_add_notifier(C, NC_BRUSH | NA_EDITED, brush);
617
618   return OPERATOR_FINISHED;
619 }
620
621 static void BRUSH_OT_reset(wmOperatorType *ot)
622 {
623   /* identifiers */
624   ot->name = "Reset Brush";
625   ot->description = "Return brush to defaults based on current tool";
626   ot->idname = "BRUSH_OT_reset";
627
628   /* api callbacks */
629   ot->exec = brush_reset_exec;
630
631   /* flags */
632   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
633 }
634
635 static int brush_tool(const Brush *brush, size_t tool_offset)
636 {
637   return *(((char *)brush) + tool_offset);
638 }
639
640 static void brush_tool_set(const Brush *brush, size_t tool_offset, int tool)
641 {
642   *(((char *)brush) + tool_offset) = tool;
643 }
644
645 static Brush *brush_tool_cycle(Main *bmain, Paint *paint, Brush *brush_orig, const int tool)
646 {
647   Brush *brush, *first_brush;
648
649   if (!brush_orig && !(brush_orig = bmain->brushes.first)) {
650     return NULL;
651   }
652
653   if (brush_tool(brush_orig, paint->runtime.tool_offset) != tool) {
654     /* If current brush's tool is different from what we need,
655      * start cycling from the beginning of the list.
656      * Such logic will activate the same exact brush not relating from
657      * which tool user requests other tool.
658      */
659
660     /* Try to tool-slot first. */
661     first_brush = BKE_paint_toolslots_brush_get(paint, tool);
662     if (first_brush == NULL) {
663       first_brush = bmain->brushes.first;
664     }
665   }
666   else {
667     /* If user wants to switch to brush with the same  tool as
668      * currently active brush do a cycling via all possible
669      * brushes with requested tool.
670      */
671     first_brush = brush_orig->id.next ? brush_orig->id.next : bmain->brushes.first;
672   }
673
674   /* get the next brush with the active tool */
675   brush = first_brush;
676   do {
677     if ((brush->ob_mode & paint->runtime.ob_mode) &&
678         (brush_tool(brush, paint->runtime.tool_offset) == tool)) {
679       return brush;
680     }
681
682     brush = brush->id.next ? brush->id.next : bmain->brushes.first;
683   } while (brush != first_brush);
684
685   return NULL;
686 }
687
688 static Brush *brush_tool_toggle(Main *bmain, Paint *paint, Brush *brush_orig, const int tool)
689 {
690   if (!brush_orig || brush_tool(brush_orig, paint->runtime.tool_offset) != tool) {
691     Brush *br;
692     /* if the current brush is not using the desired tool, look
693      * for one that is */
694     br = brush_tool_cycle(bmain, paint, brush_orig, tool);
695     /* store the previously-selected brush */
696     if (br) {
697       br->toggle_brush = brush_orig;
698     }
699
700     return br;
701   }
702   if (brush_orig->toggle_brush) {
703     /* if current brush is using the desired tool, try to toggle
704      * back to the previously selected brush. */
705     return brush_orig->toggle_brush;
706   }
707   return NULL;
708 }
709
710 static bool brush_generic_tool_set(bContext *C,
711                                    Main *bmain,
712                                    Paint *paint,
713                                    const int tool,
714                                    const char *tool_name,
715                                    const bool create_missing,
716                                    const bool toggle)
717 {
718   Brush *brush, *brush_orig = BKE_paint_brush(paint);
719
720   if (toggle) {
721     brush = brush_tool_toggle(bmain, paint, brush_orig, tool);
722   }
723   else {
724     brush = brush_tool_cycle(bmain, paint, brush_orig, tool);
725   }
726
727   if (((brush == NULL) && create_missing) &&
728       ((brush_orig == NULL) || brush_tool(brush_orig, paint->runtime.tool_offset) != tool)) {
729     brush = BKE_brush_add(bmain, tool_name, paint->runtime.ob_mode);
730     id_us_min(&brush->id); /* fake user only */
731     brush_tool_set(brush, paint->runtime.tool_offset, tool);
732     brush->toggle_brush = brush_orig;
733   }
734
735   if (brush) {
736     BKE_paint_brush_set(paint, brush);
737     BKE_paint_invalidate_overlay_all();
738
739     WM_main_add_notifier(NC_BRUSH | NA_EDITED, brush);
740
741     /* Tool System
742      * This is needed for when there is a non-sculpt tool active (transform for e.g.).
743      * In case we are toggling (and the brush changed to the toggle_brush), we need to get the
744      * tool_name again. */
745     int tool_result = brush_tool(brush, paint->runtime.tool_offset);
746     ePaintMode paint_mode = BKE_paintmode_get_active_from_context(C);
747     const EnumPropertyItem *items = BKE_paint_get_tool_enum_from_paintmode(paint_mode);
748     RNA_enum_name_from_value(items, tool_result, &tool_name);
749
750     char tool_id[MAX_NAME];
751     SNPRINTF(tool_id, "builtin_brush.%s", tool_name);
752     WM_toolsystem_ref_set_by_id(C, tool_id);
753
754     return true;
755   }
756   return false;
757 }
758
759 static const ePaintMode brush_select_paint_modes[] = {
760     PAINT_MODE_SCULPT,
761     PAINT_MODE_VERTEX,
762     PAINT_MODE_WEIGHT,
763     PAINT_MODE_TEXTURE_3D,
764     PAINT_MODE_GPENCIL,
765     PAINT_MODE_VERTEX_GPENCIL,
766     PAINT_MODE_SCULPT_GPENCIL,
767     PAINT_MODE_WEIGHT_GPENCIL,
768 };
769
770 static int brush_select_exec(bContext *C, wmOperator *op)
771 {
772   Main *bmain = CTX_data_main(C);
773   Scene *scene = CTX_data_scene(C);
774   const bool create_missing = RNA_boolean_get(op->ptr, "create_missing");
775   const bool toggle = RNA_boolean_get(op->ptr, "toggle");
776   const char *tool_name = "Brush";
777   int tool = 0;
778
779   ePaintMode paint_mode = PAINT_MODE_INVALID;
780   for (int i = 0; i < ARRAY_SIZE(brush_select_paint_modes); i++) {
781     paint_mode = brush_select_paint_modes[i];
782     const char *op_prop_id = BKE_paint_get_tool_prop_id_from_paintmode(paint_mode);
783     PropertyRNA *prop = RNA_struct_find_property(op->ptr, op_prop_id);
784     if (RNA_property_is_set(op->ptr, prop)) {
785       tool = RNA_property_enum_get(op->ptr, prop);
786       break;
787     }
788   }
789
790   if (paint_mode == PAINT_MODE_INVALID) {
791     return OPERATOR_CANCELLED;
792   }
793
794   Paint *paint = BKE_paint_get_active_from_paintmode(scene, paint_mode);
795   if (paint == NULL) {
796     return OPERATOR_CANCELLED;
797   }
798   const EnumPropertyItem *items = BKE_paint_get_tool_enum_from_paintmode(paint_mode);
799   RNA_enum_name_from_value(items, tool, &tool_name);
800
801   if (brush_generic_tool_set(C, bmain, paint, tool, tool_name, create_missing, toggle)) {
802     return OPERATOR_FINISHED;
803   }
804   return OPERATOR_CANCELLED;
805 }
806
807 static void PAINT_OT_brush_select(wmOperatorType *ot)
808 {
809   PropertyRNA *prop;
810
811   /* identifiers */
812   ot->name = "Brush Select";
813   ot->description = "Select a paint mode's brush by tool type";
814   ot->idname = "PAINT_OT_brush_select";
815
816   /* api callbacks */
817   ot->exec = brush_select_exec;
818
819   /* flags */
820   ot->flag = 0;
821
822   /* props */
823   /* All properties are hidden, so as not to show the redo panel. */
824   for (int i = 0; i < ARRAY_SIZE(brush_select_paint_modes); i++) {
825     const ePaintMode paint_mode = brush_select_paint_modes[i];
826     const char *prop_id = BKE_paint_get_tool_prop_id_from_paintmode(paint_mode);
827     prop = RNA_def_enum(
828         ot->srna, prop_id, BKE_paint_get_tool_enum_from_paintmode(paint_mode), 0, prop_id, "");
829     RNA_def_property_flag(prop, PROP_HIDDEN);
830   }
831
832   prop = RNA_def_boolean(
833       ot->srna, "toggle", 0, "Toggle", "Toggle between two brushes rather than cycling");
834   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
835   prop = RNA_def_boolean(ot->srna,
836                          "create_missing",
837                          0,
838                          "Create Missing",
839                          "If the requested brush type does not exist, create a new brush");
840   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
841 }
842
843 /***** Stencil Control *****/
844
845 typedef enum {
846   STENCIL_TRANSLATE,
847   STENCIL_SCALE,
848   STENCIL_ROTATE,
849 } StencilControlMode;
850
851 typedef enum {
852   STENCIL_PRIMARY = 0,
853   STENCIL_SECONDARY = 1,
854 } StencilTextureMode;
855
856 typedef enum {
857   STENCIL_CONSTRAINT_X = 1,
858   STENCIL_CONSTRAINT_Y = 2,
859 } StencilConstraint;
860
861 typedef struct {
862   float init_mouse[2];
863   float init_spos[2];
864   float init_sdim[2];
865   float init_rot;
866   float init_angle;
867   float lenorig;
868   float area_size[2];
869   StencilControlMode mode;
870   StencilConstraint constrain_mode;
871   /** We are tweaking mask or color stencil. */
872   int mask;
873   Brush *br;
874   float *dim_target;
875   float *rot_target;
876   float *pos_target;
877   short launch_event;
878 } StencilControlData;
879
880 static void stencil_set_target(StencilControlData *scd)
881 {
882   Brush *br = scd->br;
883   float mdiff[2];
884   if (scd->mask) {
885     copy_v2_v2(scd->init_sdim, br->mask_stencil_dimension);
886     copy_v2_v2(scd->init_spos, br->mask_stencil_pos);
887     scd->init_rot = br->mask_mtex.rot;
888
889     scd->dim_target = br->mask_stencil_dimension;
890     scd->rot_target = &br->mask_mtex.rot;
891     scd->pos_target = br->mask_stencil_pos;
892
893     sub_v2_v2v2(mdiff, scd->init_mouse, br->mask_stencil_pos);
894   }
895   else {
896     copy_v2_v2(scd->init_sdim, br->stencil_dimension);
897     copy_v2_v2(scd->init_spos, br->stencil_pos);
898     scd->init_rot = br->mtex.rot;
899
900     scd->dim_target = br->stencil_dimension;
901     scd->rot_target = &br->mtex.rot;
902     scd->pos_target = br->stencil_pos;
903
904     sub_v2_v2v2(mdiff, scd->init_mouse, br->stencil_pos);
905   }
906
907   scd->lenorig = len_v2(mdiff);
908
909   scd->init_angle = atan2f(mdiff[1], mdiff[0]);
910 }
911
912 static int stencil_control_invoke(bContext *C, wmOperator *op, const wmEvent *event)
913 {
914   Paint *paint = BKE_paint_get_active_from_context(C);
915   Brush *br = BKE_paint_brush(paint);
916   const float mvalf[2] = {event->mval[0], event->mval[1]};
917   ARegion *region = CTX_wm_region(C);
918   StencilControlData *scd;
919   int mask = RNA_enum_get(op->ptr, "texmode");
920
921   if (mask) {
922     if (br->mask_mtex.brush_map_mode != MTEX_MAP_MODE_STENCIL) {
923       return OPERATOR_CANCELLED;
924     }
925   }
926   else {
927     if (br->mtex.brush_map_mode != MTEX_MAP_MODE_STENCIL) {
928       return OPERATOR_CANCELLED;
929     }
930   }
931
932   scd = MEM_mallocN(sizeof(StencilControlData), "stencil_control");
933   scd->mask = mask;
934   scd->br = br;
935
936   copy_v2_v2(scd->init_mouse, mvalf);
937
938   stencil_set_target(scd);
939
940   scd->mode = RNA_enum_get(op->ptr, "mode");
941   scd->launch_event = WM_userdef_event_type_from_keymap_type(event->type);
942   scd->area_size[0] = region->winx;
943   scd->area_size[1] = region->winy;
944
945   op->customdata = scd;
946   WM_event_add_modal_handler(C, op);
947
948   return OPERATOR_RUNNING_MODAL;
949 }
950
951 static void stencil_restore(StencilControlData *scd)
952 {
953   copy_v2_v2(scd->dim_target, scd->init_sdim);
954   copy_v2_v2(scd->pos_target, scd->init_spos);
955   *scd->rot_target = scd->init_rot;
956 }
957
958 static void stencil_control_cancel(bContext *UNUSED(C), wmOperator *op)
959 {
960   StencilControlData *scd = op->customdata;
961
962   stencil_restore(scd);
963   MEM_freeN(op->customdata);
964 }
965
966 static void stencil_control_calculate(StencilControlData *scd, const int mval[2])
967 {
968 #define PIXEL_MARGIN 5
969
970   float mdiff[2];
971   const float mvalf[2] = {mval[0], mval[1]};
972   switch (scd->mode) {
973     case STENCIL_TRANSLATE:
974       sub_v2_v2v2(mdiff, mvalf, scd->init_mouse);
975       add_v2_v2v2(scd->pos_target, scd->init_spos, mdiff);
976       CLAMP(scd->pos_target[0],
977             -scd->dim_target[0] + PIXEL_MARGIN,
978             scd->area_size[0] + scd->dim_target[0] - PIXEL_MARGIN);
979
980       CLAMP(scd->pos_target[1],
981             -scd->dim_target[1] + PIXEL_MARGIN,
982             scd->area_size[1] + scd->dim_target[1] - PIXEL_MARGIN);
983
984       break;
985     case STENCIL_SCALE: {
986       float len, factor;
987       sub_v2_v2v2(mdiff, mvalf, scd->pos_target);
988       len = len_v2(mdiff);
989       factor = len / scd->lenorig;
990       copy_v2_v2(mdiff, scd->init_sdim);
991       if (scd->constrain_mode != STENCIL_CONSTRAINT_Y) {
992         mdiff[0] = factor * scd->init_sdim[0];
993       }
994       if (scd->constrain_mode != STENCIL_CONSTRAINT_X) {
995         mdiff[1] = factor * scd->init_sdim[1];
996       }
997       clamp_v2(mdiff, 5.0f, 10000.0f);
998       copy_v2_v2(scd->dim_target, mdiff);
999       break;
1000     }
1001     case STENCIL_ROTATE: {
1002       float angle;
1003       sub_v2_v2v2(mdiff, mvalf, scd->pos_target);
1004       angle = atan2f(mdiff[1], mdiff[0]);
1005       angle = scd->init_rot + angle - scd->init_angle;
1006       if (angle < 0.0f) {
1007         angle += (float)(2 * M_PI);
1008       }
1009       if (angle > (float)(2 * M_PI)) {
1010         angle -= (float)(2 * M_PI);
1011       }
1012       *scd->rot_target = angle;
1013       break;
1014     }
1015   }
1016 #undef PIXEL_MARGIN
1017 }
1018
1019 static int stencil_control_modal(bContext *C, wmOperator *op, const wmEvent *event)
1020 {
1021   StencilControlData *scd = op->customdata;
1022
1023   if (event->type == scd->launch_event && event->val == KM_RELEASE) {
1024     MEM_freeN(op->customdata);
1025     WM_event_add_notifier(C, NC_WINDOW, NULL);
1026     return OPERATOR_FINISHED;
1027   }
1028
1029   switch (event->type) {
1030     case MOUSEMOVE:
1031       stencil_control_calculate(scd, event->mval);
1032       break;
1033     case EVT_ESCKEY:
1034       if (event->val == KM_PRESS) {
1035         stencil_control_cancel(C, op);
1036         WM_event_add_notifier(C, NC_WINDOW, NULL);
1037         return OPERATOR_CANCELLED;
1038       }
1039       break;
1040     case EVT_XKEY:
1041       if (event->val == KM_PRESS) {
1042
1043         if (scd->constrain_mode == STENCIL_CONSTRAINT_X) {
1044           scd->constrain_mode = 0;
1045         }
1046         else {
1047           scd->constrain_mode = STENCIL_CONSTRAINT_X;
1048         }
1049
1050         stencil_control_calculate(scd, event->mval);
1051       }
1052       break;
1053     case EVT_YKEY:
1054       if (event->val == KM_PRESS) {
1055         if (scd->constrain_mode == STENCIL_CONSTRAINT_Y) {
1056           scd->constrain_mode = 0;
1057         }
1058         else {
1059           scd->constrain_mode = STENCIL_CONSTRAINT_Y;
1060         }
1061
1062         stencil_control_calculate(scd, event->mval);
1063       }
1064       break;
1065     default:
1066       break;
1067   }
1068
1069   ED_region_tag_redraw(CTX_wm_region(C));
1070
1071   return OPERATOR_RUNNING_MODAL;
1072 }
1073
1074 static bool stencil_control_poll(bContext *C)
1075 {
1076   ePaintMode mode = BKE_paintmode_get_active_from_context(C);
1077
1078   Paint *paint;
1079   Brush *br;
1080
1081   if (!paint_supports_texture(mode)) {
1082     return false;
1083   }
1084
1085   paint = BKE_paint_get_active_from_context(C);
1086   br = BKE_paint_brush(paint);
1087   return (br && (br->mtex.brush_map_mode == MTEX_MAP_MODE_STENCIL ||
1088                  br->mask_mtex.brush_map_mode == MTEX_MAP_MODE_STENCIL));
1089 }
1090
1091 static void BRUSH_OT_stencil_control(wmOperatorType *ot)
1092 {
1093   static const EnumPropertyItem stencil_control_items[] = {
1094       {STENCIL_TRANSLATE, "TRANSLATION", 0, "Translation", ""},
1095       {STENCIL_SCALE, "SCALE", 0, "Scale", ""},
1096       {STENCIL_ROTATE, "ROTATION", 0, "Rotation", ""},
1097       {0, NULL, 0, NULL, NULL},
1098   };
1099
1100   static const EnumPropertyItem stencil_texture_items[] = {
1101       {STENCIL_PRIMARY, "PRIMARY", 0, "Primary", ""},
1102       {STENCIL_SECONDARY, "SECONDARY", 0, "Secondary", ""},
1103       {0, NULL, 0, NULL, NULL},
1104   };
1105   /* identifiers */
1106   ot->name = "Stencil Brush Control";
1107   ot->description = "Control the stencil brush";
1108   ot->idname = "BRUSH_OT_stencil_control";
1109
1110   /* api callbacks */
1111   ot->invoke = stencil_control_invoke;
1112   ot->modal = stencil_control_modal;
1113   ot->cancel = stencil_control_cancel;
1114   ot->poll = stencil_control_poll;
1115
1116   /* flags */
1117   ot->flag = 0;
1118
1119   PropertyRNA *prop;
1120   prop = RNA_def_enum(ot->srna, "mode", stencil_control_items, STENCIL_TRANSLATE, "Tool", "");
1121   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1122   prop = RNA_def_enum(ot->srna, "texmode", stencil_texture_items, STENCIL_PRIMARY, "Tool", "");
1123   RNA_def_property_flag(prop, PROP_HIDDEN | PROP_SKIP_SAVE);
1124 }
1125
1126 static int stencil_fit_image_aspect_exec(bContext *C, wmOperator *op)
1127 {
1128   Paint *paint = BKE_paint_get_active_from_context(C);
1129   Brush *br = BKE_paint_brush(paint);
1130   bool use_scale = RNA_boolean_get(op->ptr, "use_scale");
1131   bool use_repeat = RNA_boolean_get(op->ptr, "use_repeat");
1132   bool do_mask = RNA_boolean_get(op->ptr, "mask");
1133   Tex *tex = NULL;
1134   MTex *mtex = NULL;
1135   if (br) {
1136     mtex = do_mask ? &br->mask_mtex : &br->mtex;
1137     tex = mtex->tex;
1138   }
1139
1140   if (tex && tex->type == TEX_IMAGE && tex->ima) {
1141     float aspx, aspy;
1142     Image *ima = tex->ima;
1143     float orig_area, stencil_area, factor;
1144     ED_image_get_uv_aspect(ima, NULL, &aspx, &aspy);
1145
1146     if (use_scale) {
1147       aspx *= mtex->size[0];
1148       aspy *= mtex->size[1];
1149     }
1150
1151     if (use_repeat && tex->extend == TEX_REPEAT) {
1152       aspx *= tex->xrepeat;
1153       aspy *= tex->yrepeat;
1154     }
1155
1156     orig_area = fabsf(aspx * aspy);
1157
1158     if (do_mask) {
1159       stencil_area = fabsf(br->mask_stencil_dimension[0] * br->mask_stencil_dimension[1]);
1160     }
1161     else {
1162       stencil_area = fabsf(br->stencil_dimension[0] * br->stencil_dimension[1]);
1163     }
1164
1165     factor = sqrtf(stencil_area / orig_area);
1166
1167     if (do_mask) {
1168       br->mask_stencil_dimension[0] = fabsf(factor * aspx);
1169       br->mask_stencil_dimension[1] = fabsf(factor * aspy);
1170     }
1171     else {
1172       br->stencil_dimension[0] = fabsf(factor * aspx);
1173       br->stencil_dimension[1] = fabsf(factor * aspy);
1174     }
1175   }
1176
1177   WM_event_add_notifier(C, NC_WINDOW, NULL);
1178
1179   return OPERATOR_FINISHED;
1180 }
1181
1182 static void BRUSH_OT_stencil_fit_image_aspect(wmOperatorType *ot)
1183 {
1184   /* identifiers */
1185   ot->name = "Image Aspect";
1186   ot->description =
1187       "When using an image texture, adjust the stencil size to fit the image aspect ratio";
1188   ot->idname = "BRUSH_OT_stencil_fit_image_aspect";
1189
1190   /* api callbacks */
1191   ot->exec = stencil_fit_image_aspect_exec;
1192   ot->poll = stencil_control_poll;
1193
1194   /* flags */
1195   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1196
1197   RNA_def_boolean(ot->srna, "use_repeat", 1, "Use Repeat", "Use repeat mapping values");
1198   RNA_def_boolean(ot->srna, "use_scale", 1, "Use Scale", "Use texture scale values");
1199   RNA_def_boolean(
1200       ot->srna, "mask", 0, "Modify Mask Stencil", "Modify either the primary or mask stencil");
1201 }
1202
1203 static int stencil_reset_transform_exec(bContext *C, wmOperator *op)
1204 {
1205   Paint *paint = BKE_paint_get_active_from_context(C);
1206   Brush *br = BKE_paint_brush(paint);
1207   bool do_mask = RNA_boolean_get(op->ptr, "mask");
1208
1209   if (!br) {
1210     return OPERATOR_CANCELLED;
1211   }
1212
1213   if (do_mask) {
1214     br->mask_stencil_pos[0] = 256;
1215     br->mask_stencil_pos[1] = 256;
1216
1217     br->mask_stencil_dimension[0] = 256;
1218     br->mask_stencil_dimension[1] = 256;
1219
1220     br->mask_mtex.rot = 0;
1221   }
1222   else {
1223     br->stencil_pos[0] = 256;
1224     br->stencil_pos[1] = 256;
1225
1226     br->stencil_dimension[0] = 256;
1227     br->stencil_dimension[1] = 256;
1228
1229     br->mtex.rot = 0;
1230   }
1231
1232   WM_event_add_notifier(C, NC_WINDOW, NULL);
1233
1234   return OPERATOR_FINISHED;
1235 }
1236
1237 static void BRUSH_OT_stencil_reset_transform(wmOperatorType *ot)
1238 {
1239   /* identifiers */
1240   ot->name = "Reset Transform";
1241   ot->description = "Reset the stencil transformation to the default";
1242   ot->idname = "BRUSH_OT_stencil_reset_transform";
1243
1244   /* api callbacks */
1245   ot->exec = stencil_reset_transform_exec;
1246   ot->poll = stencil_control_poll;
1247
1248   /* flags */
1249   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1250
1251   RNA_def_boolean(
1252       ot->srna, "mask", 0, "Modify Mask Stencil", "Modify either the primary or mask stencil");
1253 }
1254
1255 /**************************** registration **********************************/
1256
1257 void ED_operatormacros_paint(void)
1258 {
1259   wmOperatorType *ot;
1260   wmOperatorTypeMacro *otmacro;
1261
1262   ot = WM_operatortype_append_macro("PAINTCURVE_OT_add_point_slide",
1263                                     "Add Curve Point and Slide",
1264                                     "Add new curve point and slide it",
1265                                     OPTYPE_UNDO);
1266   ot->description = "Add new curve point and slide it";
1267   WM_operatortype_macro_define(ot, "PAINTCURVE_OT_add_point");
1268   otmacro = WM_operatortype_macro_define(ot, "PAINTCURVE_OT_slide");
1269   RNA_boolean_set(otmacro->ptr, "align", true);
1270   RNA_boolean_set(otmacro->ptr, "select", false);
1271 }
1272
1273 void ED_operatortypes_paint(void)
1274 {
1275   /* palette */
1276   WM_operatortype_append(PALETTE_OT_new);
1277   WM_operatortype_append(PALETTE_OT_color_add);
1278   WM_operatortype_append(PALETTE_OT_color_delete);
1279
1280   WM_operatortype_append(PALETTE_OT_extract_from_image);
1281   WM_operatortype_append(PALETTE_OT_sort);
1282   WM_operatortype_append(PALETTE_OT_color_move);
1283   WM_operatortype_append(PALETTE_OT_join);
1284
1285   /* paint curve */
1286   WM_operatortype_append(PAINTCURVE_OT_new);
1287   WM_operatortype_append(PAINTCURVE_OT_add_point);
1288   WM_operatortype_append(PAINTCURVE_OT_delete_point);
1289   WM_operatortype_append(PAINTCURVE_OT_select);
1290   WM_operatortype_append(PAINTCURVE_OT_slide);
1291   WM_operatortype_append(PAINTCURVE_OT_draw);
1292   WM_operatortype_append(PAINTCURVE_OT_cursor);
1293
1294   /* brush */
1295   WM_operatortype_append(BRUSH_OT_add);
1296   WM_operatortype_append(BRUSH_OT_add_gpencil);
1297   WM_operatortype_append(BRUSH_OT_scale_size);
1298   WM_operatortype_append(BRUSH_OT_curve_preset);
1299   WM_operatortype_append(BRUSH_OT_reset);
1300   WM_operatortype_append(BRUSH_OT_stencil_control);
1301   WM_operatortype_append(BRUSH_OT_stencil_fit_image_aspect);
1302   WM_operatortype_append(BRUSH_OT_stencil_reset_transform);
1303
1304   /* note, particle uses a different system, can be added with existing operators in wm.py */
1305   WM_operatortype_append(PAINT_OT_brush_select);
1306
1307   /* image */
1308   WM_operatortype_append(PAINT_OT_texture_paint_toggle);
1309   WM_operatortype_append(PAINT_OT_image_paint);
1310   WM_operatortype_append(PAINT_OT_sample_color);
1311   WM_operatortype_append(PAINT_OT_grab_clone);
1312   WM_operatortype_append(PAINT_OT_project_image);
1313   WM_operatortype_append(PAINT_OT_image_from_view);
1314   WM_operatortype_append(PAINT_OT_brush_colors_flip);
1315   WM_operatortype_append(PAINT_OT_add_texture_paint_slot);
1316   WM_operatortype_append(PAINT_OT_add_simple_uvs);
1317
1318   /* weight */
1319   WM_operatortype_append(PAINT_OT_weight_paint_toggle);
1320   WM_operatortype_append(PAINT_OT_weight_paint);
1321   WM_operatortype_append(PAINT_OT_weight_set);
1322   WM_operatortype_append(PAINT_OT_weight_from_bones);
1323   WM_operatortype_append(PAINT_OT_weight_gradient);
1324   WM_operatortype_append(PAINT_OT_weight_sample);
1325   WM_operatortype_append(PAINT_OT_weight_sample_group);
1326
1327   /* uv */
1328   WM_operatortype_append(SCULPT_OT_uv_sculpt_stroke);
1329
1330   /* vertex selection */
1331   WM_operatortype_append(PAINT_OT_vert_select_all);
1332   WM_operatortype_append(PAINT_OT_vert_select_ungrouped);
1333
1334   /* vertex */
1335   WM_operatortype_append(PAINT_OT_vertex_paint_toggle);
1336   WM_operatortype_append(PAINT_OT_vertex_paint);
1337   WM_operatortype_append(PAINT_OT_vertex_color_set);
1338   WM_operatortype_append(PAINT_OT_vertex_color_smooth);
1339
1340   WM_operatortype_append(PAINT_OT_vertex_color_brightness_contrast);
1341   WM_operatortype_append(PAINT_OT_vertex_color_hsv);
1342   WM_operatortype_append(PAINT_OT_vertex_color_invert);
1343   WM_operatortype_append(PAINT_OT_vertex_color_levels);
1344   WM_operatortype_append(PAINT_OT_vertex_color_from_weight);
1345
1346   /* face-select */
1347   WM_operatortype_append(PAINT_OT_face_select_linked);
1348   WM_operatortype_append(PAINT_OT_face_select_linked_pick);
1349   WM_operatortype_append(PAINT_OT_face_select_all);
1350   WM_operatortype_append(PAINT_OT_face_select_hide);
1351   WM_operatortype_append(PAINT_OT_face_select_reveal);
1352
1353   /* partial visibility */
1354   WM_operatortype_append(PAINT_OT_hide_show);
1355
1356   /* paint masking */
1357   WM_operatortype_append(PAINT_OT_mask_flood_fill);
1358   WM_operatortype_append(PAINT_OT_mask_lasso_gesture);
1359   WM_operatortype_append(PAINT_OT_mask_box_gesture);
1360 }
1361
1362 void ED_keymap_paint(wmKeyConfig *keyconf)
1363 {
1364   wmKeyMap *keymap;
1365
1366   keymap = WM_keymap_ensure(keyconf, "Paint Curve", 0, 0);
1367   keymap->poll = paint_curve_poll;
1368
1369   /* Sculpt mode */
1370   keymap = WM_keymap_ensure(keyconf, "Sculpt", 0, 0);
1371   keymap->poll = SCULPT_mode_poll;
1372
1373   /* Vertex Paint mode */
1374   keymap = WM_keymap_ensure(keyconf, "Vertex Paint", 0, 0);
1375   keymap->poll = vertex_paint_mode_poll;
1376
1377   /* Weight Paint mode */
1378   keymap = WM_keymap_ensure(keyconf, "Weight Paint", 0, 0);
1379   keymap->poll = weight_paint_mode_poll;
1380
1381   /*Weight paint's Vertex Selection Mode */
1382   keymap = WM_keymap_ensure(keyconf, "Paint Vertex Selection (Weight, Vertex)", 0, 0);
1383   keymap->poll = vert_paint_poll;
1384
1385   /* Image/Texture Paint mode */
1386   keymap = WM_keymap_ensure(keyconf, "Image Paint", 0, 0);
1387   keymap->poll = image_texture_paint_poll;
1388
1389   /* face-mask mode */
1390   keymap = WM_keymap_ensure(keyconf, "Paint Face Mask (Weight, Vertex, Texture)", 0, 0);
1391   keymap->poll = facemask_paint_poll;
1392
1393   /* paint stroke */
1394   keymap = paint_stroke_modal_keymap(keyconf);
1395   WM_modalkeymap_assign(keymap, "SCULPT_OT_brush_stroke");
1396 }